namespace System.Workflow.Activities
{
    using System;
    using System.Text;
    using System.Reflection;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.CodeDom;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Drawing.Design;
    using System.Drawing;
    using System.Drawing.Drawing2D;
    using System.Diagnostics;
    using System.IO;
    using System.Windows.Forms;
    using System.Workflow.ComponentModel;
    using System.Workflow.ComponentModel.Design;
    using System.Runtime.Serialization;

    #region StateMachineDesignerPaint

    internal static class StateMachineDesignerPaint
    {
        // same as AmbientTheme.FadeBrush
        internal static readonly Brush FadeBrush = new SolidBrush(Color.FromArgb(120, 255, 255, 255));

        internal static Size MeasureString(Graphics graphics, Font font, string text, StringAlignment alignment, Size maxSize)
        {
            // copied from DesignerHelpers.cs
            SizeF textSize = SizeF.Empty;
            if (maxSize.IsEmpty)
            {
                textSize = graphics.MeasureString(text, font);
            }
            else
            {
                StringFormat format = new StringFormat();
                format.Alignment = alignment;
                format.LineAlignment = StringAlignment.Center;
                format.Trimming = StringTrimming.EllipsisCharacter;
                format.FormatFlags = StringFormatFlags.LineLimit;
                textSize = graphics.MeasureString(text, font, new SizeF(maxSize.Width, maxSize.Height), format);
            }

            return new Size(Convert.ToInt32(Math.Ceiling(textSize.Width)), Convert.ToInt32(Math.Ceiling(textSize.Height)));
        }
        /// <summary>
        /// Makes sure that rectangle is completely contained in the bounds rectangle
        /// </summary>
        /// <param name="rectangle"></param>
        /// <param name="bounds"></param>
        /// <returns></returns>
        internal static Rectangle TrimRectangle(Rectangle rectangle, Rectangle bounds)
        {
            int left = rectangle.Left;
            int top = rectangle.Top;
            int width = rectangle.Width;
            int height = rectangle.Height;

            if (left < bounds.Left)
                left = bounds.Left;

            if (top < bounds.Top)
                top = bounds.Top;

            if ((left + width) > bounds.Right)
                width -= rectangle.Right - bounds.Right;

            if ((top + height) > bounds.Bottom)
                height -= rectangle.Bottom - bounds.Bottom;

            return new Rectangle(left, top, width, height);
        }

        private static Point[] OptimizeConnectorPoints(Point[] points)
        {
            Debug.Assert(points.Length >= 2);
            List<Point> optimized = new List<Point>();
            optimized.Add(points[0]);
            Point p1;
            Point p2 = points[0];
            Point p3 = points[1];

            if ((p2.X != p3.X) && (p2.Y != p3.Y))
                optimized.Add(new Point(p3.X, p2.Y));

            for (int i = 2; i < points.Length; i++)
            {
                p1 = p2;
                p2 = p3;
                p3 = points[i];
                if ((p1.X == p2.X) && (p2.X == p3.X) ||
                    (p1.Y == p2.Y) && (p2.Y == p3.Y))
                    continue;

                optimized.Add(p2);
                if ((p2.X != p3.X) && (p2.Y != p3.Y))
                    optimized.Add(new Point(p3.X, p2.Y));
            }

            optimized.Add(points[points.Length - 1]);

            return optimized.ToArray();
        }

