HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Llama;

using Plaice;

namespace SPPIDAutoModeling

{

    public enum SPPID_ITEM_TYPE

    {

        SYMBOL = 1,

        LINE = 2,

        LABEL = 3,

        TEXT = 4,

    }

    public class SymbolChild

    {

        private string _Arrow;

        private string _Name;

        private int _Index;

        private string _SPPIDMAPPINGNAME;

        private object _SPPID_ITEM_OBJECT;

        public string Arrow { get => _Arrow; set => _Arrow = value; }

        public string Name { get => _Name; set => _Name = value; }

        public int Index { get => _Index; set => _Index = value; }

        public string SPPIDMAPPINGNAME { get => _SPPIDMAPPINGNAME; set => _SPPIDMAPPINGNAME = value; }

        public object SPPID_ITEM_OBJECT { get => _SPPID_ITEM_OBJECT; set => _SPPID_ITEM_OBJECT = value; }

    }

    public class Group

    {

        private List<Symbol> _SYMBOLS = new List<Symbol>();

        private List<Line> _LINES = new List<Line>();

        public List<Symbol> SYMBOLS { get => _SYMBOLS; set => _SYMBOLS = value; }

        public List<Line> LINES { get => _LINES; set => _LINES = value; }

    }

    public class Drawing

    {

        #region Property

        private string _DWGNAME;

        private string _SIZE;

        private string _UNIT;

        private List<Symbol> _SYMBOLS = new List<Symbol>();

        private List<Line> _LINES = new List<Line>();

        private List<LineNumber> _LINENUMBERS = new List<LineNumber>();

        private List<Text> _TEXTS = new List<Text>();

        private Dictionary<string, List<PointdInfo>> _PipeRunPoint = new Dictionary<string, List<PointdInfo>>();

        private List<Group> _GROUP = new List<Group>();

        private double _WIDTH;

        private double _HEIGHT;

        public string DWGNAME { get => _DWGNAME; set => _DWGNAME = value; }

        public string SIZE

        {

            get { return _SIZE; }

            set

            {

                _SIZE = value;

                SPPIDUtill.ConvertPointBystring(_SIZE, ref _WIDTH, ref _HEIGHT);

            }

        }

        public string UNIT { get => _UNIT; set => _UNIT = value; }

        public Dictionary<string, List<PointdInfo>> PipeRunPoint { get => _PipeRunPoint; set => _PipeRunPoint = value; }

        public List<Symbol> SYMBOLS { get => _SYMBOLS; set => _SYMBOLS = value; }

        public List<Line> LINES { get => _LINES; set => _LINES = value; }

        public List<LineNumber> LINENUMBERS { get => _LINENUMBERS; set => _LINENUMBERS = value; }

        public List<Text> TEXTS { get => _TEXTS; set => _TEXTS = value; }

        public double WIDTH { get => _WIDTH; set => _WIDTH = value; }

        public double HEIGHT { get => _HEIGHT; set => _HEIGHT = value; }

        public List<Group> GROUP { get => _GROUP; set => _GROUP = value; }

        #endregion

    }

    public class PointdInfo

    {

        public enum PointType

        {

            None = 0,

            Run = 1,

            Branch = 2,

        }

        #region Property

        private Pointd _Pointd;

        private PointType _Type;

        private string _SP_ID;

        public Pointd Pointd { get => _Pointd; set => _Pointd = value; }

        public PointType Type { get => _Type; set => _Type = value; }

        public string SP_ID { get => _SP_ID; set => _SP_ID = value; }

        #endregion

    }

    public struct Pointd

    {

        public Pointd(double x, double y)

        {

            X = x;

            Y = y;

        }

        public double X;

        public double Y;

    }

    public abstract class SPPID_ITEM

    {

        #region Property

        private string _UID;

        private string _TYPE;

        private string _NAME;

        private SPPID_ITEM_TYPE _SPPID_TYPE ;

        private string _SPPIDMAPPINGNAME;

        private bool _GROUPING = true;

        private string _AREA;

        private List<Attribute> _ATTRIBUTES = new List<Attribute>();

        private object _SPPID_ITEM_OBJECT;

        public string UID { get => _UID; set => _UID = value; }

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public string NAME { get => _NAME; set => _NAME = value; }

