HYTOS

using DevExpress.Utils.StructuredStorage.Internal.Reader;

using System;

using System.Collections.Generic;

using System.Data;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Xml.Linq;

namespace ID2PSN

{

    public class Document

    {

        public string DrawingName { get; set; }

        public string FileName { get; set; }

        public string FilePath { get; set; }

        public List<Item> Items { get; set; }

        public List<LineNumber> LineNumbers { get; set; }

        public List<Group> Groups { get; set; }

        public List<RunInfo> RunInfos { get; set; }

        public List<Item> SegmentBreaks { get; set; }

        public List<Equipment> Equipments { get; set; }

        public List<TextInfo> TextInfos { get; set; }

        private DataTable symbolNameTable = null;

        private DataTable equipmentTable = DB.GetEquipmentType();

        public Document(string filePath, DataTable symbolNameTable)

        {

            this.symbolNameTable = symbolNameTable;

            FilePath = filePath;

            // XML Data 정리

            ReadFile();

            // 해당 소스는 Line-Equipment가 붙어있을 시 가상의 Nozzle Data를 넣어줌 (삼엔 요청)

            InsertNozzle();

            // ID2 Item Relation 정보 기준으로 Item Object 연결

            SetRelationItem();

            // 속성 상관 없이 drawing 단위의 PSN 생성

            SetGroup();

            // Instrument Line이 있는 아이템/group 제거

            RemoveItems();

            foreach (var item in Items)

                item.Document = this;

        }

        private void ReadFile()

        {

            XElement xml = XElement.Load(FilePath);

            FileName = Path.GetFileNameWithoutExtension(FilePath);

            DrawingName = xml.Element("DWGNAME").Value;

            Items = new List<Item>();

            LineNumbers = new List<LineNumber>();

            RunInfos = new List<RunInfo>();

            Groups = new List<Group>();

            SegmentBreaks = new List<Item>();

            Equipments = new List<Equipment>();

            TextInfos = new List<TextInfo>();

            foreach (XElement element in xml.Element("SYMBOLS").Elements("SYMBOL"))

                Items.Add(GetSymbolItem(element));

            foreach (XElement element in xml.Element("LINEINFOS").Elements("LINE"))

                Items.Add(GetLineItem(element));

            foreach (XElement element in xml.Element("LINENOS").Elements("LINE_NO"))

                LineNumbers.Add(GetLineNumber(element));

            foreach (XElement element in xml.Element("VENDORS").Elements("VENDOR"))

                Equipments.Add(GetEquipment(element));

            foreach (XElement element in xml.Element("TEXTINFOS").Elements("ATTRIBUTE"))

                TextInfos.Add(GetTextInfo(element));

            List<Item> segmentBreaks = Items.FindAll(x => x.ID2DBType.ToUpper() == "Segment Breaks".ToUpper() || x.ID2DBType.ToUpper() == "End Break".ToUpper());

            SegmentBreaks.AddRange(segmentBreaks);

            foreach (var item in segmentBreaks)

                Items.Remove(item);

            foreach (DataRow row in equipmentTable.Rows)

            {

                string type = row["Type"].ToString();

                List<Item> equipments = Items.FindAll(x => x.ID2DBType == type);

                foreach (Item item in equipments)

                {

                    Equipments.Add(ConvertEquipment(item));

                    Items.Remove(item);

                }

            }

            SetRunInfo(xml);

        }

        private Item GetSymbolItem(XElement element)