        internal static void DrawConnector(Graphics graphics, Pen pen, Point[] points, Size connectorCapSize, Size maxCapSize, LineAnchor startConnectorCap, LineAnchor endConnectorCap)
        {
            if (points.GetLength(0) < 2)
                return;

            points = OptimizeConnectorPoints(points);

            //First we start with drawing start cap
            GraphicsPath startCap = null;
            float startCapInset = 0.0f;
            if (startConnectorCap != LineAnchor.None)
            {
                Point[] startSegment = new Point[] { points[0], points[1] };
                int capSize = (startSegment[0].Y == startSegment[1].Y) ? connectorCapSize.Width : connectorCapSize.Height;
                capSize += (capSize % 2);
                capSize = Math.Min(Math.Min(capSize, maxCapSize.Width), maxCapSize.Height);
                startCap = GetLineCap(startConnectorCap, capSize, out startCapInset);

                //Now if user has requested us to fill the line cap then we do so
                //THIS IS A WORKAROUND IN FILLING THE CUSTOM CAPS AS GDI+ HAS A 
                bool fill = (startCap != null && (((int)startConnectorCap % 2) == 0) && (startSegment[0].X == startSegment[1].X || startSegment[0].Y == startSegment[1].Y));
                if (fill)
                {
                    Matrix oldTransform = graphics.Transform;
                    graphics.TranslateTransform(startSegment[0].X, startSegment[0].Y);
                    if (startSegment[0].Y == startSegment[1].Y)
                        graphics.RotateTransform((startSegment[0].X < startSegment[1].X) ? 90.0f : 270.0f);
                    else
                        graphics.RotateTransform((startSegment[0].Y < startSegment[1].Y) ? 180.0f : 0.0f);
                    using (Brush penBrush = new SolidBrush(pen.Color))
                        graphics.FillPath(penBrush, startCap);
                    graphics.Transform = (oldTransform != null) ? oldTransform : new Matrix();
                }
            }

            GraphicsPath endCap = null;
            float endCapInset = 0.0f;
            if (endConnectorCap != LineAnchor.None)
            {
                Point[] endSegment = new Point[] { points[points.GetLength(0) - 2], points[points.GetLength(0) - 1] };
                int capSize = (endSegment[0].Y == endSegment[1].Y) ? connectorCapSize.Width : connectorCapSize.Height;
                capSize += (capSize % 2);
                capSize = Math.Min(Math.Min(capSize, maxCapSize.Width), maxCapSize.Height);
                endCap = GetLineCap(endConnectorCap, capSize, out endCapInset);

                //Now if user has requested us to fill the line cap then we do so,
                //THIS IS A WORKAROUND IN FILLING THE CUSTOM CAPS AS GDI+ HAS A 
                bool fill = (endCap != null && (((int)endConnectorCap % 2) == 0) && (endSegment[0].X == endSegment[1].X || endSegment[0].Y == endSegment[1].Y));
                if (fill)
                {
                    Matrix oldTransform = graphics.Transform;
                    graphics.TranslateTransform(endSegment[1].X, endSegment[1].Y);
                    if (endSegment[0].Y == endSegment[1].Y)
                        graphics.RotateTransform((endSegment[0].X < endSegment[1].X) ? 270.0f : 90.0f);
                    else
                        graphics.RotateTransform((endSegment[0].Y < endSegment[1].Y) ? 0.0f : 180.0f);
                    using (Brush penBrush = new SolidBrush(pen.Color))
                        graphics.FillPath(penBrush, endCap);
                    graphics.Transform = (oldTransform != null) ? oldTransform : new Matrix();
                }
            }

            if (startCap != null)
            {
                CustomLineCap customStartCap = new CustomLineCap(null, startCap);
                customStartCap.WidthScale = 1.0f / pen.Width;
                customStartCap.BaseInset = startCapInset;
                pen.CustomStartCap = customStartCap;
            }

            if (endCap != null)
            {
                CustomLineCap customEndCap = new CustomLineCap(null, endCap);
                customEndCap.WidthScale = 1.0f / pen.Width;
                customEndCap.BaseInset = endCapInset;
                pen.CustomEndCap = customEndCap;
            }

            using (GraphicsPath path = GetRoundedPath(points, StateDesignerConnector.ConnectorPadding / 2))
            {
                graphics.DrawPath(pen, path);
            }

            if (startCap != null)
            {
                CustomLineCap disposableLineCap = pen.CustomStartCap;
                pen.StartCap = LineCap.Flat;
                disposableLineCap.Dispose();
            }

            if (endCap != null)
            {
                CustomLineCap disposableLineCap = pen.CustomEndCap;
                pen.EndCap = LineCap.Flat;
                disposableLineCap.Dispose();
            }
        }

