MARKUS

using System;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using System.ComponentModel;

using System.Collections.Generic;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Common;

using MarkupToPDF.Serialize.S_Control;

using MarkupToPDF.Serialize.Core;

using System.Linq;

namespace MarkupToPDF.Controls.Line

{

    public class ArrowControl_Multi : CommentUserInfo, IDisposable, INotifyPropertyChanged, IDashControl

    {

        public event PropertyChangedEventHandler PropertyChanged;

        private const string PART_ArrowMultiPath = "PART_ArrowMultiPath";

        public Path Base_ArrowMultiPath = null;

        static ArrowControl_Multi()

        {

            DefaultStyleKeyProperty.OverrideMetadata(typeof(ArrowControl_Multi), new FrameworkPropertyMetadata(typeof(ArrowControl_Multi)));

            //Application.Current.Resources.MergedDictionaries.Add(Application.LoadComponent(new Uri("/MarkupToPDF;Component/Themes/generic.xaml")) as ResourceDictionary);

            //ResourceDictionary dictionary = new ResourceDictionary();

            //dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);

            //Application.Current.Resources.MergedDictionaries.Add(dictionary);

            //System.Diagnostics.Debug.WriteLine("resource Count :" + Application.Current.Resources.MergedDictionaries.Count);

        }

        public ArrowControl_Multi()

        {

            //this.DefaultStyleKey = typeof(ArrowControl_Multi);

        }

        public override void Copy(CommentUserInfo lhs)

        {

            if (lhs is ArrowControl_Multi item)

            {

                this.LineSize = item.LineSize;

                this.StartPoint = new Point(item.StartPoint.X, item.StartPoint.Y);

                this.MiddlePoint = new Point(item.MiddlePoint.X, item.MiddlePoint.Y);

                this.DashSize = item.DashSize;

                this.EndPoint = new Point(item.EndPoint.X, item.EndPoint.Y);

                this.PointSet = item.PointSet.ConvertAll(x => new Point(x.X, x.Y));

                this.Opacity = item.Opacity;

                this.StrokeColor = item.StrokeColor;

                this.UserID = item.UserID;

                this.Memo = item.Memo;

            }

        }

        public override CommentUserInfo Clone()

        {

            var clone = new ArrowControl_Multi();

            clone.Copy(this);

            return clone;

        }

        #region Dependency Properties

        public static readonly DependencyProperty IsSelectedProperty =

DependencyProperty.Register("IsSelected", typeof(bool), typeof(ArrowControl_Multi), new FrameworkPropertyMetadata(false, IsSelectedChanged));

        public static readonly DependencyProperty ControlTypeProperty =

    DependencyProperty.Register("ControlType", typeof(ControlType), typeof(ArrowControl_Multi), new FrameworkPropertyMetadata(ControlType.ArrowMultiLine));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

                "OverViewPathData", typeof(Geometry), typeof(ArrowControl_Multi), new PropertyMetadata(null));

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

