HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using SPPID.Model;

using SPPID.DB;

using SPPID.Modeling;

using System.IO;

using System.Xml.Linq;

using Newtonsoft.Json;

namespace SPPID.Utill

{

    public static class SPPIDUtill

    {

        private static readonly double _DWG_X = 0.875;

        private static readonly double _DWG_Y = 0.617;

        public static string defaultPath = "";

        public static string mappingFilePath = "";

        public static string dbFilePath = "";

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

        {

            double calcX = 0;

            double calcY = 0;

            calcX = (dX * _DWG_X) / dDwgX;

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

            calcY = _DWG_Y - ((dY * _DWG_Y) / dDwgY);

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

            dX = calcX;

            dY = calcY;

        }

        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 Line.SlopeType CalcSlop(PointInfo point1, PointInfo point2)

        {

            Line.SlopeType _type = Line.SlopeType.NONE;

            if (point1.X - point2.X == 0)

                _type = Line.SlopeType.VERTICAL;

            else

            {

                double angle = Math.Atan(Math.Abs(point2.Y - point1.Y) / Math.Abs(point2.X - point1.X)) * 180 / Math.PI;

                if (angle < 20)

                    _type = Line.SlopeType.HORIZONTAL;

                else if (angle > 70)

                    _type = Line.SlopeType.VERTICAL;

                else

                    _type = Line.SlopeType.SLOPE;

            }

            return _type;

        }

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

            {

                if (item.UID == UID)

                    return item;

            }

            foreach (LineNumber item in document.LINENUMBERS)

            {

                if (item.UID == UID)

                    return item;

            }

            return null;

        }

        public static string GetSPPIDSymbolMappingName(string name, Dictionary<string, string> symbolMapping)

        {

            if (name == "SIZE")

            {

                if (symbolMapping.ContainsKey(Text.pipingCompSize) && symbolMapping.ContainsKey(Text.instrumentSize))

                {

                    return "true";

                }

                else

                {

                    return "";

                }

            }

            if (symbolMapping.ContainsKey(name))

                return symbolMapping[name];

            else

                return "";

        }

        public static string GetSPPIDAttributeMappingName(string name, Dictionary<string, string> attributeMapping)

        {

            if (attributeMapping.ContainsKey(name))

                return attributeMapping[name];

            else

                return "";

        }

        public static bool IsBranchLine(string UID, Line connectedLine)

        {

            try

            {

                if (connectedLine.CONNECTORS[0].CONNECTEDITEM != UID && connectedLine.CONNECTORS[1].CONNECTEDITEM != UID)

                    return true; 

            }

            catch (Exception ex)

            {

                Log.WriteLine(ex);

            }

            return false;

        }

        public static double CalcPointToPointdDistance(PointInfo point1, PointInfo point2)

        {

            return Math.Pow(Math.Pow(point1.X - point2.X, 2) + Math.Pow(point1.Y - point2.Y, 2), 0.5);

        }

        public static double CalcLineToPointDistance(PointInfo linePoint1, PointInfo linePoint2, PointInfo point)

        {

            double distance = 0;

            if (linePoint1.X == linePoint2.X)

                distance = Math.Abs(point.X - linePoint1.X);

            else

            {

                double a;

                double b;

                double c;

                a = (linePoint2.Y - linePoint1.Y) / (linePoint2.X - linePoint1.X);

                b = -1;

                c = -a * linePoint1.X + linePoint1.Y;

                distance = Math.Abs(a * point.X + b * point.Y + c) / Math.Pow(a * a + b * b, 0.5);

            }

            return distance;

        }

        public static bool GroupValidationCheck(Group group)

        {

            bool result = true;

            foreach (SPPID_ITEM item in group.Items)

            {

            }

            return result;

        }

        public static void SaveMapping(Dictionary<string, string> symbolMapping, Dictionary<string,string> attributeMapping)

        {

            XElement mappingElement = new XElement("Mapping");

            XElement symbolElement = new XElement("Symbol");

            foreach (var item in symbolMapping)

            {

                string name = item.Key;

                string SPPID_Name = item.Value;

                XElement element = new XElement("DATA");

                element.SetAttributeValue("SPPID", SPPID_Name);

                element.Value = name;

                symbolElement.Add(element);

            }

            mappingElement.Add(symbolElement);

            XElement attributeElement = new XElement("Attribute");

            foreach (var item in attributeMapping)

            {

                string name = item.Key;

                string SPPID_Name = item.Value;

                XElement element = new XElement("DATA");

                element.SetAttributeValue("SPPID", SPPID_Name);

                element.Value = name;

                attributeElement.Add(element);

            }

            mappingElement.Add(attributeElement);

            mappingElement.Save(mappingFilePath);

        }

        public static void LoadMapping(Dictionary<string, string> symbolMapping, Dictionary<string, string> attributeMapping)

        {

            try

            {

                if (System.IO.File.Exists(mappingFilePath))

                {

                    XElement xml = XElement.Load(mappingFilePath);

                    XElement symbolXml = xml.Element("Symbol");

                    foreach (XElement mappingData in symbolXml.Elements("DATA"))

                    {

                        if (symbolMapping.ContainsKey(mappingData.Value))

                            symbolMapping[mappingData.Value] = mappingData.Attribute("SPPID").Value;

                        else

                            symbolMapping.Add(mappingData.Value, mappingData.Attribute("SPPID").Value);

                    }

                    XElement attributeXml = xml.Element("Attribute");

                    foreach (XElement mappingData in attributeXml.Elements("DATA"))

                    {

                        if (attributeMapping.ContainsKey(mappingData.Value))

                            attributeMapping[mappingData.Value] = mappingData.Attribute("SPPID").Value;

                        else

                            attributeMapping.Add(mappingData.Value, mappingData.Attribute("SPPID").Value);

                    }

                }

            }

            catch (Exception ex)

            {

                Log.WriteLine(ex);

            }

        }

        public static void SaveDB(string sJson)

        {

            using (StreamWriter sw = new StreamWriter(dbFilePath, false))

            {

                sw.Write(sJson);

            }

        }

        public static bool LoadDB()

        {

            DBInformation dbInfo = DBInformation.GetInstance();

            try

            {

                using (StreamReader sr = new StreamReader(dbFilePath))

                {

                    DBInformation savedDbInfo = JsonConvert.DeserializeObject<DBInformation>(sr.ReadToEnd());

                    dbInfo.DBPassword = savedDbInfo.DBPassword;

                    dbInfo.DBType = savedDbInfo.DBType;

                    dbInfo.DBUser = savedDbInfo.DBUser;

                    dbInfo.Port = savedDbInfo.Port;

                    dbInfo.ServerIP = savedDbInfo.ServerIP;

                    dbInfo.Service = savedDbInfo.Service;

                    dbInfo.Site = savedDbInfo.Site;

                    dbInfo.Plant = savedDbInfo.Plant;

                    dbInfo.PlantDic = savedDbInfo.PlantDic;

                    dbInfo.PlantPID = savedDbInfo.PlantPID;

                    dbInfo.PlantPIDDic = savedDbInfo.PlantPIDDic;

                    dbInfo.PlantPath = savedDbInfo.PlantPath;

                    dbInfo.Status = savedDbInfo.Status;

                    return dbInfo.Status;

                }

            }

            catch (Exception ex)

            {

            }

            return false;

        }

    }

}