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

    {

        private double[] DrawingSize = null;

        private double DrawingWidth = double.NaN;

        private double DrawingHeight = double.NaN;

        public int Revision;

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

        {

        }

        public PSN(List<Document> documents, int Revision)

        {

            Documents = documents;

            foreach (Document document in Documents)

                groups.AddRange(document.Groups);

            opcDT = GetOPCInfo();

            topologyRuleDT = GetTopologyRule();

            this.Revision = Revision;

            DrawingSize = DB.GetDrawingSize();

            DrawingWidth = DrawingSize[2] - DrawingSize[0];

            DrawingHeight = DrawingSize[3] - DrawingSize[1];

        }

        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;

                    item.PSNPipeLineID = 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 itemAttr = item.Attributes.Find(x => x.Name == uid);

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

                                if (attribute != null)

                                    item.TopologyData += attribute.Value;

                            }

                        }

                        Attribute insulAttr = item.LineNumber.Attributes.Find(x => x.Name == "InsulationPurpose");

                        if (!string.IsNullOrEmpty(insulAttr.Value))

                            item.PSNPipeLineID = item.TopologyData + "-" + insulAttr.Value;

                        else

                            item.PSNPipeLineID = item.TopologyData;

                    }

                }

            }

        }

        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(PSNItems.Count, Revision) { 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

            //foreach (PSNItem PSNItem in PSNItems)

            //{

            //    List<Topology> psnTopology = PSNItem.Topologies;

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

            //    foreach (string id in ids)

            //    {

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

            //        // Main

            //        List<Topology> mainTopologies = FindMainTopology(topologies);

            //        foreach (Topology topology in mainTopologies)

            //        {

            //            topology.Type = "M";

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

            //        }

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

            //        }

            //    }

            //}

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

            foreach (string id in ids)

            {

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

                // Main

                List<Topology> mainTopologies = FindMainTopology(topologies);

                foreach (Topology topology in mainTopologies)

                {

                    topology.Type = "M";

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

                }

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

        {

            DataTable nominalDiameterDT = DB.SelectNominalDiameter();

            DataTable PMCDT = DB.SelectPSNPIPINGMATLCLASS();

            DataTable fluidCodeDT = DB.SelectPSNFluidCode();

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

            main.AddRange(data);

            //

            main = GetNozzleTopology(data);

            if (main.Count == 1)

                return main;

            else

            {

                if (main.Count > 0)

                    main = GetPMCTopology(main);

                else

                    main = GetPMCTopology(data);

                if (main.Count == 1)

                    return main;

                else

                {

                    if (main.Count > 0)

                        main = GetDiaTopology(main);

                    else

                        main = GetDiaTopology(data);

                    if (main.Count == 1)

                        return main;

                    else

                    {

                        if (main.Count > 0)

                            main = GetItemTopology(main);

                        else

                            main = GetItemTopology(data);

                    }

                }

            }

            List<Topology> GetNozzleTopology(List<Topology> topologies)

            {

                return topologies.FindAll(x => x.Items.Find(y => y.SubItemType == SubItemType.Nozzle) != null);

            }

            List<Topology> GetPMCTopology(List<Topology> topologies)

            {

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

                foreach (DataRow row in PMCDT.Rows)

                {

                    string value = row["CODE"].ToString();

                    foreach (Topology topology in topologies)

                    {

                        foreach (Item item in topology.Items)

                        {

                            if (item.LineNumber == null)

                                continue;

                            string pmcValue = item.LineNumber.Attributes.Find(x => x.Name == "PipingMaterialsClass").Value;

                            if (value == pmcValue)

                            {

                                result.Add(topology);

                                break;

                            }

                        }

                    }

                    if (result.Count > 0)

                        break;

                }

                return result;

            }

            List<Topology> GetDiaTopology(List<Topology> topologies)

            {

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

                foreach (DataRow row in nominalDiameterDT.Rows)

                {

                    string inchValue = row["InchStr"].ToString();

                    string metricValue = row["MetricStr"].ToString();

                    foreach (Topology topology in topologies)

                    {

                        foreach (Item item in topology.Items)

                        {

                            if (item.LineNumber == null)

                                continue;

                            string value = item.LineNumber.Attributes.Find(x => x.Name == "NominalDiameter").Value;

                            if (inchValue == value || metricValue == value)

                            {

                                result.Add(topology);

                                break;

                            }

                        }

                    }

                    if (result.Count > 0)

                        break;

                }

                return result;

            }

            List<Topology> GetItemTopology(List<Topology> topologies)

            {

                return new List<Topology>() { topologies.OrderByDescending(x => x.Items.Count).ToList().First() };

            }

            return main;

        }

        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}", string.Format("{0:D3}", equipment.Nozzles.Count + 100));

                    row["Equipment_OID"] = equipment.UID;

                    item.Equipment = equipment;

                }

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

                row["YCOORDS"] = (item.POINT[1] / DrawingHeight).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;

                double angle = Math.PI * 2 - Convert.ToDouble(item.ANGLE);

                if (angle >= Math.PI * 2)

                    angle = angle - Math.PI * 2;

                row["ROTATION"] = angle.ToString();

                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"] = equipment.Name;

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

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

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

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

                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("Show", 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));

            // key = 미입력 branch

            Dictionary<Item, Item> startBranchDic = new Dictionary<Item, Item>();

            Dictionary<Item, Item> endBranchDic = new Dictionary<Item, Item>();

            foreach (PSNItem PSNItem in PSNItems)

            {

                int psnOrder = 0;

                int index = 0;

                bool bPSNStart = true;

                string sPSNData = string.Empty;

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

                                if (item.BranchItems[i].Relations[0].Item != null && item.BranchItems[i].Relations[0].Item == item)

                                    startBranchDic.Add(item.BranchItems[i], item);

                                else if (item.BranchItems[i].Relations[1].Item != null && item.BranchItems[i].Relations[1].Item == item)

                                    endBranchDic.Add(item.BranchItems[i], item);

                            }

                        }

                        if (bPSNStart)

                        {

                            CreatePipeSystemNetworkDataRow();

                            sPSNData = item.TopologyData;

                            psnOrder++;

                            bPSNStart = false;

                        }

                        else

                        {

                            if (item.TopologyData != sPSNData)

                            {

                                CreatePipeSystemNetworkDataRow();

                                sPSNData = item.TopologyData;

                                psnOrder++;

                            }

                        }

                        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"] = item.PSNPipeLineID;

                            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"] = PSNItem.PSN_OID();

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

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

                        }

                        void CreatePipeSystemNetworkDataRow()

                        {

                            DataRow newRow = pipeSystemNetworkDT.NewRow();

                            newRow["OID"] = PSNItem.PSN_OID();

                            newRow["Type"] = PSNItem.GetPSNType();

                            newRow["OrderNumber"] = psnOrder;

                            newRow["Pipeline_OID"] = item.PSNPipeLineID;

                            newRow["FROM_DATA"] = PSNItem.GetFromData();

                            newRow["TO_DATA"] = PSNItem.GetToData();

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

                            newRow["PSNRevisionNumber"] = string.Format("{0:D3}", Revision);

                            newRow["PathOID"] = null;

                            newRow["PBS"] = null;

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

                            foreach (Group _group in PSNItem.Groups)

                            {

                                if (newRow["PBS"] == null)

                                {

                                    List<Item> _items = _group.Items.FindAll(x => x.Attributes.Find(y => y.Name.ToUpper() == "UNITNUMBER" && !string.IsNullOrEmpty(y.Value)) != null);

                                    foreach (Item _item in _items)

                                    {

                                        string _value = _item.Attributes.Find(x => x.Name.ToUpper() == "UNITNUMBER").Value;

                                        newRow["PBS"] = _value;

                                        break;

                                    }

                                }

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

                        }

                        string GetItemTag()

                        {

                            string result = string.Empty;

                            if (item.ItemType == ItemType.Line)

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

                            else if (item.ItemType == ItemType.Symbol && item.SubItemType == SubItemType.Nozzle)

                                result = Nozzle.Select(string.Format("OID = '{0}'", item.UID)).First()["ITEMTAG"].ToString();

                            return result;

                        }

                    }

                }

            }

            foreach (var item in startBranchDic)

            {

                string uid = item.Key.UID;

                string topologyName = item.Value.Topology.FullName;

                DataRow[] rows = pathItemsDT.Select(string.Format("OID LIKE '{0}%'", uid));

                if (rows.Length == 1)

                    rows.First()["BranchTopologySet_OID"] = topologyName;

                else if (rows.Length > 1)

                {

                    DataRow targetRow = null;

                    int index = int.MaxValue;

                    foreach (DataRow row in rows)

                    {

                        string split = row["OID"].ToString().Split(new char[] { '_' })[1];

                        if (split.StartsWith("L"))

                        {

                            int num = Convert.ToInt32(split.Remove(0, 1));

                            if (index > num)

                            {

                                index = num;

                                targetRow = row;

                            }

                        }

                    }

                    if (targetRow != null)

                        targetRow["BranchTopologySet_OID"] = topologyName;

                }

            }

            foreach (var item in endBranchDic)

            {

                string uid = item.Key.UID;

                string topologyName = item.Value.Topology.FullName;

                DataRow[] rows = pathItemsDT.Select(string.Format("OID LIKE '{0}%'", uid));

                if (rows.Length == 1)

                    rows.First()["BranchTopologySet_OID"] = topologyName;

                else if (rows.Length > 1)

                {

                    DataRow targetRow = null;

                    int index = int.MinValue;

                    foreach (DataRow row in rows)

                    {

                        string split = row["OID"].ToString().Split(new char[] { '_' })[1];

                        if (split.StartsWith("L"))

                        {

                            int num = Convert.ToInt32(split.Remove(0, 1));

                            if (index < num)

                            {

                                index = num;

                                targetRow = row;

                            }

                        }

                    }

                    if (targetRow != null)

                        targetRow["BranchTopologySet_OID"] = topologyName;

                }

            }

            PathItems = pathItemsDT;

            SequenceData = sequenceDataDT;

            PipeSystemNetwork = pipeSystemNetworkDT;

        }

    }

    public class PSNItem

    {

        public PSNItem(int count, int Revision)

        {

            Groups = new List<Group>();

            Topologies = new List<Topology>();

            Index = count + 1;

            this.Revision = Revision;

        }

        private int Revision;

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

        public int Index { get; set; }

        public string PSN_OID()

        {

            return string.Format("R{0}-PSN-{1}", string.Format("{0:D3}", Revision), string.Format("{0:D5}", Index));

        }

        public string GetPSNType()

        {

            string result = string.Empty;

            if (EnableType(StartType) && EnableType(EndType))

            {

                if (StartType == PSNType.Equipment && EndType == PSNType.Equipment)

                    result = "E2E";

                else if (StartType == PSNType.Branch && EndType == PSNType.Branch)

                    result = "B2B";

                else if (StartType == PSNType.Header && EndType == PSNType.Header)

                    result = "HD2";

                else if (StartType == PSNType.Equipment && EndType == PSNType.Branch)

                    result = "E2B";

                else if (StartType == PSNType.Branch && EndType == PSNType.Equipment)

                    result = "B2E";

                else if (StartType == PSNType.Header && EndType == PSNType.Branch)

                    result = "HDB";

                else if (StartType == PSNType.Branch && EndType == PSNType.Header)

                    result = "HDB";

                else if (StartType == PSNType.Header && EndType == PSNType.Equipment)

                    result = "HDE";

                else if (StartType == PSNType.Equipment && EndType == PSNType.Header)

                    result = "HDE";

                else

                    result = "Error";

            }

            else

                result = "Error";

            return result;

        }

        private bool EnableType(PSNType type)

        {

            bool result = false;

            if (type == PSNType.Branch ||

                type == PSNType.Equipment ||

                type == PSNType.Header)

            {

                result = true;

            }

            return result;

        }

        public string GetFromData()

        {

            string result = string.Empty;

            if (StartType == PSNType.Header)

                result = "ENDOFHEADER";

            else if (StartType == PSNType.Branch)

                result = Groups.First().Items.First().LineNumber.Name;

            else if (StartType == PSNType.Equipment)

                result = Groups.First().Items.First().Equipment.Name;

            else

                result = "Unknown";

            return result;

        }

        public string GetToData()

        {

            string result = string.Empty;

            if (EndType == PSNType.Header)

                result = "ENDOFHEADER";

            else if (EndType == PSNType.Branch)

                result = Groups.Last().Items.Last().LineNumber.Name;

            else if (EndType == PSNType.Equipment)

                result = Groups.Last().Items.Last().Equipment.Name;

            else 

                result = "Unknown";

            return result;

        }

    }

}