        public string SPPIDMAPPINGNAME { get => _SPPIDMAPPINGNAME; set => _SPPIDMAPPINGNAME = value; }

        public bool GROUPING { get => _GROUPING; set => _GROUPING = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public object SPPID_ITEM_OBJECT { get => _SPPID_ITEM_OBJECT; set => _SPPID_ITEM_OBJECT = value; }

        public SPPID_ITEM_TYPE SPPID_TYPE { get => _SPPID_TYPE; set => _SPPID_TYPE = value; }

        public List<Attribute> ATTRIBUTES { get => _ATTRIBUTES; set => _ATTRIBUTES = value; }

        #endregion

        public abstract void Modeling();

        public abstract void AfterSetting();

        public abstract void SetAttribute();

    }

    public class Symbol : SPPID_ITEM

    {

        #region Property

        private string _ORIGINALPOINT;

        private List<Connector> _CONNECTORS = new List<Connector>();

        private string _CONNECTIONPOINT;

        private string _LOCATION;

        private string _SIZE;

        private double _ANGLE;

        private string _PARENT;

        private string _CHILD;

        private List<SymbolChild> _CHILD_LIST = new List<SymbolChild>();

        private string _HASINSTRUMENTLABEL;

        private string _CURRENTPOINTMODEINDEX;

        private bool _DRAWCHECKED;

        private double _LOCATION_X;

        private double _LOCATION_Y;

        private int _MIRROR = 0;