        private static GraphicsPath GetRoundedPath(Point[] points, int radius)
        {
            Debug.Assert(points.Length >= 2);
            GraphicsPath path = new GraphicsPath();
            if (points.Length == 2)
            {
                path.AddLine(points[0], points[1]);
                return path;
            }

            int diameter = radius * 2;

            Point p1 = points[0];
            Point p2 = points[1];
            Point p3 = points[2];
            int previousConnectorSize;
            int currentConnectorSize = GetDistance(p1, p2);
            int nextConnectorSize = GetDistance(p2, p3);
            ArrowDirection direction1 = GetDirection(p1, p2);
            ArrowDirection direction2 = GetDirection(p2, p3);

            if (currentConnectorSize < diameter || nextConnectorSize < diameter)
            {
                AddSegment(path, radius, p1, p2, false, false, direction1);
            }
            else
            {
                AddSegment(path, radius, p1, p2, false, true, direction1);
                AddRoundedCorner(path, diameter, p2, direction1, direction2);
            }
            int i = 2;
            while (i < (points.Length - 1))
            {
                previousConnectorSize = currentConnectorSize;
                currentConnectorSize = nextConnectorSize;
                direction1 = direction2;
                p1 = p2;
                p2 = p3;
                p3 = points[i + 1];
                direction2 = GetDirection(p2, p3);
                nextConnectorSize = GetDistance(p2, p3);
                if (currentConnectorSize >= diameter && nextConnectorSize >= diameter)
                {
                    AddSegment(path, radius, p1, p2, (previousConnectorSize >= diameter), true, direction1);
                    AddRoundedCorner(path, diameter, p2, direction1, direction2);
                }
                else
                {
                    AddSegment(path, radius, p1, p2, (previousConnectorSize >= diameter), false, direction1);
                }

                i++;
            }

            AddSegment(path, radius, p2, p3,
                (currentConnectorSize >= diameter && nextConnectorSize >= diameter),
                false, direction2);

            return path;
        }

        private static int GetDistance(Point p1, Point p2)
        {
            if (p1.X == p2.X)
                return Math.Abs(p1.Y - p2.Y);
            else
                return Math.Abs(p1.X - p2.X);
        }

        private static void AddSegment(GraphicsPath path, int radius, Point p1, Point p2, bool roundP1, bool roundP2, ArrowDirection direction)
        {
            if (roundP1)
            {
                switch (direction)
                {
                    case ArrowDirection.Down:
                        p1.Y += radius;
                        break;
                    case ArrowDirection.Up:
                        p1.Y -= radius;
                        break;
                    case ArrowDirection.Left:
                        p1.X -= radius;
                        break;
                    default:
                        p1.X += radius;
                        break;
                }
            }
            if (roundP2)
            {
                switch (direction)
                {
                    case ArrowDirection.Down:
                        p2.Y -= radius;
                        break;
                    case ArrowDirection.Up:
                        p2.Y += radius;
                        break;
                    case ArrowDirection.Left:
                        p2.X += radius;
                        break;
                    default:
                        p2.X -= radius;
                        break;
                }
            }
            path.AddLine(p1, p2);
        }

        private static void AddRoundedCorner(GraphicsPath path, int diameter, Point midPoint, ArrowDirection direction1, ArrowDirection direction2)
        {
            switch (direction1)
            {
                case ArrowDirection.Left:
                    if (direction2 == ArrowDirection.Down)
                        path.AddArc(midPoint.X, midPoint.Y, diameter, diameter, 270f, -90f);
                    else
                        path.AddArc(midPoint.X, midPoint.Y - diameter, diameter, diameter, 90f, 90f);
                    break;
                case ArrowDirection.Right:
                    if (direction2 == ArrowDirection.Down)
                        path.AddArc(midPoint.X - diameter, midPoint.Y, diameter, diameter, 270f, 90f);
                    else
                        path.AddArc(midPoint.X - diameter, midPoint.Y - diameter, diameter, diameter, 90f, -90f);
                    break;
                case ArrowDirection.Up:
                    if (direction2 == ArrowDirection.Left)
                        path.AddArc(midPoint.X - diameter, midPoint.Y, diameter, diameter, 0f, -90f);
                    else
                        path.AddArc(midPoint.X, midPoint.Y, diameter, diameter, 180f, 90f);
                    break;
                default:
                    if (direction2 == ArrowDirection.Left)
                        path.AddArc(midPoint.X - diameter, midPoint.Y - diameter, diameter, diameter, 0f, 90f);
                    else
                        path.AddArc(midPoint.X, midPoint.Y - diameter, diameter, diameter, 180f, -90f);
                    break;
            }
        }

