HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Llama;

using Plaice;

using Converter.BaseModel;

using Converter.SPPID.Model;

using Converter.SPPID.Properties;

using Converter.SPPID.Util;

using Converter.SPPID.DB;

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;

        SPPID_Document document;

        public AutoModeling(SPPID_Document document)

        {

            this.document = document;

        }

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

            foreach (Equipment equipment in document.Equipments)

            {

                SymbolModeling(equipment as Symbol, null, null);

            }

            foreach (LineNumber lineNumber in document.LINENUMBERS)

            {

                foreach (LineNumberRun run in lineNumber.RUNS)

                {

                    SymbolModelingByRun(run);

                    LineModelingByRun(run);

                    //bool IsFirst = true;

                    //// Run 별로 Modeling

                    //Symbol prevSymbol = null;

                    //object prevItem = null;

                    //// Symbol 먼저

                    //foreach (var item in run.RUNITEMS)

                    //{

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

                    //    {

                    //        Symbol symbol = item as Symbol;

                    //        SymbolModeling(symbol, prevSymbol, prevItem, IsFirst);

                    //        prevSymbol = symbol;

                    //    }

                    //    IsFirst = false;

                    //    prevItem = item;

                    //}

                    //Line prevLine = null;

                    //prevSymbol = null;

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

                    //        }

                    //    }

                    //    prevItem = item;

                    //}

                    //if (lines.Count > 0)

                    //    LineModeling(lines);

                }

            }

            ReleaseCOMObjects(dataSource);

            ReleaseCOMObjects(_placement);

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

        }

        private void LineModelingByRun(LineNumberRun 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(LineNumberRun 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, LineNumberRun 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, LineNumberRun 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 TestSource()

        {

        }

        private void SymbolModeling(Symbol symbol, Symbol prevSymbol, object prevItem, bool IsFirst)

        {

            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;

            LMSymbol _TargetItem = null;

            if (IsFirst)

            {

                foreach (var connector in symbol.CONNECTORS)

                {

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

                    if (item != null && 

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

                        !IsSameLineNumber(symbol, item))

                    {

                        _TargetItem = dataSource.GetSymbol(((Symbol)item).SPPID.RepresentationId);

                        break;

                    }

                }

            }

            else if (prevItem != null && prevItem.GetType() == typeof(Symbol))

                _TargetItem = dataSource.GetSymbol(((Symbol)prevItem).SPPID.RepresentationId);

            if (prevSymbol != null)

            {

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

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

                double prevX = prevLMSymbol.get_XCoordinate();

                double prevY = prevLMSymbol.get_YCoordinate();

                if (slopeType == SlopeType.HORIZONTAL)

                    y = prevY;

                else if (slopeType == SlopeType.VERTICAL)

                    x = prevX;

                ReleaseCOMObjects(prevLMSymbol);

            }

            if (_TargetItem == null)

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

            else

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

            if (_LMSymbol != null)

            {

                _LMSymbol.Commit();

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

            }

            if (_TargetItem != null)

                ReleaseCOMObjects(_TargetItem);

            ReleaseCOMObjects(_LMSymbol);

        }

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

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

                //double prevX = _TargetItem.get_XCoordinate();

                //double prevY = _TargetItem.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, 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)

        {

            object DrwingID = "0";

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

            PlaceRunInputs placeRunInputs = new PlaceRunInputs();

            LMSymbol _LMSymbol1 = null;

            LMSymbol _LMSymbol2 = 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

                        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 (connItem != null && connItem.GetType() == typeof(Symbol))

                    {

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

                        if (_LMSymbol2 != null)

                        {

                            if (i != 0)

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

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

                        }

                        else

                        {

                            if (i != 0)

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

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

                        }

                    }

                    else

                    {

                        if (i != 0)

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

                        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.RepresentationId = _lMConnector.AsLMRepresentation().Id;

                _lMConnector.Commit();

            }

            if (_LMSymbol1 != null)

                ReleaseCOMObjects(_LMSymbol1);

            if (_LMSymbol2 != null)

                ReleaseCOMObjects(_LMSymbol2);

            ReleaseCOMObjects(_lMConnector);

            ReleaseCOMObjects(placeRunInputs);

            ReleaseCOMObjects(_LMAItem);

        }

        private void LineNumberModeling(LineNumber lineNumber)

        {

        }

        private void TextModeling(Text text)

        {

        }

        private void NoteModeling(Note note)

        {

        }

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

            }

        }

    }

}