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.TextLocation = jsonETCSetting.TextLocation;

                _ETCSetting.NoteLocation = jsonETCSetting.NoteLocation;

                _ETCSetting.LineNumberLocation = jsonETCSetting.LineNumberLocation;

            }

            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;

            }

            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;

            //calcX = Math.Truncate(calcX * 1000) / 1000;

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

            //calcY = Math.Truncate(calcY * 1000) / 1000;

            //dX = Math.Round(Convert.ToDouble(calcX), 10);

            //dY = Math.Round(Convert.ToDouble(calcY), 10);

            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 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 <= 2)

                    return SlopeType.HORIZONTAL;

                else if (angle >= 88)

                    return SlopeType.VERTICAL;

                else

                    return SlopeType.Slope;

            }

        }

        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)

        {

            x1 = Math.Round(x1, 10);

            x2 = Math.Round(x2, 10);

            x3 = Math.Round(x3, 10);

            x4 = Math.Round(x4, 10);

            y1 = Math.Round(y1, 10);

            y2 = Math.Round(y2, 10);

            y3 = Math.Round(y3, 10);

            y4 = Math.Round(y4, 10);

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

                (y1 == y2 && y3 == y4))

            {

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

        {

            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;

            }

            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 List<List<Symbol>> GetThreeConnectedSymbolGroup(Document document)

        {

            List<List<Symbol>> tempGroups = new List<List<Symbol>>();

            foreach (Symbol symbol in document.SYMBOLS)

            {

                if (tempGroups.Find(x => x.Find(y => y.UID == symbol.UID) != null) != null)

                    continue;

                List<Symbol> symbolGroup = new List<Symbol>() { symbol };

                GetConnectedSymbol(document, symbol, symbolGroup);

                tempGroups.Add(symbolGroup);

            }

            List<List<Symbol>> symbolGroups = new List<List<Symbol>>();

            foreach (var group in tempGroups)

                if (group.Count == 3)

                    symbolGroups.Add(group);

            return symbolGroups;

        }

        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;

        }

    }

}