using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace Sinvo.EplanHpD.Plugin.DynaClient
{
    class XmlFormatStream
    {
        private const string XTN_PDMOUT_STATUS = "pdmOut/status";
        private const string XTN_PDMOUT_MESSAGE = "pdmOut/message";
        private const string XTN_PDMOUT_RESULT = "pdmOut/result";
        private const string XTN_PDMOUT_RESULT_FIELDTYPE = "pdmOut/result/fieldtype";
        private const string XTN_PDMOUT_RESULT_FIELDNAME = "pdmOut/result/fieldname";
        private const string XTN_PDMOUT_RESULT_VALUE_ROW = "pdmOut/result/value/row";
        private const string XTN_PDMIN = "pdmIn";
        private const string XTN_PDM_IN_SERIAL = "serial";
        private const string XTN_PDM_IN_PARAM = "param";
        private const string XTN_PDM_IN_FIELD_TYPE = "fieldtype";
        private const string XTN_PDM_IN_FIELD_NAME = "fieldname";
        private const string XTN_PDM_IN_FIELD_VALUE = "value";
        private const string XTN_PDM_IN_FIELD_VALUE_ROW = "row";
        private const string XAN_PDM_IN_PARAM_TYPE = "type";

        /// <summary>
        /// 检查XML流是不是个异常
        /// </summary>
        /// <param name="xmlStream"></param>
        public static void CheckXmlException(string xmlStream)
        {
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(xmlStream);
            XmlNode statusNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_STATUS);
            if (statusNode == null)
            {
                return;
            }
            string strStatus = statusNode.InnerText;
            if (strStatus.CompareTo("1") == 0)
            {
                // 失败
                XmlNode msgNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_MESSAGE);
                if (msgNode == null)
                {
                    throw new Exception("无法解析XML，请检查");
                }
                string strFailedMsg = msgNode.InnerText;
                throw new Exception(strFailedMsg);
            }
            else if (strStatus.CompareTo("201") == 0)
            {
                throw new Exception("登录过期！");
            }
        }
        /// <summary>
        /// PDM XML格式返回值转化成String类型
        /// </summary>
        /// <param name="xmlStream">xml流字符串</param>
        /// <returns></returns>
        public static string PDMSimpleReturnXmlStreamToString(string xmlStream)
        {
            //<pdmOut>
            //  <serial>simple</serial> 
            //  <starttime>2009-07-08 10:40:00</starttime> 
            //  <endtime>2009-07-08 10:40:02</endtime> 
            //  <status>0/1</status> 
            //  <message>login sucessfully!</message> 
            //  <exception /> 
            //  <result type="string">5F2BB7B637654441BB3460C3A55386A7</result> 
            //</pdmOut>

            string strResult = "";

            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(xmlStream);

            XmlNode statusNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_STATUS);
            if (statusNode == null)
            {
                throw new Exception();
            }
            string strStatus = statusNode.InnerText;
            if (strStatus.CompareTo("1") == 0)
            {
                // 失败
                XmlNode msgNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_MESSAGE);
                if (msgNode == null)
                {
                    throw new Exception();
                }
                string strFailedMsg = msgNode.InnerText;
                throw new Exception(strFailedMsg);
            }
            else if (strStatus.CompareTo("201") == 0)
            {
                throw new Exception("登录过期！");
            }
            else
            {
                XmlNode resultNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_RESULT);
                if (resultNode == null)
                {
                    throw new Exception();
                }
                strResult = resultNode.InnerText;
                return strResult;
            }
        }

        /// <summary>
        /// 获取由PDMRecordReturnXMLStreamToString解析后的某个字段的值
        /// </summary>
        /// <param name="strFieldName">传入要获取的字段名</param>
        /// <param name="arrFieldTypeString">所要查找的所有字段类型</param>
        /// <param name="arrFieldNameString">所要查找的所有字段名称</param>
        /// <param name="arrFieldValueString">所要查找的所有字段值</param>
        /// <param name="strFieldType">返回查找字段的类型</param>
        /// <param name="strFieldValue">返回查找字段的值</param>
        /// <returns></returns>
        public static bool GetFieldValueByName(string strFieldName, string[] arrFieldTypeString,
                                                string[] arrFieldNameString, string[] arrFieldValueString,
                                                out string strFieldType, out string strFieldValue)
        {
            strFieldType = "";
            strFieldValue = "";
            if (string.IsNullOrEmpty(strFieldName))
            {
                return false;
            }
            if ((arrFieldTypeString == null) || (arrFieldNameString == null) || (arrFieldValueString == null))
            {
                return false;
            }
            if (arrFieldNameString.Length < 1)
            {
                return false;
            }
            if (arrFieldTypeString.Length != arrFieldNameString.Length)
            {
                return false;
            }
            if (arrFieldTypeString.Length != arrFieldValueString.Length)
            {
                return false;
            }

            for (int i = 0; i < arrFieldNameString.Length; i++)
            {
                if (string.Compare(arrFieldNameString[i], strFieldName) == 0)
                {
                    strFieldType = arrFieldTypeString[i];
                    strFieldValue = arrFieldValueString[i];
                    return true;
                }
            }

            return false;
        }

        public static List<string> PDMRecordReturnXMLStreamRowToList(string xmlStream)
        {
            //<pdmOut>
            //  <serial>record</serial>
            //  <starttime>2014-11-25 17:19:16</starttime>
            //  <endtime>2014-11-25 17:19:16</endtime>
            //  <status>0</status>
            //  <result type="record">
            //    <fieldtype>String</fieldtype>
            //    <fieldname>filename</fieldname>   <--字段名为FileName，其实传回的是文件的本地完整路径
            //    <value>
            //      <row>D:\\ws\\SolidWorks\\测试博众-图档管理性能\\BZPART01.SLDPRT|D:\\ws\\SolidWorks\\测试博众-图档管理性能\\BZPART23.SLDPRT</row>
            //    </value>
            //  </result>
            //</pdmOut>
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xmlStream);
            XmlNode pdmOut = doc.SelectSingleNode("pdmOut");
            if (pdmOut == null)
                return null;
            XmlNode rt = pdmOut.SelectSingleNode("result");
            if (rt == null)
                return null;
            XmlNode val = rt.SelectSingleNode("value");
            if (val == null)
                return null;
            XmlNode row = val.SelectSingleNode("row");
            if (row == null)
                return null;
            string[] strs = row.InnerText.Trim().Split('|');
            if (strs.Length > 0)
            {
                return new List<string>(strs);
            }

            return null;
        }


        public static void PDMRecordReturnXMLStreamToString(string xmlStream,
                                                      out string fieldTypeString,
                                                      out string fieldNameString,
                                                      out List<string> fieldValueStringList)

        {
            #region WebService XML流格式返回值格式
            //<pdmOut>
            //  <serial>record</serial> 
            //  <starttime>2009-07-08 10:40:00</starttime> 
            //  <endtime>2009-07-08 10:40:02</endtime> 
            //  <status>0/1</status> 
            //  <message>login sucessfully!</message> 
            //  <exception /> 
            //  <result type="record">
            //    <type>string|string|string|boolean|byte|int|float|double|date|datetime</type> 
            //    <field>guid|md$number|md$description|booleanValue|byteValue|intValue|floatValue|doubleValue|dateValue|datetimeValue</field> 
            //    <value>
            //       <row>doc$vf@8606abcd|doc-001|文档|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:10:00</row> 
            //       <row>doc$vf@8606abce|doc-002|文档|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:20:00</row> 
            //       <row>doc$vf@8606abd0|doc-003|文档|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:30:00</row> 
            //       <row>doc$vf@8606abd1|doc-004|文档|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:40:00</row> 
            //    </value>
            //  </result>
            //</pdmOut>
            #endregion

            fieldTypeString = "";
            fieldNameString = "";
            fieldValueStringList = new List<string>();

            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(xmlStream);

            XmlNode statusNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_STATUS);
            if (statusNode == null)
            {
                throw new Exception();
            }
            string strStatus = statusNode.InnerText;
            if (strStatus.CompareTo("1") == 0)
            {
                // 失败
                XmlNode messageNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_MESSAGE);
                if (messageNode == null)
                {
                    throw new Exception();
                }

                string strFailedMsg = messageNode.InnerText;
                throw new Exception(strFailedMsg);
            }
            else if (strStatus.CompareTo("201") == 0)
            {
                throw new Exception("登录过期！");
            }
            else
            {
                XmlNode fieldTypeNode = null;
                XmlNode fieldNameNode = null;
                fieldTypeNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_RESULT_FIELDTYPE);
                fieldNameNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_RESULT_FIELDNAME);
                if (fieldTypeNode == null || fieldNameNode == null)
                {
                    throw new Exception();
                }
                fieldTypeString = fieldTypeNode.InnerText;
                fieldNameString = fieldNameNode.InnerText;
                XmlNodeList valueNodeList = xmlDoc.SelectNodes(XTN_PDMOUT_RESULT_VALUE_ROW);
                if (valueNodeList != null)
                {
                    foreach (XmlNode tmpNode in valueNodeList)
                    {
                        fieldValueStringList.Add(tmpNode.InnerText);
                    }
                }
            }

        }


        /// <summary>
        /// Record类型字符串转化成PDM　XML流类型参数
        /// </summary>
        /// <param name="typeString">参数的类型组合字符串</param>
        /// <param name="fieldString">参数名称组合字符串</param>
        /// <param name="valueStringList">参数值组合字符串列表</param>
        /// <returns>XML流类型字符串</returns>
        public static string RecordParameterToXmlStream(string typeString, string fieldString, List<string> valueStringList)
        {
            //<!--record 数据类型-->
            // <pdmIn>
            //  <serial>record</serial> 
            //  <param type="record/bom">
            //      <fieldtype>string|string|string|boolean|byte|int|float|double|date|datetime</fieldtype> 
            //      <fieldname>guid|md$number|md$description|booleanValue|byteValue|intValue|floatValue|doubleValue|dateValue|datetimeValue</fieldname> 
            //      <value>
            //          <row>doc$vf@8606abcd|doc-001|11|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:10:00</row> 
            //          <row>doc$vf@8606abce|doc-002|22|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:20:00</row> 
            //          <row>doc$vf@8606abd0|doc-003|33|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:30:00</row> 
            //          <row>doc$vf@8606abd1|doc-004|44|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:40:00</row>
            //      </value>
            //  </param>
            // </pdmIn>

            XmlDocument xmlDoc = new XmlDocument();
            XmlElement rootElement = xmlDoc.CreateElement(XTN_PDMIN);
            xmlDoc.AppendChild(rootElement);

            XmlElement serialElement = xmlDoc.CreateElement(XTN_PDM_IN_SERIAL);
            serialElement.InnerText = "record";
            rootElement.AppendChild(serialElement);

            XmlElement paramElement = xmlDoc.CreateElement(XTN_PDM_IN_PARAM);
            paramElement.SetAttribute(XAN_PDM_IN_PARAM_TYPE, "record");
            rootElement.AppendChild(paramElement);

            XmlElement typeElement = xmlDoc.CreateElement(XTN_PDM_IN_FIELD_TYPE);
            typeElement.InnerText = typeString;
            paramElement.AppendChild(typeElement);

            XmlElement fieldElement = xmlDoc.CreateElement(XTN_PDM_IN_FIELD_NAME);
            fieldElement.InnerText = fieldString;
            paramElement.AppendChild(fieldElement);

            XmlElement valueElement = xmlDoc.CreateElement(XTN_PDM_IN_FIELD_VALUE);
            paramElement.AppendChild(valueElement);

            foreach (string tmpValueString in valueStringList)
            {
                XmlElement tmpRowElement = xmlDoc.CreateElement(XTN_PDM_IN_FIELD_VALUE_ROW);
                tmpRowElement.InnerText = tmpValueString;
                valueElement.AppendChild(tmpRowElement);
            }
            //LogFile.WriteMessageToLog($"RecordParameterToXmlStream->\r\n{xmlDoc.InnerXml}");
            return xmlDoc.InnerXml;
        }

        /// <summary>
        /// 从XML流中转换成对象
        /// </summary>
        /// <typeparam name="T">要转换成的对象类型</typeparam>
        /// <param name="xml">XML字符串</param>
        /// <param name="clazz">对象类型</param>
        /// <returns>转换后的对象</returns>
        public static List<T> ConvertXMLToObjectList<T>(string xml)
        {
            #region WebService XML流格式返回值格式
            //<pdmOut>
            //  <serial>record</serial> 
            //  <starttime>2009-07-08 10:40:00</starttime> 
            //  <endtime>2009-07-08 10:40:02</endtime> 
            //  <status>0/1</status> 
            //  <message>login sucessfully!</message> 
            //  <exception /> 
            //  <result type="record">
            //    <type>string|string|string|boolean|byte|int|float|double|date|datetime</type> 
            //    <field>guid|md$number|md$description|booleanValue|byteValue|intValue|floatValue|doubleValue|dateValue|datetimeValue</field> 
            //    <value>
            //       <row>doc$vf@8606abcd|doc-001|文档|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:10:00</row> 
            //       <row>doc$vf@8606abce|doc-002|文档|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:20:00</row> 
            //       <row>doc$vf@8606abd0|doc-003|文档|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:30:00</row> 
            //       <row>doc$vf@8606abd1|doc-004|文档|true|1|2|1.0|2.0|2009-07-08|2009-07-08 00:40:00</row> 
            //    </value>
            //  </result>
            //</pdmOut>
            #endregion
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(xml);
            XmlNode statusNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_STATUS);
            if (statusNode == null)
            {
                throw new Exception("XML流中未找到状态节点");
            }

            string strStatus = statusNode.InnerText;
            if (strStatus.CompareTo("1") == 0)
            {
                // 失败
                XmlNode msgNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_MESSAGE);
                if (msgNode == null)
                {
                    throw new Exception("XML流中未找到消息节点");
                }
                string strFailedMsg = msgNode.InnerText;
                throw new Exception(strFailedMsg);
            }
            else if (strStatus.CompareTo("201") == 0)
            {
                throw new Exception("登录过期！");
            }
            else
            {
                XmlNode resultNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_RESULT);
                if (resultNode == null)
                {
                    throw new Exception("XML流中未找到结果节点");
                }

                XmlNode fieldTypeNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_RESULT_FIELDTYPE);
                XmlNode fieldNameNode = XMLMethod.GetXmlNode(xmlDoc, XTN_PDMOUT_RESULT_FIELDNAME);
                XmlNodeList valueNodeList = xmlDoc.SelectNodes(XTN_PDMOUT_RESULT_VALUE_ROW);

                if (fieldTypeNode == null || fieldNameNode == null || valueNodeList == null)
                {
                    throw new Exception("XML流中数据格式不正确");
                }

                // 解析字段类型和字段名称
                string[] fieldTypes = fieldTypeNode.InnerText.Split('|');
                string[] fieldNames = fieldNameNode.InnerText.Split('|');

                // 验证字段类型与字段名称数量是否匹配
                if (fieldTypes.Length != fieldNames.Length)
                {
                    throw new Exception("字段类型和字段名称数量不匹配");
                }

                // 创建结果列表
                List<T> resultList = new List<T>();

                // 处理每一行数据
                foreach (XmlNode rowNode in valueNodeList)
                {
                    string[] values = rowNode.InnerText.Split('|');

                    // 验证值的数量是否匹配字段数量
                    if (values.Length != fieldNames.Length)
                    {
                        throw new Exception($"字段值数量({values.Length})与字段名称数量({fieldNames.Length})不匹配");
                    }
                    var clazz = typeof(T);
                    // 创建对象实例
                    T obj = (T)Activator.CreateInstance(clazz);

                    // 设置对象属性
                    for (int i = 0; i < fieldNames.Length; i++)
                    {
                        try
                        {
                            // 获取属性信息
                            var property = clazz.GetProperty(fieldNames[i],
                                System.Reflection.BindingFlags.Public |
                                System.Reflection.BindingFlags.Instance |
                                System.Reflection.BindingFlags.IgnoreCase);

                            if (property != null && property.CanWrite)
                            {
                                // 根据字段类型转换值
                                object convertedValue = ConvertValueByType(values[i], fieldTypes[i]);
                                property.SetValue(obj, convertedValue);
                            }
                        }
                        catch (Exception ex)
                        {
                            throw new Exception($"设置属性 {fieldNames[i]} 值失败: {ex.Message}");
                        }
                    }

                    resultList.Add(obj);
                }

                return resultList;
            }
        }

        /// <summary>
        /// 根据字段类型将字符串值转换为对应的类型
        /// </summary>
        /// <param name="value">字符串值</param>
        /// <param name="type">字段类型</param>
        /// <returns>转换后的对象</returns>
        private static object ConvertValueByType(string value, string type)
        {
            switch (type.ToLower())
            {
                case "string":
                    return value;
                case "boolean":
                    return Convert.ToBoolean(value);
                case "byte":
                    return Convert.ToByte(value);
                case "int":
                    return Convert.ToInt32(value);
                case "float":
                    return Convert.ToSingle(value);
                case "double":
                    return Convert.ToDouble(value);
                case "date":
                    return DateTime.Parse(value).Date;
                case "datetime":
                    return DateTime.Parse(value);
                default:
                    return value;
            }
        }

    }
}