MARKUS

using iTextSharp.text;

using MarkupToPDF.Common;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Serialize.Core;

using MarkupToPDF.Serialize.S_Control;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Forms;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Shapes;

namespace MarkupToPDF.Controls.Polygon

{

     public class PolygonControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IShapeControl, IMarkupControlData

    {

        #region Constructure

        static PolygonControl()

        {

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

            //ResourceDictionary dictionary = new ResourceDictionary();

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

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

        }

        public PolygonControl()

        {

            //this.DefaultStyleKey = typeof(PolygonControl);

        }

        public override void Copy(CommentUserInfo lhs)

        {

            if(lhs is PolygonControl item)

            {

                this.LineSize = item.LineSize;

                this.IsCompleted = item.IsCompleted;

                this.Opacity = item.Opacity;

                this.StrokeColor = item.StrokeColor;

                this.ControlType = item.ControlType;

                this.DashSize = item.DashSize;

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

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

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

                this.UserID = item.UserID;

                this.Paint = item.Paint;

                this.Memo = item.Memo;

                this.ZIndex = item.ZIndex;

            }

        }

        public override CommentUserInfo Clone()

        {

            var clone = new PolygonControl();

            clone.Copy(this);

            return clone; 

        }

        #endregion

        #region Variable

        private const string PART_PolyPath = "PART_PolyPath";

        public Path Base_PolyPath = null;

        #endregion

        #region Internal Method

        public override void OnApplyTemplate()

        {   

            base.OnApplyTemplate();

            Base_PolyPath = GetTemplateChild(PART_PolyPath) as Path;

            if (Base_PolyPath == null)

                return;

            this.SetPolyPath();

        }

        #endregion

        #region Method

        public override void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

        #endregion

        #region Dependency Properties

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

               "StrokeColor", typeof(SolidColorBrush), typeof(PolygonControl), 

               new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

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

        //강인구 추가

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

                "DashSize", typeof(DoubleCollection), typeof(PolygonControl), new PropertyMetadata(new DoubleCollection { 99999999  }, PointValueChanged));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

