using PaintDotNet.Annotation.Enum;
using PaintDotNet.Base.SettingModel;

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Globalization;
using System.Runtime.Serialization;
using System.Windows.Forms;

namespace PaintDotNet.Annotation.Label
{
    /// <summary>
    /// 标注->圆角矩形
    /// </summary>
    public class DrawRoundRectangle : DrawObject
    {
        private const string entryRectangle = "Rect";

        /// <summary>
        /// 标注样式信息model
        /// </summary>
        public LabelStyleModel.RoundedRectangle labelRoundedRectStyleModel;

        // 圆角半径
        private int radius = 10;
 
        public DrawRoundRectangle(ISurfaceBox surfaceBox, int x, int y, int width, int height) : base()
        {
            this.objectType = DrawClass.Label;
            this.drawToolType = DrawToolType.DrawRoundRectangle;

            labelRoundedRectStyleModel = surfaceBox.GetLabelStyleModel().roundedRectangle;
            rectangle.X = x;
            rectangle.Y = y;
            rectangle.Width = width;
            rectangle.Height = height;
            Initialize();
        }

        public DrawRoundRectangle(ISurfaceBox surfaceBox, List<PointF> points, ParentStyleModel parentStyleModel, Object content) : base()
        {
            this.objectType = DrawClass.Label;
            this.drawToolType = DrawToolType.DrawRoundRectangle;
            this.ISurfaceBox = surfaceBox;

            labelRoundedRectStyleModel = (LabelStyleModel.RoundedRectangle)parentStyleModel;
            rectangle.X = points[0].X;
            rectangle.Y = points[0].Y;
            rectangle.Width = points[1].X - points[0].X;
            rectangle.Height = points[1].Y - points[0].Y;
        }

        /// <summary>
        /// Clone this instance
        /// </summary>
        public override DrawObject Clone()
        {
            DrawRoundRectangle drawRoundRectangle = new DrawRoundRectangle(ISurfaceBox, 0, 0, 1, 0);
            drawRoundRectangle.objectType = DrawClass.Label;
            drawRoundRectangle.drawToolType = DrawToolType.DrawRoundRectangle;
            drawRoundRectangle.ISurfaceBox = this.ISurfaceBox;
            drawRoundRectangle.rectangle = this.rectangle;
            FillDrawObjectFields(drawRoundRectangle);
            return drawRoundRectangle;
        }

        public override DrawObject Clone(ISurfaceBox surfaceBox)
        {
            DrawRoundRectangle drawRoundRectangle = new DrawRoundRectangle(surfaceBox, 0, 0, 1, 0);
            drawRoundRectangle.objectType = DrawClass.Label;
            drawRoundRectangle.drawToolType = DrawToolType.DrawRoundRectangle;
            drawRoundRectangle.ISurfaceBox = surfaceBox;
            drawRoundRectangle.rectangle = this.rectangle;
            drawRoundRectangle.labelRoundedRectStyleModel = this.labelRoundedRectStyleModel;
            FillDrawObjectFields(drawRoundRectangle);
            return drawRoundRectangle;
        }

