HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Llama;

using Plaice;

using Ingr.RAD2D.Interop.RAD2D;

using Ingr.RAD2D.Internal;

using Ingr.RAD2D.Helper;

using Converter.BaseModel;

using Converter.SPPID.Model;

using Converter.SPPID.Properties;

using Converter.SPPID.Util;

using Converter.SPPID.DB;

using Ingr.RAD2D.MacroControls.CmdCtrl;

using Ingr.RAD2D;

using System.Windows;

using System.Threading;

using System.Drawing;

using Microsoft.VisualBasic;

using Newtonsoft.Json;

namespace Converter.SPPID

{

    public class AutoModeling

    {

        Placement _placement;

        LMADataSource dataSource;

        Ingr.RAD2D.Application radApp;

        SPPID_Document document;

        List<Tuple<string, Line, Line>> BranchLines = new List<Tuple<string, Line, Line>>();

        public AutoModeling(SPPID_Document document, Ingr.RAD2D.Application radApp)

        {

            this.document = document;

            this.radApp = radApp;

        }

        public void Run()

        {

            _placement = new Placement();

            dataSource = _placement.PIDDataSource;

            //dynamic application = Interaction.GetObject("", "PIDAutomation.Application");

            //dynamic newDrawing = application.Drawings.Add(document.Unit, document.Template, document.DrawingNumber, document.DrawingName);

            //application.ActiveWindow.Fit();

            //Thread.Sleep(100);

            //application.ActiveWindow.Zoom = 60;

            //Thread.Sleep(100);

            try

            {

                // Equipment Modeling

                foreach (Equipment equipment in document.Equipments)

                    SymbolModeling(equipment as Symbol, null, null);

                // LineRun Symbol Modeling

                foreach (LineNumber lineNumber in document.LINENUMBERS)

                    foreach (LineRun run in lineNumber.RUNS)

                        SymbolModelingByRun(run);

                // TrimLineRun Symbol Modeling

                foreach (TrimLine trimLine in document.TRIMLINES)

                    foreach (LineRun run in trimLine.RUNS)

                        SymbolModelingByRun(run);

                // LineRun Line Modeling

                foreach (LineNumber lineNumber in document.LINENUMBERS)

                    foreach (LineRun run in lineNumber.RUNS)

                        LineModelingByRun(run);

                // TrimLineRun Line Modeling

                foreach (TrimLine trimLine in document.TRIMLINES)

                    foreach (LineRun run in trimLine.RUNS)

                        LineModelingByRun(run);

                // Branch Line Modeling

                foreach (var item in BranchLines)

                    BranchLineModeling(item);

                // EndBreak Modeling

                foreach (var item in document.EndBreaks)

                    EndBreakModeling(item);

                // LineNumber Modeling

                foreach (var item in document.LINENUMBERS)

                    LineNumberModeling(item);

                // LineRun Line Join

                foreach (LineNumber lineNumber in document.LINENUMBERS)

                    foreach (LineRun run in lineNumber.RUNS)

                        JoinRunLine(run);

                // TrimLineRun Line Join

                foreach (TrimLine trimLine in document.TRIMLINES)

                    foreach (LineRun run in trimLine.RUNS)

                        JoinRunLine(run);

                // Note Modeling

                foreach (var item in document.NOTES)

                    NoteModeling(item);

                // Text Modeling

                foreach (var item in document.TEXTINFOS)

                    TextModeling(item);

                // Input LineNumber Attribute

                foreach (var item in document.LINENUMBERS)

                    InputLineNumberAttribute(item);

                // Input Symbol Attribute

                foreach (var item in document.SYMBOLS)

                    InputSymbolAttribute(item);

            }

            catch (Exception ex)

            {

                System.Windows.Forms.MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);

            }

            finally

            {

                ReleaseCOMObjects(dataSource);

                ReleaseCOMObjects(_placement);

            }

            //System.Windows.Forms.MessageBox.Show("end");

        }

        public void Test()

        {

            _placement = new Placement();

            dataSource = _placement.PIDDataSource;

            DependencyObject drawingObject = radApp.ActiveDocument.SelectSet[0] as DependencyObject;

            if (drawingObject != null)

            {

                string modelitemID = drawingObject.AttributeSets[0][5].GetValue().ToString();

                radApp.ActiveDocument.SelectSet.RemoveAll();

                LMPipeRun run = dataSource.GetPipeRun(modelitemID);

                _LMAItem item = run.AsLMAItem();

                string modelitemID2 = item.Id;

                _placement.PIDAutoJoin(item, AutoJoinEndConstants.autoJoin_Both, ref item);

                string afterModelItemID = item.Id;

                if (modelitemID2 != afterModelItemID)

                {

                }

            }

        }

        private void LineModelingByRun(LineRun run)

        {

            Line prevLine = null;

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

            foreach (var item in run.RUNITEMS)

            {

                // Line일 경우

                if (item.GetType() == typeof(Line))

                {

                    Line line = item as Line;

                    if (prevLine == null)

                        lines.Add(line);

                    else if (prevLine != null)

                    {

                        if (prevLine.SPPID.MAPPINGNAME == line.SPPID.MAPPINGNAME)

                            lines.Add(line);

                        else

                        {

                            LineModeling(lines);

                            lines.Clear();

                            lines.Add(line);

                        }

                    }

                    prevLine = line;

                }

                // Symbol 일 경우

                else if (item.GetType() == typeof(Symbol))

                {

                    if (lines.Count > 0)

                    {

                        LineModeling(lines);

                        lines.Clear();

                    }

                }

            }

            if (lines.Count > 0)

                LineModeling(lines);

        }