        {

            Item item = new Item();

            item.UID = element.Element("UID").Value;

            item.Name = element.Element("NAME").Value;

            item.ID2DBType = element.Element("TYPE").Value;

            item.Owner = element.Element("OWNER").Value;

            item.ID2DBName = element.Element("PARENT").Value;

            string[] sPoint = element.Element("ORIGINALPOINT").Value.Split(new char[] { ',' });

            item.POINT = new double[] { Convert.ToDouble(sPoint[0]), Convert.ToDouble(sPoint[1]) };

            item.ANGLE = element.Element("ANGLE").Value;

            item.Relations = GetRelations(element.Element("CONNECTORS"));

            item.Attributes = GetAttributes(element.Element("SYMBOLATTRIBUTES"));

            item.ItemType = ItemType.Symbol;

            item.ID2DBCategory = GetID2DBCategory(item.ID2DBType, item.ID2DBName);

            if (item.ID2DBType.ToUpper().Equals("PIPING OPC'S"))

                item.SubItemType = SubItemType.OPC;

            else if (item.ID2DBType.ToUpper().Equals("NOZZLES"))

                item.SubItemType = SubItemType.Nozzle;

            return item;

        }

        private Item GetLineItem(XElement element)

        {

            Item item = new Item();

            item.UID = element.Element("UID").Value;

            item.Name = element.Element("TYPE").Value;

            item.ID2DBType = element.Element("TYPE").Value;

            item.Owner = element.Attribute("OWNER").Value;

            item.Relations = GetRelations(element.Element("CONNECTORS"));

            item.Attributes = GetAttributes(element.Element("SYMBOLATTRIBUTES"));

            item.ItemType = ItemType.Line;

            return item;

        }

        private LineNumber GetLineNumber(XElement element)

        {

            LineNumber lineNumber = new LineNumber();

            lineNumber.UID = element.Element("UID").Value;

            lineNumber.Name = element.Element("TEXT").Value;

            lineNumber.Attributes = GetAttributes(element);

            return lineNumber;

        }

        private Equipment GetEquipment(XElement element)

        {

            Equipment item = new Equipment();

            item.UID = element.Element("UID").Value;

            item.Attributes = GetAttributes(element.Element("SYMBOLATTRIBUTES"));

            string[] sPoint = element.Element("POINT").Value.Split(new char[] { '/' });

            foreach (var sp in sPoint)

            {

                string[] xy = sp.Split(new char[] { ',' });

                item.POINT.Add(new double[] { Convert.ToDouble(xy[0]), Convert.ToDouble(xy[1]) });

            }

            return item;

        }

        private TextInfo GetTextInfo(XElement element)

        {

            TextInfo textInfo = new TextInfo();

            textInfo.Value = element.Element("VALUE").Value;

            textInfo.Area = element.Element("AREA").Value;

            return textInfo;

        }

        private Equipment ConvertEquipment(Item item)

        {

            Equipment equipment = new Equipment();

            equipment.Name = item.Name;

            equipment.UID = item.UID;

            equipment.POINT.Add(item.POINT);

            equipment.Attributes.AddRange(item.Attributes);

            return equipment;

        }

        private List<Relation> GetRelations(XElement element)

        {

            List<Relation> result = new List<Relation>();

            foreach (XElement item in element.Elements("CONNECTOR"))

            {

                string[] sPoint = item.Element("SCENECONNECTPOINT").Value.Split(new char[] { ',' });

                result.Add(new Relation()

                {

                    UID = item.Element("CONNECTEDITEM").Value,

                    Point = new double[] { Convert.ToDouble(sPoint[0]), Convert.ToDouble(sPoint[1]) }

                });

            }

            return result;

        }

        private List<Attribute> GetAttributes(XElement element)

        {

            List<Attribute> result = new List<Attribute>();

            foreach (XElement item in element.Elements("ATTRIBUTE"))

            {

                result.Add(new Attribute()

                {

                    UID = item.Attribute("UID").Value,

                    Name = item.Attribute("Attribute").Value,

                    DisplayName = item.Attribute("DisplayAttribute").Value,

                    Value = item.Value

                });

            }

            return result;

        }

        private string GetID2DBCategory(string type, string name)

