MARKUS

using KCOMDataModel.DataModel;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Controls.Parsing;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Input;

using System.Windows.Media;

namespace MarkupToPDF.Common

{

    public interface ICommentUserInfo

    {

        void OnCreatingMouseMove(Point pt, bool bAxisLocked);

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

        void OnTranslate(double dx, double dy);

        void UpdateControl();

    }

    public class CommentUserInfo : System.Windows.Controls.Control, ICommentUserInfo

    {

        public static readonly string[] delimiterChars = { "|DZ|" };

        public static readonly string[] delimiterChars2 = { "|" };

        public static readonly SolidColorBrush DefaultColor = new SolidColorBrush(MarkupToPDF.Controls.Common.ValueConverter.StringToColorConverter.Parse(""));

        public const int MaxZIndex = 99;

        public string Memo { get; set; }

        public string MarkupInfoID { get; set; }

        public bool IsMouseEnter { get; set; }

        public bool IsNew { get; set; }

        public string CommentID { get; set; }

        public string SymbolID { get; set; }

        public string GroupID { get; set; }

        [Description("ZIndex 값이 높을 수록 앞쪽으로 배치된다.")]

        public int ZIndex { get; set; } = 10;

        /// <summary>

        /// 리스트 인덱스

        /// </summary>

        [Description("리스트 인덱스")]

        public int Index { get; set; }

        private SolidColorBrush _TempBorderBrush { get; set; }

        private SolidColorBrush _HoverBorderBrush { get; } = new SolidColorBrush(Color.FromRgb(255, 0, 255));

        public CommentUserInfo()

        {

            Load();

        }

        public virtual void Copy(CommentUserInfo lhs) { throw new NotImplementedException("Must implement Copy()"); }

        public virtual CommentUserInfo Clone() { throw new NotImplementedException("Must implement Clone()"); }

        public void Load()

        {

            this.IsHitTestVisible = true;

            this.SetValue(Telerik.Windows.Controls.TabNavigationExtensions.IsTabStopProperty, false);

               this.BorderThickness = new System.Windows.Thickness(20.0);

            this.MouseEnter += CommentUserInfo_MouseEnter;

            this.MouseLeave += CommentUserInfo_MouseLeave;

        }

        protected override GeometryHitTestResult HitTestCore(GeometryHitTestParameters hitTestParameters)

        {

            var temp = base.HitTestCore(hitTestParameters);

            return temp;

        }

        private void CommentUserInfo_MouseLeave(object sender, System.Windows.Input.MouseEventArgs e)

        {

            System.Diagnostics.Debug.WriteLine("Is Mouse Leave."); 

            this.IsMouseEnter = false;

            if (this.StrokeColor != this._TempBorderBrush)

            {

                this.StrokeColor = this._TempBorderBrush;

                this.UpdateLayout();

            }

        }

        private void CommentUserInfo_MouseEnter(object sender, System.Windows.Input.MouseEventArgs e)

        {

            this.IsMouseEnter = true;

            System.Diagnostics.Debug.WriteLine("Is Mouse Enter.");

            OnMouseHover();

        }

        public void OnMouseHover()

        {

            if (this.StrokeColor != this._HoverBorderBrush)

            {

                this._TempBorderBrush = this.StrokeColor;

                this.StrokeColor = this._HoverBorderBrush;

                this.UpdateLayout();

            }

        }

        public virtual void OnCreatingMouseMove(Point pt, bool bAxisLocked) { }

        public virtual void OnMoveCtrlPoint(Point pt, double dx, double dy, bool bAxisLocked = false) { }

        /// <summary>

        /// translate control along given dx,dy

        /// </summary>

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

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

        public virtual void OnTranslate(double dx, double dy)

        {

            var path = (this as IPath);

            for (int i = 0; i < path.PointSet.Count; ++i)

            {

                path.PointSet[i] = new Point(path.PointSet[i].X + dx, path.PointSet[i].Y + dy);

            }

            this.UpdateControl();

        }

