HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Data;

using Converter.BaseModel;

using Converter.SPPID.Util;

namespace Converter.SPPID.Model

{

    public class SPPID_Document : Document

    {

        public SPPID_Document(string xmlPath) : base(xmlPath)

        {

        }

        private double testX = 0.855;

        private double testY = 0.55;

        public List<SymbolMapping> SymbolMappings;

        public List<LineMapping> LineMappings;

        public List<LineNumberMapping> LineNumberMappings;

        public List<AssociationMapping> AssociationMappings;

        public ETCSetting ETCSetting;

        public List<Group> GROUPS = new List<Group>();

        public string DrawingName { get; set; }

        public string DrawingNumber { get; set; }

        public string Unit { get; set; }

        public string Template { get; set; }

        public void SetSPPIDInfo()

        {

            foreach (var item in SYMBOLS)

            {

                if (item.SPPID == null)

                    item.SPPID = new SPPIDSymbolInfo();

                double x = double.NaN;

                double y = double.NaN;

                SPPIDUtil.ConvertPointBystring(item.ORIGINALPOINT, ref x, ref y);

                SPPIDUtil.ConvertSPPIDPoint(ref x, ref y, SIZE_WIDTH, SIZE_HEIGHT, testX, testY);

                item.SPPID.ORIGINAL_X = x;

                item.SPPID.ORIGINAL_Y = y;

            }

            foreach (var item in LINES)

            {

                if (item.SPPID == null)

                    item.SPPID = new SPPIDLineInfo();

                double x = double.NaN;

                double y = double.NaN;

                SPPIDUtil.ConvertPointBystring(item.STARTPOINT, ref x, ref y);

                SPPIDUtil.ConvertSPPIDPoint(ref x, ref y, SIZE_WIDTH, SIZE_HEIGHT, testX, testY);

                item.SPPID.START_X = x;

                item.SPPID.START_Y = y;

                SPPIDUtil.ConvertPointBystring(item.ENDPOINT, ref x, ref y);

                SPPIDUtil.ConvertSPPIDPoint(ref x, ref y, SIZE_WIDTH, SIZE_HEIGHT, testX, testY);

                item.SPPID.END_X = x;

                item.SPPID.END_Y = y;

            }

            foreach (var item in Equipments)

            {

                if (item.SPPID == null)

                    item.SPPID = new SPPIDSymbolInfo();

                double x = double.NaN;

                double y = double.NaN;

                SPPIDUtil.ConvertPointBystring(item.ORIGINALPOINT, ref x, ref y);

                SPPIDUtil.ConvertSPPIDPoint(ref x, ref y, SIZE_WIDTH, SIZE_HEIGHT, testX, testY);

                item.SPPID.ORIGINAL_X = x;

                item.SPPID.ORIGINAL_Y = y;

            }

        }

        public bool SetSPPIDMapping()

        {

            foreach (var item in SYMBOLS)

            {

                SymbolMapping mapping = SymbolMappings.Find(x => x.UID == item.DBUID);

                item.SPPID.MAPPINGNAME = mapping != null ? mapping.SPPIDSYMBOLNAME : null;

                if (string.IsNullOrEmpty(item.SPPID.MAPPINGNAME))

                    return false;

            }

            foreach (var item in LINES)

            {

                LineMapping mapping = LineMappings.Find(x => x.UID == item.TYPEUID);

                item.SPPID.MAPPINGNAME = mapping != null ? mapping.SPPIDSYMBOLNAME : null;

                if (string.IsNullOrEmpty(item.SPPID.MAPPINGNAME))

                    return false;

            }

            foreach (var item in Equipments)

            {

                SymbolMapping mapping = SymbolMappings.Find(x => x.UID == item.DBUID);

                item.SPPID.MAPPINGNAME = mapping != null ? mapping.SPPIDSYMBOLNAME : null;

                if (string.IsNullOrEmpty(item.SPPID.MAPPINGNAME))

                    return false;

            }

            return true;

        }

        #region Grouping Source

        private bool SetGrouping()

        {

            try

            {

                // Line 기준으로 묶음

                foreach (Line item in LINES)

                    if (!item.SPPID.IsGroup)

                        SetGroupingByItem(item);

                // End

                // Symbol 기준으로 묶음

                foreach (Symbol item in SYMBOLS)

                    if (!item.SPPID.IsGroup)

                        SetGroupingByItem(item);

                // End

            }

            catch (Exception ex)

            {

                return false;

            }

            return true;

        }

        private void SetGroupingByItem(object item)

        {

            Group group = new Group();

            group.Items.Add(item);

            bool forward = true;

            SetGroupingByConnectedItem(item, group.Items, ref forward);

            GROUPS.Add(group);

        }

        private void SetGroupingByConnectedItem(object item, List<object> list, ref bool IsForward)

        {

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

            {

                Line line = item as Line;

                line.SPPID.IsGroup = true;

                SetGroupingByConnectedItem_ConnectorsLogic(item, list, ref IsForward, line.CONNECTORS);

            }

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

            {

                Symbol symbol = item as Symbol;

                symbol.SPPID.IsGroup = true;

                // Symbol의 경우 BaseSymbol Connector가 2개 이하때 진행 / 나머지는 Grouping 종료

                int baseSymbolCount = 0;

                if (symbol.CONNECTORS.Count > 0)

                {

                    foreach (Connector symbolConnector in symbol.CONNECTORS)

                        if (symbolConnector.Index == 0)

                            baseSymbolCount++;

                    if (baseSymbolCount <= 2)

                        SetGroupingByConnectedItem_ConnectorsLogic(item, list, ref IsForward, symbol.CONNECTORS);

                }

            }

            IsForward = false;

        }

        private void SetGroupingByConnectedItem_ConnectorsLogic(object item, List<object> list, ref bool IsForward, List<Connector> connectors)

        {

            foreach (Connector connector in connectors)

            {

                object connItem = SPPIDUtil.FindObjectByUID(this, connector.CONNECTEDITEM);

                if (connItem != null)

                {

                    bool result = false;

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

                    {

                        Line connLine = connItem as Line;

                        // 연결되는 Item이 전부 Line일 경우 Branch, Line Type을 확인

                        if (item.GetType() == connLine.GetType())

                        {

                            Line line = item as Line;

                            if (SPPIDUtil.IsBranchLine(line.UID, connLine) || line.SPPID.MAPPINGNAME != connLine.SPPID.MAPPINGNAME)

                                continue;

                        }

                        result = true;

                    }

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

                    {

                        Symbol connSymbol = connItem as Symbol;

                        // 연결되는 Symbol의 Connector가 부가 심볼일 경우는 result = false

                        foreach (Connector symbolConnector in connSymbol.CONNECTORS)

                        {

                            string itemUID = item as Symbol != null ? ((Symbol)item).UID : ((Line)item).UID;

                            if (symbolConnector.CONNECTEDITEM == itemUID)

                            {

                                if (symbolConnector.Index == 0)

                                    result = true;

                                else

                                    result = false;

                                break;

                            }

                        }

                    }

                    if (!(connItem as Symbol != null ? ((Symbol)connItem).SPPID.IsGroup : ((Line)connItem).SPPID.IsGroup) && result)

                    {

                        if (IsForward)

                            list.Add(connItem);

                        else

                            list.Insert(0, connItem);

                        SetGroupingByConnectedItem(connItem, list, ref IsForward);

                    }

                }

            }

        }

        #endregion

    }

}