HYTOS

using System;

using System.Collections.Generic;

using System.Data;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using ID2PSN.Properties;

using System.Text.RegularExpressions;

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 string EquipTagNoAttributeName = string.Empty;

        public DataTable PathItems { get; set; }

        public DataTable SequenceData { get; set; }

        public DataTable PipeSystemNetwork { get; set; }

        public DataTable TopologySet { 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];

        }

        private string GetItemTag(Item item)

        {

            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;

        }

        private string GetItemName(Item item, string itemOID)

        {

            string result = string.Empty;

            if (item.ItemType == ItemType.Line && (item.Name == "Secondary" || item.Name == "Primary"))

            {

                if (itemOID.Contains("_"))

                {

                    string split = itemOID.Split(new char[] { '_' })[1];

                    if (split.StartsWith("B"))

                        result = "Branch";

                    else

                        result = "PipeRun";

                }

                else

                    result = "PipeRun";

            }

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

            {

                if (item.ID2DBCategory == "Instrumentation")

                    result = "Instrument";

                else if (item.ID2DBType == "Nozzles")

                    result = "Nozzle";

                else if (item.ID2DBType == "Fittings" ||

                        item.ID2DBType == "Piping OPC's" ||

                        item.ID2DBType == "Specialty Components" ||

                        item.ID2DBType == "Valves" ||

                        item.ID2DBType == "Reducers")

                    result = "PipingComp";

            }

            return result;

        }

        private string GetClass(Item item, string itemOID)

        {

            string result = string.Empty;

            if (item.ItemType == ItemType.Line && (item.Name == "Secondary" || item.Name == "Primary"))

            {

                if (itemOID.Contains("_"))

                {

                    string split = itemOID.Split(new char[] { '_' })[1];

                    if (split.StartsWith("B"))

                        result = "Branch";

                    else

                        result = "Piping";

                }

                else

                    result = "Piping";

            }

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

            {

                if (item.ID2DBCategory == "Instrumentation")

                    result = item.ID2DBType;

                else if (item.ID2DBType == "Nozzles")

                    result = string.Empty;

                else if (item.ID2DBType == "Fittings" ||

                       item.ID2DBType == "Piping OPC's" ||

                       item.ID2DBType == "Specialty Components" ||

                       item.ID2DBType == "Valves" ||

                       item.ID2DBType == "Reducers")

                    result = item.ID2DBType;

            }

            return result;

        }

        private string GetSubClass(Item item, string itemOID)

        {

            string result = string.Empty;

            if (item.ItemType == ItemType.Line && (item.Name == "Secondary" || item.Name == "Primary"))

            {

                if (itemOID.Contains("_"))

                {

                    string split = itemOID.Split(new char[] { '_' })[1];

                    if (split.StartsWith("B"))

                        result = "Tee";

                    else

                        result = "";

                }

                else

                    result = "";

            }

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

            {

                if (item.ID2DBCategory == "Instrumentation")

                    result = string.Empty;

                else if (item.ID2DBType == "Nozzles")

                    result = string.Empty;

                else if (item.ID2DBType == "Fittings" ||

                       item.ID2DBType == "Piping OPC's" ||

                       item.ID2DBType == "Specialty Components" ||

                       item.ID2DBType == "Valves" ||

                       item.ID2DBType == "Reducers")

                    result = "In-line component";

            }

            return result;

        }

        public void SetPSNData()

        {

            // Item들의 속성으로 Topology Data를 생성한다.

            // Topology Data는 Topology Rule Setting을 기준으로 생성한다. 

            SetTopologyData();

            // ID2의 OPC연결 Data 기반으로 Group(도면단위 PSN)을 연결한다.

            ConnectByOPC();

            // 실제 PSN 생성 로직

            // 연결된 Group을 하나의 PSN으로 만든다.

            SetPSNItem();

            // 생성된 PSN의 Type을 설정한다.

            SetPSNType();

            // ID2에는 Branch 정보가 없어서 Branch 정보를 생성한다.

            SetBranchInfo();

            // 생성된 Topology Data들을 정리하며 Main, Branch를 판단한다.

            SetTopology();

            // PSN이 Bypass인지 검사 

            SetPSNBypass();

            // Topology들에게 Index를 부여한다

            SetTopologyIndex();

            // Nozzle, Equipment의 정보를 저장

            SaveNozzleAndEquipment();

            // PSN의 정보를 저장

            SavePSNData();

            // Topology의 subtype을 update(bypass, Header, 등등) 

            UpdateSubType();

            // Update Error

            //UpdateErrorForPSN();

        }

        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 (insulAttr != null && !string.IsNullOrEmpty(insulAttr.Value))

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

                        else

                            item.PSNPipeLineID = item.TopologyData;

                    }

                    else

                    {

                        item.TopologyData = "Empty LineNumber";

                        item.LineNumber = new LineNumber();

                    }

                }

            }

            int emptyIndex = 1;

            foreach (Group group in groups)

            {

                List<Item> groupItems = group.Items.FindAll(x => x.TopologyData == "Empty LineNumber");

                if (groupItems.Count > 0)

                {

                    foreach (var item in groupItems)

                        item.TopologyData += string.Format("-{0}", emptyIndex);

                    emptyIndex++;

                }

            }

        }

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

                foreach (Item groupItem in group.Items)

                    groupItem.PSNItem = PSNItem;

            }

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

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

                // Branch

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

                foreach (Topology topology in branchToplogies)

                    topology.Type = "B";

            }

            #endregion

        }

        private void SetTopologyIndex()

        {

            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 = topologies.FindAll(x => x.Type == "M");

                foreach (Topology topology in mainTopologies)

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

                // Branch

                List<Topology> branchToplogies = topologies.FindAll(x => x.Type == "B");

                foreach (Topology topology in branchToplogies)

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

            }

        }

        private void SetPSNBypass()

        {

            foreach (PSNItem PSNItem in PSNItems)

                PSNItem.IsBypass = IsBypass(PSNItem);

        }

        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;

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

                            if (attribute != null && value == attribute.Value)

                            {

                                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;

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

                            if (attribute != null && (inchValue == attribute.Value || metricValue == attribute.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;

                if (!string.IsNullOrEmpty(EquipTagNoAttributeName))

                {

                    Attribute attribute = equipment.Attributes.Find(x => x.Name == EquipTagNoAttributeName);

                    if (attribute != null)

                        equipment.ItemTag = attribute.Value;

                }

                else

                    equipment.ItemTag = equipment.Name;

                row["ITEMTAG"] = equipment.ItemTag;

                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("Class", typeof(string));

            pathItemsDT.Columns.Add("SubClass", 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("ViewPipeSystemNetwork_OID", typeof(string));

            pathItemsDT.Columns.Add("PipeRun_OID", 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("PBS", typeof(string));

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

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

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

            DataTable topologySetDT = new DataTable();

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

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

            topologySetDT.Columns.Add("SubType", typeof(string));

            topologySetDT.Columns.Add("HeadItemTag", typeof(string));

            topologySetDT.Columns.Add("TailItemTag", typeof(string));

            topologySetDT.Columns.Add("HeadItemID", typeof(string));

            topologySetDT.Columns.Add("TailItemID", typeof(string));

            // Set Header Info

            List<VentDrainInfo> VentDrainInfos = new List<VentDrainInfo>();

            DataTable dt = DB.SelectVentDrainSetting();

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

                VentDrainInfo ventDrainInfo = VentDrainInfos.Find(x => x.UID.Equals(groupID));

                if (ventDrainInfo == null)

                {

                    ventDrainInfo = new VentDrainInfo(groupID);

                    ventDrainInfo.Description = desc;

                    VentDrainInfos.Add(ventDrainInfo);

                }

                ventDrainInfo.VentDrainItems.Add(new VentDrainItem()

                {

                    Index = index,

                    Name = name

                });

            }

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

                bool bVentDrain = false;

                //VentDrain 검사

                if (PSNItem.Groups.Count.Equals(1))

                {

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

                    Group group = PSNItem.Groups[0];

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

                    {

                        Item item = group.Items[i];

                        foreach (VentDrainInfo ventDrainInfo in VentDrainInfos)

                        {

                            if (endInfos.Contains(ventDrainInfo) || ventDrainInfo.VentDrainItems.Count != group.Items.Count)

                                continue;

                            if (!ventDrainInfo.VentDrainItems[i].Name.Equals(item.Name))

                            {

                                endInfos.Add(ventDrainInfo);

                                continue;

                            }

                            if (i + 1 == group.Items.Count && group.Items.Count.Equals(ventDrainInfo.VentDrainItems.Count))

                                bVentDrain = true;

                        }

                    }

                    if (!bVentDrain)

                    {

                        endInfos = new List<VentDrainInfo>();

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

                        {

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

                            foreach (VentDrainInfo ventDrainInfo in VentDrainInfos)

                            {

                                if (endInfos.Contains(ventDrainInfo) || ventDrainInfo.VentDrainItems.Count != group.Items.Count)

                                    continue;

                                if (!ventDrainInfo.VentDrainItems[i].Name.Equals(item.Name))

                                {

                                    endInfos.Add(ventDrainInfo);

                                    continue;

                                }

                                if (i + 1 == group.Items.Count && group.Items.Count.Equals(ventDrainInfo.VentDrainItems.Count))

                                    bVentDrain = true;

                            }

                        }

                    }

                }

                //PSN, PathItems, SequenceData 관련

                foreach (Group group in PSNItem.Groups)

                {

                    foreach (Item item in group.Items)

                    {

                        if (item.BranchItems.Count == 0)

                        {

                            CreatePathItemsDataRow(item.UID, item.ID2DBType);

                            CreateSequenceDataDataRow(item.UID);

                            index++;

                        }

                        else

                        {

                            CreatePathItemsDataRow(item.UID + "_L1", item.ID2DBType);

                            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, item.BranchItems[i]);

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

                                index++;

                                CreatePathItemsDataRow(string.Format(item.UID + "_L{0}", i + 2), item.ID2DBType);

                                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 = "", Item branchItem = null)

                        {

                            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"] = GetItemName(item, itemOID);

                            newRow["ITEMTAG"] = GetItemTag(item);

                            newRow["Class"] = GetClass(item, itemOID);

                            newRow["SubClass"] = GetSubClass(item, itemOID);

                            if (item.ItemType == ItemType.Symbol)

                                newRow["TYPE"] = item.ID2DBName;

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

                                newRow["TYPE"] = item.ID2DBType;

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

                            if (branchItem == null)

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

                            else

                                newRow["ViewPipeSystemNetwork_OID"] = branchItem.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()

                        {

                            // VentDrain의 경우 제외 요청

                            if (bVentDrain)

                                return;

                            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("V{0:D4}", Revision);

                            newRow["PBS"] = PSNItem.GetPBSData();

                            newRow["Validity"] = PSNItem.Validity;

                            newRow["Status"] = !string.IsNullOrEmpty(PSNItem.Status) ? PSNItem.Status.Remove(0, 2) : string.Empty;

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

                        }

                    }

                }

                //TopologySet 관련

                foreach (Topology topology in PSNItem.Topologies)

                {

                    DataRow newRow = topologySetDT.NewRow();

                    newRow["OID"] = topology.FullName;

                    newRow["Type"] = topology.FullName.Split(new char[] { '-' }).Last().StartsWith("M") ? "Main" : "Branch";

                    if (bVentDrain)

                        newRow["SubType"] = "Vent_Drain";

                    else

                        newRow["SubType"] = null;

                    newRow["HeadItemTag"] = GetItemTag(topology.Items.Last());

                    newRow["TailItemTag"] = GetItemTag(topology.Items.First());

                    newRow["HeadItemID"] = topology.Items.Last().UID;

                    newRow["TailItemID"] = topology.Items.First().UID;

                    topologySetDT.Rows.Add(newRow);

                }

            }

            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;

            TopologySet = topologySetDT;

        }

        private void UpdateSubType()

        {

            foreach (PSNItem PSNItem in PSNItems)

            {

                if (PSNItem.IsBypass)

                {

                    foreach (Topology topology in PSNItem.Topologies)

                    {

                        DataRow[] rows = TopologySet.Select(string.Format("OID = '{0}'", topology.FullName));

                        if (rows.Length.Equals(1))

                            rows.First()["SubType"] = "Bypass";

                    }

                }

                if (PSNItem.StartType == PSNType.Header)

                {

                    Topology topology = PSNItem.Topologies.First();

                    DataRow[] rows = TopologySet.Select(string.Format("OID = '{0}'", topology.FullName));

                    if (rows.Length.Equals(1))

                        rows.First()["SubType"] = "Header";

                }

                else if (PSNItem.EndType == PSNType.Header)

                {

                    Topology topology = PSNItem.Topologies.Last();

                    DataRow[] rows = TopologySet.Select(string.Format("OID = '{0}'", topology.FullName));

                    if (rows.Length.Equals(1))

                        rows.First()["SubType"] = "Header";

                }

            }

            foreach (Topology topology in Topologies)

            {

                DataRow[] rows = TopologySet.Select(string.Format("OID = '{0}'", topology.FullName));

                if (rows.Length.Equals(1) && rows.First()["SubType"] == null || string.IsNullOrEmpty(rows.First()["SubType"].ToString()))

                {

                    Item firstItem = topology.Items.First();

                    Item lastItem = topology.Items.Last();

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

                    relations.AddRange(firstItem.Relations.FindAll(x => x.Item != null && x.Item.Topology.ID != topology.ID));

                    relations.AddRange(lastItem.Relations.FindAll(x => x.Item != null && x.Item.Topology.ID != topology.ID));

                    if (relations.Count > 0)

                        rows.First()["SubType"] = "OtherSystem";

                }

            }

            foreach (DataRow row in TopologySet.Rows)

                if (row["SubType"] == null || string.IsNullOrEmpty(row["SubType"].ToString()))

                    row["SubType"] = "Normal";

        }

        private bool IsBypass(PSNItem PSNItem)

        {

            bool bResult = false;

            if (PSNItem.GetPSNType() == "B2B")

            {

                Group firstGroup = PSNItem.Groups.First();

                Group lastGroup = PSNItem.Groups.Last();

                Item firstItem = firstGroup.Items.First();

                Item lastItem = lastGroup.Items.Last();

                Item connectedFirstItem = GetConnectedItemByPSN(firstItem);

                Item connectedLastItem = GetConnectedItemByPSN(lastItem);

                if (connectedFirstItem.LineNumber != null && connectedLastItem.LineNumber != null &&

                    !string.IsNullOrEmpty(connectedFirstItem.LineNumber.Name) && !string.IsNullOrEmpty(connectedLastItem.LineNumber.Name) &&

                    connectedFirstItem.LineNumber.Name == connectedLastItem.LineNumber.Name)

                    bResult = true;

                else if (connectedFirstItem.PSNItem == connectedLastItem.PSNItem)

                    bResult = true;

            }

            Item GetConnectedItemByPSN(Item item)

            {

                Item result = null;

                Relation relation = item.Relations.Find(x => x.Item != null && x.Item.PSNItem != item.PSNItem);

                if (relation != null)

                    result = relation.Item;

                return result;

            }

            return bResult;

        }

        private void UpdateErrorForPSN()

        {

            DataRow[] errorRows = PipeSystemNetwork.Select(" Type = 'Error'");

            foreach (DataRow dataRow in errorRows)

            {

                PSNItem PSNItem = PSNItems.Find(x=>x.PSN_OID() == dataRow["OID"].ToString());

                if (PSNItem.StartType == PSNType.OPC)

                    PSNItem.StartType = PSNType.Equipment;

                if (PSNItem.EndType == PSNType.OPC)

                    PSNItem.EndType = PSNType.Equipment;

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

            }

        }

    }

    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 Validity { get; set; }

        public string Status { get; set; }

        public string PSN_OID()

        {

            return string.Format("V{0}-PSN-{1}", string.Format("{0:D4}", 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 bool IsBypass { get; set; }

        public string GetFromData()

        {

            string result = string.Empty;

            if (StartType == PSNType.Header)

                result = "ENDOFHEADER";

            else if (StartType == PSNType.Branch)

            {

                Item item = Groups.First().Items.First();

                if (!string.IsNullOrEmpty(item.Relations.First().Item.LineNumber.Name))

                    result = item.Relations.First().Item.LineNumber.Name;

                else

                {

                    Status += ", Missing LineNumber";

                    result = "Empty LineNumber";

                }

            }

            else if (StartType == PSNType.Equipment)

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

            else

            {

                Validity = "Error";

                Item item = Groups.First().Items.First();

                if (item.ItemType == ItemType.Symbol)

                {

                    if (item.ID2DBType.Contains("OPC's"))

                        Status += ", OPC Disconneted";

                    else

                        Status += ", Missing ItemTag or Description";

                    result = item.ID2DBName;

                }

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

                {

                    Status += ", Line Disconnected";

                    result = !string.IsNullOrEmpty(item.LineNumber.Name) ? item.LineNumber.Name : "Empty LineNumber";

                }

                else

                    result = "Unknown";

            }

            return result;

        }

        public string GetToData()

        {

            string result = string.Empty;

            if (EndType == PSNType.Header)

                result = "ENDOFHEADER";

            else if (EndType == PSNType.Branch)

            {

                Item item = Groups.Last().Items.Last();

                if (!string.IsNullOrEmpty(item.Relations.Last().Item.LineNumber.Name))

                    result = item.Relations.Last().Item.LineNumber.Name;

                else

                {

                    Status += ", Missing LineNumber";

                    result = "Empty LineNumber";

                }

            }

            else if (EndType == PSNType.Equipment)

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

            else

            {

                Validity = "Error";

                Item item = Groups.Last().Items.Last();

                if (item.ItemType == ItemType.Symbol)

                {

                    if (item.ID2DBType.Contains("OPC's"))

                        Status += ", OPC Disconneted";

                    else

                        Status += ", Missing ItemTag or Description";

                    result = item.ID2DBName;

                }

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

                {

                    Status += ", Line Disconnected";

                    result = !string.IsNullOrEmpty(item.LineNumber.Name) ? item.LineNumber.Name : "Empty LineNumber";

                }

                else

                    result = "Unknown";

            }

            return result;

        }

        public string GetPBSData()

        {

            string result = string.Empty;

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

            if (Settings.Default.PBSSetting.Equals("Line Number"))

            {

                string attrValue = Settings.Default.PBSSettingValue;

                foreach (Group group in Groups)

                {

                    List<LineNumber> lineNumbers = group.Items.Select(x =>x.LineNumber).Distinct().ToList();

                    foreach (LineNumber lineNumber in lineNumbers)

                    {

                        Attribute attribute = lineNumber.Attributes.Find(x => x.Name == attrValue && !string.IsNullOrEmpty(x.Value));

                        if (attribute != null)

                        {

                            string value = attribute.Value;

                            if (!PBSList.Contains(value))

                                PBSList.Add(value);

                        }

                    }

                }

            }

            else if (Settings.Default.PBSSetting.Equals("Item Attribute"))

            {

                string attrValue = Settings.Default.PBSSettingValue;

                foreach (Group group in Groups)

                {

                    List<Item> items = group.Items.FindAll(x => x.Attributes.Find(y => y.Name == attrValue && !string.IsNullOrEmpty(y.Value)) != null);

                    foreach (Item item in items)

                    {

                        string value = item.Attributes.Find(x => x.Name == attrValue).Value;

                        if (!PBSList.Contains(value))

                            PBSList.Add(value);

                    }

                }

            }

            else if (Settings.Default.PBSSetting.Equals("Drawing No"))

            {

                string attrValue = Settings.Default.PBSSettingValue;

                foreach (Group group in Groups)

                {

                    List<Document> documents = group.Items.Select(x => x.Document).Distinct().ToList();

                    foreach (Document document in documents)

                    {

                        string name = document.DrawingName;

                        int startIndex = Settings.Default.PBSSettingStartValue;

                        int endIndex = Settings.Default.PBSSettingEndValue;

                        string subStr = name.Substring(startIndex - 1, endIndex - startIndex + 1);

                        if (!PBSList.Contains(subStr))

                            PBSList.Add(subStr);

                    }

                }

            }

            else if (Settings.Default.PBSSetting.Equals("Unit Area"))

            {

                foreach (Group group in Groups)

                {

                    List<Document> documents = group.Items.Select(x => x.Document).Distinct().ToList();

                    foreach (Document document in documents)

                    {

                        List<TextInfo> textInfos = document.TextInfos.FindAll(x => x.Area == "Unit");

                        foreach (TextInfo textInfo in textInfos)

                        {

                            if (!PBSList.Contains(textInfo.Value))

                                PBSList.Add(textInfo.Value);

                        }

                    }

                }

            }

            foreach (var item in PBSList)

            {

                if (string.IsNullOrEmpty(result))

                    result = item;

                else

                    result += ", " + item;

            }

            return result;

        }

    }

}