        private void SymbolModelingByRun(LineRun run)

        {

            // 양끝 Symbol 검사 후 Line이 나올때까지만 Symbol Modeling

            if (run.RUNITEMS.Count > 0)

            {

                if (run.RUNITEMS[0].GetType() == typeof(Symbol))

                    SymbolModelingByRunStart(run.RUNITEMS[0] as Symbol, run);

                if (run.RUNITEMS[run.RUNITEMS.Count - 1].GetType() == typeof(Symbol))

                    SymbolModelingByRunEnd(run.RUNITEMS[run.RUNITEMS.Count - 1] as Symbol, run);

            }

            Symbol prevSymbol = null;

            Symbol targetSymbol = null;

            foreach (var item in run.RUNITEMS)

            {

                if (item.GetType() == typeof(Symbol))

                {

                    Symbol symbol = item as Symbol;

                    SymbolModeling(symbol, targetSymbol, prevSymbol);

                    prevSymbol = symbol;

                    targetSymbol = symbol;

                }

                else

                {

                    targetSymbol = null;

                }

            }

        }

        private void SymbolModelingByRunStart(Symbol symbol, LineRun run)

        {

            foreach (var connector in symbol.CONNECTORS)

            {

                object targetItem = SPPIDUtil.FindObjectByUID(document, connector.CONNECTEDITEM);

                if (targetItem != null &&

                    (targetItem.GetType() == typeof(Symbol) || targetItem.GetType() == typeof(Equipment)) &&

                    !IsSameLineNumber(symbol, targetItem))

                {

                    SymbolModeling(symbol, targetItem as Symbol, null);

                    for (int i = 1; i < run.RUNITEMS.Count; i++)

                    {

                        object item = run.RUNITEMS[i];

                        if (item.GetType() == typeof(Symbol))

                            SymbolModeling(item as Symbol, run.RUNITEMS[i - 1] as Symbol, null);

                        else

                            break;

                    }

                    break;

                }

            }

        }

        private void SymbolModelingByRunEnd(Symbol symbol, LineRun run)

        {

            foreach (var connector in symbol.CONNECTORS)

            {

                object targetItem = SPPIDUtil.FindObjectByUID(document, connector.CONNECTEDITEM);

                if (targetItem != null &&

                    (targetItem.GetType() == typeof(Symbol) || targetItem.GetType() == typeof(Equipment)) &&

                    !IsSameLineNumber(symbol, targetItem))

                {

                    SymbolModeling(symbol, targetItem as Symbol, null);

                    for (int i = run.RUNITEMS.Count - 2; i >= 0; i--)

                    {

                        object item = run.RUNITEMS[i];

                        if (item.GetType() == typeof(Symbol))

                            SymbolModeling(item as Symbol, run.RUNITEMS[i + 1] as Symbol, null);

                        else

                            break;

                    }

                    break;

                }

            }

        }

        private void SymbolModeling(Symbol symbol, Symbol targetSymbol, Symbol prevSymbol)

        {

            if (!string.IsNullOrEmpty(symbol.SPPID.RepresentationId))

                return;

            LMSymbol _LMSymbol = null;

            string mappingPath = symbol.SPPID.MAPPINGNAME;

            double x = symbol.SPPID.ORIGINAL_X;

            double y = symbol.SPPID.ORIGINAL_Y;

            int mirror = 0;

            double angle = symbol.ANGLE;

            if (targetSymbol != null && !string.IsNullOrEmpty(targetSymbol.SPPID.RepresentationId))

            {

                LMSymbol _TargetItem = dataSource.GetSymbol(targetSymbol.SPPID.RepresentationId);

                _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle, TargetItem: _TargetItem);

                ReleaseCOMObjects(_TargetItem);

            }

            else if (prevSymbol != null)