        /// <summary>

        /// update control

        /// </summary>

        public virtual void UpdateControl() { }

        /// <summary>

        /// subclass has to override this property

        /// </summary>

        public virtual bool IsSelected { get; set; }

        /// <summary>

        /// subclass has to override this property

        /// </summary>

        public virtual ControlType ControlType { get; set; }

        private double _CommentAngle;

        /// <summary>

        /// 컨트롤의 ANGLE

        /// </summary>

        public virtual double CommentAngle

        {

            get { return _CommentAngle; }

            set

            {

                _CommentAngle = value;

                System.Diagnostics.Debug.WriteLine($"CommentInfo CommentAngle {value}");

            }

        }

        private double _PageAngle;

        /// <summary>

        /// 실제 저장된 Page의 ANGLE

        /// DB에 저장됨

        /// </summary>

        public virtual double PageAngle

        {

            get { return _PageAngle; }

            set

            {

                _PageAngle = value;

                System.Diagnostics.Debug.WriteLine($"CommentInfo PageAngle {value}");

            }

        }

        private double _VisualPageAngle;

        /// <summary>

        /// Display되는 Page의 ANGLE

        /// PageAngle에서 변형됨

        /// </summary>

        public virtual double VisualPageAngle

        {

            get { return _VisualPageAngle; }

            set

            {

                _VisualPageAngle = value;

                //System.Diagnostics.Debug.WriteLine($"CommentInfo VisualPageAngle {value}");

            }

        }

        public virtual SolidColorBrush StrokeColor { get; set; }

        /// <summary>

        /// 

        /// </summary>

        public virtual void ApplyOverViewData() { }

        /// <summary>

        /// subclass has to override this method

        /// </summary>

        /// <returns>serialized string</returns>

        public virtual string Serialize() { return string.Empty; }

        /// <summary>

        /// return MARKUP_DATA

        /// </summary>

        /// <param name="sUserID"></param>

        /// <param name="iPageNo"></param>

        /// <returns></returns>

        public virtual MARKUP_DATA GetMarkupData(string sUserID, int iPageNo, string sMarkupVersionID)

        {

            var root = MarkupParser.MarkupToString(this, sUserID);

            return new MARKUP_DATA

            {

                ID = this.CommentID,

                DATA = root.ConvertData,

                DATA_TYPE = root.DATA_TYPE,

                PAGENUMBER = iPageNo,

                MARKUPINFO_VERSION_ID = sMarkupVersionID,

                SYMBOL_ID = this.SymbolID,

                //GROUP_ID = this.GroupID

            };

        }

        /// <summary>

        /// return item's area

        /// </summary>

        public virtual Rect ItemRect

        {

            get;

        }

        /// <summary>

        /// 정원, 정사각형, 정삼각형을 그리기 위한 EndPoint계산

        /// </summary>

        /// <param name="StartP">StartPoint</param>

        /// <param name="EndP">EndPoint</param>

        /// <returns>Return_EndPoint</returns>

        public Point GetSquareEndPoint(Point StartP, Point EndP)

        {

            Point? res = null;

            double dx = EndP.X - StartP.X;

            double dy = EndP.Y - StartP.Y;

            double length;

            switch (this.ControlType)

            {

                case ControlType.Triangle:

                    {

                        //삼각형의 StartPoint기준으로 반지름 만큼 증가하기 때문에 곱하기2 필요

                        length = Math.Max(Math.Abs(dx) * 2, Math.Abs(dy));

                        res = (dy < 0) ? new Point(StartP.X + length / 2, StartP.Y - length) : new Point(StartP.X + length / 2, StartP.Y + length);

                    }

                    break;

                default:

                    {

                        length = Math.Max(Math.Abs(dx), Math.Abs(dy));

                        res = new Point((dx > 0) ? StartP.X + length : StartP.X - length, (dy > 0) ? StartP.Y + length : StartP.Y - length);

                    }

                    break;

            }

            return res.Value;

        }

    }

}