using log4net;
using MemoryRead;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Web.UI;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Serialization;


namespace DataHandling
{
    public class WebServiceHelper
    {
        private ILog _log;
        public WebServiceHelper(ILog log)
        {
            _log = log;
        }
        //<webServices>
        //  <protocols>
        //    <add name="HttpGet"/>
        //    <add name="HttpPost"/>
        //  </protocols>
        //</webServices>
        private static Hashtable _xmlNamespaces = new Hashtable();//缓存xmlNamespace，避免重复调用GetNamespace

        /// <summary>
        /// 需要WebService支持Post调用
        /// </summary>
        public  Dictionary<string,string> QueryPostWebService(String URL, String MethodName, Dictionary<string,string> Pars)
        {
            //Dictionary<string, string> dic=new Dictionary<string, string>();
            //try
            //{
            //    HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(URL + "/" + MethodName);
            //    request.Method = "POST";
            //    request.ContentType = "application/x-www-form-urlencoded";                
            //    SetWebRequest(request);
            //    byte[] data = EncodePars(Pars);
            //    WriteRequestData(request, data);
            //    XmlDocument xmlDocument = ReadXmlResponse(request.GetResponse());
            //    dic=XmlToDictionary(xmlDocument);                
            //}
            //catch (Exception ex)
            //{
            //    _log.Info($"WebServer_POST错误提示：{ex.Message}");
            //}
            //return dic;
            Dictionary<string, string> dic = new Dictionary<string, string>();
            try
            {
                using (HttpClient client = new HttpClient())
                {
                    string requestUri = $"{URL}/{MethodName}";
                    _log.Info($"WebServer_POST,请求路径：{requestUri}");
                    HttpResponseMessage response;

                    using (HttpContent content = new FormUrlEncodedContent(Pars))
                    {
                        response =client.PostAsync(requestUri, content).Result;
                    }

                    if (response.IsSuccessStatusCode)
                    {
                        string responseContent = response.Content.ReadAsStringAsync().Result;
                        XmlDocument xmlDocument = new XmlDocument();
                        xmlDocument.LoadXml(responseContent);

                        dic = XmlToDictionary(xmlDocument);
                    }
                    else
                    {
                        _log.Info($"WebServer_POST错误提示：{response.ReasonPhrase}");
                    }
                }
            }
            catch (Exception ex)
            {
                _log.Info($"WebServer_POST错误提示：{ex.Message}");
            }

            return dic;
        }

        /// <summary>
        /// 需要WebService支持Get调用
        /// </summary>
        public Dictionary<string,string> QueryGetWebService(String URL, String MethodName, Dictionary<string,string> Pars)
        {
            Dictionary<string, string> dic= new Dictionary<string, string>();   
            try
            {
                HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(URL + "/" + MethodName + "?" + ParsToString(Pars));
                request.Method = "GET";
                request.ContentType = "text/xml";
                //_log.Info($"WebServer_Http请求路径为：{request.RequestUri};请求方式：{request.Method};" +
                   //$"ContentType：{request.ContentType};");
                SetWebRequest(request);                
                XmlDocument xmlDocument = ReadXmlResponse(request.GetResponse());
                dic = XmlToDictionary(xmlDocument);
                string json = JsonConvert.SerializeObject(dic);
                //_log.Info($"WebServer_返回数据：{json}");
            }
            catch (Exception ex)
            {
                using (StreamWriter writer = new StreamWriter("D:\\example.txt"))
                {
                    writer.WriteLine($"{ex.Message}");
                }
                //LogUtil.info($"get报错{ex.Message}");
                //_log.Error(ex.Message);
            }
            return dic;
        }


        /// <summary>
        /// 通用WebService调用(Soap),参数Pars为String类型的参数名、参数值
        /// </summary>
        public  Dictionary<string,string> QuerySoapWebService(String URL, String MethodName, Dictionary<string,string> Pars)
        {
            if (_xmlNamespaces.ContainsKey(URL))
            {
                return QuerySoapWebService(URL, MethodName, Pars, _xmlNamespaces[URL].ToString());
            }
            else
            {
                return QuerySoapWebService(URL, MethodName, Pars, GetNamespace(URL));
            }
        }

