HYTOS

using System;

using System.Collections.Generic;

using System.Data;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ID2PSN

{

    public enum PSNType

    {

        None,

        Branch,

        Equipment,

        Header,

        Symbol,

        OPC,

    }

    public class PSN

    {

        public DataTable PathItems { get; set; }

        public DataTable SequenceData { get; set; }

        public DataTable PipeSystemNetwork { get; set; }

        public DataTable Equipment { get; set; }

        public DataTable Nozzle { get; set; }

        List<Document> Documents;

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

        List<PSNItem> PSNItems = new List<PSNItem>();

        List<Topology> Topologies = new List<Topology>();

        DataTable opcDT = null;

        DataTable topologyRuleDT = null;

        const string FluidPriorityType = "FLUIDCODE";

        const string PipingMaterialsPriorityType = "PIPINGMATERIALSCLASS";

        public PSN(List<Document> documents)

        {

            Documents = documents;

            foreach (Document document in Documents)

                groups.AddRange(document.Groups);

            opcDT = GetOPCInfo();

            topologyRuleDT = GetTopologyRule();

        }

        public void SetPSNData()

        {

            SetTopologyData();

            ConnectByOPC();

            SetPSNItem();

            SetPSNType();

            SetBranchInfo();

            SetTopology();

            SaveNozzleAndEquipment();

            SavePSNData();

        }

        private void SetTopologyData()

        {

            foreach (Document document in Documents)

            {

                foreach (Item item in document.Items)

                {

                    item.TopologyData = string.Empty;

                    LineNumber lineNumber = document.LineNumbers.Find(x => x.UID == item.Owner);

                    if (lineNumber != null)

                    {

                        item.LineNumber = lineNumber;

                        foreach (DataRow row in topologyRuleDT.Rows)

                        {

                            string uid = row["UID"].ToString();

                            if (uid == "-")

                                item.TopologyData += "-"; 

                            else

                            {

                                Attribute attribute = lineNumber.Attributes.Find(x => x.UID == uid);

                                if (attribute != null)

                                    item.TopologyData += attribute.Value;

                            }

                        }

                    }

                }

            }

        }

        private void ConnectByOPC()

        {

            foreach (Group group in groups.FindAll(x => x.Items.Last().SubItemType == SubItemType.OPC))

            {

                Item opcItem = group.Items.Last();

                DataRow[] fromRows = opcDT.Select(string.Format("FromOPCUID = '{0}'", opcItem.UID));

                if (fromRows.Length.Equals(1))

                {

                    DataRow opcRow = fromRows.First();

                    string toDrawing = opcRow["ToDrawing"].ToString();

                    string toOPCUID = opcRow["ToOPCUID"].ToString();

                    Document toDocument = Documents.Find(x => x.DrawingName == toDrawing);

                    Group toGroup = toDocument.Groups.Find(x => x.Items.Find(y => y.UID == toOPCUID) != null);

                    group.EndGroup = toGroup;

                    toGroup.StartGroup = group;

                }

            }

        }

        private void SetPSNItem()

        {

            Dictionary<Group, string> groupDic = new Dictionary<Group, string>(); 

            foreach (Group group in groups)

                groupDic.Add(group, Guid.NewGuid().ToString());

            foreach (Group group in groups)

            {

                string groupKey = groupDic[group];

                if (group.StartGroup != null)

                {

                    string otherKey = groupDic[group.StartGroup];

                    ChangeGroupID(otherKey, groupKey);

                }

            }

            // PSN 정리

            foreach (var item in groupDic)

            {

                Group group = item.Key;

                string uid = item.Value;

                PSNItem PSNItem = PSNItems.Find(x => x.UID == uid);

                if (PSNItem == null)

                {

                    PSNItem = new PSNItem() { UID = uid };

                    PSNItems.Add(PSNItem);

                }

                PSNItem.Groups.Add(group);

            }

            // Sort PSN

            foreach (PSNItem PSNItem in PSNItems)

            {

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

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

                stacks.Push(PSNItem.Groups.First());

                while (stacks.Count > 0)

                {

                    Group stack = stacks.Pop();

                    if (_groups.Contains(stack))

                        continue;

                    if (_groups.Count == 0)

                        _groups.Add(stack);

                    else

                    {

                        if (stack.StartGroup != null && _groups.Contains(stack.StartGroup))

                        {

                            int index = _groups.IndexOf(stack.StartGroup);

                            _groups.Insert(index + 1, stack);

                        }

                        else if (stack.EndGroup != null && _groups.Contains(stack.EndGroup))

                        {

                            int index = _groups.IndexOf(stack.EndGroup);

                            _groups.Insert(index, stack);

                        }

                    }

                    if (stack.StartGroup != null)

                        stacks.Push(stack.StartGroup);

                    if (stack.EndGroup != null)

                        stacks.Push(stack.EndGroup);

                }

                PSNItem.Groups.Clear();

                PSNItem.Groups.AddRange(_groups);

            }

            void ChangeGroupID(string from, string to)

            {

                if (from.Equals(to))

                    return;

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

                foreach (var _item in groupDic)

                    if (_item.Value.Equals(from))

                        changeItems.Add(_item.Key);

                foreach (var _item in changeItems)

                    groupDic[_item] = to;

            }

        }

        private void SetPSNType()

        {

            foreach (PSNItem PSNItem in PSNItems)

            {

                Group firstGroup = PSNItem.Groups.First();

                Group lastGroup = PSNItem.Groups.Last();

                Item firstItem = firstGroup.Items.First();

                Item lastItem = lastGroup.Items.Last();

                PSNItem.StartType = GetPSNType(firstItem, true);

                PSNItem.EndType = GetPSNType(lastItem, false);

            }

            PSNType GetPSNType(Item item, bool bFirst = true)

            {

                PSNType type = PSNType.None;

                if (item.ItemType == ItemType.Line)

                {

                    Group group = groups.Find(x => x.Items.Contains(item));

                    if (bFirst && item.Relations[0].Item != null && !group.Items.Contains(item.Relations[0].Item))

                    {

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

                        if (connItem.ItemType == ItemType.Line && !IsConnected(item, connItem))

                            type = PSNType.Branch;

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

                            type = PSNType.Symbol;

                    }

                    else if (!bFirst && item.Relations[1].Item != null && !group.Items.Contains(item.Relations[1].Item))

                    {

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

                        if (connItem.ItemType == ItemType.Line && !IsConnected(item, connItem))

                            type = PSNType.Branch;

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

                            type = PSNType.Symbol;

                    }

                }

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

                {

                    if (item.SubItemType == SubItemType.Nozzle)

                        type = PSNType.Equipment;

                    else if (item.SubItemType == SubItemType.Header)

                        type = PSNType.Header;

                    else if (item.SubItemType == SubItemType.OPC)

                        type = PSNType.OPC;

                }

                return type;

            }

        }

        private void SetBranchInfo()

        {

            foreach (Document document in Documents)

            {

                List<Item> lines = document.Items.FindAll(x => x.ItemType == ItemType.Line).ToList();

                foreach (Item line in lines)

                {

                    double[] point = line.Relations[0].Point;

                    List<Item> connLines = lines.FindAll(x => x.Relations.Find(y => y.UID == line.UID) != null && line.Relations.Find(y => y.UID == x.UID) == null);

                    connLines.Sort(SortBranchLine);

                    line.BranchItems.AddRange(connLines);

                    int SortBranchLine(Item a, Item b)

                    {

                        double[] pointA = a.Relations[0].UID == line.UID ? a.Relations[0].Point : a.Relations[1].Point;

                        double distanceA = CalcPointToPointdDistance(point[0], point[1], pointA[0], pointA[1]);

                        double[] pointB = b.Relations[0].UID == line.UID ? b.Relations[0].Point : b.Relations[1].Point;

                        double distanceB = CalcPointToPointdDistance(point[0], point[1], pointB[0], pointB[1]);

                        // 내림차순

                        return distanceA.CompareTo(distanceB);

                    }

                    double CalcPointToPointdDistance(double x1, double y1, double x2, double y2)

                    {

                        return Math.Pow(Math.Pow(x1 - x2, 2) + Math.Pow(y1 - y2, 2), 0.5);

                    }

                }

            }

        }

        private void SetTopology()

        {

            #region 기본 topology 정리

            foreach (PSNItem PSNItem in PSNItems)

            {

                Topology topology = null;

                foreach (Group group in PSNItem.Groups)

                {

                    foreach (Item item in group.Items)

                    {

                        if (string.IsNullOrEmpty(item.TopologyData))

                            topology = null;

                        else

                        {

                            if (topology == null)

                            {

                                topology = new Topology()

                                {

                                    ID = item.TopologyData

                                };

                                Topologies.Add(topology);

                                if (!PSNItem.Topologies.Contains(topology))

                                    PSNItem.Topologies.Add(topology);

                            }

                            else

                            {

                                if (topology.ID != item.TopologyData)

                                {

                                    topology = new Topology()

                                    {

                                        ID = item.TopologyData

                                    };

                                    Topologies.Add(topology);

                                    if (!PSNItem.Topologies.Contains(topology))

                                        PSNItem.Topologies.Add(topology);

                                }

                            }

                            item.Topology = topology;

                            topology.Items.Add(item);

                        }

                    }

                }

            }

            #endregion

            #region Type

            DataTable nominalDiameterDT = DB.SelectNominalDiameter();

            List<string> ids = Topologies.Select(x => x.ID).Distinct().ToList();

            foreach (string id in ids)

            {

                List<Topology> topologies = Topologies.FindAll(x => x.ID == id);

                FindMainTopology(topologies);

                // Main

                List<Topology> mainTopologies = topologies.FindAll(x => x.Items.Find(y => y.SubItemType == SubItemType.Nozzle) != null);

                if (mainTopologies.Count != 0)

                {

                    foreach (Topology topology in mainTopologies)

                    {

                        topology.Type = "M";

                        topology.Index = mainTopologies.IndexOf(topology).ToString();

                    }

                }

                else

                {

                }

                // Branch

                List<Topology> branchToplogies = topologies.FindAll(x => string.IsNullOrEmpty(x.Type));

                foreach (Topology topology in branchToplogies)

                {

                    topology.Type = "B";

                    topology.Index = (branchToplogies.IndexOf(topology) + 1).ToString();

                }

            }

            #endregion

        }

        private List<Topology> FindMainTopology(List<Topology> data)

        {

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

            result.AddRange(data);

            //

            result  = data.FindAll(x => x.Items.Find(y => y.SubItemType == SubItemType.Nozzle) != null);

            return result;

        }

        private DataTable GetOPCInfo()

        {

            DataTable opc = DB.SelectOPCRelations();

            DataTable drawing = DB.SelectDrawings();

            DataTable dt = new DataTable();

            dt.Columns.Add("FromDrawing", typeof(string));

            dt.Columns.Add("FromDrawingUID", typeof(string));

            dt.Columns.Add("FromOPCUID", typeof(string));

            dt.Columns.Add("ToDrawing", typeof(string));

            dt.Columns.Add("ToDrawingUID", typeof(string));

            dt.Columns.Add("ToOPCUID", typeof(string));

            foreach (DataRow row in opc.Rows)

            {

                string fromDrawingUID = row["From_Drawings_UID"] == null ? string.Empty : row["From_Drawings_UID"].ToString();

                string fromOPCUID = row["From_OPC_UID"] == null ? string.Empty : row["From_OPC_UID"].ToString(); 

                string toDrawingUID = row["To_Drawings_UID"] == null ? string.Empty : row["To_Drawings_UID"].ToString(); 

                string toOPCUID = row["To_OPC_UID"] == null ? string.Empty : row["To_OPC_UID"].ToString();

                if (!string.IsNullOrEmpty(toOPCUID))

                {

                    DataRow[] fromRows = drawing.Select(string.Format("UID = '{0}'", fromDrawingUID));

                    DataRow[] toRows = drawing.Select(string.Format("UID = '{0}'", toDrawingUID));

                    if (fromRows.Length.Equals(1) && toRows.Length.Equals(1))

                    {

                        string fromDrawingName = Path.GetFileNameWithoutExtension(fromRows.First()["NAME"].ToString());

                        string toDrawingName = Path.GetFileNameWithoutExtension(toRows.First()["NAME"].ToString());

                        DataRow newRow = dt.NewRow();

                        newRow["FromDrawing"] = fromDrawingName;

                        newRow["FromDrawingUID"] = fromDrawingUID;

                        newRow["FromOPCUID"] = fromOPCUID;

                        newRow["ToDrawing"] = toDrawingName;

                        newRow["ToDrawingUID"] = toDrawingUID;

                        newRow["ToOPCUID"] = toOPCUID;

                        dt.Rows.Add(newRow);

                    }

                }

            }

            return dt;

        }

        private DataTable GetTopologyRule()

        {

            DataTable dt = DB.SelectTopologyRule();

            return dt;

        }

        private 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;

        }

        private void SaveNozzleAndEquipment()

        {

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

            List<Equipment> equipments = new List<Equipment>();

            foreach (Document document in Documents)

            {

                nozzles.AddRange(document.Items.FindAll(x => x.SubItemType == SubItemType.Nozzle));

                equipments.AddRange(document.Equipments);

            }

            DataTable nozzleDT = new DataTable();

            nozzleDT.Columns.Add("OID", typeof(string));

            nozzleDT.Columns.Add("ITEMTAG", typeof(string));

            nozzleDT.Columns.Add("XCOORDS", typeof(string));

            nozzleDT.Columns.Add("YCOORDS", typeof(string));

            nozzleDT.Columns.Add("Equipment_OID", typeof(string));

            nozzleDT.Columns.Add("FLUID", typeof(string));

            nozzleDT.Columns.Add("NPD", typeof(string));

            nozzleDT.Columns.Add("ROTATION", typeof(string));

            nozzleDT.Columns.Add("FlowDirection", typeof(string));

            foreach (Item item in nozzles)

            {

                DataRow row = nozzleDT.NewRow();

                row["OID"] = item.UID;

                Relation relation = item.Relations.Find(x => equipments.Find(y => y.UID == x.UID) != null);

                if (relation != null)

                {

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

                    equipment.Nozzles.Add(item);

                    row["ITEMTAG"] = string.Format("N-{0}", equipment.Nozzles.Count);

                    row["Equipment_OID"] = equipment.UID;

                }

                row["XCOORDS"] = item.POINT[0].ToString();

                row["YCOORDS"] = item.POINT[1].ToString();

                Attribute fluidAttr = item.LineNumber.Attributes.Find(x => x.Name == "FluidCode");

                row["FLUID"] = fluidAttr != null ? fluidAttr.Value : string.Empty;

                Attribute npdAttr = item.LineNumber.Attributes.Find(x => x.Name == "NominalDiameter");

                row["NPD"] = npdAttr != null ? npdAttr.Value : string.Empty;

                row["ROTATION"] = item.ANGLE;

                if (item.Topology.Items.First().Equals(item))

                    row["FlowDirection"] = "Outlet";

                else if (item.Topology.Items.Last().Equals(item))

                    row["FlowDirection"] = "Inlet";

                else

                    row["FlowDirection"] = string.Empty;

                nozzleDT.Rows.Add(row);

            }

            DataTable equipDT = new DataTable();

            equipDT.Columns.Add("OID", typeof(string));

            equipDT.Columns.Add("ITEMTAG", typeof(string));

            equipDT.Columns.Add("XCOORDS", typeof(string));

            equipDT.Columns.Add("YCOORDS", typeof(string));

            foreach (Equipment equipment in equipments)

            {

                DataRow row = equipDT.NewRow();

                row["OID"] = equipment.UID;

                row["ITEMTAG"] = null;

                List<double> xList = equipment.POINT.Select(x => x[0]).ToList();

                row["XCOORDS"] = xList.Sum() / (double)xList.Count;

                List<double> yList = equipment.POINT.Select(x => x[1]).ToList();

                row["YCOORDS"] = yList.Sum() / (double)yList.Count;

                equipDT.Rows.Add(row);

            }

            Equipment = equipDT;

            Nozzle = nozzleDT;

        }

        private void SavePSNData()

        {

            DataTable pathItemsDT = new DataTable();

            pathItemsDT.Columns.Add("OID", typeof(string));

            pathItemsDT.Columns.Add("SequenceData_OID", typeof(string));

            pathItemsDT.Columns.Add("TopologySet_OID", typeof(string));

            pathItemsDT.Columns.Add("BranchTopologySet_OID", typeof(string));

            pathItemsDT.Columns.Add("PipeLine_OID", typeof(string));

            pathItemsDT.Columns.Add("ITEMNAME", typeof(string));

            pathItemsDT.Columns.Add("ITEMTAG", typeof(string));

            pathItemsDT.Columns.Add("TYPE", typeof(string));

            pathItemsDT.Columns.Add("PIDNAME", typeof(string));

            pathItemsDT.Columns.Add("NPD", typeof(string));

            pathItemsDT.Columns.Add("PipeSystemNetwork_OID", typeof(string));

            pathItemsDT.Columns.Add("PipeRun_OID", typeof(string));

            pathItemsDT.Columns.Add("DrawingName", typeof(string));

            DataTable sequenceDataDT = new DataTable();

            sequenceDataDT.Columns.Add("OID", typeof(string));

            sequenceDataDT.Columns.Add("SERIALNUMBER", typeof(string));

            sequenceDataDT.Columns.Add("PathItem_OID", typeof(string));

            sequenceDataDT.Columns.Add("TopologySet_OID_Key", typeof(string));

            DataTable pipeSystemNetworkDT = new DataTable();

            pipeSystemNetworkDT.Columns.Add("OID", typeof(string));

            pipeSystemNetworkDT.Columns.Add("Type", typeof(string));

            pipeSystemNetworkDT.Columns.Add("OrderNumber", typeof(string));

            pipeSystemNetworkDT.Columns.Add("Pipeline_OID", typeof(string));

            pipeSystemNetworkDT.Columns.Add("FROM_DATA", typeof(string));

            pipeSystemNetworkDT.Columns.Add("TO_DATA", typeof(string));

            pipeSystemNetworkDT.Columns.Add("TopologySet_OID_Key", typeof(string));

            pipeSystemNetworkDT.Columns.Add("PSNRevisionNumber", typeof(string));

            pipeSystemNetworkDT.Columns.Add("PathOID", typeof(string));

            pipeSystemNetworkDT.Columns.Add("PBS", typeof(string));

            pipeSystemNetworkDT.Columns.Add("PIDDrawings", typeof(string));

            foreach (PSNItem PSNItem in PSNItems)

            {

                int index = 0;

                foreach (Group group in PSNItem.Groups)

                {

                    foreach (Item item in group.Items)

                    {

                        if (item.BranchItems.Count == 0)

                        {

                            CreatePathItemsDataRow(item.UID, item.Type);

                            CreateSequenceDataDataRow(item.UID);

                            index++;

                        }

                        else

                        {

                            CreatePathItemsDataRow(item.UID + "-L1", item.Type);

                            CreateSequenceDataDataRow(item.UID + "-L1");

                            index++;

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

                            {

                                CreatePathItemsDataRow(string.Format(item.UID + "-B{0}", i + 1), "Branch", item.BranchItems[i].Topology.FullName);

                                CreateSequenceDataDataRow(string.Format(item.UID + "-B{0}", i + 1));

                                index++;

                                CreatePathItemsDataRow(string.Format(item.UID + "-L{0}", i + 2), item.Type);

                                CreateSequenceDataDataRow(string.Format(item.UID + "-L{0}", i + 2));

                                index++;

                            }

                        }

                        void CreatePathItemsDataRow(string itemOID, string itemType, string branchTopologyName = "")

                        {

                            DataRow newRow = pathItemsDT.NewRow();

                            newRow["OID"] = itemOID;

                            newRow["SequenceData_OID"] = string.Format(item.Topology.FullName + "-{0}", index);

                            newRow["TopologySet_OID"] = item.Topology.FullName;

                            newRow["BranchTopologySet_OID"] = branchTopologyName;

                            newRow["PipeLine_OID"] = null;

                            newRow["ITEMNAME"] = null;

                            newRow["ITEMTAG"] = GetItemTag();

                            newRow["TYPE"] = item.Name;

                            newRow["PIDNAME"] = group.Document.DrawingName;

                            // NPD

                            if (item.LineNumber != null)

                            {

                                Attribute attribute = item.LineNumber.Attributes.Find(x => x.Name == "NominalDiameter");

                                if (attribute != null)

                                    newRow["NPD"] = attribute.Value;

                            }

                            else

                                newRow["NPD"] = null;

                            newRow["PipeSystemNetwork_OID"] = string.Empty;//PSNItem.UID;

                            newRow["PipeRun_OID"] = item.LineNumber != null ? item.LineNumber.Name : string.Empty;

                            newRow["DrawingName"] = group.Document.DrawingName;

                            pathItemsDT.Rows.Add(newRow);

                        }

                        void CreateSequenceDataDataRow(string itemOID)

                        {

                            DataRow newRow = sequenceDataDT.NewRow();

                            newRow["OID"] = string.Format(item.Topology.FullName + "-{0}", index);

                            newRow["SERIALNUMBER"] = string.Format("{0}", index);

                            newRow["PathItem_OID"] = itemOID;

                            newRow["TopologySet_OID_Key"] = item.Topology.FullName;

                            sequenceDataDT.Rows.Add(newRow);

                        }

                        string GetItemTag()

                        {

                            string result = string.Empty;

                            if (item.ItemType == ItemType.Line)

                                result = item.LineNumber != null ? item.LineNumber.Name : string.Empty; ;

                            return result;

                        }

                    }

                }

                CreatePipeSystemNetworkDataRow();

                void CreatePipeSystemNetworkDataRow()

                {

                    DataRow newRow = pipeSystemNetworkDT.NewRow();

                    newRow["OID"] = PSNItem.UID;

                    newRow["Type"] = null;

                    newRow["OrderNumber"] = null;

                    newRow["Pipeline_OID"] = PSNItem.Groups.First().Items.First().TopologyData;

                    newRow["FROM_DATA"] = PSNItem.StartType.ToString();

                    newRow["TO_DATA"] = PSNItem.EndType.ToString();

                    newRow["TopologySet_OID_Key"] = PSNItem.Groups.First().Items.First().Topology.FullName;

                    newRow["PSNRevisionNumber"] = null;

                    newRow["PathOID"] = null;

                    newRow["PBS"] = null;

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

                    foreach (Group group in PSNItem.Groups)

                    {

                        if (!drawingNames.Contains(group.Document.DrawingName))

                        {

                            if (drawingNames.Count == 0)

                                newRow["PIDDrawings"] = group.Document.DrawingName;

                            else

                                newRow["PIDDrawings"] = newRow["PIDDrawings"] + ", " + group.Document.DrawingName;

                            drawingNames.Add(group.Document.DrawingName);

                        }

                    }

                    pipeSystemNetworkDT.Rows.Add(newRow);

                }

            }

            PathItems = pathItemsDT;

            SequenceData = sequenceDataDT;

            PipeSystemNetwork = pipeSystemNetworkDT;

        }

    }

    public class PSNItem

    {

        public PSNItem()

        {

            Groups = new List<Group>();

            Topologies = new List<Topology>();

        }

        public string UID { get; set; }

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

        public List<Topology> Topologies { get; set; }

        public PSNType StartType { get; set; }

        public PSNType EndType { get; set; }

    }

}