        public string ORIGINALPOINT { get => _ORIGINALPOINT; set => _ORIGINALPOINT = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string SIZE { get => _SIZE; set => _SIZE = value; }

        public double ANGLE { get => _ANGLE; set => _ANGLE = value; }

        public string PARENT { get => _PARENT; set => _PARENT = value; }

        public string CHILD { get => _CHILD; set => _CHILD = value; }

        public string HASINSTRUMENTLABEL { get => _HASINSTRUMENTLABEL; set => _HASINSTRUMENTLABEL = value; }

        public string CURRENTPOINTMODEINDEX { get => _CURRENTPOINTMODEINDEX; set => _CURRENTPOINTMODEINDEX = value; }

        public bool DRAWCHECKED { get => _DRAWCHECKED; set => _DRAWCHECKED = value; }

        public double LOCATION_X { get => _LOCATION_X; set => _LOCATION_X = value; }

        public double LOCATION_Y { get => _LOCATION_Y; set => _LOCATION_Y = value; }

        public int MIRROR { get => _MIRROR; set => _MIRROR = value; }

        public List<Connector> CONNECTORS { get => _CONNECTORS; set => _CONNECTORS = value; }

        public string CONNECTIONPOINT { get => _CONNECTIONPOINT; set => _CONNECTIONPOINT = value; }

        public List<SymbolChild> CHILD_LIST { get => _CHILD_LIST; set => _CHILD_LIST = value; }

        #endregion

        public override void AfterSetting()

        {

            // SPPIDMAPPINGNAME Setting

            SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(NAME);

            // End

            // Angle Setting

            if (ANGLE == 1.57)

                ANGLE = 90 * Math.PI / 180;

            else if (ANGLE == 3.14)

                ANGLE = Math.PI;

            else if (ANGLE == 4.71)

                ANGLE = 270 * Math.PI / 180;

            else

                ANGLE = 0;

            // End

            // Location Setting

            SPPIDUtill.ConvertPointBystring(_ORIGINALPOINT, ref _LOCATION_X, ref _LOCATION_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _LOCATION_X, ref _LOCATION_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            // End

            // SPPID Type Setting

            SPPID_TYPE = SPPID_ITEM_TYPE.SYMBOL;

            // End

            // Child Setting

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

            {

                string[] childArray = CHILD.Split(new char[] { ',' });

                for (int i = 0; i < childArray.Length; i++)

                {

                    SymbolChild child = new SymbolChild()

                    {

                        Arrow = childArray[0],

                        Name = childArray[1],

                        Index = i

                    };

                    child.SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(child.Name);

                    CHILD_LIST.Add(child);

                }

            }

            // End

            // Input Drawing

            AutoModeling.DrawingItem.SYMBOLS.Add(this);

            // End

        }

        public override void Modeling()

        {

            try

            {

                Placement _placement = new Placement();

                LMSymbol lmSymbol = null;

                SPPID_ITEM_OBJECT = null;

                if (!string.IsNullOrEmpty(SPPIDMAPPINGNAME))

                {

                    LMSymbol connectedSymbol = null;

                    foreach (Connector connector in CONNECTORS)

                    {

                        if (!string.IsNullOrEmpty(connector.CONNECTEDITEM) || connector.CONNECTEDITEM != "None")

                        {

                            object _obj = SPPIDUtill.FindObjectByUID(connector.CONNECTEDITEM);

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

                            {

                                Symbol _symbol = _obj as Symbol;

                                if (_symbol.SPPID_ITEM_OBJECT != null)

                                    connectedSymbol = _symbol.SPPID_ITEM_OBJECT as LMSymbol;

                            }

                        }

                    }

                    if (connectedSymbol != null)

                        lmSymbol = _placement.PIDPlaceSymbol(SPPIDMAPPINGNAME, LOCATION_X, LOCATION_Y, Mirror: MIRROR, Rotation: ANGLE, TargetItem: connectedSymbol);

                    else

                        lmSymbol = _placement.PIDPlaceSymbol(SPPIDMAPPINGNAME, LOCATION_X, LOCATION_Y, Mirror: MIRROR, Rotation: ANGLE);

                    // Commit and input sppid item object

                    lmSymbol.Commit();

                    SPPID_ITEM_OBJECT = lmSymbol;

                    // End

                    // Check Child And Modeling

                    foreach (SymbolChild symoblChild in CHILD_LIST)

                    {

                        try

                        {

                            string sArrow = symoblChild.Arrow;

                            string sMappingName = symoblChild.SPPIDMAPPINGNAME;

                            double dChildAngle = 0;

                            if (sArrow == "UP")

                                dChildAngle = 0;

                            else if (sArrow == "RIGHT")

                                dChildAngle = 90 * Math.PI / 180;

                            else if (sArrow == "DOWN")

                                dChildAngle = Math.PI;

                            else

                                dChildAngle = 270 * Math.PI / 180;

                            LMSymbol _childLmSymbol = _placement.PIDPlaceSymbol(sMappingName, LOCATION_X, LOCATION_Y, Mirror: 0, Rotation: dChildAngle, TargetItem: SPPID_ITEM_OBJECT);

                            _childLmSymbol.Commit();

                            symoblChild.SPPID_ITEM_OBJECT = _childLmSymbol;

                        }

                        catch (Exception)

                        {

                        }

                    }

                    // End

                }

            }

            catch (Exception)

            {

            }

        }

        public override void SetAttribute()

        {

            throw new NotImplementedException();

        }

    }

    public class Line : SPPID_ITEM

    {

        public enum SlopType

        {

            NONE = 0,

            VERTICAL = 1,

            HORIZONTAL = 2,

            SLOPE = 3,

        }

        #region Property

        private string _STARTPOINT;

        private string _ENDPOINT;

        private List<Connector> _CONNECTORS = new List<Connector>();

        private string _LMCONNECTOR_MODELID;

        private SlopType _SLOPTYPE;

        private double _START_X;

        private double _START_Y;

        private double _END_X;

        private double _END_Y;

        public string STARTPOINT { get => _STARTPOINT; set => _STARTPOINT = value; }

        public string ENDPOINT { get => _ENDPOINT; set => _ENDPOINT = value; }

        public string LMCONNECTOR_MODELID { get => _LMCONNECTOR_MODELID; set => _LMCONNECTOR_MODELID = value; }

        public double START_X { get => _START_X; set => _START_X = value; }

        public double START_Y { get => _START_Y; set => _START_Y = value; }

        public double END_X { get => _END_X; set => _END_X = value; }

        public double END_Y { get => _END_Y; set => _END_Y = value; }

        public List<Connector> CONNECTORS { get => _CONNECTORS; set => _CONNECTORS = value; }

        public SlopType SLOPTYPE { get => _SLOPTYPE; set => _SLOPTYPE = value; }

        #endregion

        public override void AfterSetting()

        {

            // SPPIDMAPPINGNAME Setting

            SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(NAME);

            // End

            // Point Setting

            SPPIDUtill.ConvertPointBystring(_STARTPOINT, ref _START_X, ref _START_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _START_X, ref _START_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            SPPIDUtill.ConvertPointBystring(_ENDPOINT, ref _END_X, ref _END_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _END_X,ref _END_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            // End

            // Slop Setting

            _SLOPTYPE = SPPIDUtill.CalcSlop(new Pointd(_START_X, _START_Y), new Pointd(_END_X, _END_Y));

            // End

            // SPPID Type Setting

            SPPID_TYPE = SPPID_ITEM_TYPE.LINE;

            // End

            // Input Drawing

            AutoModeling.DrawingItem.LINES.Add(this);

            // End

        }

        public override void Modeling()

        {

            throw new MissingMethodException();

        }

        public override void SetAttribute()

        {

            throw new NotImplementedException();

        }

    }

    public class LineNumber : SPPID_ITEM

    {

        public enum LineNumberType

        {

            LineNumber = 1,

            TrimLine = 2,

        }

        #region Property

        private double _ANGLE;

        private string _LOCATION;

        private double _LOCATION_X;

        private double _LOCATION_Y;

        private string _TEXT;

        private string _CONNECTLINE;

        private Line _TARGETLINE;

        private LineNumberType _LINENUMBERTYPE;

        public double ANGLE { get => _ANGLE; set => _ANGLE = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public double LOCATION_X { get => _LOCATION_X; set => _LOCATION_X = value; }

        public double LOCATION_Y { get => _LOCATION_Y; set => _LOCATION_Y = value; }

        public string TEXT { get => _TEXT; set => _TEXT = value; }

        public string CONNECTLINE { get => _CONNECTLINE; set => _CONNECTLINE = value; }

        public Line TARGETLINE { get => _TARGETLINE; set => _TARGETLINE = value; }

        public LineNumberType LINENUMBERTYPE { get => _LINENUMBERTYPE; set => _LINENUMBERTYPE = value; }

        #endregion

        public override void AfterSetting()

        {

            // SPPIDMAPPINGNAME Setting

            SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(NAME);

            // End

            // Angle Setting

            if (ANGLE == 1.57)

                ANGLE = 90 * Math.PI / 180;

            else if (ANGLE == 3.14)

                ANGLE = Math.PI;

            else if (ANGLE == 4.71)

                ANGLE = 270 * Math.PI / 180;

            else

                ANGLE = 0;

            // End

            // Location Setting

            SPPIDUtill.ConvertPointBystring(_LOCATION, ref _LOCATION_X, ref _LOCATION_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _LOCATION_X, ref _LOCATION_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            // End

            // SPPID  Type Setting

            SPPID_TYPE = SPPID_ITEM_TYPE.LABEL;

            // End

            // Input Drawing

            AutoModeling.DrawingItem.LINENUMBERS.Add(this);

            // End

        }

        public override void Modeling()

        {

            try

            {

                if (TARGETLINE != null && !string.IsNullOrEmpty(TARGETLINE.LMCONNECTOR_MODELID))

                {

                    Placement _placement = new Placement();

                    Array points = new double[] { LOCATION_X, LOCATION_Y };

                    LMPipeRun _pipeRun = _placement.PIDDataSource.GetPipeRun(TARGETLINE.LMCONNECTOR_MODELID);

                    if (_pipeRun != null)

                    {

                        foreach (LMRepresentation rep in _pipeRun.Representations)

                        {

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

                            {

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

                                LMLabelPersist _LmLabelPresist = _placement.PIDPlaceLabel(SPPIDMAPPINGNAME, ref points, Rotation: ANGLE, LabeledItem: _LmConnector.AsLMRepresentation(), IsLeaderVisible: true);

                                _LmLabelPresist.Commit();

                                SPPID_ITEM_OBJECT = _LmLabelPresist;

                            }

                        }

                    }

                }

            }

            catch (Exception)

            {

            }

        }

        public override void SetAttribute()

        {

            throw new NotImplementedException();

        }

    }

    public class Text : SPPID_ITEM

    {

        #region Property

        private double _ANGLE;

        private string _LOCATION;

        private double _LOCATION_X;

        private double _LOCATION_Y;

        private string _TEXT;

        private string _OWNER;

        public double ANGLE { get => _ANGLE; set => _ANGLE = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public double LOCATION_X { get => _LOCATION_X; set => _LOCATION_X = value; }

        public double LOCATION_Y { get => _LOCATION_Y; set => _LOCATION_Y = value; }

        public string TEXT { get => _TEXT; set => _TEXT = value; }

        public string OWNER { get => _OWNER; set => _OWNER = value; }

        #endregion

        public override void AfterSetting()

        {

            // SPPIDMAPPINGNAME Setting

            SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(NAME);

            // End

            // Angle Setting

            if (ANGLE == 1.57)

                ANGLE = 90 * Math.PI / 180;

            else if (ANGLE == 3.14)

                ANGLE = Math.PI;

            else if (ANGLE == 4.71)

                ANGLE = 270 * Math.PI / 180;

            else

                ANGLE = 0;

            // End

            // Location Setting

            SPPIDUtill.ConvertPointBystring(_LOCATION, ref _LOCATION_X, ref _LOCATION_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _LOCATION_X, ref _LOCATION_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            // End

            // SPPID  Type Setting

            SPPID_TYPE = SPPID_ITEM_TYPE.TEXT;

            // End

            // Input Drawing

            AutoModeling.DrawingItem.TEXTS.Add(this);

            // End

        }

        public override void Modeling()

        {

            try

            {

                Placement _placement = new Placement();

                if (NAME == "TEXT" || NAME == "NOTE")

                {

                    LMSymbol _LmSymbol = _placement.PIDPlaceSymbol(SPPIDMAPPINGNAME, LOCATION_X, LOCATION_Y, Rotation: ANGLE);

                    LMItemNote _LmItemNote = _placement.PIDDataSource.GetItemNote(_LmSymbol.ModelItemID);

                    _LmItemNote.Attributes["Note.Body"].set_Value(TEXT);

                    _LmItemNote.Commit();

                    SPPID_ITEM_OBJECT = _LmItemNote;

                }

                else if (NAME == "SIZE" && !string.IsNullOrEmpty(OWNER))

                {

                    object _obj = SPPIDUtill.FindObjectByUID(OWNER);

                    Array array = new double[] { LOCATION_X, LOCATION_Y };

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

                    {

                        Symbol _symbol = _obj as Symbol;

                        LMSymbol _LmSymbol = _symbol.SPPID_ITEM_OBJECT as LMSymbol;

                        string fileName = _LmSymbol.get_FileName();

                        if (fileName.Contains("Piping"))

                            SPPIDMAPPINGNAME = @"\Piping\Labels - Piping Components\Nominal Diameter.sym";

                        else if (fileName.Contains("Instrumentation"))

                            SPPIDMAPPINGNAME = @"\Instrumentation\Labels - General Instrument\Nominal Diameter.sym";

                        LMLabelPersist _LmLabelPersist = _placement.PIDPlaceLabel(SPPIDMAPPINGNAME, ref array, Rotation: ANGLE, LabeledItem: _LmSymbol.AsLMRepresentation(), IsLeaderVisible: true);

                        _LmLabelPersist.Commit();

                        SPPID_ITEM_OBJECT = _LmLabelPersist;

                    }

                }

            }

            catch (Exception)

            {

            }

        }

        public override void SetAttribute()

        {

            throw new NotImplementedException();

        }

    }

    public class Attribute

    {

        #region Property

        private string _UID;

        private string _NAME;

        private string _VALUE;

        public string UID { get => _UID; set => _UID = value; }

        public string NAME { get => _NAME; set => _NAME = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

        #endregion

    }

    public class Connector

    {

        #region Property

        private string _CONNECTEDITEM;

        private string _CONNECTPOINT;

        private string _SCENECONNECTPOINT;

        private string _INDEX;

        public string CONNECTEDITEM { get => _CONNECTEDITEM; set => _CONNECTEDITEM = value; }

        public string CONNECTPOINT { get => _CONNECTPOINT; set => _CONNECTPOINT = value; }

        public string SCENECONNECTPOINT { get => _SCENECONNECTPOINT; set => _SCENECONNECTPOINT = value; }

        public string INDEX { get => _INDEX; set => _INDEX = value; }

        #endregion

    }

}