        /// <summary>
        /// 通用WebService调用(Soap)
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="MethodName"></param>
        /// <param name="Pars"></param>
        /// <param name="XmlNs"></param>
        /// <returns></returns>
        private Dictionary<string,string> QuerySoapWebService(String URL, String MethodName, Dictionary<string,string> Pars, string XmlNs)
        {
            Dictionary<string,string> dic= new Dictionary<string,string>(); 
            try
            {
                _xmlNamespaces[URL] = XmlNs;//加入缓存，提高效率
                HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(URL);
                request.Method = "POST";
                request.ContentType = "text/xml; charset=utf-8";
                request.Headers.Add("SOAPAction", "\"" + XmlNs + (XmlNs.EndsWith("/") ? "" : "/") + MethodName + "\"");
                //_log.Info($"WebServer_SOAP请求路径为：{request.RequestUri};请求方式：{request.Method};" +
                //   $"ContentType：{request.ContentType};Headers_SOAPAction：{request.Headers.Get("SOAPAction")}");
                SetWebRequest(request);
                byte[] data = EncodeParsToSoap(Pars, XmlNs, MethodName);
                WriteRequestData(request, data);
                XmlDocument doc = new XmlDocument();
                doc = ReadXmlResponse(request.GetResponse());
                dic=XmlToDictionary(doc);
                string json= JsonConvert.SerializeObject(dic);
                string filePath = "D:\\example.txt";


                using (StreamWriter writer = new StreamWriter(filePath))
                {
                    writer.WriteLine(json);
                }
                //_log.Info($"WebServer_SOAP请求结果:{json}");

                //XmlNamespaceManager mgr = new XmlNamespaceManager(doc.NameTable);
                //mgr.AddNamespace("soap", "http://schemas.xmlsoap.org/soap/envelope/");
                //String RetXml = doc.SelectSingleNode("//soap:Body/*/*", mgr).InnerXml;
                //doc2.LoadXml("<root>" + RetXml + "</root>");
                //AddDelaration(doc2);
                //return doc2;
            }
            catch (Exception ex)
            {
                string filePath = "D:\\example.txt";


                using (StreamWriter writer = new StreamWriter(filePath))
                {
                    writer.WriteLine(ex.Message);
                }
                //_log.Error(ex.Message);
            }
            return dic;    
        }

        /// <summary>
        /// 通过WebService的WSDL获取XML名称空间
        /// </summary>
        /// <param name="URL"></param>
        /// <returns></returns>
        private static string GetNamespace(String URL)
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(URL + "?WSDL");
            SetWebRequest(request);
            WebResponse response = request.GetResponse();
            StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(sr.ReadToEnd());
            sr.Close();
            return doc.SelectSingleNode("//@targetNamespace").Value;
        }

        /// <summary>
        /// 动态生成SOP请求报文内容
        /// </summary>
        /// <param name="Pars"></param>
        /// <param name="XmlNs"></param>
        /// <param name="MethodName"></param>
        /// <returns></returns>
        private static byte[] EncodeParsToSoap(Dictionary<string,string> Pars, String XmlNs, String MethodName)
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml("<soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"></soap:Envelope>");
            AddDelaration(doc);
            XmlElement soapBody = doc.CreateElement("soap", "Body", "http://schemas.xmlsoap.org/soap/envelope/");
            XmlElement soapMethod = doc.CreateElement(MethodName);
            soapMethod.SetAttribute("xmlns", XmlNs);
            foreach (string k in Pars.Keys)
            {
                XmlElement soapPar = doc.CreateElement(k);
                soapPar.InnerXml = ObjectToSoapXml(Pars[k]);
                soapMethod.AppendChild(soapPar);
            }
            soapBody.AppendChild(soapMethod);
            doc.DocumentElement.AppendChild(soapBody);
            return Encoding.UTF8.GetBytes(doc.OuterXml);
        }

        /// <summary>
        /// 将对象转换成XML节点格式
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        private static string ObjectToSoapXml(object o)
        {
            XmlSerializer mySerializer = new XmlSerializer(o.GetType());
            MemoryStream ms = new MemoryStream();
            mySerializer.Serialize(ms, o);
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(Encoding.UTF8.GetString(ms.ToArray()));
            if (doc.DocumentElement != null)
            {
                return doc.DocumentElement.InnerXml;
            }
            else
            {
                return o.ToString();
            }
        }

