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.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Common;

using MarkupToPDF.Serialize.Core;

using MarkupToPDF.Serialize.S_Control;

using System.Windows.Media.Imaging;

using System.Threading.Tasks;

using static System.Windows.Forms.AxHost;

//강인구 추가

namespace MarkupToPDF.Controls.Etc

{

    [TemplatePart(Name = "PART_Image", Type = typeof(Image))]

    public class SignControl : CommentUserInfo, IDisposable, INormal, INotifyPropertyChanged, IViewBox

    {

        #region 초기선언

        public string ProjectNO { get; set; }

        private const string PART_Image = "PART_Image";

        public Image Base_Image = null;

        #endregion

        static SignControl()

        {

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

        }

        public override void Copy(CommentUserInfo lhs)

        {

            if(lhs is SignControl item)

            {

                this.CommentAngle = item.CommentAngle;

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

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

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

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

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

                this.Opacity = item.Opacity;

                this.SignImage = item.SignImage;

                this.UserID = item.UserID;

                this.UserNumber = item.UserNumber;

                this.Memo = item.Memo;

                this.ZIndex = item.ZIndex;

                this.GroupID = item.GroupID;

            }

        }

        public override CommentUserInfo Clone()

        {

            var clone = new SignControl();

            clone.Copy(this);

            return clone;

        }

        public void Dispose()

        {

            //GC.Collect();

            ////GC.SuppressFinalize(this);

            this.Base_Image = null;

        }

        #region Dependency Properties

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty SignImageProperty = DependencyProperty.Register(

            "SignImage", typeof(ImageSource), typeof(SignControl), new PropertyMetadata(null));

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

            "EndPoint", typeof(Point), typeof(SignControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty UserNubmerProperty = DependencyProperty.Register(

            "UserNumber", typeof(string), typeof(SignControl), new PropertyMetadata(null));

        public static readonly DependencyProperty TopRightPointProperty = DependencyProperty.Register(

             "TopRightPoint", typeof(Point), typeof(SignControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty LeftBottomPointProperty = DependencyProperty.Register(

              "LeftBottomPoint", typeof(Point), typeof(SignControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register("Angle", typeof(double), typeof(SignControl),

                        new PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));

        public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register("CenterX", typeof(double), typeof(SignControl),

                        new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register("CenterY", typeof(double), typeof(SignControl),

                        new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty IsSelectedProperty =

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

        public static readonly DependencyProperty ControlTypeProperty =

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

        #endregion

        #region PropertyChanged Method

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (SignControl)sender;

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

            {

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

                instance.SetImage();

            }

        }

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

        }

            public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (SignControl)sender;

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

            {

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

                instance.SetImage();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (SignControl)sender;

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

            {

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

                instance.SetImage();

            }

        }

        #endregion

        #region Properties

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    RaisePropertyChanged("UserID");

                }

            }

        }

        public double CenterX

        {

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

            set { SetValue(CenterXProperty, value); }

        }

        public double CenterY

        {

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

            set { SetValue(CenterYProperty, value); }

        }

        public Point EndPoint

        {

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

            set

            {

                if (this.EndPoint != value)

                {

                    SetValue(EndPointProperty, value);

                    RaisePropertyChanged("EndPoint");

                }

            }

        }

        public List<Point> PointSet

        {

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

            set { SetValue(PointSetProperty, value); }

        }

        public Point StartPoint

        {

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

            set

            {

                if (this.StartPoint != value)

                {

                    SetValue(StartPointProperty, value);

                    RaisePropertyChanged("StartPoint");

                }

            }

        }

        public string UserNumber

        {

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

            set

            {

                if (this.UserNumber != value)

                {

                    SetValue(UserNubmerProperty, value);

                    RaisePropertyChanged("UserNumber");

                }

            }

        }

        public Point TopRightPoint

        {

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

            set

            {

                SetValue(TopRightPointProperty, value);

                RaisePropertyChanged("TopRightPoint");

            }

        }

        public Point LeftBottomPoint

        {

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

            set

            {

                SetValue(LeftBottomPointProperty, value);

                RaisePropertyChanged("LeftBottomPoint");

            }

        }

        public override double CommentAngle

        {

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

            set

            {

                if (this.CommentAngle != value)

                {

                    SetValue(AngleProperty, value);

                }

            }

        }

        public ImageSource SignImage

        {

            get { return (ImageSource)this.GetValue(SignImageProperty); }

            set { this.SetValue(SignImageProperty, value); }

        }

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

            }

        }

        public override ControlType ControlType

        {

            set

            {

                SetValue(ControlTypeProperty, value);

            }

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

        }

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_Image = GetTemplateChild(PART_Image) as Image;