            {

                LMSymbol _PrevSymbol = dataSource.GetSymbol(prevSymbol.SPPID.RepresentationId);

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

                double prevX = _PrevSymbol.get_XCoordinate();

                double prevY = _PrevSymbol.get_YCoordinate();

                if (slopeType == SlopeType.HORIZONTAL)

                    y = prevY;

                else if (slopeType == SlopeType.VERTICAL)

                    x = prevX;

                _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle);

            }

            else

            {

                _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle);

            }

            if (_LMSymbol != null)

            {

                _LMSymbol.Commit();

                symbol.SPPID.RepresentationId = _LMSymbol.AsLMRepresentation().Id;

            }

            ReleaseCOMObjects(_LMSymbol);

        }

        private bool IsSameLineNumber(object item, object targetItem)

        {

            foreach (var lineNumber in document.LINENUMBERS)

            {

                foreach (var run in lineNumber.RUNS)

                {

                    foreach (var runItem in run.RUNITEMS)

                    {

                        if (runItem == item)

                        {

                            foreach (var findItem in run.RUNITEMS)

                            {

                                if (findItem == targetItem)

                                {

                                    return true;

                                }

                            }

                            return false;

                        }

                    }

                }

            }

            return false;

        }

        private void LineModeling(List<Line> lines)

        {

            _LMAItem _LMAItem = _placement.PIDCreateItem(lines[0].SPPID.MAPPINGNAME);

            PlaceRunInputs placeRunInputs = new PlaceRunInputs();

            LMSymbol _LMSymbol1 = null;

            LMSymbol _LMSymbol2 = null;

            Dictionary<LMConnector, List<double[]>> connectorVertices1 = new Dictionary<LMConnector, List<double[]>>();

            LMConnector targetConnector1 = null;

            Dictionary<LMConnector, List<double[]>> connectorVertices2 = new Dictionary<LMConnector, List<double[]>>();

            LMConnector targetConnector2 = null;

            Line startBranchLine = null;

            Line endBranchLine = null;

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

            {

                Line line = lines[i];

                if (i == 0 || i + 1 != lines.Count)

                {

                    // 시작점에 연결된 Symbol 찾기

                    object connItem = SPPIDUtil.FindObjectByUID(document, line.CONNECTORS[0].CONNECTEDITEM);

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

                    {

                        _LMSymbol1 = dataSource.GetSymbol(((Symbol)connItem).SPPID.RepresentationId);

                        if (_LMSymbol1 != null)

                            placeRunInputs.AddSymbolTarget(_LMSymbol1, line.SPPID.START_X, line.SPPID.START_Y);

                        else

                            placeRunInputs.AddPoint(line.SPPID.START_X, line.SPPID.START_Y);

                    }

                    else if (connItem != null && connItem.GetType() == typeof(Line) && !lines.Contains(connItem))

                    {

                        connectorVertices1 = GetPipeRunVertices(((Line)connItem).SPPID.ModelItemId);

                        targetConnector1 = FindTargetLMConnector(connectorVertices1, line.SPPID.START_X, line.SPPID.START_Y, line.SPPID.END_X, line.SPPID.END_Y);

                        if (targetConnector1 != null)

                            placeRunInputs.AddConnectorTarget(targetConnector1, line.SPPID.START_X, line.SPPID.START_Y);

                        else

                        {

                            startBranchLine = connItem as Line;

                            placeRunInputs.AddPoint(line.SPPID.START_X, line.SPPID.START_Y);

                        }

                    }

                    else

                        placeRunInputs.AddPoint(line.SPPID.START_X, line.SPPID.START_Y);

                }

                if (i + 1 == lines.Count)

                {

                    // 끝점에 연결된 Symbol 찾기

                    object connItem = SPPIDUtil.FindObjectByUID(document, line.CONNECTORS[1].CONNECTEDITEM);

                    if (i != 0)

                        placeRunInputs.AddPoint(line.SPPID.START_X, line.SPPID.START_Y);

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

                    {

                        _LMSymbol2 = dataSource.GetSymbol(((Symbol)connItem).SPPID.RepresentationId);

                        if (_LMSymbol2 != null)

                            placeRunInputs.AddSymbolTarget(_LMSymbol2, line.SPPID.END_X, line.SPPID.END_Y);

                        else

                            placeRunInputs.AddPoint(line.SPPID.END_X, line.SPPID.END_Y);

                    }

                    else if (connItem != null && connItem.GetType() == typeof(Line) && !lines.Contains(connItem))

                    {

                        connectorVertices2 = GetPipeRunVertices(((Line)connItem).SPPID.ModelItemId);

                        targetConnector2 = FindTargetLMConnector(connectorVertices2, line.SPPID.END_X, line.SPPID.END_Y, line.SPPID.START_X, line.SPPID.START_Y);

                        if (targetConnector2 != null)

                            placeRunInputs.AddConnectorTarget(targetConnector2, line.SPPID.END_X, line.SPPID.END_Y);

                        else

                        {

                            endBranchLine = connItem as Line;

                            placeRunInputs.AddPoint(line.SPPID.END_X, line.SPPID.END_Y);

                        }

                    }

                    else

                    {

                        placeRunInputs.AddPoint(line.SPPID.END_X, line.SPPID.END_Y);

                    }

                }

            }

            LMConnector _lMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

            if (_lMConnector != null)

            {

                foreach (var line in lines)

                    line.SPPID.ModelItemId = _lMConnector.ModelItemID;

                _lMConnector.Commit();

                if (startBranchLine != null || endBranchLine != null)

                {

                    BranchLines.Add(new Tuple<string, Line, Line>(_lMConnector.ModelItemID, startBranchLine, endBranchLine));

                }

            }

            if (_LMSymbol1 != null)

                ReleaseCOMObjects(_LMSymbol1);

            if (_LMSymbol2 != null)

                ReleaseCOMObjects(_LMSymbol2);

            if (targetConnector1 != null)

                ReleaseCOMObjects(targetConnector1);

            if (targetConnector2 != null)

                ReleaseCOMObjects(targetConnector2);

            foreach (var item in connectorVertices1)

                ReleaseCOMObjects(item.Key);

            foreach (var item in connectorVertices2)

                ReleaseCOMObjects(item.Key);

            ReleaseCOMObjects(_lMConnector);

            ReleaseCOMObjects(placeRunInputs);

            ReleaseCOMObjects(_LMAItem);

        }

        private void BranchLineModeling(Tuple<string, Line, Line> branch)

        {

            List<Line> lines = SPPIDUtil.FindLinesByModelId(document, branch.Item1);

            Dictionary<LMConnector, List<double[]>> connectorVertices = GetPipeRunVertices(branch.Item1);

            LMConnector _StartConnector = null;

            LMConnector _EndConnector = null;

            double lengthStart = double.MaxValue;

            double lengthEnd = double.MaxValue;

            List<double[]> startPoints = new List<double[]>();

            List<double[]> endPoints = new List<double[]>();

            foreach (var item in connectorVertices)

            {

                foreach (var point in item.Value)

                {

                    // Start Point가 Branch

                    if (branch.Item2 != null)

                    {

                        Line targetLine = branch.Item2;

                        double distance = SPPIDUtil.CalcLineToPointDistance(targetLine.SPPID.START_X, targetLine.SPPID.START_Y, targetLine.SPPID.END_X, targetLine.SPPID.END_Y, point[0], point[1]);

                        if (lengthStart > distance)

                        {

                            _StartConnector = item.Key;

                            lengthStart = distance;

                            startPoints = item.Value;

                        }

                    }

                    // End Point가 Branch

                    if (branch.Item3 != null)

                    {

                        Line targetLine = branch.Item3;

                        double distance = SPPIDUtil.CalcLineToPointDistance(targetLine.SPPID.START_X, targetLine.SPPID.START_Y, targetLine.SPPID.END_X, targetLine.SPPID.END_Y, point[0], point[1]);

                        if (lengthEnd > distance)

                        {

                            _EndConnector = item.Key;

                            lengthEnd = distance;

                            endPoints = item.Value;

                        }

                    }

                }

            }

            #region Branch가 양쪽 전부일 때

            if (_StartConnector != null && _StartConnector == _EndConnector)

            {

                _placement.PIDRemovePlacement(_StartConnector.AsLMRepresentation());

                _LMAItem _LMAItem = _placement.PIDCreateItem(lines[0].SPPID.MAPPINGNAME);

                PlaceRunInputs placeRunInputs = new PlaceRunInputs();

                Dictionary<LMConnector, List<double[]>> startConnectorVertices = GetPipeRunVertices(branch.Item2.SPPID.ModelItemId);

                LMConnector _StartTargetConnector = FindTargetLMConnector(startConnectorVertices, startPoints[0][0], startPoints[0][1], startPoints[1][0], startPoints[1][1]);

                Dictionary<LMConnector, List<double[]>> endConnectorVertices = GetPipeRunVertices(branch.Item3.SPPID.ModelItemId);

                LMConnector _EndTargetConnector = FindTargetLMConnector(endConnectorVertices,

                   startPoints[startPoints.Count - 1][0],

                   startPoints[startPoints.Count - 1][1],

                   startPoints[startPoints.Count - 2][0],

                   startPoints[startPoints.Count - 2][1]);

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

                {

                    double[] point = startPoints[i];

                    if (i == 0)

                        placeRunInputs.AddConnectorTarget(_StartTargetConnector, point[0], point[1]);

                    else if (i == startPoints.Count - 1)

                        placeRunInputs.AddConnectorTarget(_EndTargetConnector, point[0], point[1]);

                    else

                        placeRunInputs.AddPoint(point[0], point[1]);

                }

                LMConnector _LMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

                if (_LMConnector != null)

                {

                    _LMConnector.Commit();

                    foreach (var item in lines)

                        item.SPPID.ModelItemId = _LMConnector.ModelItemID;

                }

                foreach (var item in startConnectorVertices)

                    ReleaseCOMObjects(item.Key);

                foreach (var item in endConnectorVertices)

                    ReleaseCOMObjects(item.Key);

                ReleaseCOMObjects(placeRunInputs);

                ReleaseCOMObjects(_LMAItem);

                ReleaseCOMObjects(_LMConnector);

            }

            #endregion

            #region 양쪽이 다른 Branch 

            else

            {

                // Branch 시작 Connector

                if (_StartConnector != null)

                    BranchLineModelingByConnector(branch, _StartConnector, startPoints, true);

                // Branch 끝 Connector

                if (_EndConnector != null)

                    BranchLineModelingByConnector(branch, _EndConnector, endPoints, false);

            }

            #endregion

            if (_StartConnector != null)

                ReleaseCOMObjects(_StartConnector);

            if (_EndConnector != null)

                ReleaseCOMObjects(_EndConnector);

            foreach (var item in connectorVertices)

                ReleaseCOMObjects(item.Key);

        }

        private void BranchLineModelingByConnector(Tuple<string, Line, Line> branch, LMConnector _Connector, List<double[]> points, bool IsStart)

        {

            List<Line> lines = SPPIDUtil.FindLinesByModelId(document, branch.Item1);

            Dictionary<LMConnector, List<double[]>> connectorVertices = GetPipeRunVertices(branch.Item1);

            LMConnector _SameRunTargetConnector = null;

            LMSymbol _SameRunTargetSymbol = null;

            Dictionary<LMConnector, List<double[]>> branchConnectorVertices = null;

            LMConnector _BranchTargetConnector = null;

            PlaceRunInputs placeRunInputs = new PlaceRunInputs();

            // 같은 Line Run의 Connector 찾기

            foreach (var item in connectorVertices)

            {

                if (item.Key == _Connector)

                    continue;

                if (IsStart &&

                    !DBNull.Value.Equals(item.Key.ConnectItem1SymbolID) &&

                    !DBNull.Value.Equals(_Connector.ConnectItem2SymbolID)&& 

                    item.Key.ConnectItem1SymbolID == _Connector.ConnectItem2SymbolID)

                {

                    _SameRunTargetConnector = item.Key;

                    break;

                }

                else if (!IsStart &&

                    !DBNull.Value.Equals(item.Key.ConnectItem2SymbolID) &&

                    !DBNull.Value.Equals(_Connector.ConnectItem1SymbolID) && 

                    item.Key.ConnectItem2SymbolID == _Connector.ConnectItem1SymbolID)

                {

                    _SameRunTargetConnector = item.Key;

                    break;

                }

            }

            // Branch 반대편이 Symbol

            if (_SameRunTargetConnector == null)

            {

                foreach (var line in lines)

                {

                    foreach (var connector in line.CONNECTORS)

                    {

                        Symbol symbol = SPPIDUtil.FindObjectByUID(document, connector.CONNECTEDITEM) as Symbol;

                        if (symbol != null)

                        {

                            _SameRunTargetSymbol = dataSource.GetSymbol(symbol.SPPID.RepresentationId);

                            break;

                        }

                    }

                }

            }

            // 기존 Connector 제거

            _placement.PIDRemovePlacement(_Connector.AsLMRepresentation());

            // 시작 Connector일 경우 첫 Point가 TargetConnector를 찾아야함

            if (IsStart)

            {

                branchConnectorVertices = GetPipeRunVertices(branch.Item2.SPPID.ModelItemId);

                _BranchTargetConnector = FindTargetLMConnector(branchConnectorVertices, points[0][0], points[0][1], points[1][0], points[1][1]);

            }

            // 끝 Conenctor일 경우 마지막 Point가 TargetConnector를 찾아야함

            else

            {

                branchConnectorVertices = GetPipeRunVertices(branch.Item3.SPPID.ModelItemId);

                _BranchTargetConnector = FindTargetLMConnector(branchConnectorVertices,

                    points[points.Count - 1][0],

                    points[points.Count - 1][1],

                    points[points.Count - 2][0],

                    points[points.Count - 2][1]);

            }

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

            {

                double[] point = points[i];

                if (i == 0)

                {

                    if (IsStart)

                    {

                        placeRunInputs.AddConnectorTarget(_BranchTargetConnector, point[0], point[1]);

                    }

                    else

                    {

                        if (_SameRunTargetConnector != null)

                            placeRunInputs.AddConnectorTarget(_SameRunTargetConnector, point[0], point[1]);

                        else if (_SameRunTargetSymbol != null)

                            placeRunInputs.AddSymbolTarget(_SameRunTargetSymbol, point[0], point[1]);

                        else

                            placeRunInputs.AddPoint(point[0], point[1]);

                    }

                }

                else if (i == points.Count - 1)

                {

                    if (IsStart)

                    {

                        if (_SameRunTargetConnector != null)

                            placeRunInputs.AddConnectorTarget(_SameRunTargetConnector, point[0], point[1]);

                        else if (_SameRunTargetSymbol != null)

                            placeRunInputs.AddSymbolTarget(_SameRunTargetSymbol, point[0], point[1]);

                        else

                            placeRunInputs.AddPoint(point[0], point[1]);

                    }

                    else

                    {

                        placeRunInputs.AddConnectorTarget(_BranchTargetConnector, point[0], point[1]);

                    }

                }

                else

                    placeRunInputs.AddPoint(point[0], point[1]);

            }

            _LMAItem _LMAItem = _placement.PIDCreateItem(lines[0].SPPID.MAPPINGNAME);

            LMConnector _LMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

            if (_LMConnector != null)

            {

                if (_SameRunTargetConnector != null)

                {

                    JoinPipeRun(_LMConnector.ModelItemID, _SameRunTargetConnector.ModelItemID);

                }

                else

                {

                    foreach (var item in lines)

                        item.SPPID.ModelItemId = _LMConnector.ModelItemID;

                }

                _LMConnector.Commit();

                ReleaseCOMObjects(_LMConnector);

            }

            ReleaseCOMObjects(placeRunInputs);

            ReleaseCOMObjects(_LMAItem);

            if (_BranchTargetConnector != null)

                ReleaseCOMObjects(_BranchTargetConnector);

            if (_SameRunTargetConnector != null)

                ReleaseCOMObjects(_SameRunTargetConnector);

            if (_SameRunTargetSymbol != null)

                ReleaseCOMObjects(_SameRunTargetSymbol);

            foreach (var item in connectorVertices)

                ReleaseCOMObjects(item.Key);

            foreach (var item in branchConnectorVertices)

                ReleaseCOMObjects(item.Key);

        }

        private void EndBreakModeling(EndBreak endBreak)

        {

            Line ownerLine = SPPIDUtil.FindObjectByUID(document, endBreak.OWNER) as Line;

            Line connLine = null;   

            Property property = endBreak.PROPERTIES.Find(x => x.ATTRIBUTE == "Connected Item");

            if (property != null)

                connLine = SPPIDUtil.FindObjectByUID(document, property.VALUE) as Line;

            if (ownerLine != null && connLine != null)

            {

                LMLabelPersist _LmLabelPersist = null;

                string lineModelId = ownerLine.SPPID.ModelItemId;

                LMPipeRun _LMPipeRun = _placement.PIDDataSource.GetPipeRun(lineModelId);

                LMPipeRun _ConnLMPipeRun = _placement.PIDDataSource.GetPipeRun(connLine.SPPID.ModelItemId);

                LMConnector connectedLMConnector = null;

                if (_LMPipeRun != null && _ConnLMPipeRun != null)

                {

                    foreach (LMRepresentation rep in _LMPipeRun.Representations)

                    {

                        if (rep.Attributes["RepresentationType"].get_Value() == "Connector" && rep.Attributes["ItemStatus"].get_Value() == "Active")

                        {

                            LMConnector _LMConnector = _placement.PIDDataSource.GetConnector(rep.Id);

                            if (_LMConnector.ConnectItem1SymbolID != null && !DBNull.Value.Equals(_LMConnector.ConnectItem1SymbolID) && ExistConnItem(_ConnLMPipeRun, _LMConnector.ConnectItem1SymbolID))

                            {

                                connectedLMConnector = _LMConnector;

                                break;

                            }

                            else if (_LMConnector.ConnectItem2SymbolID != null && !DBNull.Value.Equals(_LMConnector.ConnectItem2SymbolID) && ExistConnItem(_ConnLMPipeRun, _LMConnector.ConnectItem2SymbolID))

                            {

                                connectedLMConnector = _LMConnector;

                                break;

                            }

                            else

                            {

                                ReleaseCOMObjects(_LMConnector);

                            }

                        }

                    }

                    if (connectedLMConnector != null)

                    {

                        Array array = new double[] { 0, endBreak.SPPID.ORIGINAL_X, endBreak.SPPID.ORIGINAL_Y };

                        _LmLabelPersist = _placement.PIDPlaceLabel(endBreak.SPPID.MAPPINGNAME, ref array, Rotation: 0, LabeledItem: connectedLMConnector.AsLMRepresentation(), IsLeaderVisible: true);

                        ReleaseCOMObjects(connectedLMConnector);

                    }

                    ReleaseCOMObjects(_LMPipeRun);

                    ReleaseCOMObjects(_ConnLMPipeRun);

                    if (_LmLabelPersist != null)

                        ReleaseCOMObjects(_LmLabelPersist);

                }

            }

        }

        private bool ExistConnItem(LMPipeRun _LMPipeRun, string ConnItem)

        {

            foreach (LMRepresentation rep in _LMPipeRun.Representations)

            {

                if (rep.Attributes["RepresentationType"].get_Value() == "Connector" && rep.Attributes["ItemStatus"].get_Value() == "Active")

                {

                    LMConnector _LMConnector = dataSource.GetConnector(rep.Id);

                    if (_LMConnector.ConnectItem1SymbolID != null && !DBNull.Value.Equals(_LMConnector.ConnectItem1SymbolID) && _LMConnector.ConnectItem1SymbolID == ConnItem)

                    {

                        ReleaseCOMObjects(_LMConnector);

                        return true;

                    }

                    else if (_LMConnector.ConnectItem2SymbolID != null && !DBNull.Value.Equals(_LMConnector.ConnectItem2SymbolID) && _LMConnector.ConnectItem2SymbolID == ConnItem)

                    {

                        ReleaseCOMObjects(_LMConnector);

                        return true;

                    }

                    else

                    {

                        ReleaseCOMObjects(_LMConnector);

                    }

                }

            }

            return false;

        }

        private void JoinPipeRun(string fromModelItemId, string toModelItemId)

        {

            LMPipeRun run1 = dataSource.GetPipeRun(toModelItemId);

            LMPipeRun run2 = dataSource.GetPipeRun(fromModelItemId);

            // item2가 item1으로 조인

            try

            {

                _LMAItem item1 = run1.AsLMAItem();

                _LMAItem item2 = run2.AsLMAItem();

                _placement.PIDJoinRuns(ref item1, ref item2);

                item1.Commit();

                item2.Commit();

            }

            catch (Exception ex)

            {

                System.Windows.Forms.MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);

            }

            finally

            {

                ReleaseCOMObjects(run1);

                ReleaseCOMObjects(run2);

            }

        }

        private void AutoJoinPipeRun(string modelItemId)

        {

            LMPipeRun run = dataSource.GetPipeRun(modelItemId);

            try

            {

                _LMAItem item = run.AsLMAItem();

                string modelitemID = item.Id;

                _placement.PIDAutoJoin(item, AutoJoinEndConstants.autoJoin_Both, ref item);

                string afterModelItemID = item.Id;

                if (modelitemID != afterModelItemID)

                {

                    List<Line> lines = SPPIDUtil.FindLinesByModelId(document, modelitemID);

                    foreach (var line in lines)

                        line.SPPID.ModelItemId = afterModelItemID;

                }

                item.Commit();

            }

            catch (Exception ex)

            {

                System.Windows.Forms.MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);

            }

            finally

            {

                ReleaseCOMObjects(run);

            }

        }

        private void JoinRunLine(LineRun run)

        {

            string modelItemId = string.Empty;

            foreach (var item in run.RUNITEMS)

            {

                if (item.GetType() == typeof(Line))

                {

                    Line line = item as Line;

                    if (modelItemId != line.SPPID.ModelItemId)

                    {

                        AutoJoinPipeRun(line.SPPID.ModelItemId);

                        modelItemId = line.SPPID.ModelItemId;

                    }

                }

            }

        }

        private Dictionary<LMConnector, List<double[]>> GetPipeRunVertices(string modelId)

        {

            Dictionary<LMConnector, List<double[]>> connectorVertices = new Dictionary<LMConnector, List<double[]>>();

            LMPipeRun _LMPipeRun = dataSource.GetPipeRun(modelId);

            if (_LMPipeRun != null)

            {

                foreach (LMRepresentation rep in _LMPipeRun.Representations)

                {

                    if (rep.Attributes["RepresentationType"].get_Value() == "Connector" && rep.Attributes["ItemStatus"].get_Value() == "Active")

                    {

                        LMConnector _LMConnector = dataSource.GetConnector(rep.Id);

                        connectorVertices.Add(_LMConnector, new List<double[]>());

                        dynamic OID = rep.get_GraphicOID();

                        DependencyObject drawingObject = radApp.ActiveDocument.ActiveSheet.DrawingObjects[OID];

                        Ingr.RAD2D.LineStringGeometry2d lineStringGeometry = drawingObject.GetGeometry() as Ingr.RAD2D.LineStringGeometry2d;

                        int verticesCount = lineStringGeometry.VertexCount;

                        double[] vertices = null;

                        lineStringGeometry.GetVertices(ref verticesCount, ref vertices);

                        for (int i = 0; i < verticesCount; i++)

                        {

                            double x = 0;

                            double y = 0;

                            lineStringGeometry.GetVertex(i + 1, ref x, ref y);

                            connectorVertices[_LMConnector].Add(new double[] { Math.Round(x, 10), Math.Round(y, 10) });

                        }

                    }

                }

                ReleaseCOMObjects(_LMPipeRun);

            }

            return connectorVertices;

        }

        private LMConnector FindTargetLMConnector(Dictionary<LMConnector, List<double[]>> connectorVertices, double connX, double connY, double x2, double y2)

        {

            double length = double.MaxValue;

            LMConnector targetConnector = null;

            foreach (var item in connectorVertices)

            {

                List<double[]> points = item.Value;

                for (int i = 0; i < points.Count - 1; i++)

                {

                    double[] point1 = points[i];

                    double[] point2 = points[i + 1];

                    double maxLineX = Math.Max(point1[0], point2[0]);

                    double minLineX = Math.Min(point1[0], point2[0]);

                    double maxLineY = Math.Max(point1[1], point2[1]);

                    double minLineY = Math.Min(point1[1], point2[1]);

                    SlopeType slope = SPPIDUtil.CalcSlope(minLineX, minLineY, maxLineX, maxLineY);

                    // 두직선의 교차점

                    double[] crossingPoint = SPPIDUtil.CalcLineCrossingPoint(connX, connY, x2, y2, point1[0], point1[1], point2[0], point2[1]);

                    if (crossingPoint != null)

                    {

                        double distance = SPPIDUtil.CalcPointToPointdDistance(connX, connY, crossingPoint[0], crossingPoint[1]);

                        if (length >= distance)

                        {

                            if (slope == SlopeType.Slope &&

                                minLineX <= crossingPoint[0] && maxLineX >= crossingPoint[0] &&

                                minLineY <= crossingPoint[1] && maxLineY >= crossingPoint[1])

                            {

                                targetConnector = item.Key;

                                length = distance;

                            }

                            else if (slope == SlopeType.HORIZONTAL &&

                                minLineX <= crossingPoint[0] && maxLineX >= crossingPoint[0])

                            {

                                targetConnector = item.Key;

                                length = distance;

                            }

                            else if (slope == SlopeType.VERTICAL &&

                               minLineY <= crossingPoint[1] && maxLineY >= crossingPoint[1])

                            {

                                targetConnector = item.Key;

                                length = distance;

                            }

                        }

                    }

                }

            }

            return targetConnector;

        }

        private void LineNumberModeling(LineNumber lineNumber)

        {

            Line line = null;

            foreach (var lineRun in lineNumber.RUNS)

            {

                foreach (var item in lineRun.RUNITEMS)

                {

                    line = item as Line;

                    if (line != null && !string.IsNullOrEmpty(line.SPPID.ModelItemId))

                        break;

                    else

                        line = null;

                }

                if (line != null)

                    break;

            }

            if (line != null && !string.IsNullOrEmpty(line.SPPID.ModelItemId))

            {

                Array points = new double[] { 0, lineNumber.SPPID.ORIGINAL_X, lineNumber.SPPID.ORIGINAL_Y };

                LMPipeRun _pipeRun = dataSource.GetPipeRun(line.SPPID.ModelItemId);

                if (_pipeRun != null)

                {

                    foreach (LMRepresentation rep in _pipeRun.Representations)

                    {

                        if (rep.get_RepresentationType() == "Connector" && rep.get_ItemStatus() == "Active")

                        {

                            LMConnector _LmConnector = dataSource.GetConnector(rep.Id);

                            LMLabelPersist _LmLabelPresist = _placement.PIDPlaceLabel(lineNumber.SPPID.MAPPINGNAME, ref points, Rotation: lineNumber.ANGLE, LabeledItem: _LmConnector.AsLMRepresentation(), IsLeaderVisible: false);

                            _LmLabelPresist.Commit();

                            if (_LmConnector != null)

                                ReleaseCOMObjects(_LmConnector);

                            if (_LmLabelPresist != null)

                            {

                                lineNumber.SPPID.RepresentationId = _LmLabelPresist.AsLMRepresentation().Id;

                                ReleaseCOMObjects(_LmConnector);

                            }

                            break;

                        }

                    }

                    ReleaseCOMObjects(_pipeRun);

                }

            }

        }

        private void InputLineNumberAttribute(LineNumber lineNumber)

        {

            foreach (var run in lineNumber.RUNS)

            {

                foreach (var item in run.RUNITEMS)

                {

                    if (item.GetType() == typeof(Line))

                    {

                        Line line = item as Line;

                        LMPipeRun _LMPipeRun = dataSource.GetPipeRun(line.SPPID.ModelItemId);

                        foreach (var attribute in lineNumber.ATTRIBUTES)

                        {

                            LineNumberMapping mapping = document.LineNumberMappings.Find(x => x.UID == attribute.UID);

                            if (mapping != null)

                            {

                                LMAAttribute _LMAAttribute = _LMPipeRun.Attributes[mapping.SPPIDATTRIBUTENAME];

                                if (_LMAAttribute != null)

                                {

                                    if (DBNull.Value.Equals(_LMAAttribute.get_Value()))

                                        _LMAAttribute.set_Value(attribute.VALUE);

                                    else if (_LMAAttribute.get_Value() != attribute.VALUE)

                                        _LMAAttribute.set_Value(attribute.VALUE);

                                }

                            }

                        }

                        _LMPipeRun.Commit();

                        ReleaseCOMObjects(_LMPipeRun);

                        break;

                    }

                }

            }

        }

        private void InputSymbolAttribute(Symbol symbol)

        {

            if (!string.IsNullOrEmpty(symbol.SPPID.RepresentationId))

            {

                LMSymbol _LMSymbol = dataSource.GetSymbol(symbol.SPPID.RepresentationId);

                LMPipingComp _LMPipingComp = null;

                LMInstrument _LMInstrument = null;

                LMAAttributes _Attributes = null;

                if (_LMSymbol.get_FileName().Contains("Instrumentation"))

                {

                    _LMInstrument = dataSource.GetInstrument(_LMSymbol.ModelItemID);

                    _Attributes = _LMInstrument.Attributes;

                }

                else

                {

                    _LMPipingComp = dataSource.GetPipingComp(_LMSymbol.ModelItemID);

                    _Attributes = _LMPipingComp.Attributes;

                }

                foreach (var item in symbol.PROPERTIES)

                {

                }

                foreach (var item in symbol.ATTRIBUTES)

                {

                    AttributeMapping mapping = document.AttributeMappings.Find(x => x.UID == item.UID);

                    if (mapping != null)

                    {

                        LMAAttribute _Attribute = _Attributes[mapping.SPPIDATTRIBUTENAME];

                        if (_Attribute != null)

                            _Attribute.set_Value(item.VALUE);

                    }

                }

                foreach (var item in symbol.ASSOCIATIONS)

                {

                }

                ReleaseCOMObjects(_LMSymbol);

                if (_LMPipingComp != null)

                {

                    _LMPipingComp.Commit();

                    ReleaseCOMObjects(_LMPipingComp);

                }

                if (_LMInstrument != null)

                {

                    _LMInstrument.Commit();

                    ReleaseCOMObjects(_LMInstrument);

                }

            }

        }

        private void TextModeling(Text text)

        {

            LMSymbol _LMSymbol = null;

            LMItemNote _LMItemNote = null;

            LMAAttribute _LMAAttribute = null;

            try

            {

                _LMSymbol = _placement.PIDPlaceSymbol(text.SPPID.MAPPINGNAME, text.SPPID.ORIGINAL_X, text.SPPID.ORIGINAL_Y);

                _LMSymbol.Commit();

                _LMItemNote = _placement.PIDDataSource.GetItemNote(_LMSymbol.ModelItemID);

                _LMItemNote.Commit();

                _LMAAttribute = _LMItemNote.Attributes["Note.Body"];

                _LMAAttribute.set_Value(text.VALUE);

                _LMItemNote.Commit();

            }

            catch (Exception ex)

            {

            }

            finally

            {

                if (_LMAAttribute != null)

                    ReleaseCOMObjects(_LMAAttribute);

                if (_LMItemNote != null)

                    ReleaseCOMObjects(_LMItemNote);

                if (_LMSymbol != null)

                    ReleaseCOMObjects(_LMSymbol);

            }

        }

        private void NoteModeling(Note note)

        {

            LMSymbol _LMSymbol = null;

            LMItemNote _LMItemNote = null;

            LMAAttribute _LMAAttribute = null;

            try

            {

                _LMSymbol = _placement.PIDPlaceSymbol(note.SPPID.MAPPINGNAME, note.SPPID.ORIGINAL_X, note.SPPID.ORIGINAL_Y);

                _LMSymbol.Commit();

                _LMItemNote = _placement.PIDDataSource.GetItemNote(_LMSymbol.ModelItemID);

                _LMItemNote.Commit();

                _LMAAttribute = _LMItemNote.Attributes["Note.Body"];

                _LMAAttribute.set_Value(note.VALUE);

                _LMItemNote.Commit();

            }

            catch (Exception ex)

            {

            }

            finally

            {

                if (_LMAAttribute != null)

                    ReleaseCOMObjects(_LMAAttribute);

                if (_LMItemNote != null)

                    ReleaseCOMObjects(_LMItemNote);

                if (_LMSymbol != null)

                    ReleaseCOMObjects(_LMSymbol);

            }

        }

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

            }

        }

    }

}