        /// <summary>
        /// 设置WEB请求
        /// </summary>
        /// <param name="request"></param>
        private static void SetWebRequest(HttpWebRequest request)
        {
            request.Credentials = CredentialCache.DefaultCredentials;
            request.Timeout = 10000;
        }

        /// <summary>
        /// 设置请求数据
        /// </summary>
        /// <param name="request"></param>
        /// <param name="data"></param>
        private static void WriteRequestData(HttpWebRequest request, byte[] data)
        {
            request.ContentLength = data.Length;
            Stream writer = request.GetRequestStream();
            writer.Write(data, 0, data.Length);
            writer.Close();
        }

        /// <summary>
        /// 获取字符串的UTF8码字符串
        /// </summary>
        /// <param name="Pars"></param>
        /// <returns></returns>
        private byte[] EncodePars(Dictionary<string,string> Pars)
        {
            return Encoding.UTF8.GetBytes(ParsToString(Pars));
        }

        /// <summary>
        /// 将Hashtable转换成WEB请求键值对字符串
        /// </summary>
        /// <param name="Pars"></param>
        /// <returns></returns>
        private static String ParsToString(Hashtable Pars)
        {
            StringBuilder sb = new StringBuilder();
            foreach (string k in Pars.Keys)
            {
                if (sb.Length > 0)
                {
                    sb.Append("&");
                }
                sb.Append(HttpUtility.UrlEncode(k) + "=" + HttpUtility.UrlEncode(Pars[k].ToString()));
            }
            return sb.ToString();
        }

        /// <summary>
        /// 获取Webservice响应报文XML
        /// </summary>
        /// <param name="response"></param>
        /// <returns></returns>
        private static XmlDocument ReadXmlResponse(WebResponse response)
        {
            StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
            String retXml = sr.ReadToEnd();
            sr.Close();
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(retXml);
            return doc;
        }

        /// <summary>
        /// 设置XML文档版本声明
        /// </summary>
        /// <param name="doc"></param>
        private static void AddDelaration(XmlDocument doc)
        {
            XmlDeclaration decl = doc.CreateXmlDeclaration("1.0", "utf-8", null);
            doc.InsertBefore(decl, doc.DocumentElement);
        }


        public static  string ParsToString(Dictionary<string, string> Pars)
        {
            StringBuilder sb = new StringBuilder();
            foreach (string key in Pars.Keys)
            {
                if (sb.Length > 0)
                {
                    sb.Append("&");
                }
                sb.Append(HttpUtility.UrlEncode(key) + "=" + HttpUtility.UrlEncode(Pars[key]));
            }
            string str= sb.ToString();   
            return str;
        }

        private static Dictionary<string, string> XmlToDictionary(XmlDocument xml) 
        {                  
            XmlNodeList stringNodes = xml.SelectNodes("//ns:string", GetXmlNamespaceManager(xml));
            Dictionary<string, string> dic = new Dictionary<string, string>();
            if (stringNodes != null)
            {
                int i = 1;
                foreach (XmlNode node in stringNodes)
                {
                    // 将 <string> 元素的内容添加到字典中
                    dic.Add(i.ToString(), node.InnerText);
                    i++;
                }
            }
            return dic;
        }

        static XmlNamespaceManager GetXmlNamespaceManager(XmlDocument xmlDoc)
        {
            XmlNamespaceManager namespaceManager = new XmlNamespaceManager(xmlDoc.NameTable);
            namespaceManager.AddNamespace("ns", xmlDoc.DocumentElement.NamespaceURI);
            return namespaceManager;
        }

        private static List<string> XmlToString(XmlDocument xml)
        {
            List<string> strings = new List<string>(); 
            String xmlnode = ConfigHelper.Config.Get("WebServer_xmlnode", "/ArrayOfString/");
            XmlNodeList stringNodes = xml.SelectNodes(xmlnode);
            foreach (XmlNode node in stringNodes)
            {
                strings.Add(node.InnerText);
            }
            return strings;
        }
    }
}