HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Newtonsoft.Json;

using System.IO;

using Converter.SPPID.DB;

using Converter.BaseModel;

using System.Windows.Forms;

using Converter.SPPID.Model;

using System.Drawing;

namespace Converter.SPPID.Util

{

    public enum SlopeType

    {

        None,

        Slope,

        HORIZONTAL,

        VERTICAL

    }

    public class SPPIDUtil

    {

        public static bool ConvertToSPPIDInfo(string jsonString)

        {

            SPPID_DBInfo _SPPIDInfo = SPPID_DBInfo.GetInstance();

            try

            {

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

                _SPPIDInfo.DBType = jsonSPPIDInfo.DBType;

                _SPPIDInfo.Service = jsonSPPIDInfo.Service;

                _SPPIDInfo.Site = jsonSPPIDInfo.Site;

                _SPPIDInfo.ServerIP = jsonSPPIDInfo.ServerIP;

                _SPPIDInfo.Port = jsonSPPIDInfo.Port;

                _SPPIDInfo.DBUser = jsonSPPIDInfo.DBUser;

                _SPPIDInfo.DBPassword = jsonSPPIDInfo.DBPassword;

                _SPPIDInfo.PlantPath = jsonSPPIDInfo.PlantPath;

                _SPPIDInfo.PlantDic = jsonSPPIDInfo.PlantDic;

                _SPPIDInfo.PlantPID = jsonSPPIDInfo.PlantPID;

                _SPPIDInfo.PlantPIDDic = jsonSPPIDInfo.PlantPIDDic;

                _SPPIDInfo.Plant = jsonSPPIDInfo.Plant;

                _SPPIDInfo.Enable = jsonSPPIDInfo.Enable;

                _SPPIDInfo.SelectedPlant = jsonSPPIDInfo.SelectedPlant;

                _SPPIDInfo.PlantList = jsonSPPIDInfo.PlantList;

            }

            catch (Exception ex)

            {

                _SPPIDInfo.Enable = false;

                return false;

            }

            return true;

        }

        public static bool ConvertToETCSetting(string jsonString)

        {

            ETCSetting _ETCSetting = ETCSetting.GetInstance();

            try

            {

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

                _ETCSetting.NoteSymbolPath = jsonETCSetting.NoteSymbolPath;

                _ETCSetting.TextSymbolPath = jsonETCSetting.TextSymbolPath;

                _ETCSetting.DrainValveSize = jsonETCSetting.DrainValveSize;

                _ETCSetting.VendorPackageSymbolPath = jsonETCSetting.VendorPackageSymbolPath;

                _ETCSetting.TextLocation = jsonETCSetting.TextLocation;

                _ETCSetting.NoteLocation = jsonETCSetting.NoteLocation;

                _ETCSetting.LineNumberLocation = jsonETCSetting.LineNumberLocation;

                _ETCSetting.FlowMarkSymbolPath = jsonETCSetting.FlowMarkSymbolPath;

                _ETCSetting.BorderFilePath = jsonETCSetting.BorderFilePath;

            }

            catch (Exception ex)

            {

                return false;

            }

            return true;

        }

        public static bool ConvertToGridSetting(string jsonString)

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            try

            {

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

                _GridSetting.UseSnapGrid = jsonGridSetting.UseSnapGrid;

                _GridSetting.Density = jsonGridSetting.Density;

                _GridSetting.Unit = jsonGridSetting.Unit;

                _GridSetting.DrainValveCellCount = jsonGridSetting.DrainValveCellCount;

            }

            catch (Exception ex)

            {

                return false;

            }

            return true;

        }

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

        {

            try

            {

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

                if (pointArr.Length == 2)

                {

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

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

                }

            }

            catch (Exception)

            {

                dX = 0;

                dY = 0;

                return false;

            }

            return true;

        }

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