                "UserID", typeof(string), typeof(ArrowControl_Multi), new PropertyMetadata(null));

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

              "LineSize", typeof(double), typeof(ArrowControl_Multi), new PropertyMetadata((Double)3, PointValueChanged));

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

               "DashSize", typeof(DoubleCollection), typeof(ArrowControl_Multi), new PropertyMetadata(new DoubleCollection { 99999099 }, PointValueChanged));

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

              "StrokeColor", typeof(SolidColorBrush), typeof(ArrowControl_Multi), new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

              "PathData", typeof(Geometry), typeof(ArrowControl_Multi), null);

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

               "StartPoint", typeof(Point), typeof(ArrowControl_Multi), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

               "EndPoint", typeof(Point), typeof(ArrowControl_Multi), new PropertyMetadata(new Point(100, 100), PointValueChanged));

        public static readonly DependencyProperty MiddlePointProperty = DependencyProperty.Register(

                "MiddlePoint", typeof(Point), typeof(ArrowControl_Multi), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

               "PointSet", typeof(List<Point>), typeof(ArrowControl_Multi), new PropertyMetadata(new List<Point>(), PointValueChanged));

        #endregion

        #region PropertyChanged Method

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (ArrowControl_Multi)sender;

            //if (e.OldValue != e.NewValue && instance.Base_ArrowMultiPath != null)

            //{

            //    instance.SetValue(e.Property, e.NewValue);

            //    if (instance.IsSelected)

            //    {

            //        instance.Base_ArrowMultiPath.Stroke = new SolidColorBrush(Colors.Blue);

            //    }

            //    else

            //    {

            //        instance.Base_ArrowMultiPath.Stroke = new SolidColorBrush(Colors.Red);

            //    }

            //}

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowControl_Multi)sender;

            if (e.OldValue != e.NewValue && instance.Base_ArrowMultiPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetArrowMultiPath();

            }

        }

        #endregion

        #region Properties

        public string UserID

        {

            get { return (string)GetValue(UserIDProperty); }

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public Double LineSize

        {

            get { return (Double)GetValue(LineSizeProperty); }

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                }

            }

        }

        public Geometry OverViewPathData

        {

            get

            {

                return (Geometry)GetValue(OverViewPathDataProperty);

            }

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

            }

        }

        public override ControlType ControlType

        {

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

            set

            {

                SetValue(ControlTypeProperty, value);

            }

        }

        public DoubleCollection DashSize

        {

            get { return (DoubleCollection)GetValue(DashSizeProperty); }

            set

            {

                if (this.DashSize != value)

                {

                    SetValue(DashSizeProperty, value);

                }

            }

        }

        public List<Point> PointSet

        {

            get { return (List<Point>)GetValue(PointSetProperty); }

            set { SetValue(PointSetProperty, value); }

        }

        public override SolidColorBrush StrokeColor

        {

            get { return (SolidColorBrush)GetValue(StrokeColorProperty); }

            set

            {

                if (this.StrokeColor != value)

                {

                    SetValue(StrokeColorProperty, value);

                }

            }

        }

        public Geometry PathData

        {

            get { return (Geometry)GetValue(PathDataProperty); }

            set { SetValue(PathDataProperty, value); }

        }

        public Point EndPoint

        {

            get { return (Point)GetValue(EndPointProperty); }

            set { SetValue(EndPointProperty, value); }

        }

        public Point StartPoint

        {

            get { return (Point)GetValue(StartPointProperty); }

            set { SetValue(StartPointProperty, value); }

        }

        public Point MiddlePoint

        {

            get { return (Point)GetValue(MiddlePointProperty); }

            set

            {

                SetValue(MiddlePointProperty, value);

                OnPropertyChanged("MiddlePoint");

            }

        }

        #endregion

        #region Object & Variable

        GeometryGroup instanceGroup = new GeometryGroup();

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_ArrowMultiPath = GetTemplateChild(PART_ArrowMultiPath) as Path;

            SetArrowMultiPath();

        }

        public override void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

        public void SetArrowMultiPath()

        {

            Base_ArrowMultiPath.StrokeDashArray.Clear();

            foreach (var item in this.DashSize)

            {

                Base_ArrowMultiPath.StrokeDashArray.Add(item);

            }

            Base_ArrowMultiPath.StrokeDashCap = PenLineCap.Square;

            instanceGroup.Children.Clear();

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = this.StartPoint;

            LineSegment lineSegment0 = new LineSegment();

            lineSegment0.Point = this.StartPoint;

            pathFigure.Segments.Add(lineSegment0);

            //if (this.EndPoint == this.MiddlePoint)

            if (this.MiddlePoint == new Point(0,0))

            {

                //instanceGroup.Children.Add(SingleAllow(this.StartPoint, this.MiddlePoint, this.LineSize));

                instanceGroup.Children.Add(DrawSet.DrawArrow(this.StartPoint, this.EndPoint, this.LineSize));

            }

            else

            {

                instanceGroup.Children.Add(DrawSet.DrawArrow(this.MiddlePoint, this.EndPoint, this.LineSize));

                LineSegment lineSegment1 = new LineSegment();

                lineSegment1.Point = this.MiddlePoint;

                pathFigure.Segments.Add(lineSegment1);

            }

            LineSegment lineSegment2 = new LineSegment();

            lineSegment2.Point = this.EndPoint;

            pathFigure.Segments.Add(lineSegment2);

            PathGeometry pathGeometry = new PathGeometry();

            pathGeometry.Figures.Add(pathFigure);

            pathFigure.IsFilled = false;

            instanceGroup.Children.Add(pathGeometry);

            //this.Base_ArrowMultiPath.Stroke = this.StrokeColor;

            //if (this.IsSelected)

            //{

            //    Base_ArrowMultiPath.Stroke = new SolidColorBrush(Colors.Blue);

            //}

            //else

            //{

            //    Base_ArrowMultiPath.Stroke = new SolidColorBrush(Colors.Red);

            //}

            this.PathData = instanceGroup;

            OverViewPathData = PathData;

        }

        //public static PathGeometry SingleAllow(Point p2, Point p1, double lineSize)

        //{

        //    double theta = Math.Atan2((p2.Y - p1.Y), (p2.X - p1.X)) * 180 / Math.PI;

        //    PathGeometry pathGeometry = new PathGeometry();

        //    PathFigure pathFigure = new PathFigure();

        //    pathFigure.StartPoint = p1;

        //    Point lpoint = new Point(p1.X + lineSize * 3, p1.Y + lineSize * 6);

        //    Point rpoint = new Point(p1.X - lineSize * 3, p1.Y + lineSize * 6);

        //    //Point lpoint = new Point(p1.X + lineSize, p1.Y + lineSize * 4);

        //    //Point rpoint = new Point(p1.X - lineSize, p1.Y + lineSize * 4);

        //    //Point lpoint = new Point(p1.X + lineSize * 3, p1.Y + lineSize * 6);

        //    //Point rpoint = new Point(p1.X - lineSize * 3, p1.Y + lineSize * 6);

        //    LineSegment seg1 = new LineSegment();

        //    seg1.Point = lpoint;

        //    pathFigure.Segments.Add(seg1);

        //    LineSegment seg2 = new LineSegment();

        //    seg2.Point = rpoint;

        //    pathFigure.Segments.Add(seg2);

        //    LineSegment seg3 = new LineSegment();

        //    seg3.Point = p1;

        //    pathFigure.Segments.Add(seg3);

        //    pathFigure.IsClosed = true;

        //    pathFigure.IsFilled = true;

        //    pathGeometry.Figures.Add(pathFigure);

        //    pathGeometry.FillRule = FillRule.Nonzero;

        //    RotateTransform transform = new RotateTransform();

        //    transform.Angle = theta - 90;

        //    transform.CenterX = p1.X;

        //    transform.CenterY = p1.Y;

        //    pathGeometry.Transform = transform;

        //    return pathGeometry;

        //}

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        public override void UpdateControl()

        {

            this.StartPoint = new Point(this.PointSet[0].X, this.PointSet[0].Y);

            this.MiddlePoint = new Point(this.PointSet[1].X, this.PointSet[1].Y);

            this.EndPoint = new Point(this.PointSet[2].X, this.PointSet[2].Y);

        }

        /// <summary>

        /// call when mouse is moving while drawing control

        /// </summary>

        /// <author>humkyung</author>

        /// <param name="pt"></param>

        /// <param name="bAxisLocked"></param>

        public override void OnCreatingMouseMove(Point pt, bool bAxisLocked)

        {

            this.EndPoint = pt;

            if (this.MiddlePoint == new Point(0, 0))

            {

                Point tmp = this.EndPoint;

                CommentAngle = MathSet.returnAngle(this.StartPoint, ref tmp, bAxisLocked);

                if (bAxisLocked)

                {

                    this.EndPoint = tmp;

                }

            }

            else

            {

                Point tmp = this.EndPoint;

                CommentAngle = MathSet.returnAngle(this.MiddlePoint, ref tmp, bAxisLocked);

                if (bAxisLocked)

                {

                    this.EndPoint = tmp;

                }

            }

            this.PointSet = new List<Point>

            {

                this.StartPoint,

                this.MiddlePoint,

                this.EndPoint,

            };

        }

        /// <summary>

        /// move control point has same location of given pt along given delta

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.06.20</date>

        /// <param name="pt"></param>

        /// <param name="dx"></param>

        /// <param name="dy"></param>

        public override void OnMoveCtrlPoint(Point pt, double dx, double dy, bool bAxisLocked = false)

        {

            Point selected = MathSet.getNearPoint((this as IPath).PointSet, pt);

            var tmpPointSet = (this as IPath).PointSet.Where(x => !x.Equals(selected));

            Point NearStartpoint = MathSet.getNearPoint(tmpPointSet.ToList(), pt);

            selected.X += dx;

            selected.Y += dy;

            Point tmp = selected;

            CommentAngle = MathSet.returnAngle(NearStartpoint, ref tmp, bAxisLocked);

            if (bAxisLocked)

            {

                selected = tmp;

            }

            for (int i = 0; i < (this as IPath).PointSet.Count; i++)

            {

                if (pt.Equals((this as IPath).PointSet[i]))

                {

                    (this as IPath).PointSet[i] = selected;

                }

            }

            this.UpdateControl();

        }

        /// <summary>

        /// return ArrowControl_Multi's area

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.06.13</date>

        public override Rect ItemRect

        {

            get

            {

                double dMinX = Math.Min(this.StartPoint.X, this.EndPoint.X);

                dMinX = Math.Min(this.MiddlePoint.X, dMinX);

                double dMinY = Math.Min(this.StartPoint.Y, this.EndPoint.Y);

                dMinY = Math.Min(this.MiddlePoint.Y, dMinY);

                double dMaxX = Math.Max(this.StartPoint.X, this.EndPoint.X);

                dMaxX = Math.Max(this.MiddlePoint.X, dMaxX);

                double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.Y);

                dMaxY = Math.Max(this.MiddlePoint.Y, dMaxY);

                return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));

            }

        }

        /// <summary>

        /// Serialize this

        /// </summary>

        /// <param name="sUserId"></param>

        /// <returns></returns>

        public override string Serialize()

        {

            using (S_ArrowControl_Multi STemp = new S_ArrowControl_Multi())

            {

                STemp.TransformPoint = "0|0";

                STemp.PointSet = this.PointSet;

                STemp.SizeSet = String.Format("{0}", this.LineSize);

                STemp.StrokeColor = this.StrokeColor.Color.ToString();

                STemp.StartPoint = this.StartPoint;

                STemp.EndPoint = this.EndPoint;

                STemp.UserID = this.UserID;

                STemp.Opac = this.Opacity;

                STemp.DashSize = this.DashSize;

                STemp.MidPoint = this.MiddlePoint;

                STemp.Name = this.GetType().Name.ToString();

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                STemp.Memo = this.Memo;

                return "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));

            };

        }

        /// <summary>

        /// create a arrowcontrol_multi from given string

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        public static ArrowControl_Multi FromString(string str, SolidColorBrush brush, string sProjectNo)

        {

            ArrowControl_Multi instance = null;

            using (S_ArrowControl_Multi s = JsonSerializerHelper.JsonDeserialize<S_ArrowControl_Multi>(str))

            {

                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);

                instance = new ArrowControl_Multi

                {

                    LineSize = Convert.ToDouble(data2.First()),

                    StartPoint = s.StartPoint,

                    MiddlePoint = s.MidPoint,

                    DashSize = s.DashSize,

                    EndPoint = s.EndPoint,

                    PointSet = s.PointSet,

                    Opacity = s.Opac,

                    StrokeColor = brush,

                    UserID = s.UserID,

                    Memo = s.Memo

                };

            }

            return instance;

        }

        public void Dispose()

        {

            //GC.Collect();

            ////GC.SuppressFinalize(this);

            this.Base_ArrowMultiPath = null;

        }

    }

}