        /// <summary>
        /// Draw rectangle
        /// </summary>
        /// <param name="g"></param>
        public override void Draw(Graphics g)
        {
            Color color = Color.FromArgb(this.labelRoundedRectStyleModel.lineColor);
            Pen pen = new Pen(color, PenWidth);

            int penWidth = this.labelRoundedRectStyleModel.lineWidth;
            pen.DashStyle = (DashStyle)this.labelRoundedRectStyleModel.lineStyle;
            pen.Width = penWidth;
            Color fillColor = Color.FromArgb(this.labelRoundedRectStyleModel.fillColor);
            SolidBrush fillBrush = new SolidBrush(fillColor);

            Rectangle panel4 = DrawRectangle.GetNormalizedRectangle(Rectangle);

            //计算圆角半径,以短的一边为准
            if (panel4.Width > panel4.Height)
                radius = Convert.ToInt32(Math.Ceiling(panel4.Height * (this.labelRoundedRectStyleModel.roundAngle / 100)));
            else
                radius = Convert.ToInt32(Math.Ceiling(panel4.Width * (this.labelRoundedRectStyleModel.roundAngle / 100)));
            if (radius == 0)
                radius = 1;

            // 要实现 圆角化的 矩形
            Rectangle rect = new Rectangle(panel4.X, panel4.Y, panel4.Width - radius, panel4.Height - radius);

            // 指定图形路径， 有一系列 直线/曲线 组成
            GraphicsPath myPath = new GraphicsPath();
            myPath.StartFigure();
            myPath.AddArc(new Rectangle(new Point(rect.X, rect.Y), new Size(2 * radius, 2 * radius)), 180, 90);
            myPath.AddLine(new Point(rect.X + radius, rect.Y), new Point(rect.Right - radius, rect.Y));
            myPath.AddArc(new Rectangle(new Point(rect.Right - 2 * radius, rect.Y), new Size(2 * radius, 2 * radius)), 270, 90);
            myPath.AddLine(new Point(rect.Right, rect.Y + radius), new Point(rect.Right, rect.Bottom - radius));
            myPath.AddArc(new Rectangle(new Point(rect.Right - 2 * radius, rect.Bottom - 2 * radius), new Size(2 * radius, 2 * radius)), 0, 90);
            myPath.AddLine(new Point(rect.Right - radius, rect.Bottom), new Point(rect.X + radius, rect.Bottom));
            myPath.AddArc(new Rectangle(new Point(rect.X, rect.Bottom - 2 * radius), new Size(2 * radius, 2 * radius)), 90, 90);
            myPath.AddLine(new Point(rect.X, rect.Bottom - radius), new Point(rect.X, rect.Y + radius));
            myPath.CloseFigure();
            g.DrawPath(pen, myPath);
            
            g.FillPath(fillBrush, myPath);


            //g.DrawRectangle(pen, DrawRectangle.GetNormalizedRectangle(Rectangle));
            //pen.Dispose();
        }

        protected void SetRectangle(float x, float y, float width, float height)
        {
            rectangle.X = x;
            rectangle.Y = y;
            rectangle.Width = width;
            rectangle.Height = height;
        }


        /// <summary>
        /// Get number of handles
        /// </summary>
        public override int HandleCount
        {
            get
            {
                return 8;
            }
        }


        /// <summary>
        /// Get handle pointscroll by 1-based number
        /// </summary>
        /// <param name="handleNumber"></param>
        /// <returns></returns>
        public override PointF GetHandle(int handleNumber)
        {
            float x, y, xCenter, yCenter;

            xCenter = rectangle.X + rectangle.Width / 2;
            yCenter = rectangle.Y + rectangle.Height / 2;
            x = rectangle.X;
            y = rectangle.Y;

            switch (handleNumber)
            {
                case 1:
                    x = rectangle.X;
                    y = rectangle.Y;
                    break;
                case 2:
                    x = xCenter;
                    y = rectangle.Y;
                    break;
                case 3:
                    x = rectangle.Right;
                    y = rectangle.Y;
                    break;
                case 4:
                    x = rectangle.Right;
                    y = yCenter;
                    break;
                case 5:
                    x = rectangle.Right;
                    y = rectangle.Bottom;
                    break;
                case 6:
                    x = xCenter;
                    y = rectangle.Bottom;
                    break;
                case 7:
                    x = rectangle.X;
                    y = rectangle.Bottom;
                    break;
                case 8:
                    x = rectangle.X;
                    y = yCenter;
                    break;
            }

            return new PointF(x, y);

        }

        /// <summary>
        /// Hit test.
        /// Return value: -1 - no hit
        ///                0 - hit anywhere
        ///                > 1 - handle number
        /// </summary>
        /// <param name="pointscroll"></param>
        /// <returns></returns>
        public override int HitTest(Point point)
        {
            if (Selected)
            {
                for (int i = 1; i <= HandleCount; i++)
                {
                    if (GetHandleRectangle(i).Contains(point))
                        return i;
                }
            }

            if (PointInObject(point))
                return 0;

            return -1;
        }


        protected override bool PointInObject(Point point)
        {
            return rectangle.Contains(point);
        }



        /// <summary>
        /// Get cursor for the handle
        /// </summary>
        /// <param name="handleNumber"></param>
        /// <returns></returns>
        public override Cursor GetHandleCursor(int handleNumber)
        {
            switch (handleNumber)
            {
                case 1:
                    return Cursors.SizeNWSE;
                case 2:
                    return Cursors.SizeNS;
                case 3:
                    return Cursors.SizeNESW;
                case 4:
                    return Cursors.SizeWE;
                case 5:
                    return Cursors.SizeNWSE;
                case 6:
                    return Cursors.SizeNS;
                case 7:
                    return Cursors.SizeNESW;
                case 8:
                    return Cursors.SizeWE;
                default:
                    return Cursors.Default;
            }
        }