        {

            string result = string.Empty;

            DataRow[] rows = symbolNameTable.Select(string.Format("Type = '{0}' AND Name = '{1}'", type.Replace("'", "''"), name.Replace("'", "''")));

            if (rows.Length.Equals(1))

                result = rows.First()["Category"].ToString();

            return result;

        }

        private void SetRelationItem()

        {

            foreach (Item item in Items)

                foreach (Relation relation in item.Relations)

                    relation.Item = Items.Find(x => x.UID.Equals(relation.UID));

        }

        private void SetRunInfo(XElement xml)

        {

            foreach (XElement element in xml.Element("LINENOS").Elements("LINE_NO"))

            {

                string UID = element.Element("UID").Value;

                foreach (XElement run in element.Elements("RUN"))

                {

                    RunInfo runInfo = new RunInfo() { UID = UID };

                    foreach (XElement line in run.Elements("LINE"))

                        runInfo.Items.Add(Items.Find(x => x.UID == line.Element("UID").Value));

                    foreach (XElement symbol in run.Elements("SYMBOL"))

                        runInfo.Items.Add(Items.Find(x => x.UID == symbol.Element("UID").Value));

                    RunInfos.Add(runInfo);

                }

            }

            foreach (XElement element in xml.Element("TRIMLINENOS").Elements("TRIM_LINE_NO"))

            {

                string UID = element.Element("UID").Value;

                foreach (XElement run in element.Elements("RUN"))

                {

                    RunInfo runInfo = new RunInfo() { UID = UID };

                    foreach (XElement line in run.Elements("LINE"))

                        runInfo.Items.Add(Items.Find(x => x.UID == line.Element("UID").Value));

                    foreach (XElement symbol in run.Elements("SYMBOL"))

                        runInfo.Items.Add(Items.Find(x => x.UID == symbol.Element("UID").Value));

                    RunInfos.Add(runInfo);

                }

            }

        }

        private void SetGroup()

        {

            List<Item> orderItems = Items.OrderByDescending(x => x.ItemType == ItemType.Line).ToList();

            Dictionary<Item, string> itemDic = new Dictionary<Item, string>();

            foreach (Item item in orderItems)

                itemDic.Add(item, Guid.NewGuid().ToString());

            foreach (Item item in orderItems)

            {

                string groupKey = itemDic[item];

                if (item.ItemType == ItemType.Line)

                {

                    GroupingForwardLine();

                    GroupingBackwardLine();

                }

                void GroupingForwardLine()

                {

                    Item connItem = item.Relations[1].Item;

                    if (connItem != null && IsConnected(connItem, item))

                    {

                        if (connItem.ItemType == ItemType.Line && item.Equals(connItem.Relations[0].Item))

                            ChangeGroupID(itemDic[connItem], groupKey);

                        else if (connItem.ItemType == ItemType.Symbol)

                        {

                            List<Item> allConnItems = GetConnectedLines(connItem);

                            allConnItems.Remove(item);

                            List<Item> connItems = GetConnectedForwardLines(connItem);

                            if (allConnItems.Count.Equals(1) && connItems.Count.Equals(1) && allConnItems[0].Equals(connItems[0]))

                            {

                                List<Item> connSymbols = GetConnectedSymbols(connItem);

                                foreach (Item loopItem in connSymbols)

                                    ChangeGroupID(itemDic[loopItem], groupKey);

                            }

                            else

                            {

                                List<Item> endItems = new List<Item>();

                                Stack<Item> stacks = new Stack<Item>();

                                stacks.Push(connItem);

                                while (stacks.Count > 0)

                                {

                                    Item stack = stacks.Pop();

                                    if (endItems.Contains(stack))

                                        continue;

                                    endItems.Add(stack);

                                    if (GetConnectedItemCount(stack) < 3)

                                    {

                                        ChangeGroupID(itemDic[stack], groupKey);

                                        List<Relation> relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Symbol);

                                        foreach (Relation relation in relations)

                                            stacks.Push(relation.Item);

                                    }

                                    else if (IsSameRun(item, stack))

                                    {

                                        ChangeGroupID(itemDic[stack], groupKey);

                                        List<Relation> relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Symbol && IsSameRun(item, x.Item));

                                        foreach (Relation relation in relations)

                                            stacks.Push(relation.Item);

                                    }

                                }

                            }

                        }

                    }

                }