        {

            decimal calcX = 0;

            decimal calcY = 0;

            decimal tempX = Convert.ToDecimal(dX);

            decimal tempY = Convert.ToDecimal(dY);

            decimal tempWidth = Convert.ToDecimal(SPPID_Width);

            decimal tempHeight = Convert.ToDecimal(SPPID_Height);

            decimal tempDwgX = Convert.ToDecimal(dDwgX);

            decimal tempDwgY = Convert.ToDecimal(dDwgY);

            calcX = (tempX * tempWidth) / tempDwgX;

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

            dX = Convert.ToDouble(calcX);

            dY = Convert.ToDouble(calcY);

        }

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

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            if (_GridSetting.UseSnapGrid)

            {

                if (_GridSetting.Unit == GridUnit.Inch)

                {

                    double length = _GridSetting.Density * 0.0254;

                    double tempX = x;

                    double tempY = y;

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

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

                }

            }

        }

        public static void ConvertGridPointOnlyOnePoint(ref double value)

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            if (_GridSetting.UseSnapGrid)

            {

                if (_GridSetting.Unit == GridUnit.Inch)

                {

                    double temp = value;

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

                }

            }

        }

        public static double ConvertGridPointOnlyOnePoint(double value)

        {

            GridSetting _GridSetting = GridSetting.GetInstance();

            if (_GridSetting.UseSnapGrid)

            {

                if (_GridSetting.Unit == GridUnit.Inch)

                {

                    double temp = value;

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

                }

            }

            return value;

        }

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

        {

            if (x1 - x2 == 0)

            {

                return SlopeType.VERTICAL;

            }

            else

            {

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

                if (angle <= 15)

                    return SlopeType.HORIZONTAL;

                else if (angle >= 75)

                    return SlopeType.VERTICAL;

                else

                    return SlopeType.Slope;

            }

        }

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

        {

            double result = 90;

            if (x1 - x2 != 0)

            {

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

            }

            return result;

        }

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

        {

            double distance = 0;

            if (lineX1 == lineX2)

                distance = Math.Abs(x - lineX1);

            else

            {

                double a;

                double b;

                double c;

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

                b = -1;

                c = -a * lineX1 + lineY1;

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

            }

            return distance;

        }

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

        {

            double a1;

            double a2;

            double b1;

            double b2;

            if (x1 == x2)

                a1 = 0;

            else

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

            if (x3 == x4)

                a2 = 0;

            else

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

            b1 = -a1 * x1 + y1;

            b2 = -a2 * x3 + y3;

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

            {

                return null;

            }

            else if (x1 == x2)

            {

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

            }

            else if (x3 == x4)

            {

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

            }

            else

            {

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

            }            

        }

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

        {

            double result = double.NaN;

            if (x1 != x2)

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

            return result;

        }

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

        {

            return Math.Pow(Math.Pow(x1 - x2, 2) + Math.Pow(y1 - y2, 2), 0.5);

        }

        public static object FindObjectByUID(Document document, string UID)

        {

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

            {

                foreach (Symbol item in document.SYMBOLS)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (Line item in document.LINES)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (Text item in document.TEXTINFOS)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (Note item in document.NOTES)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (LineNumber item in document.LINENUMBERS)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (Equipment item in document.Equipments)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (SpecBreak item in document.SpecBreaks)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (EndBreak item in document.EndBreaks)

                {

                    if (item.UID == UID)

                        return item;

                }

                foreach (VendorPackage item in document.VendorPackages)

                {

                    if (item.UID == UID)

                        return item;

                }

            }

            return null;

        }

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

        {

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

            foreach (Line item in document.LINES)

            {

                if (item.SPPID.ModelItemId == ModelItemId)

                    lines.Add(item);

            }

            return lines;

        }

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

        {

            if (!group.Contains(symbol))

                group.Add(symbol);

            foreach (var connector in symbol.CONNECTORS)

            {

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

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

                {

                    Symbol connSymbol = connectedItem as Symbol;

                    if (!group.Contains(connSymbol))

                    {

                        group.Add(connSymbol);

                        FindConnectedSymbolGroup(document, connSymbol, group);

                    }

                }

            }

        }

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

        {

            Symbol result = null;

            // Group의 가운데 찾기

            if (group.Count == 3)

            {

                foreach (var symbol in group)

                {

                    int count = 0;

                    foreach (var connector in symbol.CONNECTORS)

                    {

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

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

                            count++;

                    }

                    if (count == 2)

                    {

                        result = symbol;

                        break;

                    }

                }

            }

            return result;

        }

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

        {

            foreach (Connector connector in symbol.CONNECTORS)

            {

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

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

                {

                    Symbol connSymbol = item as Symbol;

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

                    {

                        symbolGroup.Add(connSymbol);

                        GetConnectedSymbol(document, connSymbol, symbolGroup);

                    }

                }

            }

        }

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

        {

            foreach (var connector in targetSymbol.CONNECTORS)

            {

                if (connector.CONNECTEDITEM == uid)

                {

                    return connector;

                }

            }

            return null;

        }

        public static Symbol FindSymbolByRepresentationID(Document document, string repID)

        {

            Symbol findSymbol = null;

            foreach (var symbol in document.SYMBOLS)

            {

                if (symbol.SPPID.RepresentationId == repID)

                {

                    findSymbol = symbol;

                }

                else

                {

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

                    if (childSymbol != null)

                        findSymbol = symbol;

                }

                if (findSymbol != null)

                    break;

            }

            return findSymbol;

        }

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

        {

            ChildSymbol childSymbol = null;

            foreach (ChildSymbol loopChild in symbol.ChildSymbols)

            {

                if (loopChild.SPPID.RepresentationId == repID)

                {

                    childSymbol = loopChild;

                    break;

                }

                else

                {

                    childSymbol = FindChildSymbolByRepresentationIDLoop(document, repID, loopChild);

                    if (childSymbol != null)

                        break;

                }

            }

            return childSymbol;

        }

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

        {

            ChildSymbol findChild = null;

            foreach (var item in childSymbol.ChildSymbols)

            {

                if (item.SPPID.RepresentationId == repID)

                {

                    findChild = item;

                    break;

                }

                else

                {

                    findChild = FindChildSymbolByRepresentationIDLoop(document, repID, item);

                    if (findChild != null)

                        break;

                }

            }

            return findChild;

        }

        public static bool IsBranchLine(Line line1, Line line2)

        {

            bool result = true;

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

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

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

                result = false;

            return result;

        }

        public static bool IsBranchLine(Line line)

        {

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

            x.ConnectedObject != null &&

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

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

            return connector != null ? true : false;

        }

        public static bool IsBranchedLine(Document document,Line line)

        {

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

        }

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

        {

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

            {

                overlapX = true;

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

            }

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

            {

                overlapY = true;

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

            }

        }

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

        {

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

                return true;

            else

                return false;

        }

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

        {

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

            GridSetting _GridSetting = GridSetting.GetInstance();

            if (slopeType == SlopeType.HORIZONTAL)

            {

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

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

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

                else

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

            }

            else if (slopeType == SlopeType.VERTICAL)

            {

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

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

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

                else

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

            }

        }

        public static Line GetConnectedLine(Symbol symbol1, Symbol symbol2)

        {

            Line line = null;

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

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

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

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

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

                line = connector1.ConnectedObject as Line;

            return line;

        }

        public static int GetBranchLineCount(Document document, Line line)

        {

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

        }

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

        {

            bool bStart = false;

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

            if (index == 0)

            {

                x = line.SPPID.START_X;

                y = line.SPPID.START_Y;

                bStart = true;

            }

            else

            {

                x = line.SPPID.END_X;

                y = line.SPPID.END_Y;

            }

            return bStart;

        }

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

        {

            bool result = false;

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

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

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

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

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

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

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

                result = true;

            return result;

        }

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

        {

            bool result = false;

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

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

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

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

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

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

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

                result = true;

            return result;

        }

    }

}