        /// <summary>
        /// Move handle to new pointscroll (resizing)
        /// </summary>
        /// <param name="pointscroll"></param>
        /// <param name="handleNumber"></param>
        public override void MoveHandleTo(Point point, int handleNumber)
        {
            float left = Rectangle.Left;
            float top = Rectangle.Top;
            float right = Rectangle.Right;
            float bottom = Rectangle.Bottom;

            switch (handleNumber)
            {
                case 1:
                    left = point.X;
                    top = point.Y;
                    break;
                case 2:
                    top = point.Y;
                    break;
                case 3:
                    right = point.X;
                    top = point.Y;
                    break;
                case 4:
                    right = point.X;
                    break;
                case 5:
                    right = point.X;
                    bottom = point.Y;
                    break;
                case 6:
                    bottom = point.Y;
                    break;
                case 7:
                    left = point.X;
                    bottom = point.Y;
                    break;
                case 8:
                    left = point.X;
                    break;
            }

            SetRectangle(left, top, right - left, bottom - top);
        }


        public override bool IntersectsWith(Rectangle rectangle)
        {
            return Rectangle.IntersectsWith(rectangle);
        }

        /// <summary>
        /// Move object
        /// </summary>
        /// <param name="deltaX"></param>
        /// <param name="deltaY"></param>
        public override void Move(int deltaX, int deltaY)
        {

            int x = ISurfaceBox.UnscaleScalar(deltaX);
            int y = ISurfaceBox.UnscaleScalar(deltaY);

            rectangle.X += x;
            rectangle.Y += y;
        }

        public override void Dump()
        {
            base.Dump();

            Trace.WriteLine("rectangle.X = " + rectangle.X.ToString(CultureInfo.InvariantCulture));
            Trace.WriteLine("rectangle.Y = " + rectangle.Y.ToString(CultureInfo.InvariantCulture));
            Trace.WriteLine("rectangle.Width = " + rectangle.Width.ToString(CultureInfo.InvariantCulture));
            Trace.WriteLine("rectangle.Height = " + rectangle.Height.ToString(CultureInfo.InvariantCulture));
        }

        /// <summary>
        /// Normalize rectangle
        /// </summary>
        public override void Normalize()
        {
            rectangle = DrawRectangle.GetNormalizedRectangle(rectangle);
        }

        /// <summary>
        /// Save objevt to serialization stream
        /// </summary>
        /// <param name="info"></param>
        /// <param name="orderNumber"></param>
        public override void SaveToStream(System.Runtime.Serialization.SerializationInfo info, int orderNumber)
        {
            info.AddValue(
                String.Format(CultureInfo.InvariantCulture,
                "{0}{1}",
                entryRectangle, orderNumber),
                rectangle);

            base.SaveToStream(info, orderNumber);
        }

        /// <summary>
        /// LOad object from serialization stream
        /// </summary>
        /// <param name="info"></param>
        /// <param name="orderNumber"></param>
        public override void LoadFromStream(SerializationInfo info, int orderNumber)
        {
            rectangle = (Rectangle)info.GetValue(
                String.Format(CultureInfo.InvariantCulture,
                "{0}{1}",
                entryRectangle, orderNumber),
                typeof(Rectangle));

            base.LoadFromStream(info, orderNumber);
        }


        #region Helper Functions

        public static Rectangle GetNormalizedRectangle(int x1, int y1, int x2, int y2)
        {
            if (x2 < x1)
            {
                int tmp = x2;
                x2 = x1;
                x1 = tmp;
            }

            if (y2 < y1)
            {
                int tmp = y2;
                y2 = y1;
                y1 = tmp;
            }

            return new Rectangle(x1, y1, x2 - x1, y2 - y1);
        }

        public static Rectangle GetNormalizedRectangle(Point p1, Point p2)
        {
            return GetNormalizedRectangle(p1.X, p1.Y, p2.X, p2.Y);
        }

        public static Rectangle GetNormalizedRectangle(Rectangle r)
        {
            return GetNormalizedRectangle(r.X, r.Y, r.X + r.Width, r.Y + r.Height);
        }

        #endregion
        public override RectangleF GetBoundingBox()
        {
            return rectangle;
        }

        public override List<PointF> GetPoints()
        {
            List<PointF> points = new List<PointF>();
            points.Add(new PointF(rectangle.X, rectangle.Y));
            points.Add(new PointF(rectangle.Right, rectangle.Bottom));
            return points;
        }

        public override ParentStyleModel GetStyle()
        {
            return labelRoundedRectStyleModel;
        }
    }
}