                void GroupingBackwardLine()

                {

                    Item connItem = item.Relations[0].Item;

                    if (connItem != null && IsConnected(connItem, item))

                    {

                        if (connItem.ItemType == ItemType.Line && item.Equals(connItem.Relations[1].Item))

                            ChangeGroupID(itemDic[connItem], groupKey);

                        else if (connItem.ItemType == ItemType.Symbol)

                        {

                            List<Item> allConnItems = GetConnectedLines(connItem);

                            allConnItems.Remove(item);

                            List<Item> connItems = GetConnectedBackwardLines(connItem);

                            if (allConnItems.Count.Equals(1) && connItems.Count.Equals(1) && allConnItems[0].Equals(connItems[0]))

                            {

                                List<Item> connSymbols = GetConnectedSymbols(connItem);

                                foreach (Item loopItem in connSymbols)

                                    ChangeGroupID(itemDic[loopItem], groupKey);

                            }

                            else

                            {

                                List<Item> endItems = new List<Item>();

                                Stack<Item> stacks = new Stack<Item>();

                                stacks.Push(connItem);

                                while (stacks.Count > 0)

                                {

                                    Item stack = stacks.Pop();

                                    if (endItems.Contains(stack))

                                        continue;

                                    endItems.Add(stack);

                                    if (GetConnectedItemCount(stack) < 3)

                                    {

                                        ChangeGroupID(itemDic[stack], groupKey);

                                        List<Relation> relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Symbol);

                                        foreach (Relation relation in relations)

                                            stacks.Push(relation.Item);

                                    }

                                    else if (IsSameRun(item, stack))

                                    {

                                        ChangeGroupID(itemDic[stack], groupKey);

                                        List<Relation> relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Symbol && IsSameRun(item, x.Item));

                                        foreach (Relation relation in relations)

                                            stacks.Push(relation.Item);

                                    }

                                }

                            }

                        }

                    }

                }

            }

            List<string> endGroupIds = new List<string>();

            foreach (var item in itemDic)

            {

                if (endGroupIds.Contains(item.Value))

                    continue;

                endGroupIds.Add(item.Value);

                List<Item> groupItems = itemDic.Where(x => x.Value.Equals(item.Value)).Select(x => x.Key).ToList();

                if (groupItems.Find(x => x.ItemType == ItemType.Line) == null)

                {

                    foreach (var groupItem in groupItems)

                        Items.Remove(groupItem);

                }

                else

                {

                    Group group = new Group(this);

                    group.Items = groupItems;

                    group.UID = item.Value;

                    group.SortItems();

                    foreach (Item groupItem in groupItems)

                        groupItem.Group = group;

                    Groups.Add(group);

                }

            }

            #region HeaderSetting

            List<HeaderInfo> HeaderInfos = new List<HeaderInfo>();

            DataTable dt = DB.SelectHeaderSetting();

            foreach (DataRow row in dt.Rows)

            {

                string groupID = row["GROUP_ID"].ToString();

                string desc = row["DESCRIPTION"].ToString();

                int index = Convert.ToInt32(row["INDEX"]);

                string name = row["NAME"].ToString();

                HeaderInfo headerInfo = HeaderInfos.Find(x => x.UID.Equals(groupID));

                if (headerInfo == null)

                {

                    headerInfo = new HeaderInfo(groupID);

                    headerInfo.Description = desc;

                    HeaderInfos.Add(headerInfo);

                }

                headerInfo.HeaderItems.Add(new HeaderItem()

                {

                    Index = index,

                    Name = name

                });

            }

            foreach (HeaderInfo headerInfo in HeaderInfos)

                headerInfo.HeaderItems = headerInfo.HeaderItems.OrderBy(x => x.Index).ToList();

            foreach (Group group in Groups)

            {

                List<HeaderInfo> endInfos = new List<HeaderInfo>();

                bool bFind = false;

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

                {

                    Item item = group.Items[i];

                    foreach (HeaderInfo header in HeaderInfos)

                    {

                        if (endInfos.Contains(header))

                            continue;

                        if (!header.HeaderItems[i].Name.Equals(item.Name))

                        {

                            endInfos.Add(header);

                            continue;

                        }

                        if (header.HeaderItems.Count.Equals(i + 1))

                        {

                            for (int j = 0; j < i + 1; j++)

                                group.Items[j].SubItemType = SubItemType.Header;

                            bFind = true;

                            break;

                        }

                    }

                    if (bFind || endInfos.Count.Equals(HeaderInfos.Count))

                        break;

                }

                endInfos = new List<HeaderInfo>();

                bFind = false;

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

                {

                    Item item = group.Items[group.Items.Count - i - 1];

                    foreach (HeaderInfo header in HeaderInfos)

                    {

                        if (endInfos.Contains(header))

                            continue;

                        if (!header.HeaderItems[i].Name.Equals(item.Name))

                        {

                            endInfos.Add(header);

                            continue;

                        }

                        if (header.HeaderItems.Count.Equals(i + 1))

                        {

                            for (int j = 0; j < i + 1; j++)

                                group.Items[group.Items.Count - j - 1].SubItemType = SubItemType.Header;

                            bFind = true;

                            break;

                        }

                    }

                    if (bFind || endInfos.Count.Equals(HeaderInfos.Count))

                        break;

                }

            }

            #endregion

            int GetConnectedItemCount(Item item)

            {

                return item.Relations.FindAll(x => x.Item != null).Count;

            }

            List<Item> GetConnectedLines(Item item)

            {

                List<Item> result = new List<Item>();

                List<Item> end = new List<Item>();

                Stack<Item> stacks = new Stack<Item>();

                stacks.Push(item);

                while (stacks.Count > 0)

                {

                    Item stack = stacks.Pop();

                    if (end.Contains(stack) || stack.ItemType != ItemType.Symbol)

                        continue;

                    end.Add(stack);

                    List<Relation> relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Symbol);

                    foreach (Relation relation in relations)

                        stacks.Push(relation.Item);

                    relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Line);

                    foreach (Relation relation in relations)

                    {

                        result.Add(relation.Item);

                        end.Add(relation.Item);

                    }

                }

                return result;

            }

            List<Item> GetConnectedForwardLines(Item item)

            {

                List<Item> result = new List<Item>();

                List<Item> end = new List<Item>();

                Stack<Item> stacks = new Stack<Item>();

                stacks.Push(item);

                while (stacks.Count > 0)

                {

                    Item stack = stacks.Pop();

                    if (end.Contains(stack) || stack.ItemType != ItemType.Symbol)

                        continue;

                    end.Add(stack);

                    List<Relation> relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Symbol);

                    foreach (Relation relation in relations)

                        stacks.Push(relation.Item);

                    relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Line);

                    foreach (Relation relation in relations)

                    {

                        if (relation.Item.Relations.FindIndex(x => x.Item != null && x.Item.Equals(stack)).Equals(0))

                            result.Add(relation.Item);

                        end.Add(relation.Item);

                    }

                }

                return result;

            }

            List<Item> GetConnectedBackwardLines(Item item)

            {

                List<Item> result = new List<Item>();

                List<Item> end = new List<Item>();

                Stack<Item> stacks = new Stack<Item>();

                stacks.Push(item);

                while (stacks.Count > 0)

                {

                    Item stack = stacks.Pop();

                    if (end.Contains(stack) || stack.ItemType != ItemType.Symbol)

                        continue;

                    end.Add(stack);

                    List<Relation> relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Symbol);

                    foreach (Relation relation in relations)

                        stacks.Push(relation.Item);

                    relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Line);

                    foreach (Relation relation in relations)

                    {

                        if (relation.Item.Relations.FindIndex(x => x.Item != null && x.Item.Equals(stack)).Equals(1))

                            result.Add(relation.Item);

                        end.Add(relation.Item);

                    }

                }

                return result;

            }

            List<Item> GetConnectedSymbols(Item item)

            {

                List<Item> result = new List<Item>();

                List<Item> end = new List<Item>();

                Stack<Item> stacks = new Stack<Item>();

                stacks.Push(item);

                while (stacks.Count > 0)

                {

                    Item stack = stacks.Pop();

                    if (end.Contains(stack) || stack.ItemType != ItemType.Symbol)

                        continue;

                    end.Add(stack);

                    result.Add(stack);

                    List<Relation> relations = stack.Relations.FindAll(x => x.Item != null && x.Item.ItemType == ItemType.Symbol);

                    foreach (Relation relation in relations)

                        stacks.Push(relation.Item);

                }

                return result;

            }

            void ChangeGroupID(string from, string to)

            {

                if (from.Equals(to))

                    return;

                List<Item> changeItems = new List<Item>();

                foreach (var _item in itemDic)

                    if (_item.Value.Equals(from))

                        changeItems.Add(_item.Key);

                foreach (var _item in changeItems)

                    itemDic[_item] = to;

            }

            bool IsConnected(Item item1, Item item2)

            {

                if (item1.Relations.Find(x => x.UID.Equals(item2.UID)) != null &&

                    item2.Relations.Find(x => x.UID.Equals(item1.UID)) != null)

                    return true;

                else

                    return false;

            }

            bool IsSameRun(Item item1, Item item2)

            {

                return RunInfos.Find(x => x.Items.Contains(item1) && x.Items.Contains(item2)) != null ? true : false;

            }

        }

        private void RemoveItems()

        {

            List<Group> removeGroups = new List<Group>();

            foreach (Group group in Groups)

            {

                Item instLine = group.Items.Find(x => x.ItemType == ItemType.Line && (x.Name != "Secondary" && x.Name != "Primary"));

                if (instLine != null)

                    removeGroups.Add(group);

            }

            foreach (Group group in removeGroups)

            {

                foreach (var item in group.Items)

                    Items.Remove(item);

                Groups.Remove(group);

            }

        }

        private void InsertNozzle()

        {

            List<Item> newNozzles = new List<Item>();

            foreach (var item in Items)

            {

                if (item.SubItemType == SubItemType.Nozzle)

                    continue;

                foreach (Relation relation in item.Relations)

                {

                    Equipment equipment = Equipments.Find(x => x.UID == relation.UID);

                    if (equipment != null)

                    {

                        Item newNozzle = new Item();

                        newNozzle.UID = Guid.NewGuid().ToString();

                        newNozzle.Name = "PSN_Nozzle";

                        newNozzle.ID2DBType = "Nozzles";

                        newNozzle.Owner = item.Owner;

                        newNozzle.ID2DBName = "PSN_Nozzle";

                        newNozzle.POINT = relation.Point;

                        newNozzle.Relations = new List<Relation>();

                        newNozzle.Relations.Add(new Relation()

                        {

                            Point = relation.Point,

                            UID = equipment.UID

                        });

                        newNozzle.Relations.Add(new Relation()

                        {

                            Point = relation.Point,

                            UID = item.UID

                        });

                        newNozzle.ItemType = ItemType.Symbol;

                        newNozzle.SubItemType = SubItemType.Nozzle;

                        newNozzles.Add(newNozzle);

                        relation.UID = newNozzle.UID;

                    }

                }

            }

            Items.AddRange(newNozzles);

        }

    }

}