HYTOS

using devDept.Eyeshot;

using devDept.Eyeshot.Entities;

using devDept.Eyeshot.Translators;

using devDept.Geometry.Entities;

using GemBox.Spreadsheet;

using ID2.Manager.Common;

using ID2.Manager.Data.Models;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using Telerik.WinControls;

using Telerik.WinControls.UI;

using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;

using Telerik.Windows.Documents.Fixed.Model;

using Telerik.Windows.Documents.Fixed.Model.Editing;

namespace ID2.Manager.Controls

{

    public partial class Classify : UserControl

    {

        class DocAttrValue

        {

            public DocAttrValue(string DocNo, Dictionary<string, List<KeyValuePair<string, string>>> _BlockAttrValueList)

            {

                this.DocNo = DocNo;

                this.BlockAttrValueList = _BlockAttrValueList;

            }

            public string DocNo { get; set; }

            public Dictionary<string, List<KeyValuePair<string, string>>> BlockAttrValueList { get; set; }

        }

        public delegate void DocumentSelected(Documents doc);

        readonly Informations informations = Informations.Instance;

        readonly string IniFilePath = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), 

            Application.ProductName, $"{Application.ProductName}.ini");

        #region 기본값

        private static double Tolerance = 0;

        private static double Simularity { get; set; } = 80;

        private static double LengthToleranceRatio { get; set; } = 0.1;

        private static Font UnmatchedFont = new System.Drawing.Font("Segoe UI", 9F, FontStyle.Italic);

        private static Font MatchedFont = new System.Drawing.Font("Segoe UI", 9F, FontStyle.Bold);

        private string dwgExtension { get; } = ".dwg";

        #endregion

        class DrawingGroup

        {

            public string GroupNo { get; } = Guid.NewGuid().ToString();

            public List<string> Drawings {get;} = new List<string>();

        }

        private RadProgressBarElement _progressBar = null;

        public Classify(RadProgressBarElement progressBar)

        {

            InitializeComponent();

            this.radGridViewDocument.AutoSizeColumnsMode = Telerik.WinControls.UI.GridViewAutoSizeColumnsMode.Fill;

            this.Load += Verification_Load;

            this.radSpinEditorTolerance.ValueChanged += RadSpinEditorTolerance_ValueChanged;

            this.radButtonExceptLayer.Click += RadButtonExceptLayer_Click;

            this.radSpinEditorSimularity.ValueChanged += RadSpinEditorSimularity_ValueChanged;

            this.radButtonClassify.Click += RadButtonClassify_Click;

            this.radButtonExtractText.Click += RadButtonExtractText_Click;

            this.designDrawing.ActionMode = actionType.SelectVisibleByPickDynamic;

            this.designDrawing.Selection.ColorDynamic = Color.FromArgb(80, Color.OrangeRed);

            this.designDrawing.Selection.HaloInnerColor = Color.FromArgb(255, Color.OrangeRed);

            this.designDrawing.Selection.HaloOuterColor = Color.FromArgb(64, Color.OrangeRed);

            this.designDrawing.Selection.HaloWidthPolygons = 4;

            this.designDrawing.Selection.HaloWidthWires = 2;

            _progressBar = progressBar;

        }

        /// <summary>

        /// 선택한 도면에서 텍스트를 읽어 엑셀로 추출한다.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void RadButtonExtractText_Click(object sender, EventArgs e)

        {

            void OpenDrawing(string FilePath)

            {

                if (!File.Exists(FilePath)) return;

                #region 다른 프로세스에서 파일을 열고 있는 경우 처리

                using (var fs = File.Open(FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

                #endregion

                {

                    devDept.Eyeshot.Translators.ReadAutodesk ra = new devDept.Eyeshot.Translators.ReadAutodesk(fs);

                    ra.DoWork();

                    ra.AddToScene(designDrawing);

                }

            }

            var docs = this.radGridViewDocument.Rows.Where(x => Convert.ToBoolean(x.Cells["Checked"].Value))

                .Select(x => x.DataBoundItem as ID2.Manager.Data.Models.Documents).ToList();

            var DocBlockAttrValueList = new List<DocAttrValue>();

            _progressBar.Maximum = docs.Count;

            _progressBar.Value1 = 0;

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

            {

                this.designDrawing.Entities.Clear();

                this.designDrawing.Blocks.Clear();

                string DwgFolder = System.IO.Path.Combine(informations.FindID2LocalPath(docs.ElementAt(i).RefProjectCode), "drawings", "Native");

                string DocNo = docs.ElementAt(i).DocumentNo;

                string FilePath = System.IO.Path.Combine(DwgFolder, $"{DocNo}{dwgExtension}");

                OpenDrawing(FilePath);

                #region 블럭의 속성을 읽음

                var TitleBlocks = this.designDrawing.Entities.Where(x => x is devDept.Eyeshot.Entities.BlockReference blkref 

                && Forms.ExceptLayer.TitleBlockAttribute.Exists(y => y.BlockName.Equals(blkref.BlockName)))

                    .Select(x => x as devDept.Eyeshot.Entities.BlockReference).ToList();

                var BlockAttrValueList = new Dictionary<string, List<KeyValuePair<string, string>>>();

                foreach(var blkref in TitleBlocks)

                {

                    var AttrValueList = new List<KeyValuePair<string, string>>();

                    var AttrNameList = Forms.ExceptLayer.TitleBlockAttribute.Where(x => x.BlockName.Equals(blkref.BlockName))

                        .Select(x => x.AttrName).ToList();

                    foreach (var attr in blkref.Attributes.Where(x => AttrNameList.Contains(x.Key)))

                    {

                        var AttrNameValue = new KeyValuePair<string, string>(attr.Key, attr.Value.Value);

                        AttrValueList.Add(AttrNameValue);

                    }

                    BlockAttrValueList.Add(Guid.NewGuid().ToString(), AttrValueList);

                }

                var DocBlockAttrValue = new DocAttrValue(DocNo, BlockAttrValueList);

                DocBlockAttrValueList.Add(DocBlockAttrValue);

                #endregion

                _progressBar.Value1 += 1;

                Application.DoEvents();

            }

            #region 엑셀 파일로 저장

            using (SaveFileDialog sfd = new SaveFileDialog()

            {

                Filter = "Excel files (*.xlsx)|*.xlsx",

                Title = "Save an excel file",

                RestoreDirectory = true,

                CheckPathExists = true,

                OverwritePrompt = true

            })

            {

                if (sfd.ShowDialog() == DialogResult.OK)

                {

                    var workbook = new ExcelFile();

                    // Add new sheet.

                    var worksheet = workbook.Worksheets.Add("TEXT");

                    worksheet.Cells[0, 0].Value = "FILE NAME";

                    #region 속성 이름 작성

                    var AttrNameList = Forms.ExceptLayer.TitleBlockAttribute.Select(x => x.AttrName).Distinct().ToList();

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

                    {

                        worksheet.Cells[0, i + 1].Value = AttrNameList[i];

                    }

                    #endregion

                    int row = 1;

                    foreach(var doc in DocBlockAttrValueList)

                    {

                        foreach(var key in doc.BlockAttrValueList.Keys)

                        {

                            worksheet.Cells[row, 0].Value = doc.DocNo;

                            for (int col = 0; col < doc.BlockAttrValueList[key].Count; col++)

                            {

                                worksheet.Cells[row, col + 1].Value = doc.BlockAttrValueList[key][col].Value;

                            }

                            row++;

                        }

                    }

                    workbook.Save(sfd.FileName);

                }

            }

            #endregion

            this.designDrawing.Entities.Clear();

            this.designDrawing.Blocks.Clear();

            RadMessageBox.Show("Extracting text is complete.");

        }

        private void RadSpinEditorSimularity_ValueChanged(object sender, EventArgs e)

        {

            double simularity = Convert.ToDouble(this.radSpinEditorSimularity.Value);

            Classes.ID2Helper.IniWriteValue(IniFilePath, "Verification", "Simularity", simularity.ToString());

            Classify.Simularity = simularity;

        }

        private void RadButtonClassify_Click(object sender, EventArgs e)

        {

            void OpenDrawing(string FilePath, string LayerName, Color color)

            {

                if (!File.Exists(FilePath)) return;

                #region 다른 프로세스에서 파일을 열고 있는 경우 처리

                using (var fs = File.Open(FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

                #endregion

                {

                    devDept.Eyeshot.Translators.ReadAutodesk ra = new devDept.Eyeshot.Translators.ReadAutodesk(fs);

                    ra.DoWork();

                    var min = ra.Min;

                    if (!ra.Layers.Contains(LayerName)) ra.Layers.Add(LayerName, color);

                    foreach (var ent in ra.Entities)

                    {

                        /// 도면을 원점으로 맞춘다.

                        if (min.X != 0 && min.Y != 0) ent.Translate(-min.X, -min.Y);

                        ent.LayerName = LayerName;

                    }

                    ra.AddToScene(designDrawing);

                }

            }

            var DrawingGroupColl = new List<DrawingGroup>();

            var docs = this.radGridViewDocument.Rows.Where(x => Convert.ToBoolean(x.Cells["Checked"].Value))

                .Select(x => x.DataBoundItem as ID2.Manager.Data.Models.Documents).ToList();

            docs.ForEach(x => x.Simularity = string.Empty);

            #region 전체 비교 횟수 파악

            int sum = 0;

            for (int i = 0; i < docs.Count - 1; ++i)

            {

                for (int j = i + 1; j < docs.Count; ++j) sum++;

            }

            #endregion

            _progressBar.Maximum = sum;

            _progressBar.Value1 = 0;

            for (int i = 0;i < docs.Count - 1;++i)

            {

                string FirstDwgFolder = System.IO.Path.Combine(informations.FindID2LocalPath(docs.ElementAt(i).RefProjectCode), "drawings", "Native");

                string FirstDocNo = docs.ElementAt(i).DocumentNo;

                string FirstFilePath = System.IO.Path.Combine(FirstDwgFolder, $"{FirstDocNo}{dwgExtension}");

                for (int j = i + 1;j < docs.Count;++j)

                {

                    this.designDrawing.Entities.Clear();

                    this.designDrawing.Blocks.Clear();

                    OpenDrawing(FirstFilePath, "First", Color.FromArgb(44, 44, 44));

                    string SecondDwgFolder = System.IO.Path.Combine(informations.FindID2LocalPath(docs.ElementAt(j).RefProjectCode), "drawings", "Native");

                    string SecondDocNo = docs.ElementAt(j).DocumentNo;

                    string SecondFilePath = System.IO.Path.Combine(SecondDwgFolder, $"{SecondDocNo}{dwgExtension}");

                    OpenDrawing(SecondFilePath, "Second", Color.FromArgb(155, 155, 155));

                    var FirstEntities = this.designDrawing.Entities.Where(x => x.LayerName == "First").ToList();

                    var SecondEntities = this.designDrawing.Entities.Where(x => x.LayerName == "Second").ToList();

                    if (FirstEntities.Any() && SecondEntities.Any())

                    {

                        double simularity = 100 - CompareDrawing(designDrawing, FirstEntities, SecondEntities);

                        if (simularity >= Classify.Simularity)

                        {

                            var group = DrawingGroupColl.FirstOrDefault(x => x.Drawings.Exists(y => y.Equals(FirstDocNo) || y.Equals(SecondDocNo)));

                            if (group != null)

                            {

                                if (!group.Drawings.Exists(x => x.Equals(FirstDocNo))) group.Drawings.Add(FirstDocNo);

                                if (!group.Drawings.Exists(x => x.Equals(SecondDocNo))) group.Drawings.Add(SecondDocNo);

                            }

                            else

                            {

                                group = new DrawingGroup();

                                group.Drawings.Add(FirstDocNo);

                                group.Drawings.Add(SecondDocNo);

                                DrawingGroupColl.Add(group);

                            }

                        }

                    }

                    _progressBar.Value1 += 1;

                    Application.DoEvents();

                }

            }

            foreach(var group in DrawingGroupColl)

            {

                group.Drawings.ForEach(x =>

                {

                    var doc = docs.FirstOrDefault(y => y.DocumentNo.Equals(x));

                    if (doc != null) doc.Simularity = group.GroupNo;

                });

            }

            this.designDrawing.Entities.Clear();

            this.designDrawing.Blocks.Clear();

            RadMessageBox.Show("Classifying drawing is complete.");

        }

        /// <summary>

        /// Except Layer 폼을 띄운다.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void RadButtonExceptLayer_Click(object sender, EventArgs e)

        {

            using(var frm = new Forms.ExceptLayer())

            {

                if(DialogResult.OK == frm.ShowDialog(this))

                {

                    string ExceptLayers = string.Join(",", Forms.ExceptLayer.ExceptLayers.Select(x => x.Name));

                    Classes.ID2Helper.IniWriteValue(IniFilePath, "Verification", "Except Layers", ExceptLayers);

                    string ExceptLayersVisible = string.Join(",", Forms.ExceptLayer.ExceptLayers.Select(x => x.Visible));

                    Classes.ID2Helper.IniWriteValue(IniFilePath, "Verification", "Except Layers Visible", ExceptLayersVisible);

                    if (Forms.ExceptLayer.TitleBlockAttribute.Any())

                    {

                        string BlockName = Forms.ExceptLayer.TitleBlockAttribute.Select(x => x.BlockName).Distinct().First();

                        Classes.ID2Helper.IniWriteValue(IniFilePath, "TitleBlock", "Block Name", BlockName);

                    }

                    var AttrNameList = Forms.ExceptLayer.TitleBlockAttribute.Select(x => x.AttrName).Distinct().ToList();

                    string Attributes = string.Join(",", AttrNameList);

                    Classes.ID2Helper.IniWriteValue(IniFilePath, "TitleBlock", "Attributes", Attributes);

                }

            }

        }

        /// <summary>

        /// 수정한 Tolerance를 시스템에 반영한다.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void RadSpinEditorTolerance_ValueChanged(object sender, EventArgs e)

        {

            double toler = Convert.ToDouble(this.radSpinEditorTolerance.Value);

            Classes.ID2Helper.IniWriteValue(IniFilePath, "Verification", "Tolerance", toler.ToString());

            Classify.Tolerance = toler;

        }

        private void Verification_Load(object sender, EventArgs e)

        {

            string Toler = Classes.ID2Helper.IniReadValue(IniFilePath, "Verification", "Tolerance");

            if (!string.IsNullOrEmpty(Toler))

            {

                this.radSpinEditorTolerance.Value = Convert.ToDecimal(Toler);

                Classify.Tolerance = Convert.ToDouble(this.radSpinEditorTolerance.Value);

            }

            string Simularity = Classes.ID2Helper.IniReadValue(IniFilePath, "Verification", "Simularity");

            if (!string.IsNullOrEmpty(Simularity))

            {

                this.radSpinEditorSimularity.Value = Convert.ToDecimal(Simularity);

                Classify.Simularity = Convert.ToDouble(this.radSpinEditorSimularity.Value);

            }

            string _LengthToleranceRatio = Classes.ID2Helper.IniReadValue(IniFilePath, "Verification", "Length Tolerance Ratio");

            if (!string.IsNullOrEmpty(_LengthToleranceRatio))

            {

                LengthToleranceRatio = Convert.ToDouble(_LengthToleranceRatio);

            }

            #region Except Layer를 로딩한다.

            string _ExceptLayers = Classes.ID2Helper.IniReadValue(IniFilePath, "Verification", "Except Layers");

            if (!string.IsNullOrEmpty(_ExceptLayers))

            {

                Forms.ExceptLayer.ExceptLayers.AddRange(_ExceptLayers.Split(',').ToList().ConvertAll(x => new Forms.ExceptLayer.Layer(x)));

                string _ExceptLayersVisible = Classes.ID2Helper.IniReadValue(IniFilePath, "Verification", "Except Layers Visible");

                if (!string.IsNullOrEmpty(_ExceptLayersVisible))

                {

                    var tokens = _ExceptLayersVisible.Split(',').ToList().ConvertAll(x => Convert.ToBoolean(x));

                    for (int i = 0; i < Forms.ExceptLayer.ExceptLayers.Count; ++i)

                    {

                        if (i < tokens.Count)

                        {

                            Forms.ExceptLayer.ExceptLayers[i].Visible = tokens[i];

                        }

                    }

                }

            }

            #endregion

            #region Title Block 정보를 읽는다.

            string TitleBlockName = Classes.ID2Helper.IniReadValue(IniFilePath, "TitleBlock", "Block Name");

            if (!string.IsNullOrEmpty(TitleBlockName))

            {

                string Attributes = Classes.ID2Helper.IniReadValue(IniFilePath, "TitleBlock", "Attributes");

                if (!string.IsNullOrEmpty(Attributes))

                {

                    var tokens = Attributes.Split(',').ToList();

                    tokens.ForEach(x => 

                    {

                        var BlkAttr = new Forms.ExceptLayer.BlockAttribute(TitleBlockName, x);

                        Forms.ExceptLayer.TitleBlockAttribute.Add(BlkAttr);

                    });

                }

            }

            #endregion

            this.radGridViewDocument.CellDoubleClick += RadGridViewDocument_CellDoubleClick;

            this.radGridViewDocument.ViewRowFormatting += RadGridViewDocument_ViewRowFormatting;

        }

        private void RadGridViewDocument_ViewRowFormatting(object sender, RowFormattingEventArgs e)

        {

            if (e.RowElement is GridRowElement)

            {

                if (e.RowElement.RowInfo.DataBoundItem is Documents doc)

                {

                    string DwgFolder = System.IO.Path.Combine(informations.FindID2LocalPath(doc.RefProjectCode), "drawings", "Native");

                    string DocNo = doc.DocumentNo;

                    string FilePath = System.IO.Path.Combine(DwgFolder, $"{DocNo}{dwgExtension}");

                    if (!File.Exists(FilePath))

                    {

                        e.RowElement.ForeColor = Color.Gray;

                        e.RowElement.Font = UnmatchedFont;

                    }

                    else

                    {

                        e.RowElement.ResetValue(LightVisualElement.ForeColorProperty, ValueResetFlags.Local);

                        e.RowElement.Font = MatchedFont;

                    }

                }

            }

            else

            {

                e.RowElement.ResetValue(LightVisualElement.ForeColorProperty, ValueResetFlags.Local);

                e.RowElement.ResetValue(LightVisualElement.FontProperty, ValueResetFlags.Local);

            }

        }

        /// <summary>

        /// 더블 클릭한 도면을 연다.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void RadGridViewDocument_CellDoubleClick(object sender, GridViewCellEventArgs e)

        {

            if (sender is GridDataCellElement CellElement)

            {

                var doc = CellElement.RowInfo.DataBoundItem as Documents;

                string DwgFolder = System.IO.Path.Combine(informations.FindID2LocalPath(doc.RefProjectCode), "drawings", "Native");

                string DocNo = doc.DocumentNo;

                string FilePath = System.IO.Path.Combine(DwgFolder, $"{DocNo}{dwgExtension}");

                if (!File.Exists(FilePath))

                {

                    RadMessageBox.Show("File doesn't exist");

                    return;

                }

                #region 다른 프로세스에서 파일을 열고 있는 경우 처리

                using (var fs = File.Open(FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

                #endregion

                {

                    designDrawing.Blocks.Clear();

                    designDrawing.Entities.Clear();

                    devDept.Eyeshot.Translators.ReadAutodesk ra = new devDept.Eyeshot.Translators.ReadAutodesk(fs);

                    ra.DoWork();

                    ra.AddToScene(designDrawing);

                    designDrawing.Invalidate();

                }

            }

        }

        /// <summary>

        /// 두 도면의 엔터티들을 비교한다.

        /// <return>차이점을 %로 리턴한다.</return>

        /// </summary>

        private double CompareDrawing(Design design, IList<Entity> FirstEntities, IList<Entity> SecondEntities)

        {

            bool[] equalEntitiesInV2 = new bool[SecondEntities.Count];

            var EqualIndices = new List<int>();

            /// 서로 검사 가능한 타입인지 확인한다.

            bool CheckType(Entity ent1, Entity ent2)

            {

                return ent1.GetType() == ent2.GetType() ||

                    (ent1.GetType() == typeof(devDept.Eyeshot.Entities.Text) && ent2.GetType() == typeof(devDept.Eyeshot.Entities.MultilineText)) ||

                    (ent1.GetType() == typeof(devDept.Eyeshot.Entities.MultilineText) && ent2.GetType() == typeof(devDept.Eyeshot.Entities.Text)) ||

                    (ent1.GetType() == typeof(devDept.Eyeshot.Entities.Line) && ent2.GetType() == typeof(devDept.Eyeshot.Entities.TabulatedSurface)) ||

                    (ent1.GetType() == typeof(devDept.Eyeshot.Entities.Attribute) && ent2.GetType() == typeof(devDept.Eyeshot.Entities.Text)) ||

                    (ent1.GetType() == typeof(devDept.Eyeshot.Entities.Attribute) && ent2.GetType() == typeof(devDept.Eyeshot.Entities.MultilineText));

            }

            int[] differents = new int[2] { 0, 0 };

            try

            {

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

                {

                    Entity entVp1 = FirstEntities[i];

                    EqualIndices.Clear();

                    for (int j = 0; j < SecondEntities.Count(); j++)

                    {

                        Entity entVp2 = SecondEntities[j];

                        if (!equalEntitiesInV2[j] && CheckType(entVp1, entVp2) && CompareIfEqual(design, entVp1, design, entVp2))

                        {

                            EqualIndices.Add(j);

                        }

                    }

                    #region 임계값 안에 들어오는 항목이 여러개 있을 경우 가장 가까운 항목을 유사 항목으로 선택한다.

                    if (EqualIndices.Any())

                    {

                        var ordered = EqualIndices.ConvertAll(x => SecondEntities[x]).OrderBy(x =>

                        {

                            return x.BoxMin.DistanceTo(entVp1.BoxMin);

                        });

                        int idx = SecondEntities.ToList().FindIndex(x => x == ordered.First());

                        equalEntitiesInV2[idx] = true;

                    }

                    #endregion

                    if (!EqualIndices.Any()) differents[0]++;

                }

                for (int j = 0; j < SecondEntities.Count; j++)

                {

                    if (!equalEntitiesInV2[j]) differents[1]++;

                }

                double a = Math.Abs(FirstEntities.Count - SecondEntities.Count) / ((FirstEntities.Count + SecondEntities.Count) * 0.5) * 100;

                double b = FirstEntities.Count > 0 ? ((double)differents[0] / (double)FirstEntities.Count) * 100 : 100;

                double c = SecondEntities.Count > 0 ? ((double)differents[1] / (double)SecondEntities.Count) * 100 : 100;

                return (a + b + c) / 3;

            }

            catch (Exception ex)

            {

                Console.Write($"Error : {ex.Message}");

            }

            return 100;

        }

        public void DocumentListBinding(List<ID2.Manager.Data.Models.Documents> docs)

        {

            this.radGridViewDocument.FilterDescriptors.Clear();

            this.radGridViewDocument.DataSource = new BindingList<ID2.Manager.Data.Models.Documents>(docs);

        }

        /// <summary>

        /// 주어진 두 엔터티를 비교한다.

        /// </summary>

        /// <param name="entVp1"></param>

        /// <param name="entVp2"></param>

        /// <returns></returns>

        private bool CompareIfEqual(Design design1, Entity entVp1, Design design2, Entity entVp2)

        {

            return AreEqual(design1, entVp1, design2, entVp2);

        }

        private bool CompareGEntityIfEqual(GEntity entVp1, GEntity entVp2)

        {

            return AreGEntityEqual(entVp1, entVp2);

        }

        /// <summary>

        /// 그래픽적으로 두 엔터티가 유사한지 검사한다.

        /// </summary>

        /// <param name="design1"></param>

        /// <param name="ent1"></param>

        /// <param name="design2"></param>

        /// <param name="ent2"></param>

        /// <returns></returns>

        private bool AreEqual(Design design1, Entity ent1, Design design2, Entity ent2)

        {

            if (ent1 is CompositeCurve cc1 && ent2 is CompositeCurve cc2)

            {

                if (cc1.CurveList.Count == cc2.CurveList.Count)

                {

                    int equalCurvesInListCount = 0;

                    foreach (var entC in cc1.CurveList)

                    {

                        foreach (var entC2 in cc2.CurveList)

                        {

                            if (entC.GetType() == entC2.GetType())

                            {

                                if (entC is Entity && entC2 is Entity && CompareIfEqual(design1, entC as Entity, design2, entC2 as Entity))

                                {

                                    equalCurvesInListCount++;

                                    break;

                                }

                                else if (entC is GEntity && entC2 is GEntity && CompareGEntityIfEqual(entC as GEntity, entC2 as GEntity))

                                {

                                    equalCurvesInListCount++;

                                    break;

                                }

                            }

                        }

                    }

                    if (cc1.CurveList.Count == equalCurvesInListCount)

                    {

                        return true;

                    }

                }

            }

            else if (ent1 is LinearPath lp1 && ent2 is LinearPath lp2)

            {

                if (lp1.Vertices.Length == lp2.Vertices.Length)

                {

                    for (int i = 0; i < lp1.Vertices.Length; i++)

                    {

                        if (lp1.Vertices[i].DistanceTo(lp2.Vertices[i]) > Classify.Tolerance)

                            return false;

                    }

                    return true;

                }

            }

            else if (ent1 is PlanarEntity && ent2 is PlanarEntity)

            {

                if (ent1 is Arc arc1 && ent2 is Arc arc2)

                {

                    if (

                        arc1.Center.DistanceTo(arc2.Center) <= Classify.Tolerance &&

                        Math.Abs(arc1.Radius - arc2.Radius) <= Classify.Tolerance &&

                        Math.Abs(arc1.Domain.Min - arc2.Domain.Min) <= Classify.Tolerance &&

                        Math.Abs(arc1.Domain.Max - arc2.Domain.Max) <= Classify.Tolerance

                        )

                    {

                        return true;

                    }

                }

                else if (ent1 is Circle c1 && ent2 is Circle c2)

                {

                    if (

                        c1.Center.DistanceTo(c2.Center) <= Classify.Tolerance &&

                        Math.Abs(c1.Radius - c2.Radius) <= Classify.Tolerance

                        )

                    {

                        return true;

                    }

                }

                else if (ent1 is EllipticalArc e1 && ent2 is EllipticalArc e2)

                {

                    if (

                        e1.Center.DistanceTo(e2.Center) <= Classify.Tolerance &&

                        Math.Abs(e1.RadiusX - e2.RadiusX) <= Classify.Tolerance &&

                        Math.Abs(e1.RadiusY - e2.RadiusY) <= Classify.Tolerance &&

                        Math.Abs(e1.Domain.Low - e2.Domain.Low) <= Classify.Tolerance &&

                        Math.Abs(e1.Domain.High - e2.Domain.High) <= Classify.Tolerance

                    )

                    {

                        return true;

                    }

                }

                else if (ent1 is Ellipse el1 && ent2 is Ellipse el2)

                {

                    if (

                        el1.Center.DistanceTo(el2.Center) <= Classify.Tolerance &&

                        Math.Abs(el1.RadiusX - el2.RadiusX) <= Classify.Tolerance &&

                        Math.Abs(el1.RadiusY - el2.RadiusY) <= Classify.Tolerance

                    )

                    {

                        return true;

                    }

                }

                #region 해치는 중점만 비교

                else if (ent1 is Hatch hatch1 && ent2 is Hatch hatch2)

                {

                    if (hatch1.BoxMin == null || hatch1.BoxMax == null) return false;

                    var center1 = (hatch1.BoxMin + hatch1.BoxMax) * 0.5;

                    center1.Z = 0;

                    if (hatch2.BoxMin == null || hatch2.BoxMax == null) return false;

                    var center2 = (hatch2.BoxMin + hatch2.BoxMax) * 0.5;

                    center2.Z = 0;

                    return center1.DistanceTo(center2) < Classify.Tolerance;

                }

                #endregion

                else if (ent1 is Text)

                {

                    if (ent1 is Dimension dim1 && ent2 is Dimension dim2)

                    {

                        if (

                            dim1.InsertionPoint.DistanceTo(dim2.InsertionPoint) <= Classify.Tolerance &&

                            dim1.DimLinePosition.DistanceTo(dim2.DimLinePosition) <= Classify.Tolerance

                            )

                        {

                            if (ent1 is AngularDim ad1 && ent2 is AngularDim ad2)

                            {

                                if (

                                    ad1.ExtLine1.DistanceTo(ad2.ExtLine1) <= Classify.Tolerance &&

                                    ad1.ExtLine2.DistanceTo(ad2.ExtLine2) <= Classify.Tolerance &&

                                    Math.Abs(ad1.StartAngle - ad2.StartAngle) <= Classify.Tolerance &&

                                    Math.Abs(ad1.EndAngle - ad2.EndAngle) <= Classify.Tolerance &&

                                    Math.Abs(ad1.Radius - ad2.Radius) <= Classify.Tolerance

                                    )

                                {

                                    return true;

                                }

                            }

                            else if (ent1 is LinearDim ld1 && ent2 is LinearDim ld2)

                            {

                                if (

                                    ld1.ExtLine1.DistanceTo(ld2.ExtLine1) <= Classify.Tolerance &&

                                    ld1.ExtLine2.DistanceTo(ld2.ExtLine2) <= Classify.Tolerance

                                    )

                                {

                                    return true;

                                }

                            }

                            else if (ent1 is DiametricDim dd1 && ent2 is DiametricDim dd2)

                            {

                                if (

                                    Math.Abs(dd1.Distance - dd2.Distance) <= Classify.Tolerance &&

                                    Math.Abs(dd1.Radius - dd2.Radius) <= Classify.Tolerance &&

                                    Math.Abs(dd1.CenterMarkSize - dd2.CenterMarkSize) <= Classify.Tolerance

                                )

                                {

                                    return true;

                                }

                            }

                            else if (ent1 is RadialDim rd1 && ent2 is RadialDim rd2)

                            {

                                if (

                                    Math.Abs(rd1.Radius - rd2.Radius) <= Classify.Tolerance &&

                                    Math.Abs(rd1.CenterMarkSize - rd2.CenterMarkSize) <= Classify.Tolerance

                                )

                                {

                                    return true;

                                }

                            }

                            else if (ent1 is OrdinateDim od1 && ent2 is OrdinateDim od2)

                            {

                                if (

                                    od1.DefiningPoint.DistanceTo(od2.DefiningPoint) <= Classify.Tolerance &&

                                    od1.Origin.DistanceTo(od2.Origin) <= Classify.Tolerance &&

                                    od1.LeaderEndPoint.DistanceTo(od2.LeaderEndPoint) <= Classify.Tolerance

                                )

                                {

                                    return true;

                                }

                            }

                            else

                            {

                                Console.Write("Type " + ent1.GetType() + " not implemented.");

                                return true;

                            }

                        }

                    }

                    else if (ent1 is devDept.Eyeshot.Entities.Attribute att1 && ent2 is devDept.Eyeshot.Entities.Attribute att2)

                    {

                        if (

                            att1.Value == att2.Value &&

                            att1.InsertionPoint.DistanceTo(att2.InsertionPoint) <= Classify.Tolerance

                            )

                        {

                            return true;

                        }

                    }

                    else

                    {

                        Text tx1 = (Text)ent1;

                        Text tx2 = (Text)ent2;

                        #region 대소문자, 공백을 무시하여 비교

                        string string1 = tx1.TextString.Trim().ToUpper();

                        string string2 = tx2.TextString.Trim().ToUpper();

                        string1 = System.Text.RegularExpressions.Regex.Replace(string1, @"\s+", "");

                        string2 = System.Text.RegularExpressions.Regex.Replace(string2, @"\s+", "");

                        if (

                            tx1.BoxMin.DistanceTo(tx2.BoxMin) <= Classify.Tolerance &&

                            string1 == string2 &&

                            Math.Abs(tx1.WidthFactor - tx2.WidthFactor) <= Classify.Tolerance &&

                            Math.Abs(tx1.Height - tx2.Height) <= Classify.Tolerance

                            )

                        {

                            return true;

                        }

                        #endregion

                    }

                }

            }

            else if (ent1 is Line line1 && ent2 is Line line2)

            {

                var dir1 = line1.Direction;

                dir1.Normalize();

                var dir2 = line2.Direction;

                dir2.Normalize();

                if (devDept.Geometry.Vector3D.AreParallel(dir1, dir2, 0.1) &&

                    Math.Abs(line1.Length() - line2.Length()) <= line1.Length() * LengthToleranceRatio &&

                    line1.MidPoint.DistanceTo(line2.MidPoint) <= Classify.Tolerance

                )

                {

                    return true;

                }

            }

            else if (ent1 is Line && ent2 is devDept.Eyeshot.Entities.TabulatedSurface lwpolyline && lwpolyline.ControlPoints.Length == 4)

            {

                line1 = ent1 as Line;

                var start = new devDept.Geometry.Point3D(lwpolyline.ControlPoints[0, 0].X, lwpolyline.ControlPoints[0, 0].Y, 0);

                var end = new devDept.Geometry.Point3D(lwpolyline.ControlPoints[1, 0].X, lwpolyline.ControlPoints[1, 0].Y, 0);

                var vec = new devDept.Geometry.Vector3D(start, end);

                vec.Normalize();

                var dir = line1.Direction.Clone() as devDept.Geometry.Vector3D;

                dir.Normalize();

                if (

                    devDept.Geometry.Vector3D.AreParallel(dir, vec) &&

                    line1.StartPoint.DistanceTo(start) <= Classify.Tolerance &&

                    line1.EndPoint.DistanceTo(end) <= Classify.Tolerance

                )

                {

                    return true;

                }

            }

            else if (ent1 is devDept.Eyeshot.Entities.Point point1 && ent2 is devDept.Eyeshot.Entities.Point point2)

            {

                if (point1.Position.DistanceTo(point2.Position) <= Classify.Tolerance)

                {

                    return true;

                }

            }

            else if (ent1 is Curve cu1 && ent2 is Curve cu2)

            {

                if (

                    cu1.ControlPoints.Length == cu2.ControlPoints.Length &&

                    cu1.KnotVector.Length == cu2.KnotVector.Length &&

                    cu1.Degree == cu2.Degree

                    )

                {

                    for (int k = 0; k < cu1.ControlPoints.Length; k++)

                    {

                        if (cu1.ControlPoints[k].DistanceTo(cu2.ControlPoints[k]) > Classify.Tolerance)

                        {

                            return false;

                        }

                    }

                    for (int k = 0; k < cu1.KnotVector.Length; k++)

                    {

                        if (cu1.KnotVector[k] != cu2.KnotVector[k])

                        {

                            return false;

                        }

                    }

                    return true;

                }

            }

            else if (ent1 is Mesh m1 && ent2 is Mesh m2 && m1.Vertices.Count() == m2.Vertices.Count())

            {

                for (int i = 0; i < m1.Vertices.Count(); ++i)

                {

                    if (m1.Vertices[i].DistanceTo(m2.Vertices[i]) > Classify.Tolerance) return false;

                }

                return true;

            }

            else if (ent1 is BlockReference blkref1 && ent2 is BlockReference blkref2)

            {

                int equalCurvesInEntityList = 0;

                #region Point, Attribute, Text 제거 및 LinePath를 라인으로 분리

                var entities1 = blkref1.Explode(design1.Blocks).Where(x => x.LayerName != "AS_PORT" && !(x is devDept.Eyeshot.Entities.Point) &&

                !(x is devDept.Eyeshot.Entities.Attribute) && !(x is devDept.Eyeshot.Entities.Text)).ToList();

                var coll1 = new List<Entity>();

                entities1.ForEach(x =>

                {

                    if (x is LinearPath lp)

                    {

                        for (int i = 0; i < lp.Vertices.Length - 1; ++i)

                        {

                            if (lp.Vertices[i].DistanceTo(lp.Vertices[i + 1]) < 0.1) continue;

                            coll1.Add(new Line(lp.Vertices[i], lp.Vertices[i + 1]));

                        }

                    }

                    else

                    {

                        coll1.Add(x);

                    }

                });

                #endregion

                #region Point 및 Nesting Block 제거 및 LinePath를 라인으로 분리

                var entities2 = blkref2.Explode(design2.Blocks).Where(x =>

                !(x is devDept.Eyeshot.Entities.BlockReference blkref && blkref.BlockName == "PORT") && !(x is devDept.Eyeshot.Entities.Point)).ToList();

                var coll2 = new List<Entity>();

                entities2.ForEach(x =>

                {

                    if (x is LinearPath lp)

                    {

                        for (int i = 0; i < lp.Vertices.Length - 1; ++i)

                        {

                            if (lp.Vertices[i].DistanceTo(lp.Vertices[i + 1]) < 0.1) continue;

                            coll2.Add(new Line(lp.Vertices[i], lp.Vertices[i + 1]));

                        }

                    }

                    else if (x is devDept.Eyeshot.Entities.Attribute attr)

                    {

                        if (!attr.Invisible) coll2.Add(attr);

                    }

                    else if (x.GetType().Name == "AttributeReferenceData")

                    {

                    }

                    else

                    {

                        coll2.Add(x);

                    }

                });

                #endregion

                if (coll1.Count != coll2.Count) return false;

                foreach (var entC in coll1)

                {

                    foreach (var entC2 in coll2)

                    {

                        if (entC.GetType() == entC2.GetType())

                        {

                            if (entC is Entity && entC2 is Entity && CompareIfEqual(design1, entC as Entity, design2, entC2 as Entity))

                            {

                                equalCurvesInEntityList++;

                                break;

                            }

                        }

                    }

                }

                if (coll1.Count == equalCurvesInEntityList)

                {

                    return true;

                }

            }

            else

            {

                Console.Write("Type " + ent1.GetType() + " not implemented.");

                return false;

            }

            return false;

        }

        private bool AreGEntityEqual(GEntity ent1, GEntity ent2)

        {

            if (ent1 is GCompositeCurve cc1 && ent2 is GCompositeCurve cc2)

            {

                if (cc1.CurveList.Count == cc2.CurveList.Count)

                {

                    int equalCurvesInListCount = 0;

                    foreach (var entC in cc1.CurveList)

                    {

                        foreach (var entC2 in cc2.CurveList)

                        {

                            if (entC.GetType() == entC2.GetType())

                            {

                                if (entC is GEntity && entC2 is GEntity && CompareGEntityIfEqual(entC as GEntity, entC2 as GEntity))

                                {

                                    equalCurvesInListCount++;

                                    break;

                                }

                            }

                        }

                    }

                    if (cc1.CurveList.Count == equalCurvesInListCount)

                    {

                        return true;

                    }

                }

            }

            else if (ent1 is GLinearPath lp1 && ent2 is GLinearPath lp2)

            {

                if (lp1.Vertices.Length == lp2.Vertices.Length)

                {

                    for (int i = 0; i < lp1.Vertices.Length; i++)

                    {

                        if (lp1.Vertices[i].DistanceTo(lp2.Vertices[i]) > Classify.Tolerance)

                            return false;

                    }

                    return true;

                }

            }

            else if (ent1 is GPlanarEntity pe1 && ent2 is GPlanarEntity pe2)

            {

                if (

                    pe1.Plane.AxisZ == pe2.Plane.AxisZ &&

                    pe1.Plane.AxisX == pe2.Plane.AxisX

                    )

                {

                    if (ent1 is GArc arc1 && ent2 is GArc arc2)

                    {

                        if (

                            arc1.Center.DistanceTo(arc2.Center) <= Classify.Tolerance &&

                            Math.Abs(arc1.Radius - arc2.Radius) <= Classify.Tolerance &&

                            Math.Abs(arc1.Domain.Min - arc2.Domain.Min) <= Classify.Tolerance &&

                            Math.Abs(arc1.Domain.Max - arc2.Domain.Max) <= Classify.Tolerance

                            )

                        {

                            return true;

                        }

                    }

                    else if (ent1 is GCircle c1 && ent2 is GCircle c2)

                    {

                        if (c1.Center.DistanceTo(c2.Center) <= Classify.Tolerance && 

                            Math.Abs(c1.Radius - c2.Radius) <= Classify.Tolerance)

                        {

                            return true;

                        }

                    }

                    else if (ent1 is GEllipticalArc e1 && ent2 is GEllipticalArc e2)

                    {

                        if (

                            e1.Center.DistanceTo(e2.Center) <= Classify.Tolerance &&

                            Math.Abs(e1.RadiusX - e2.RadiusX) <= Classify.Tolerance &&

                            Math.Abs(e1.RadiusY - e2.RadiusY) <= Classify.Tolerance &&

                            Math.Abs(e1.Domain.Low - e2.Domain.Low) <= Classify.Tolerance &&

                            Math.Abs(e1.Domain.High - e2.Domain.High) <= Classify.Tolerance

                        )

                        {

                            return true;

                        }

                    }

                    else if (ent1 is GEllipse el1 && ent2 is GEllipse el2)

                    {

                        if (

                            el1.Center.DistanceTo(el2.Center) <= Classify.Tolerance &&

                            Math.Abs(el1.RadiusX - el2.RadiusX) <= Classify.Tolerance &&

                            Math.Abs(el1.RadiusY - el2.RadiusY) <= Classify.Tolerance

                        )

                        {

                            return true;

                        }

                    }

                    else

                    {

                        Console.Write("Type " + ent1.GetType() + " not implemented.");

                        return true;

                    }

                }

            }

            else if (ent1 is GLine line1 && ent2 is GLine line2)

            {

                if (line1.StartPoint.DistanceTo(line2.StartPoint) <= Classify.Tolerance && 

                    line1.EndPoint.DistanceTo(line2.EndPoint) <= Classify.Tolerance

                )

                {

                    return true;

                }

            }

#if NURBS

            else if (ent1 is Curve)

            {

                Curve cu1 = (Curve)ent1;

                Curve cu2 = (Curve)ent2;

                if (

                    cu1.ControlPoints.Length == cu2.ControlPoints.Length &&

                    cu1.KnotVector.Length == cu2.KnotVector.Length &&

                    cu1.Degree == cu2.Degree

                    )

                {

                    for (int k = 0; k < cu1.ControlPoints.Length; k++)

                    {

                        if (cu1.ControlPoints[k] != cu2.ControlPoints[k])

                        {

                            return false;

                        }

                    }

                    for (int k = 0; k < cu1.KnotVector.Length; k++)

                    {

                        if (cu1.KnotVector[k] != cu2.KnotVector[k])

                        {

                            return false;

                        }

                    }

                    return true;

                }

            }

#endif

            else

            {

                Console.Write("Type " + ent1.GetType() + " not implemented.");

                return true;

            }

            return false;

        }

    }

}