using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace GraphForge
{
    /*
     * @brief Klasa wyświetlająca zadany graf w postaci grafu płaskiego
     *
     * @todo Uzupełnić klasę o eventy: edgeClick, vertexClick, voidClick, Click, ...
     * @todo Klasa powinna samodzielnie obsługiwać przeciąganie, skalowanie, .. wierzchołków, krawędzi
     *
     * @author Paweł Kubiak
     * @author ...
     */

    public class Renderer2D: IRenderer<Point2D>
    {
        private Panel canvas = null;   //< Obiekt po którym będziemy rysować
        private Graph defaultGraph = null;   //< Graf domyślnie renderowany
        private Layout<Point2D> defaultLayout = null;   //< Domyślny layout
        private int activeMode = 0;//< Aktualny tryb edycji grafu 0-edit, 1-vertex, 2-edge

        /*
         * @brief Konstruktor
         *
         * Konstruktor powinien podpinać odpowiednie metody klasy Renderer pod przekazany obiekt:
         *  event MouseDown - do obsługi drag&drop
         *  event MouseUp - do obsługi drag&drop
         *  event MouseClick - klikanie na grafie - prawy, lewy, środkowy przycisk
         *  event Resize
         *  event MouseWheel - ruch kółka zoomuje graf
         *  ...
         *
         * @param canvas - Obiekt po którym będziemy rysować
         */

        public Renderer2D (Panel canvas)
        {
            this.canvas = canvas;
            canvas.Paint += GraphDrawHandler;
            canvas.Click += GraphClickHandler;
            canvas.MouseDown += GraphClickHandler;
            canvas.MouseWheel += GraphClickHandler;
        }

        /*
         * @brief Konstruktor
         *
         * Konstruktor powinien spróbować podpiąć podany graf i layout jako domyślne.
         *
         * @param canvas - Obiekt po krórym będziemy rysować
         * @param g - Główny graf, który będziemy renderować
         * @param l - Layout określający wygląd renderowanego grafu
         */

        public Renderer2D (Panel canvas, Graph g, Layout<Point2D> l): this(canvas){
            this.defaultGraph = g;
            this.defaultLayout = l;
            //canvas.Invalidate();// Odrysuj canvas
        }

        /*
         * @brief Ustaw tryb dodawania krawędzi
         *
         * Ustawia tryb w którym kliknięcie na dwa wierzchołki pokoleji spowoduje utworzenie nowej krawędzi skierowanej,
         * kliknięcie w inny obiekt powraca do trybu edycji
         *
         * @param sender -
         * @param e -
         */
        public void SetEdgeMode(object sender, EventArgs e){
            Console.WriteLine("SetEdgeMode");
        }

        /*
         * @brief Ustaw tryb dodawania wierzchołków
         *
         * Ustawia tryb w którym kliknięcie na puste miejsce grafu powoduje dodanie w tym miejscu nowego wierzchołka,
         * kliknięcie w innym miejscu przywraca tryb edycji
         *
         * @param sender -
         * @param e -
         */
        public void SetVertexMode(object sender, EventArgs e){
            Console.WriteLine("SetVertexMode");
        }

        /*
         * @brief Ustaw tryb edycji grafu
         *
         * Ustawia tryb w którym można przeciągać wierzchołki grafu, a także wyświetlać menu kontekstowe dla wierzchołków i krawędzi
         * @param sender -
         * @param e -
         */
        public void SetEditMode(object sender, EventArgs e){
            Console.WriteLine("SetEditMode");
        }

        /*
         * @brief Wyświetla graf g z layoutem l na obiekcie canvas
         *
         * @param canvas - obiekt na którym należy wyświetlić graf
         * @param g - graf do wyświetlenia
         * @param l - layoud grafu g
         *
         * @exception RunTimeException - gdy któryś obiekt jest błędny
         */
        public void Render(Graphics canvas, Graph g, Layout<Point2D> l){
            Console.WriteLine(canvas.VisibleClipBounds);

            canvas.FillEllipse(Brushes.Red, 10, 10, 10 ,10);
            canvas.SmoothingMode = SmoothingMode.AntiAlias;
            canvas.Clear(System.Drawing.Color.White);
            foreach(Edge e in g.Edges)
                canvas.DrawLine(l.Edges[e].Pen, l.Vertices[e.start].Position.Cast(), l.Vertices[e.end].Position.Cast());

            foreach(Vertex v in g.Vertices){
                canvas.FillEllipse(Brushes.Lime, l.Vertices[v].Position.X-0.5f*l.Vertices[v].Radius, l.Vertices[v].Position.Y-0.5f*l.Vertices[v].Radius, l.Vertices[v].Radius, l.Vertices[v].Radius);
            }
            //foreach(
        }

        /*
         * @brief Wyświetla graf defaultGraph z użyciem defaultLayout na obiekcie canvas
         *
         * @param canvas - obiekt na którym należy wyświetlić defaultGraph
         *
         * @exception RunTimeException - gdy coś nietak
         */
        public void Render(Graphics canvas){
            Render (canvas, this.defaultGraph, this.defaultLayout);
        }


        /*
         * @brief Wyświetla g z użyciem l na canvasie
         *
         * @param g - graf do wyświetlenia
         * @param l - layout grafu g
         *
         * @exception RunTimeException - kiedy g, l, canvas są błędne (bo są np. nullami)
         */
        public void Render(Graph g, Layout<Point2D> l){
            Graphics c = this.canvas.CreateGraphics();
            c.TranslateClip(this.canvas.Location.X, this.canvas.Location.Y);
            Console.WriteLine(this.canvas.Top+" "+this.canvas.Left);
            Render (c, g, l);
            c.Dispose();
        }


        /*
         * @brief Wyświetla defaultGraph z użyciem defaultLayout na canvas
         *
         * @exception RunTimeException - kiedy niemożna użyć defaultGraph, defaultLayout lub canvas (bo są np. nullami)
         */
        public void Render(){
            Render (this.defaultGraph, this.defaultLayout);

            /*
            //Przykładowy kod coś rysujący
            g.SmoothingMode = SmoothingMode.AntiAlias;//ustaw wygładzanie lini
            g.DrawLine(new Pen(Color.White, 1.0f), new Point(220,100), new Point(200, 150));//thin
            g.DrawLine(new Pen(Color.White, 2.0f), new Point(220,100), new Point(280, 150));//normal
            g.DrawLine(new Pen(Color.White, 4.0f), new Point(220,100), new Point(360, 150));//bold*/

            /*g.FillEllipse(Brushes.Yellow, 90, 90, 20, 20);
            g.FillEllipse(Brushes.Lime, 190, 140, 48, 48);*/

            /*g.FillEllipse(Brushes.Lime, 100, 200, 14, 14);//Tiny
            g.FillEllipse(Brushes.Lime, 130, 200, 20, 20);//Small
            g.FillEllipse(Brushes.Lime, 160, 200, 28, 28);//Normal
            g.FillEllipse(Brushes.Lime, 200, 200, 36, 36);//Medium
            g.FillEllipse(Brushes.Lime, 250, 200, 48, 48);//Big
            g.Dispose();*/


        }

        /*
         * @brief Zwraca obiekt, który znajduje się aktualnie w punkcie płaszczyzny p
         *
         * @return Vertex, jeżeli kliknięto vertex
         * @return Edge, jeżeli kliknięto edge
         * @return null, gdy kliknięto pustkę
         */
        private object ClickedItem(Point p){
            return null;
        }

        /*
         * @brief Handler przechwytujący eventy przychodzące z kliknięć na panelu na którym się rysuje
         *
         * W zależności od sposobu kliknięcia i aktywnego trybu podejmuje różne działania
         * @param sender -
         * @param e -
         */
        public void GraphClickHandler(object sender, EventArgs e){
            Console.WriteLine ("GraphClickHandler");
        }

        /*
         * @brief Hendler wykonujący się w momencie odrysowywania formatki canvas.
         *
         * @param sender -
         * @param e -
         */
        public void GraphDrawHandler(object sender, EventArgs e){
            Console.WriteLine ("GraphDrawHandler");
            Render();
        }
    }
}