            SetImage();

        }

        private void SetImage()

        {

            this.ApplyTemplate();

            Point mid = MathSet.FindCentroid(new List<Point>()

            {

                this.StartPoint,

                this.LeftBottomPoint,

                this.EndPoint,

                this.TopRightPoint,                

            });

            double AngleData = this.CommentAngle * -1;

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = MathSet.RotateAbout(mid, this.StartPoint, AngleData);

            LineSegment lineSegment0 = new LineSegment();

            lineSegment0.Point = MathSet.RotateAbout(mid, this.StartPoint, AngleData);

            pathFigure.Segments.Add(lineSegment0);

            LineSegment lineSegment1 = new LineSegment();

            lineSegment1.Point = MathSet.RotateAbout(mid, this.LeftBottomPoint, AngleData);

            pathFigure.Segments.Add(lineSegment1);

            LineSegment lineSegment2 = new LineSegment();

            lineSegment2.Point = MathSet.RotateAbout(mid, this.EndPoint, AngleData);

            pathFigure.Segments.Add(lineSegment2);

            LineSegment lineSegment3 = new LineSegment();

            lineSegment3.Point = MathSet.RotateAbout(mid, this.TopRightPoint, AngleData);

            pathFigure.Segments.Add(lineSegment3);

            PathGeometry pathGeometry = new PathGeometry();

            pathGeometry.Figures = new PathFigureCollection();

            pathFigure.IsClosed = true;

            pathGeometry.Figures.Add(pathFigure);

            this.Base_Image.Width = Math.Abs(pathGeometry.Bounds.Width);

            this.Base_Image.Height = Math.Abs(pathGeometry.Bounds.Height);

            this.Tag = pathGeometry;

            Canvas.SetLeft(this, MathSet.RotateAbout(mid, mid, AngleData).X - this.Base_Image.Width / 2);

            Canvas.SetTop(this, MathSet.RotateAbout(mid, mid, AngleData).Y - this.Base_Image.Height / 2);

        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void RaisePropertyChanged(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.TopRightPoint = new Point(this.PointSet[3].X, this.PointSet[3].Y);

            this.LeftBottomPoint = 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)

        {

            if (bAxisLocked)

            {

                double _dx = pt.X - this.StartPoint.X;

                double _dy = pt.Y - this.StartPoint.Y;

                double dist = Math.Max(Math.Abs(_dx) , Math.Abs(_dy));

                var dir = new Vector(_dx, _dy);

                dir.Normalize();

                this.LeftBottomPoint = new Point(this.StartPoint.X, this.StartPoint.Y + (dir.Y > 0 ? 1 : -1) * dist);

                this.TopRightPoint = new Point(this.StartPoint.X + (dir.X > 0 ? 1 : -1) * dist, this.StartPoint.Y);

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

            }

            else

            {

                this.EndPoint = pt;

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

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

            }

            var _sign = Application.Current.FindResource("UserSign");

            if (this.StartPoint != this.EndPoint && this.SignImage == null && _sign != null)

            {

                byte[] imageBytes = System.Convert.FromBase64String(_sign.ToString());

                using (System.IO.MemoryStream stream = new System.IO.MemoryStream())

                {

                    stream.Write(imageBytes, 0, imageBytes.Length);

                    stream.Position = 0;

                    BitmapImage returnImage = new BitmapImage();

                    returnImage.BeginInit();

                    using (System.Drawing.Image img = System.Drawing.Image.FromStream(stream))

                    {

                        System.IO.MemoryStream ms = new System.IO.MemoryStream();

                        img.Save(ms, System.Drawing.Imaging.ImageFormat.Png);

                        ms.Seek(0, System.IO.SeekOrigin.Begin);

                        returnImage.StreamSource = ms;

                        returnImage.EndInit();

                    }

                    stream.Close();

                    this.SignImage = returnImage;

                }

            }

            this.PointSet = new List<Point>

            {

                this.StartPoint,

                this.LeftBottomPoint,

                this.EndPoint,

                this.TopRightPoint,

            };

        }

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

        {

            IPath path = (this as IPath);

            Point selected = MathSet.getNearPoint(path.PointSet, pt);

            selected.X += dx;

            selected.Y += dy;

            int idx = (this as IPath).PointSet.FindIndex(x => x.Equals(pt));

            var OppositeP = (idx + path.PointSet.Count / 2) % path.PointSet.Count;

            var PreviousP = (idx + (path.PointSet.Count - 1)) % path.PointSet.Count;

            var NextP = (idx + 1) % path.PointSet.Count;

            if (bAxisLocked)

            {

                var PrevV = path.PointSet[PreviousP] - path.PointSet[OppositeP];

                double PrevLength = PrevV.Length;

                PrevV.Normalize();

                var NextV = path.PointSet[NextP] - path.PointSet[OppositeP];

                double NextVLength = NextV.Length;

                NextV.Normalize();

                double _dx = selected.X - path.PointSet[OppositeP].X;

                double _dy = selected.Y - path.PointSet[OppositeP].Y;

                var dir = new Vector(_dx, _dy);

                if (PrevLength > NextVLength)

                {

                    double ratio = NextVLength / PrevLength;

                    double dot = MathSet.DotProduct(PrevV.X, PrevV.Y, dir.X, dir.Y);

                    path.PointSet[PreviousP] = path.PointSet[OppositeP] + PrevV * dot;

                    path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * dot * ratio;

                    path.PointSet[idx] = path.PointSet[OppositeP] + PrevV * dot + NextV * dot * ratio;

                }

                else

                {

                    double ratio = PrevLength / NextVLength;

                    double dot = MathSet.DotProduct(NextV.X, NextV.Y, dir.X, dir.Y);

                    path.PointSet[PreviousP] = path.PointSet[OppositeP] + PrevV * dot * ratio;

                    path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * dot;

                    path.PointSet[idx] = path.PointSet[OppositeP] + PrevV * dot * ratio + NextV * dot;

                }

            }

            else

            {

                var PreviousV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[PreviousP]);

                var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[idx].X - path.PointSet[OppositeP].X,

                    path.PointSet[idx].Y - path.PointSet[OppositeP].Y);

                path.PointSet[PreviousP] = new Point(path.PointSet[OppositeP].X + PreviousV.X * l, path.PointSet[OppositeP].Y + PreviousV.Y * l);

                var NextV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[NextP]);

                l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[idx].X - path.PointSet[OppositeP].X, path.PointSet

                    [idx].Y - path.PointSet[OppositeP].Y);

                path.PointSet[NextP] = new Point(path.PointSet[OppositeP].X + NextV.X * l, path.PointSet[OppositeP].Y + NextV.Y * l);

                path.PointSet[idx] = selected;

            }

            this.UpdateControl();

        }

        /// <summary>

        /// return SignControl'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);

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

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

                double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.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_SignControl ctrl = new S_SignControl())

            {

                ctrl.Angle = this.CommentAngle;

                ctrl.EndPoint = this.EndPoint;

                ctrl.UserID = this.UserID;

                ctrl.LB = this.LeftBottomPoint;

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

                ctrl.PointSet = this.PointSet;

                ctrl.StartPoint = this.StartPoint;

                ctrl.Opac = this.Opacity;

                ctrl.TR = this.TopRightPoint;

                ctrl.UserNumber = this.UserNumber == null ? this.UserID: this.UserNumber;

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                ctrl.Memo = this.Memo;

                ctrl.ZIndex = this.ZIndex;

                ctrl.GroupID = this.GroupID;

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

            }

        }

        /// <summary>

        /// create a signcontrol from given string

        /// </summary>

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

        /// <returns></returns>

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

        {

            SignControl instance = null;

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

            {

                instance = new SignControl

                {

                    CommentAngle = s.Angle,

                    StartPoint = s.StartPoint,

                    TopRightPoint = s.TR,

                    EndPoint = s.EndPoint,

                    LeftBottomPoint = s.LB,

                    PointSet = s.PointSet,

                    Opacity = s.Opac,

                    SignImage = null,

                    UserID = s.UserID,

                    UserNumber = s.UserNumber,

                    Memo = s.Memo,

                    ZIndex = s.ZIndex,

                    GroupID = s.GroupID

                };

                if (s.UserNumber != null)

                { 

                    var _signItem = MarkupContext.GetUserSignItem(s.UserNumber);

                    if (_signItem != null)

                    {

                        byte[] imageBytes = System.Convert.FromBase64String(_signItem.Data);

                        BitmapImage returnImage = new BitmapImage();

                        using (System.IO.MemoryStream stream = new System.IO.MemoryStream())

                        {

                            stream.WriteAsync(imageBytes, 0, imageBytes.Length);

                            stream.Position = 0;

                            System.Drawing.Image img = System.Drawing.Image.FromStream(stream);

                            returnImage.BeginInit();

                            System.IO.MemoryStream ms = new System.IO.MemoryStream();

                            img.Save(ms, System.Drawing.Imaging.ImageFormat.Png);

                            ms.Seek(0, System.IO.SeekOrigin.Begin);

                            returnImage.StreamSource = ms;

                            returnImage.EndInit();

                            stream.Close();

                        }

                        instance.SignImage = returnImage;

                    }

                }

            }

            return instance;

        }

        public double LineSize

        {

            get;

            set;

        }

        public Geometry PathData

        {

            get;

            set;

        }

    }

}