using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace CoreUnit.Control.UserControl.Canvas
{
    public class DrawUtils
    {
        static Pen m_selectedPen = null;
        static public Pen SelectedPen {
            get {
                if (m_selectedPen == null) {
                    //m_selectedPen = new Pen(Color.Magenta, 1);
                    //m_selectedPen.DashStyle = DashStyle.Dash;

                    // ¼±Åà Áö¿ª Ææ ±½±â / ¼± ½ºÅ¸ÀÏ º¯°æ
                    m_selectedPen = new Pen(Color.Magenta, 4);
                    m_selectedPen.DashStyle = DashStyle.DashDotDot;
                }
                return m_selectedPen;
            }
        }

        static public void DrawNode(ICanvas canvas, UnitPoint nodepoint)
        {
            RectangleF r = new RectangleF(canvas.ToScreen(nodepoint), new SizeF(0, 0));
            r.Inflate(3, 3);
            if (r.Right < 0 || r.Left > canvas.ClientRectangle.Width)
                return;
            if (r.Top < 0 || r.Bottom > canvas.ClientRectangle.Height)
                return;
            canvas.Graphics.FillRectangle(Brushes.White, r);
            r.Inflate(1, 1);
            canvas.Graphics.DrawRectangle(Pens.Black, ScreenUtils.ConvertRect(r));
        }

        static public void DrawTriangleNode(ICanvas canvas, UnitPoint nodepoint)
        {
            PointF screenpoint = canvas.ToScreen(nodepoint);
            float size = 4;
            PointF[] p = new PointF[]
            {
                new PointF(screenpoint.X - size, screenpoint.Y),
                new PointF(screenpoint.X, screenpoint.Y + size),
                new PointF(screenpoint.X + size, screenpoint.Y),
                new PointF(screenpoint.X, screenpoint.Y - size),
            };
            canvas.Graphics.FillPolygon(Brushes.Blue, p);
        }

        static public void DrawArrowNode(ICanvas canvas, UnitPoint nodepoint, double Angle, Pen pen)
        {
            PointF screenpoint = canvas.ToScreen(nodepoint);
            float size = 10;

            double tiltX = (-size) * Math.Cos(Angle * Math.PI / 180) + (-size) * Math.Sin(Angle * Math.PI / 180);
            double tiltY = (-1) * (-size) * Math.Sin(Angle * Math.PI / 180) + (-size) * Math.Cos(Angle * Math.PI / 180);
            PointF leftPoint = new PointF((float)tiltX + screenpoint.X, (float)tiltY + screenpoint.Y);
            canvas.Graphics.DrawLine(pen, screenpoint, leftPoint);

            tiltX = (-size) * Math.Cos(Angle * Math.PI / 180) + (size) * Math.Sin(Angle * Math.PI / 180);
            tiltY = (-1) * (-size) * Math.Sin(Angle * Math.PI / 180) + (size) * Math.Cos(Angle * Math.PI / 180);
            PointF rightPoint = new PointF((float)tiltX + screenpoint.X, (float)tiltY + screenpoint.Y);
            canvas.Graphics.DrawLine(pen, screenpoint, rightPoint);

        }
    }

    interface IObjectEditInstance
    {
        IDrawObject GetDrawObject();
    }

    public abstract class DrawObjectBase
    {
        bool m_locked = false;
        [Browsable(false)]
        public bool Locked {
            get { return m_locked; }
            set { m_locked = value; }
        }

        float m_width;//¼±ÀÇ ±½±â
        Color m_color = Color.Black;
        DrawingLayer m_layer;

        enum eFlags
        {
            selected = 0x00000001,
            highlighted = 0x00000002,
            useLayerWidth = 0x00000004,
            useLayerColor = 0x00000008,
        }
        int m_flag = (int)(eFlags.useLayerWidth | eFlags.useLayerColor);
        bool GetFlag(eFlags flag)
        {
            return ((int)m_flag & (int)flag) > 0;
        }

        void SetFlag(eFlags flag, bool enable)
        {
            if (enable)
                m_flag |= (int)flag;
            else
                m_flag &= ~(int)flag;
        }

        [Browsable(false)]
        public bool UseLayerWidth {
            get { return GetFlag(eFlags.useLayerWidth); }
            set { SetFlag(eFlags.useLayerWidth, value); }
        }

        [Browsable(false)]
        public bool UseLayerColor {
            get { return GetFlag(eFlags.useLayerColor); }
            set { SetFlag(eFlags.useLayerColor, value); }
        }

        [Browsable(false)]
        public float Width {
            set { m_width = value; }
            get {
                if (Layer != null && UseLayerWidth)
                    return Layer.Width;
                return m_width;
            }
        }

        [Browsable(false)]
        public Color Color {
            set { m_color = value; }
            get {
                //if (Layer != null && UseLayerColor)
                //    return Layer.Color;
                return m_color;
            }
        }

        [Browsable(false)]
        public DrawingLayer Layer {
            get { return m_layer; }
            set { m_layer = value; }
        }

        abstract public void InitializeFromModel(UnitPoint point, DrawingLayer layer, ISnapPoint snap);

        [Browsable(false)]
        public virtual bool Selected {
            get { return GetFlag(eFlags.selected); }
            set {
                SetFlag(eFlags.selected, value);
            }
        }

        [Browsable(false)]
        public virtual bool Highlighted {
            get { return GetFlag(eFlags.highlighted); }
            set { SetFlag(eFlags.highlighted, value); }
        }

        public virtual void Copy(DrawObjectBase acopy)
        {
            UseLayerColor = acopy.UseLayerColor;
            UseLayerWidth = acopy.UseLayerWidth;
            Width = acopy.Width;
            Color = acopy.Color;
        }
    }
}