HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Newtonsoft.Json;

using System.IO;

using Converter.SPPID.DB;

using Converter.BaseModel;

using System.Windows.Forms;

using Converter.SPPID.Model;

using System.Drawing;

using Llama;

using System.Data;

using Plaice;

using Microsoft.VisualBasic;

using DevExpress.XtraBars.ViewInfo;

using Converter.SPPID.SPPIDModel;

namespace Converter.SPPID.Util

{

    public enum BulkAttributeItemType

    {

        PipeRun,

        Symbol,

    }

    public enum SlopeType

    {

        None,

        Slope,

        HORIZONTAL,

        VERTICAL

    }

    public class SPPIDUtil

    {

        public static LMPipeRun PipeRun;

        public static List<BaseModel.SPPIDCodeList> CodeListSet;

        public static bool ConvertToSPPIDInfo(string jsonString)

        {

            SPPID_DBInfo _SPPIDInfo = SPPID_DBInfo.GetInstance();

            try

            {

                SPPID_DBInfo jsonSPPIDInfo = JsonConvert.DeserializeObject<SPPID_DBInfo>(jsonString);

                _SPPIDInfo.DBType = jsonSPPIDInfo.DBType;

                _SPPIDInfo.Service = jsonSPPIDInfo.Service;

                _SPPIDInfo.Site = jsonSPPIDInfo.Site;

                _SPPIDInfo.ServerIP = jsonSPPIDInfo.ServerIP;

                _SPPIDInfo.Port = jsonSPPIDInfo.Port;

                _SPPIDInfo.DBUser = jsonSPPIDInfo.DBUser;

                _SPPIDInfo.DBPassword = jsonSPPIDInfo.DBPassword;

                _SPPIDInfo.PlantPath = jsonSPPIDInfo.PlantPath;

                _SPPIDInfo.PlantDic = jsonSPPIDInfo.PlantDic;

                _SPPIDInfo.PlantPID = jsonSPPIDInfo.PlantPID;

                _SPPIDInfo.PlantPIDDic = jsonSPPIDInfo.PlantPIDDic;

                _SPPIDInfo.Plant = jsonSPPIDInfo.Plant;

                _SPPIDInfo.Enable = jsonSPPIDInfo.Enable;

                _SPPIDInfo.SelectedPlant = jsonSPPIDInfo.SelectedPlant;

                _SPPIDInfo.PlantList = jsonSPPIDInfo.PlantList;

                _SPPIDInfo.SQLSERVER_DBNAME = jsonSPPIDInfo.SQLSERVER_DBNAME;

                _SPPIDInfo.PlantDic_DataBase = jsonSPPIDInfo.PlantDic_DataBase;

                _SPPIDInfo.Plant_DataBase = jsonSPPIDInfo.Plant_DataBase;

                _SPPIDInfo.PlantPID_DataBase = jsonSPPIDInfo.PlantPID_DataBase;

                _SPPIDInfo.PlantPIDDic_DataBase = jsonSPPIDInfo.PlantPIDDic_DataBase;

            }

            catch (Exception ex)

            {

                _SPPIDInfo.Enable = false;

                return false;

            }

            return true;

        }

        public static bool ConvertToETCSetting(string jsonString)

        {

            ETCSetting _ETCSetting = ETCSetting.GetInstance();

            try

            {

                ETCSetting jsonETCSetting = JsonConvert.DeserializeObject<ETCSetting>(jsonString);

                _ETCSetting.NoteSymbolPath = jsonETCSetting.NoteSymbolPath;

                _ETCSetting.TextSymbolPath = jsonETCSetting.TextSymbolPath;

                _ETCSetting.DrainValveSize = jsonETCSetting.DrainValveSize;

                _ETCSetting.VendorPackageSymbolPath = jsonETCSetting.VendorPackageSymbolPath;

                _ETCSetting.TextLocation = jsonETCSetting.TextLocation;

                _ETCSetting.NoteLocation = jsonETCSetting.NoteLocation;

                _ETCSetting.LineNumberLocation = jsonETCSetting.LineNumberLocation;

                _ETCSetting.FlowMarkSymbolPath = jsonETCSetting.FlowMarkSymbolPath;

                _ETCSetting.BorderFilePath = jsonETCSetting.BorderFilePath;

                _ETCSetting.UnitSetting = jsonETCSetting.UnitSetting;

                _ETCSetting.BulkAttributes = jsonETCSetting.BulkAttributes;

            }

            catch (Exception ex)

            {

                return false;

            }

            return true;

        }

        public static bool ConvertToGridSetting(string jsonString)

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            try