                "OverViewPathData", typeof(Geometry), typeof(PolygonControl), null);

        //강인구 추가

        public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(

        "Paint", typeof(PaintSet), typeof(PolygonControl), new PropertyMetadata(PaintSet.None, PointValueChanged));

        public static readonly DependencyProperty IsCompletedProperty = DependencyProperty.Register(

               "IsCompleted", typeof(bool), typeof(PolygonControl), null);

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

        /// <summary>

        /// StylusPointSet을 List<Point>로 대체하면 PointValueChanged가 작동안한다.

        /// </summary>

        //public static readonly DependencyProperty StylusPointSetProperty = DependencyProperty.Register(

        //        "PointC", typeof(StylusPointSet), typeof(PolygonControl), new PropertyMetadata(new StylusPointSet(), PointValueChanged));

        public static readonly DependencyProperty AngleProperty =

            DependencyProperty.Register("Angle", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback

                (AngleValueChanged)));

        public static readonly DependencyProperty CenterXProperty =

            DependencyProperty.Register("CenterX", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CenterYProperty =

            DependencyProperty.Register("CenterY", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty IsSelectedProperty =

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

        public static readonly DependencyProperty ControlTypeProperty =

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

        public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(

                "CanvasX", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0, OnSetCansvasChanged));

        public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(

                "CanvasY", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0, OnSetCansvasChanged));

        #endregion

        #region PropertyChanged Method

        public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (PolygonControl)sender;

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

            {

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

                //Canvas.SetLeft(instance, instance.CanvasX);

                //Canvas.SetTop(instance, instance.CanvasY);

            }

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (PolygonControl)sender;

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

            {

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

                //강인구 추가

                instance.SetPolyPath();

                //instance.SetPolyPath(); 주석처리

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (PolygonControl)sender;

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

            {

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

                instance.SetPolyPath();

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (PolygonControl)sender;

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

            {

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

                instance.SetPolyPath();

            }

        }

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (PolygonControl)sender;

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

            //{

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

            //    if (instance.IsSelected)

            //    {

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

            //    }

            //    else

            //    {

            //        instance.Base_PolyPath.Stroke = new SolidColorBrush(Colors.Transparent);

            //    }

            //}

        }

        #endregion

        #region Properties

        public bool IsCompleted

        {

            get { return (bool)GetValue(IsCompletedProperty); }

            set

            {

                SetValue(IsCompletedProperty, value);

                OnPropertyChanged("IsCompleted");

            }

        }

        public Geometry OverViewPathData

        {

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

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public double CanvasX

        {

            get { return (double)GetValue(CanvasXProperty); }

            set

            {

                if (this.CanvasX != value)

                {

                    SetValue(CanvasXProperty, value);

                    OnPropertyChanged("CanvasX");

                }

            }

        }

        public double CanvasY

        {

            get { return (double)GetValue(CanvasYProperty); }

            set

            {

                if (this.CanvasY != value)

                {

                    SetValue(CanvasYProperty, value);

                    OnPropertyChanged("CanvasY");

                }

            }

        } 

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

                OnPropertyChanged("IsSelected");

            }

        }

        public PaintSet Paint

        {

            get { return (PaintSet)GetValue(PaintProperty); }

            set

            {

                if (this.Paint != value)

                {

                    SetValue(PaintProperty, value);

                    OnPropertyChanged("Paint");

                }

            }

        }

        public override ControlType ControlType

        {

            set

            {

                SetValue(ControlTypeProperty, value);

                OnPropertyChanged("ControlType");

            }

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

        }

        public Double LineSize

        {

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

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                    OnPropertyChanged("LineSize");

                }

            }

        }

        public DoubleCollection DashSize

        {

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

            set

            {

                if (this.DashSize != value)

                {

                    SetValue(DashSizeProperty, value);

                    OnPropertyChanged("DashSize");

                }

            }

        }

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public List<Point> PointSet

        {

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

            set { SetValue(PointSetProperty, value);

            OnPropertyChanged("PointSet");

            }

        }        //public StylusPointSet PointC

        //{

        //    get { return (StylusPointSet)GetValue(StylusPointSetProperty); }

        //    set

        //    {

        //        SetValue(StylusPointSetProperty, value);

        //        OnPropertyChanged("PointC");

        //    }

        //}

        public double CenterX

        {

            get { return (double)GetValue(CenterXProperty); }

            set { SetValue(CenterXProperty, value);

            OnPropertyChanged("CenterX");

            }

        }

        public double CenterY

        {

            get

            {

                return (double)GetValue(CenterYProperty);

            }

            set

            {

                SetValue(CenterYProperty, value);

                OnPropertyChanged("CenterY");

            }

        }

        public override SolidColorBrush StrokeColor

        {

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

            set

            {

                if (this.StrokeColor != value)

                {

                    SetValue(StrokeColorProperty, value);

                    OnPropertyChanged("StrokeColor");

                }

            }

        }

        public Geometry PathData

        {

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

            set

            {

                SetValue(PathDataProperty, value);

                OnPropertyChanged("PathData");

            }

        }

        //public double Angle

        //{

        //    get { return (double)GetValue(AngleProperty); }

        //    set

        //    {

        //        if (this.Angle != value)

        //        {

        //            SetValue(AngleProperty, value);

        //            OnPropertyChanged("Angle");

        //        }

        //    }

        //}

        public Point EndPoint

        {

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

            set

            {

                SetValue(EndPointProperty, value);

                OnPropertyChanged("EndPoint");

            }

        }

        public Point StartPoint

        {

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

            set

            {

                SetValue(StartPointProperty, value);

                OnPropertyChanged("StartPoint");

            }

        }

        #endregion

        public override void UpdateControl()

        {

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

            this.EndPoint = new Point(this.PointSet[this.PointSet.Count - 1].X, this.PointSet[this.PointSet.Count - 1].Y);

            SetPolyPath();

        }

        private void SetPolyPath()

        {

            if (Base_PolyPath != null)

            {

                Base_PolyPath.StrokeDashArray.Clear();

                foreach (var item in this.DashSize)

                {

                    Base_PolyPath.StrokeDashArray.Add(item);

                }

                PathGeometry pathGeometry = new PathGeometry();

                PathFigure pathFigure = new PathFigure();

                PolyLineSegment instance = new PolyLineSegment(this.PointSet, true);

                StartPoint = instance.Points.First();

                pathFigure.StartPoint = StartPoint;

                EndPoint = instance.Points.Last();

                pathFigure.Segments.Add(instance);

                pathGeometry.Figures.Add(pathFigure);

                //강인구 추가(Chain이 아닌 Polygon일때만 채우기 및 빗금 하기)

                if (ControlType == ControlType.PolygonControl)

                {

                    switch (this.Paint)

                    {

                        case PaintSet.None:

                            {

                                pathFigure.IsFilled = false;

                                //강인구 추가

                                Base_PolyPath.Fill = null;

                            }

                            break;

                        case PaintSet.Fill:

                            {

                                Base_PolyPath.Fill = this.StrokeColor;

                            }

                            break;

                        case PaintSet.Hatch:

                            {

                                var size = this.LineSize > 5 ? 5 : this.LineSize;

                                Base_PolyPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor, 3 * 0.1);

                            }

                            break;

                        default:

                            break;

                    }

                }

                this.PathData = pathGeometry;

                this.ApplyOverViewData();

            }

        }

        public void ChangePaint(PaintSet state)

        {

        }

        /// <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.PointSet.RemoveAt(this.PointSet.Count - 1);

            Point tmp = pt;

            if (bAxisLocked)

            {

                CommentAngle = MathSet.returnAngle(this.PointSet[this.PointSet.Count - 1], ref tmp, bAxisLocked);

            }

            if (this.PointSet.Count > 2 && StartPoint == tmp)

            {

                this.IsCompleted = true;

                //var firstPoint = this.PointSet.First();

                //this.PointSet.Add(firstPoint);

                //this.ApplyOverViewData();

                UpdateControl();

            }

            else

            {

                this.PointSet.Add(tmp);

                this.UpdateControl();

            }

        }

        /// <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)

        {

            var pointSet = (this as IPath).PointSet;

            Point selected = MathSet.getNearPoint(pointSet, pt);

            Point NearStartpoint = MathSet.getNearPoint(pointSet, pt);

            var tmpPointSet = pointSet.Select((x,inx)=> new { x,inx});

            var selectPoint = tmpPointSet.Where(x => x.x.Equals(pt));

            if(selectPoint.Count() > 0)

            {

                if (tmpPointSet.Count() > selectPoint.First().inx + 1)

                {

                    NearStartpoint = pointSet[selectPoint.First().inx + 1];

                }

                else

                {

                    NearStartpoint = pointSet[selectPoint.First().inx - 1];

                }

            }

            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 Polygon's area

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.06.13</date>

        public override Rect ItemRect

        {

            get

            {

                double dMinX = double.MaxValue;

                double dMinY = double.MaxValue;

                double dMaxX = double.MinValue;

                double dMaxY = double.MinValue;

                foreach (Point pt in this.PointSet)

                {

                    dMinX = Math.Min(dMinX, pt.X);

                    dMinY = Math.Min(dMinY, pt.Y);

                    dMaxX = Math.Max(dMaxX, pt.X);

                    dMaxY = Math.Max(dMaxY, pt.Y);

                }

                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_PolyControl ctrl = new S_PolyControl())

            {

                ctrl.TransformPoint = "0|0";

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

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

                //ctrl.StrokeColor = "#FF000FFF";

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

                //ctrl.Toler = this.Toler;

                ctrl.PaintState = this.Paint;

                ctrl.Opac = this.Opacity;

                ctrl.UserID = this.UserID;

                ctrl.PaintState = this.Paint;

                //강인구 추가(Chain인지 Polygon인지 구분)

                ctrl.Type = this.ControlType;

                //ctrl.IsTrans = this.isTransOn;

                //ctrl.IsChain = this.isChain;

                ctrl.PointSet = new List<Point>();

                ctrl.DashSize = this.DashSize;

                ctrl.StartPoint = this.StartPoint;

                ctrl.EndPoint = this.EndPoint;

                ctrl.IsCompleted = this.IsCompleted;

                foreach (var point in this.PointSet)

                {

                    ctrl.PointSet.Add(point);

                }

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                ctrl.Memo = this.Memo;

                ctrl.ZIndex = this.ZIndex;

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

            }

        }

        /// <summary>

        /// create a polygoncontrol from given string

        /// </summary>

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

        /// <returns></returns>

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

        {

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

            {

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

                return new PolygonControl

                {

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

                    //Toler = s.Toler,

                    IsCompleted = s.IsCompleted,

                    //PointSet = new List<Point>(),

                    Opacity = s.Opac,

                    StrokeColor = brush,

                    //강인구 추가(Chain인지 Polygon인지 구분)

                    ControlType = s.Type,

                    DashSize = s.DashSize,

                    StartPoint = s.StartPoint,

                    EndPoint = s.EndPoint,

                    PointSet = s.PointSet,

                    UserID = s.UserID,

                    Paint = s.PaintState,

                    Memo = s.Memo,

                    ZIndex = s.ZIndex

                };

            }

        }

        #region Dispose

        public void Dispose()

        {

            //GC.Collect();

            ////GC.SuppressFinalize(this);

            this.Base_PolyPath = null;

        }

        #endregion

        #region INotifyPropertyChanged

        private void OnPropertyChanged(string name)

        {

            if (PropertyChanged != null)

            {

                PropertyChanged(this, new PropertyChangedEventArgs(name));

            }

        }

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

    }

    public class StylusPointSet : INotifyPropertyChanged

    {

        public StylusPointSet()

        {

            if (pointSet == null)

                pointSet = new List<Point>();

        }

        public List<Point> _pointSet;

        public List<Point> pointSet

        {

            get

            {

                return _pointSet;

            }

            set

            {

                _pointSet = value;

                OnPropertyChanged("pointSet");

            }

        }

        #region INotifyPropertyChanged

        private void OnPropertyChanged(string name)

        {

            if (PropertyChanged != null)

            {

                PropertyChanged(this, new PropertyChangedEventArgs(name));

            }

        }

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

    }

}