        private static ArrowDirection GetDirection(Point start, Point end)
        {
            // we only support vertical or horizotal lines. No diagonals
            Debug.Assert(start.X == end.X || start.Y == end.Y);

            if (start.X == end.X)
                // vertical
                if (start.Y < end.Y)
                    // top to bottom
                    return ArrowDirection.Down;
                else
                    // Bottom to Top
                    return ArrowDirection.Up;
            else
                // horizontal
                if (start.X < end.X)
                    // left to right
                    return ArrowDirection.Right;
                else
                    // right to left
                    return ArrowDirection.Left;
        }



        //

        internal static GraphicsPath GetLineCap(LineAnchor lineCap, int capsize, out float capinset)
        {
            //WE DO NOT SUPPORT ARROWCAPS FOR ANGULAR CONNECTORS FOR NOW
            capinset = 0.0f;
            capinset = (float)capsize / 2;
            Size capSize = new Size(capsize, capsize);

            GraphicsPath lineCapPath = new GraphicsPath();
            switch (lineCap)
            {
                case LineAnchor.Arrow:
                case LineAnchor.ArrowAnchor:
                    int arcRadius = capSize.Height / 3;
                    lineCapPath.AddLine(capSize.Width / 2, -capSize.Height, 0, 0);
                    lineCapPath.AddLine(0, 0, -capSize.Width / 2, -capSize.Height);
                    lineCapPath.AddLine(-capSize.Width / 2, -capSize.Height, 0, -capSize.Height + arcRadius);
                    lineCapPath.AddLine(0, -capSize.Height + arcRadius, capSize.Width / 2, -capSize.Height);
                    capinset = capSize.Height - arcRadius;
                    break;

                case LineAnchor.Diamond:
                case LineAnchor.DiamondAnchor:
                    lineCapPath.AddLine(0, -capSize.Height, capSize.Width / 2, -capSize.Height / 2);
                    lineCapPath.AddLine(capSize.Width / 2, -capSize.Height / 2, 0, 0);
                    lineCapPath.AddLine(0, 0, -capSize.Width / 2, -capSize.Height / 2);
                    lineCapPath.AddLine(-capSize.Width / 2, -capSize.Height / 2, 0, -capSize.Height);
                    break;

                case LineAnchor.Round:
                case LineAnchor.RoundAnchor:
                    lineCapPath.AddEllipse(new Rectangle(-capSize.Width / 2, -capSize.Height, capSize.Width, capSize.Height));
                    break;

                case LineAnchor.Rectangle:
                case LineAnchor.RectangleAnchor:
                    lineCapPath.AddRectangle(new Rectangle(-capSize.Width / 2, -capSize.Height, capSize.Width, capSize.Height));
                    break;

                case LineAnchor.RoundedRectangle:
                case LineAnchor.RoundedRectangleAnchor:
                    arcRadius = capSize.Height / 4;
                    lineCapPath.AddPath(ActivityDesignerPaint.GetRoundedRectanglePath(new Rectangle(-capSize.Width / 2, -capSize.Height, capSize.Width, capSize.Height), arcRadius), true);
                    break;
            }

            lineCapPath.CloseFigure();
            return lineCapPath;
        }

        internal static GraphicsPath GetDesignerPath(ActivityDesigner designer, Rectangle bounds, ActivityDesignerTheme designerTheme)
        {
            GraphicsPath designerPath = new GraphicsPath();

            if (designer == GetSafeRootDesigner(designer.Activity.Site) && ((IWorkflowRootDesigner)designer).InvokingDesigner == null)
            {
                designerPath.AddRectangle(bounds);
            }
            else
            {
                // Work around: This should come from AmbientTheme.ArcDiameter
                // but it is internal
                int arcDiameter = 8;
                if (designerTheme != null && designerTheme.DesignerGeometry == DesignerGeometry.RoundedRectangle)
                    designerPath.AddPath(ActivityDesignerPaint.GetRoundedRectanglePath(bounds, arcDiameter), true);
                else
                    designerPath.AddRectangle(bounds);
            }

            return designerPath;
        }

        internal static ActivityDesigner GetSafeRootDesigner(IServiceProvider serviceProvider)
        {
            return (serviceProvider != null) ? ActivityDesigner.GetRootDesigner(serviceProvider) : null;
        }
    }
    #endregion
}