            {

                GridSetting jsonGridSetting = JsonConvert.DeserializeObject<GridSetting>(jsonString);

                _GridSetting.UseSnapGrid = jsonGridSetting.UseSnapGrid;

                _GridSetting.Density = jsonGridSetting.Density;

                _GridSetting.Unit = jsonGridSetting.Unit;

                _GridSetting.DrainValveCellCount = jsonGridSetting.DrainValveCellCount;

            }

            catch (Exception ex)

            {

                return false;

            }

            return true;

        }

        public static bool ConvertPointBystring(string sPoint, ref double dX, ref double dY)

        {

            try

            {

                string[] pointArr = sPoint.Split(new char[] { ',' });

                if (pointArr.Length == 2)

                {

                    dX = Convert.ToDouble(pointArr[0]);

                    dY = Convert.ToDouble(pointArr[1]);

                }

            }

            catch (Exception)

            {

                dX = 0;

                dY = 0;

                return false;

            }

            return true;

        }

        public static void ConvertSPPIDPoint(ref double dX, ref double dY, double dDwgX, double dDwgY, double SPPID_Width, double SPPID_Height)

        {

            decimal calcX = 0;

            decimal calcY = 0;

            decimal tempX = Convert.ToDecimal(dX);

            decimal tempY = Convert.ToDecimal(dY);

            decimal tempWidth = Convert.ToDecimal(SPPID_Width);

            decimal tempHeight = Convert.ToDecimal(SPPID_Height);

            decimal tempDwgX = Convert.ToDecimal(dDwgX);

            decimal tempDwgY = Convert.ToDecimal(dDwgY);

            calcX = (tempX * tempWidth) / tempDwgX;

            calcY = tempHeight - ((tempY * tempHeight) / tempDwgY);

            dX = Convert.ToDouble(calcX);

            dY = Convert.ToDouble(calcY);

        }

        public static void ConvertGridPoint(ref double x, ref double y)

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            if (_GridSetting.UseSnapGrid)

            {

                if (_GridSetting.Unit == GridUnit.Inch)

                {

                    double length = _GridSetting.Density * 0.0254;

                    double tempX = x;

                    double tempY = y;

                    x = Math.Round(tempX / length) * length;

                    y = Math.Round(tempY / length) * length;

                }

            }

        }

        public static void ConvertGridPointOnlyOnePoint(ref double value)

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            if (_GridSetting.UseSnapGrid)

            {

                if (_GridSetting.Unit == GridUnit.Inch)

                {

                    double temp = value;

                    value = Math.Round(value / _GridSetting.Length) * _GridSetting.Length;

                }

            }

        }

        public static double ConvertGridPointOnlyOnePoint(double value)

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            if (_GridSetting.UseSnapGrid)

            {

                if (_GridSetting.Unit == GridUnit.Inch)

                {

                    double temp = value;

                    value = Math.Round(value / _GridSetting.Length) * _GridSetting.Length;

                }

            }

            return value;

        }

        public static bool EqualSpacing(double value1, double value2)

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            double multiplier = 100000000000000;

            value1 = Math.Truncate(value1 * multiplier) / multiplier;

            value2 = Math.Truncate(value2 * multiplier) / multiplier;

            return value1 == value2;

        }

        public static SlopeType CalcSlope(double x1, double y1, double x2, double y2, double degree = 15)

        {

            if (x1 - x2 == 0)

            {

                return SlopeType.VERTICAL;

            }

            else

            {

                double angle = Math.Atan(Math.Abs(y2 - y1) / Math.Abs(x2 - x1)) * 180 / Math.PI;

                if (angle <= degree)

                    return SlopeType.HORIZONTAL;

                else if (angle >= 90 - degree)

                    return SlopeType.VERTICAL;

                else

                    return SlopeType.Slope;

            }

        }

        public static double CalcAngle(double x1, double y1, double x2, double y2)

        {

            double result = 90;

            if (x1 - x2 != 0)

            {

                result = Math.Atan(Math.Abs(y2 - y1) / Math.Abs(x2 - x1)) * 180 / Math.PI;

            }

            return result;

        }

        public static double CalcLineToPointDistance(double lineX1, double lineY1, double lineX2, double lineY2, double x, double y)

        {

            double distance = 0;

            if (lineX1 == lineX2)

                distance = Math.Abs(x - lineX1);

            else

            {

                double a;

                double b;

                double c;

                a = (lineY2 - lineY1) / (lineX2 - lineX1);

                b = -1;

                c = -a * lineX1 + lineY1;

                distance = Math.Abs(a * x + b * y + c) / Math.Pow(a * a + b * b, 0.5);

            }

            return distance;

        }

        public static double[] CalcLineCrossingPoint(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)

        {

            double a1;

            double a2;

            double b1;

            double b2;

            if (x1 == x2)

                a1 = 0;

            else

                a1 = (y2 - y1) / (x2 - x1);

            if (x3 == x4)

                a2 = 0;

            else

                a2 = (y4 - y3) / (x4 - x3);

            b1 = -a1 * x1 + y1;

            b2 = -a2 * x3 + y3;

            if (x1 == x2 && x3 == x4)

            {

                return null;

            }

            else if (x1 == x2)

            {

                return new double[] { x1, a2*x1 + b2 };

            }

            else if (x3 == x4)

            {

                return new double[] { x3, a1 * x3 + b1 };

            }

            else

            {

                return new double[] { -(b1 - b2) / (a1 - a2), a1 * -(b1 - b2) / (a1 - a2) + b1 };

            }            

        }

        public static double CalcGradient(double x1, double y1, double x2, double y2)

        {

            double result = double.NaN;

            if (x1 != x2)

                result = (y2 - y1) / (x2 - x1);

            return result;

        }

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

        }

        public static object FindObjectByUID(Document document, string UID)

        {

            if (!string.IsNullOrEmpty(UID) && UID != "None")

            {

                foreach (Symbol item in document.SYMBOLS)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (Line item in document.LINES)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (Text item in document.TEXTINFOS)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (Note item in document.NOTES)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (LineNumber item in document.LINENUMBERS)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (Equipment item in document.Equipments)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (SpecBreak item in document.SpecBreaks)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (EndBreak item in document.EndBreaks)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (VendorPackage item in document.VendorPackages)

                {

                    if (item.UID == UID)

                        return item;

                }

            }

            return null;

        }

        public static List<Line> FindLinesByModelId(Document document, string ModelItemId)

        {

            List<Line> lines = new List<Line>();

            foreach (Line item in document.LINES)

            {

                if (item.SPPID.ModelItemId == ModelItemId)

                    lines.Add(item);

            }

            return lines;

        }

        public static void FindConnectedSymbolGroup(Document document, Symbol symbol, List<Symbol> group)

        {

            if (!group.Contains(symbol))

                group.Add(symbol);

            foreach (var connector in symbol.CONNECTORS)

            {

                object connectedItem = FindObjectByUID(document, connector.CONNECTEDITEM);

                if (connectedItem != null && connectedItem.GetType() == typeof(Symbol))

                {

                    Symbol connSymbol = connectedItem as Symbol;

                    if (!group.Contains(connSymbol))

                    {

                        group.Add(connSymbol);

                        FindConnectedSymbolGroup(document, connSymbol, group);

                    }

                }

            }

        }

        public static Symbol FindCenterAtThreeSymbols(Document document, List<Symbol> group)

        {

            Symbol result = null;

            // Group의 가운데 찾기

            if (group.Count == 3)

            {

                foreach (var symbol in group)

                {

                    int count = 0;

                    foreach (var connector in symbol.CONNECTORS)

                    {

                        object item = FindObjectByUID(document, connector.CONNECTEDITEM);

                        if (item != null && item.GetType() == typeof(Symbol) && group.Contains(item as Symbol))

                            count++;

                    }

                    if (count == 2)

                    {

                        result = symbol;

                        break;

                    }

                }

            }

            return result;

        }

        private static void GetConnectedSymbol(Document document, Symbol symbol, List<Symbol> symbolGroup)

        {

            foreach (Connector connector in symbol.CONNECTORS)

            {

                object item = FindObjectByUID(document, connector.CONNECTEDITEM);

                if (item != null && item.GetType() == typeof(Symbol))

                {

                    Symbol connSymbol = item as Symbol;

                    if (connSymbol != null && !symbolGroup.Contains(connSymbol))

                    {

                        symbolGroup.Add(connSymbol);

                        GetConnectedSymbol(document, connSymbol, symbolGroup);

                    }

                }

            }

        }

        public static int SortSymbolPriority(Symbol a, Symbol b)

        {

            int resultValue = a.SPPID.ORIGINAL_Y.CompareTo(b.SPPID.ORIGINAL_Y);

            if (resultValue == 0)

                resultValue = a.SPPID.ORIGINAL_X.CompareTo(b.SPPID.ORIGINAL_X);

            return resultValue;

        }

        public static Connector FindSymbolConnectorByUID(Document document, string uid, Symbol targetSymbol)

        {

            foreach (var connector in targetSymbol.CONNECTORS)

            {

                if (connector.CONNECTEDITEM == uid)

                {

                    return connector;

                }

            }

            return null;

        }

        public static Symbol FindSymbolByRepresentationID(Document document, string repID)

        {

            Symbol findSymbol = null;

            foreach (var symbol in document.SYMBOLS)

            {

                if (symbol.SPPID.RepresentationId == repID)

                {

                    findSymbol = symbol;

                }

                else

                {

                    ChildSymbol childSymbol = FindChildSymbolByRepresentationID(document, symbol, repID);

                    if (childSymbol != null)

                        findSymbol = symbol;

                }

                if (findSymbol != null)

                    break;

            }

            return findSymbol;

        }

        public static ChildSymbol FindChildSymbolByRepresentationID(Document document, Symbol symbol, string repID)

        {

            ChildSymbol childSymbol = null;

            foreach (ChildSymbol loopChild in symbol.ChildSymbols)

            {

                if (loopChild.SPPID.RepresentationId == repID)

                {

                    childSymbol = loopChild;

                    break;

                }

                else

                {

                    childSymbol = FindChildSymbolByRepresentationIDLoop(document, repID, loopChild);

                    if (childSymbol != null)

                        break;

                }

            }

            return childSymbol;

        }

        private static ChildSymbol FindChildSymbolByRepresentationIDLoop(Document document, string repID, ChildSymbol childSymbol)

        {

            ChildSymbol findChild = null;

            foreach (var item in childSymbol.ChildSymbols)

            {

                if (item.SPPID.RepresentationId == repID)

                {

                    findChild = item;

                    break;

                }

                else

                {

                    findChild = FindChildSymbolByRepresentationIDLoop(document, repID, item);

                    if (findChild != null)

                        break;

                }

            }

            return findChild;

        }

        public static bool IsBranchLine(Line line1, Line line2)

        {

            bool result = true;

            Connector conn1 = line1.CONNECTORS.Find(x => x.CONNECTEDITEM == line2.UID);

            Connector conn2 = line2.CONNECTORS.Find(x => x.CONNECTEDITEM == line1.UID);

            if (conn1 != null && conn2 != null)

                result = false;

            return result;

        }

        public static bool IsBranchLine(Line line)

        {

            Connector connector = line.CONNECTORS.Find(x => x.ConnectedObject != null &&

                                                            x.ConnectedObject.GetType() == typeof(Line) &&

                                                            IsBranchLine(line, x.ConnectedObject as Line));

            return connector != null ? true : false;

        }

        public static bool IsBranchStartLine(Line line)

        {

            bool result = false;

            if (line.CONNECTORS[0].ConnectedObject != null && line.CONNECTORS[0].ConnectedObject.GetType() == typeof(Line))

            {

                Line connLine = line.CONNECTORS[0].ConnectedObject as Line;

                if (!(connLine.CONNECTORS[1].ConnectedObject != null && connLine.CONNECTORS[1].ConnectedObject == line))

                {

                    result = true;

                }

            }

            return result;

        }

        public static bool IsBranchedLine(Document document,Line line)

        {

            return document.LINES.Find(x => x.CONNECTORS.Find(y => y.CONNECTEDITEM == line.UID && IsBranchLine(x, y.ConnectedObject as Line)) != null) != null ? true : false;

        }

        public static Line FindOtherLine(Line line, Symbol symbol,int index, string prevSymbolUID = "")

        {

            Line result = null;

            try

            {

                Connector connector = symbol.CONNECTORS.Find(x =>

                                      x.ConnectedObject != null &&

                                      x.ConnectedObject != line &&

                                      x.ConnectedObject.GetType() == typeof(Line) &&

                                      ((line.SlopeType == ((Line)x.ConnectedObject).SlopeType &&

                                        (line.SlopeType == SlopeType.VERTICAL && SPPIDUtil.IsNearValue(line.SPPID.START_X, ((Line)x.ConnectedObject).SPPID.START_X) ||

                                         line.SlopeType == SlopeType.HORIZONTAL && SPPIDUtil.IsNearValue(line.SPPID.START_Y, ((Line)x.ConnectedObject).SPPID.START_Y))) ||

                                       (line.SlopeType != ((Line)x.ConnectedObject).SlopeType &&

                                       (symbol.CONNECTORS.Count == 2 || symbol.CONNECTORS.IndexOf(x) <= 1) &&

                                       (SPPIDUtil.IsNearValue(symbol.SPPID.SPPID_X, ((Line)x.ConnectedObject).SPPID.START_X) ||

                                       SPPIDUtil.IsNearValue(symbol.SPPID.SPPID_X, ((Line)x.ConnectedObject).SPPID.END_X) ||

                                       SPPIDUtil.IsNearValue(symbol.SPPID.SPPID_Y, ((Line)x.ConnectedObject).SPPID.START_Y) ||

                                       SPPIDUtil.IsNearValue(symbol.SPPID.SPPID_Y, ((Line)x.ConnectedObject).SPPID.END_Y)))) 

                                      );

                if (connector != null)

                {

                    result = connector.ConnectedObject as Line;

                    Connector resConn = result.CONNECTORS.Find(f => f.ConnectedObject != null && f.ConnectedObject == symbol);

                    if (result.CONNECTORS.IndexOf(resConn) == index)

                    {

                        result = null ;

                    }

                }

                else

                {

                    Connector connector1 = symbol.CONNECTORS.Find(x =>

                                                                  x.ConnectedObject != null &&

                                                                  x.ConnectedObject != line &&

                                                                  x.ConnectedObject.GetType() == typeof(Symbol) &&

                                                                  (string.IsNullOrEmpty(prevSymbolUID) || ((Symbol)x.ConnectedObject).UID != prevSymbolUID)

                                                                  );

                    if (connector1 != null)

                    {

                        result = FindOtherLine(line, connector1.ConnectedObject as Symbol, index, symbol.UID);

                    }

                }

            }

            catch (System.Exception ex)

            {

                Log.Write(string.Format("[{0}] {1}\r\n{2}", DateTime.Now, ex.Message, ex.StackTrace));

                throw new System.Exception("Error", ex);

            }

            return result;

        }

        public static void CalcOverlap(double[] range1, double[] range2, ref double x, ref double y, ref bool overlapX, ref bool overlapY)

        {

            if (range1[0] <= range2[2] && range1[2] >= range2[0])

            {

                overlapX = true;

                x = Math.Min(Math.Abs(range1[0] - range2[2]), Math.Abs(range1[2] - range2[0]));

            }

            if (range1[1] <= range2[3] && range1[3] >= range2[1])

            {

                overlapY = true;

                y = Math.Min(Math.Abs(range1[1] - range2[3]), Math.Abs(range1[3] - range2[1]));

            }

        }

        public static bool IsOverlap(double[] range1, double[] range2)

        {

            if (range1[0] <= range2[2] && range1[2] >= range2[0] && range1[1] <= range2[3] && range1[3] >= range2[1])

                return true;

            else

                return false;

        }

        public static void CalcNewCoordinateForSymbol(Symbol symbol, Symbol prevSymbol, double distanceX, double distanceY)

        {

            SlopeType slopeType = SPPIDUtil.CalcSlope(prevSymbol.SPPID.ORIGINAL_X, prevSymbol.SPPID.ORIGINAL_Y, symbol.SPPID.ORIGINAL_X, symbol.SPPID.ORIGINAL_Y);

            GridSetting _GridSetting = GridSetting.GetInstance();

            if (slopeType == SlopeType.HORIZONTAL)

            {

                double length = (Math.Ceiling(distanceX / _GridSetting.Length) + 1) * _GridSetting.Length;

                if (prevSymbol.SPPID.ORIGINAL_X < symbol.SPPID.ORIGINAL_X)

                    symbol.SPPID.ORIGINAL_X = symbol.SPPID.ORIGINAL_X + length;

                else

                    symbol.SPPID.ORIGINAL_X = symbol.SPPID.ORIGINAL_X - length;

            }

            else if (slopeType == SlopeType.VERTICAL)

            {

                double length = (Math.Ceiling(distanceY / _GridSetting.Length) + 1) * _GridSetting.Length;

                if (prevSymbol.SPPID.ORIGINAL_Y < symbol.SPPID.ORIGINAL_Y)

                    symbol.SPPID.ORIGINAL_Y = symbol.SPPID.ORIGINAL_Y + length;

                else

                    symbol.SPPID.ORIGINAL_Y = symbol.SPPID.ORIGINAL_Y - length;

            }

        }

        public static Line GetConnectedLine(Symbol symbol1, Symbol symbol2)

        {

            Line line = null;

            Connector connector1 = symbol1.CONNECTORS.Find(x => x.ConnectedObject != null && x.ConnectedObject.GetType() == typeof(Line) &&

            ((Line)x.ConnectedObject).CONNECTORS.Find(y => y.ConnectedObject == symbol2) != null);

            Connector connector2 = symbol2.CONNECTORS.Find(x => x.ConnectedObject != null && x.ConnectedObject.GetType() == typeof(Line) &&

            ((Line)x.ConnectedObject).CONNECTORS.Find(y => y.ConnectedObject == symbol1) != null);

            if (connector1 != null && connector2 != null)

                line = connector1.ConnectedObject as Line;

            return line;

        }

        public static int GetBranchLineCount(Document document, Line line)

        {

            return document.LINES.FindAll(x => IsBranchLine(line, x) && x.CONNECTORS.Find(y => y.ConnectedObject == line) != null).Count;

        }

        public static bool GetLineConnectorPoint(Line line, Connector connector, ref double x, ref double y)

        {

            bool bStart = false;

            int index = line.CONNECTORS.IndexOf(connector);

            if (index == 0)

            {

                x = line.SPPID.START_X;

                y = line.SPPID.START_Y;

                bStart = true;

            }

            else

            {

                x = line.SPPID.END_X;

                y = line.SPPID.END_Y;

            }

            return bStart;

        }

        public static bool IsSegment(Document document, Line line1, Line line2)

        {

            bool result = false;

            SpecBreak specBreak = document.SpecBreaks.Find(x =>

                (x.DownStreamUID == line1.UID && x.UpStreamUID == line2.UID) || 

                (x.DownStreamUID == line2.UID && x.UpStreamUID == line1.UID));

            EndBreak endBreak = document.EndBreaks.Find(x =>

            (x.OWNER == line1.UID && x.PROPERTIES.Find(y => y.ATTRIBUTE == "Connected Item").VALUE == line2.UID) ||

            (x.OWNER == line2.UID && x.PROPERTIES.Find(y => y.ATTRIBUTE == "Connected Item").VALUE == line1.UID));

            if (specBreak != null || endBreak != null)

                result = true;

            return result;

        }

        public static bool IsSegment(Document document, Symbol symbol1, Symbol symbol2)

        {

            bool result = false;

            SpecBreak startSpecBreak = document.SpecBreaks.Find(x =>

            (x.DownStreamUID == symbol1.UID && x.UpStreamUID == symbol2.UID) ||

            (x.DownStreamUID == symbol2.UID && x.UpStreamUID == symbol1.UID));

            EndBreak startEndBreak = document.EndBreaks.Find(x =>

            (x.OWNER == symbol1.UID && x.PROPERTIES.Find(y => y.ATTRIBUTE == "Connected Item").VALUE == symbol2.UID) ||

            (x.OWNER == symbol2.UID && x.PROPERTIES.Find(y => y.ATTRIBUTE == "Connected Item").VALUE == symbol1.UID));

            if (startSpecBreak != null || startEndBreak != null)

                result = true;

            return result;

        }

        public static void test(string representationId)

        {

            Placement placement = new Placement();

            LMADataSource dataSource = new LMADataSource();

            LMSymbol symbol = dataSource.GetSymbol(representationId);

            string[] array1 = new string[] { "", "Top" };

            string[] array2 = new string[] { "", "0.005" };

            placement.PIDApplyParameters(symbol.AsLMRepresentation(), array1, array2);

            ReleaseCOMObjects(dataSource);

        }

        public static DataTable GetUnitInfo()

        {

            LMADataSource dataSource = new LMADataSource();

            LMPlantGroups units = new LMPlantGroups();

            units.Collect(dataSource);

            DataTable dt = new DataTable();

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

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

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

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

            foreach (LMPlantGroup unit in units)

            {

                object tt = unit.get_Dir_Path();

                if (tt.Equals(DBNull.Value))

                    continue;

                string dir = unit.get_Dir_Path();

                string[] array = dir.Split('\\');

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

                string prevId = "-1";

                for (int i = 1; i < array.Length; i++)

                {

                    string name = array[i];

                    string uid = Guid.NewGuid().ToString();

                    DataRow[] rows = dt.Select(string.Format("LEVEL = '{0}' AND NAME = '{1}' AND PARENTID = '{2}'", i, name, prevId));

                    if (rows.Length == 0)

                        dt.Rows.Add(i, uid, prevId, name);

                    else

                        uid = rows[0]["SP_ID"].ToString();

                    prevId = uid;

                }

            }

            dt.Columns.Remove("LEVEL");

            ReleaseCOMObjects(units);

            ReleaseCOMObjects(dataSource);

            return dt;

        }

        public static string T_OPTIONSETTING_Value(string name)

        {

            string result = string.Empty;

            LMADataSource dataSource = new LMADataSource();

            LMOptionSettings settings = new LMOptionSettings();

            LMAFilter filter = new LMAFilter();

            LMACriterion criterion = new LMACriterion();

            filter.ItemType = "OptionSetting";

            criterion.SourceAttributeName = "NAME";

            criterion.Operator = "=";

            criterion.set_ValueAttribute(name);

            filter.get_Criteria().Add(criterion);

            settings.Collect(dataSource, Filter: filter);

            foreach (LMOptionSetting item in settings)

            {

                result = item.get_Value();

                break;

            }

            ReleaseCOMObjects(criterion);

            ReleaseCOMObjects(filter);

            ReleaseCOMObjects(settings);

            ReleaseCOMObjects(dataSource);

            return result;

        }

        public static string T_PLANTSETTING_Value(string name)

        {

            string result = string.Empty;

            LMADataSource dataSource = new LMADataSource();

            LMPlantSettings settings = new LMPlantSettings();

            LMAFilter filter = new LMAFilter();

            LMACriterion criterion = new LMACriterion();

            filter.ItemType = "PlantSetting";

            criterion.SourceAttributeName = "NAME";

            criterion.Operator = "=";

            criterion.set_ValueAttribute(name);

            filter.get_Criteria().Add(criterion);

            settings.Collect(dataSource, Filter: filter);

            foreach (LMPlantSetting item in settings)

            {

                result = item.get_Value();

                break;

            }

            ReleaseCOMObjects(criterion);

            ReleaseCOMObjects(filter);

            ReleaseCOMObjects(settings);

            ReleaseCOMObjects(dataSource);

            return result;

        }

        public static void ReleaseCOMObjects(params object[] objVars)

        {

            int intNewRefCount = 0;

            foreach (object obj in objVars)

            {

                if (!Information.IsNothing(obj) && System.Runtime.InteropServices.Marshal.IsComObject(obj))

                    intNewRefCount = intNewRefCount + System.Runtime.InteropServices.Marshal.FinalReleaseComObject(obj);

            }

        }

        public static void BulkAttribute(LMADataSource dataSource, List<BulkAttribute> attributes, BulkAttributeItemType type)

        {

            switch (type)

            {

                case BulkAttributeItemType.PipeRun:

                    BulkAttribute_PipeRun();

                    break;

                case BulkAttributeItemType.Symbol:

                    BulkAttribute_Symbol();

                    break;

                default:

                    break;

            }

            void BulkAttribute_PipeRun()

            {

                string drawingId = dataSource.PIDMgr.Drawing.ID;

                LMAFilter filter = new LMAFilter();

                LMACriterion criterion = new LMACriterion();

                criterion.SourceAttributeName = "REPRESENTATION.SP_DRAWINGID";

                criterion.Operator = "=";

                criterion.set_ValueAttribute(drawingId);

                filter.get_Criteria().Add(criterion);

                filter.ItemType = "PIPERUN";

                LMACriterion criterion2 = new LMACriterion();

                criterion2.SourceAttributeName = "REPRESENTATION.INSTOCKPILE";

                criterion2.Operator = "=";

                criterion2.set_ValueAttribute("1");

                criterion2.Conjunctive = true;

                filter.get_Criteria().Add(criterion2);

                LMACriterion criterion3 = new LMACriterion();

                criterion3.SourceAttributeName = "REPRESENTATION.ITEMSTATUS";

                criterion3.Operator = "=";

                criterion3.set_ValueAttribute("1");

                criterion3.Conjunctive = true;

                filter.get_Criteria().Add(criterion3);

                LMPipeRuns items = new LMPipeRuns();

                items.Collect(dataSource, Filter: filter);

                foreach (LMPipeRun item in items)

                {

                    foreach (var attribute in attributes)

                    {

                        if (item.Attributes[attribute.SPPIDAttributeName] != null)

                            item.Attributes[attribute.SPPIDAttributeName].set_Value(attribute.Value);

                    }

                    item.Commit();

                }

                ReleaseCOMObjects(items);

                ReleaseCOMObjects(filter);

                ReleaseCOMObjects(criterion);

                ReleaseCOMObjects(criterion2);

                ReleaseCOMObjects(criterion3);

            }

            void BulkAttribute_Symbol()

            {

                string drawingId = dataSource.PIDMgr.Drawing.ID;

                LMAFilter filter = new LMAFilter();

                LMACriterion criterion = new LMACriterion();

                criterion.SourceAttributeName = "SP_DRAWINGID";

                criterion.Operator = "=";

                criterion.set_ValueAttribute(drawingId);

                filter.get_Criteria().Add(criterion);

                filter.ItemType = "SYMBOL";

                LMACriterion criterion2 = new LMACriterion();

                criterion2.SourceAttributeName = "INSTOCKPILE";

                criterion2.Operator = "=";

                criterion2.set_ValueAttribute("1");

                criterion2.Conjunctive = true;

                filter.get_Criteria().Add(criterion2);

                LMACriterion criterion3 = new LMACriterion();

                criterion3.SourceAttributeName = "ITEMSTATUS";

                criterion3.Operator = "=";

                criterion3.set_ValueAttribute("1");

                criterion3.Conjunctive = true;

                filter.get_Criteria().Add(criterion3);

                LMSymbols items = new LMSymbols();

                items.Collect(dataSource, Filter: filter);

                foreach (LMSymbol item in items)

                {

                    foreach (var attribute in attributes)

                    {

                        if (item.Attributes[attribute.SPPIDAttributeName] != null)

                            item.Attributes[attribute.SPPIDAttributeName].set_Value(attribute.Value);

                    }

                    item.Commit();

                }

                ReleaseCOMObjects(items);

                ReleaseCOMObjects(filter);

                ReleaseCOMObjects(criterion);

                ReleaseCOMObjects(criterion2);

                ReleaseCOMObjects(criterion3);

            }

        }

        public static void UpdatePipeRunProperty(LMADataSource dataSource, Model.SPPID_PipeRunPropSetting setting)

        {

            string drawingId = dataSource.PIDMgr.Drawing.ID;

            string type = setting.DataType.Substring(0, 1);

            LMAFilter filter = new LMAFilter();

            filter.ItemType = "PIPERUN";

            LMACriterion criterionID = new LMACriterion();

            criterionID.SourceAttributeName = "REPRESENTATION.SP_DRAWINGID";

            criterionID.Operator = "=";

            criterionID.set_ValueAttribute(drawingId);

            filter.get_Criteria().Add(criterionID);

            SetCriterionPipeRun(setting.Cond1_Name, setting.Cond1_Value, setting.Cond1_DataType);

            if (!string.IsNullOrWhiteSpace(setting.Cond2_Name))

                SetCriterionPipeRun(setting.Cond2_Name, setting.Cond2_Value, setting.Cond2_DataType);

            LMPipeRuns items = new LMPipeRuns();

            items.Collect(dataSource, Filter: filter);

            foreach (LMPipeRun item in items)

            {

                if (item.Attributes[setting.Name] != null)

                {

                    object oValue = null;

                    if (type == "S" || type == "C")

                        oValue = setting.Value;

                    else

                        oValue = Convert.ToDouble(setting.Value);

                    item.Attributes[setting.Name].set_Value(oValue);

                }

                try

                {

                    item.Commit();

                }

                catch (Exception ex)

                {

                }

            }

            ReleaseCOMObjects(items);

            ReleaseCOMObjects(filter);

            void SetCriterionPipeRun(string condName, string condValue, string condDataType)

            {

                if (condValue.Contains("~"))

                {

                    string[] value_Arr = condValue.Split('~');

                    object fromValue = GetPipeRunSiValue(dataSource, condName, value_Arr[0]);

                    if (fromValue.GetType() == typeof(double))

                    {

                        double dfrom = Convert.ToDouble(fromValue);

                        dfrom -= 0.000000000001;

                        fromValue = dfrom;

                    }

                    object toValue = null;

                    if (value_Arr.Length > 1)

                    {

                        toValue = GetPipeRunSiValue(dataSource, condName, value_Arr[1]);

                        if (toValue.GetType() == typeof(double))

                        {

                            double dTo = Convert.ToDouble(toValue);

                            dTo += 0.000000000001;

                            toValue = dTo;

                        }

                    }

                    LMACriterion criterionFrom = new LMACriterion();

                    criterionFrom.SourceAttributeName = condName;

                    criterionFrom.Operator = ">";

                    criterionFrom.set_ValueAttribute(fromValue);

                    criterionFrom.Conjunctive = true;

                    filter.get_Criteria().Add(criterionFrom);

                    ReleaseCOMObjects(criterionFrom);

                    if (toValue != null)

                    {

                        LMACriterion criterionTo = new LMACriterion();

                        criterionTo.SourceAttributeName = condName;

                        criterionTo.Operator = "<";

                        criterionTo.set_ValueAttribute(toValue);

                        criterionTo.Conjunctive = true;

                        filter.get_Criteria().Add(criterionTo);

                        ReleaseCOMObjects(criterionTo);

                    }

                }

                else

                {

                    LMACriterion criterion = new LMACriterion();

                    criterion.SourceAttributeName = condName;

                    criterion.Operator = "=";

                    double dValue = 0;

                    object oValue = condValue;

                    if (condDataType.StartsWith("C"))

                    {

                        oValue = GetCodeIndex(condDataType, condValue.Trim());

                    }

                    else if (double.TryParse(condValue.Trim(), out dValue))

                    {

                        oValue = dValue;

                    }

                    else

                    {

                        oValue = GetPipeRunSiValue(dataSource, condName, condValue);

                    }

                    criterion.set_ValueAttribute(oValue);

                    criterion.Conjunctive = true;

                    filter.get_Criteria().Add(criterion);

                    ReleaseCOMObjects(criterion);

                }

                ReleaseCOMObjects(criterionID);

            }

        }

        private static object GetPipeRunSiValue(LMADataSource dataSource, string attributeName, string displayValue)

        {

            object valueObject = null;

            if (PipeRun == null)

            {

                string drawingId = dataSource.PIDMgr.Drawing.ID;

                LMAFilter filter = new LMAFilter();

                LMACriterion criterion = new LMACriterion();

                criterion.SourceAttributeName = "REPRESENTATION.SP_DRAWINGID";

                criterion.Operator = "=";

                criterion.set_ValueAttribute(drawingId);

                filter.get_Criteria().Add(criterion);

                filter.ItemType = "PIPERUN";