using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Collections;
using System.Net;
using System.Net.Security;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Reflection;
using System.Net.NetworkInformation;
using BLL;

namespace BLL
{
    using System;
    using System.IO;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Web;
    using System.Collections;
    using System.Net;
    using System.Net.Security;
    using System.Security;
    using System.Security.Cryptography;
    using System.Security.Cryptography.X509Certificates;
    using System.Reflection;
    using log4net;
    using Newtonsoft.Json;
    using System.Windows.Forms;

    namespace BLL
    {
        public class HttpUtil
        {
            public static readonly ILog LOGGER = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
            public static string Post(string url, string paramData)
            {
                return Post(url, paramData, Encoding.UTF8);
            }

            public static T ObjPost<T>(string url, object o) where T : class
            {
                try
                {
                    string json = JsonUtil.SerializeObject(o);
                    string result = Post(url, json);
                    if (!string.IsNullOrEmpty(result))
                    {
                        return JsonUtil.DeserializeJsonToObject<T>(result);
                    }
                }
                catch (Exception ex)
                {
                    LOGGER.Error("Http post 出错" + ex);
                }
                return default(T);
            }

            public static List<T> ListPost<T>(string url, object o) where T : class
            {
                try
                {
                    string json = JsonUtil.SerializeObject(o);
                    string result = Post(url, json);
                    if (!string.IsNullOrEmpty(result))
                    {
                        return JsonUtil.DeserializeJsonToList<T>(result);
                    }
                }
                catch (Exception ex)
                {
                    LOGGER.Error("Http post 出错" + ex);
                }
                return new List<T>();
            }

            public static string Post(string url, string paramData, Encoding encoding)
            {
                string result = "";

                if (url.ToLower().IndexOf("https", System.StringComparison.Ordinal) > -1)
                {
                    ServicePointManager.ServerCertificateValidationCallback =
                                   new RemoteCertificateValidationCallback((sender, certificate, chain, errors) => { return true; });
                }

                try
                {
                    var wc = new TimeoutWebClient(5000);
                    if (string.IsNullOrEmpty(wc.Headers["Content-Type"]))
                        //wc.Headers.Add("Content-Type", "application/json;charset=UTF-8");
                        //如果需要将body中的参数以key/value格式发送到服务器,使用下面的Header
                        wc.Headers.Add("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
                    wc.Encoding = encoding;
                    //paramData = Uri.EscapeDataString(paramData);
                    result = wc.UploadString(url, "POST", paramData);
                    //LogUtil.info(result);
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message);
                    LOGGER.Error("POST【" + paramData + "】 ERROR:", e);
                }
                //LOGGER.Info("post receive <<" + result );
                return result;
            }

            public static string Get(string url)
            {
                return Get(url, Encoding.UTF8);
            }

            public static string Get(string url, Encoding encoding)
            {
                try
                {
                    LOGGER.Info("HTTP GET FROM: " + url);
                    var wc = new WebClient { Encoding = encoding };
                    var readStream = wc.OpenRead(url);
                    using (var sr = new StreamReader(readStream, encoding))
                    {
                        var result = sr.ReadToEnd();
                        LOGGER.Info("get receive << " + result);
                        return result;
                    }
                }
                catch (Exception e)
                {
                    LOGGER.Error("HTTP GET ERROR:", e);
                }
                return "";
            }
        }

        /// <summary>
        /// Json帮助类
        /// </summary>
        public class JsonUtil
        {
            /// <summary>
            /// 将对象序列化为JSON格式
            /// </summary>
            /// <param name="o">对象</param>
            /// <returns>json字符串</returns>
            public static string SerializeObject(object o)
            {
                string json = JsonConvert.SerializeObject(o);
                return json;
            }

            /// <summary>
            /// 解析JSON字符串生成对象实体
            /// </summary>
            /// <typeparam name="T">对象类型</typeparam>
            /// <param name="json">json字符串(eg.{"ID":"112","Name":"石子儿"})</param>
            /// <returns>对象实体</returns>
            public static T DeserializeJsonToObject<T>(string json) where T : class
            {
                JsonSerializer serializer = new JsonSerializer();
                StringReader sr = new StringReader(json);
                object o = serializer.Deserialize(new JsonTextReader(sr), typeof(T));
                T t = o as T;
                return t;
            }

            /// <summary>
            /// 解析JSON数组生成对象实体集合
            /// </summary>
            /// <typeparam name="T">对象类型</typeparam>
            /// <param name="json">json数组字符串(eg.[{"ID":"112","Name":"石子儿"}])</param>
            /// <returns>对象实体集合</returns>
            public static List<T> DeserializeJsonToList<T>(string json) where T : class
            {
                JsonSerializer serializer = new JsonSerializer();
                StringReader sr = new StringReader(json);
                object o = serializer.Deserialize(new JsonTextReader(sr), typeof(List<T>));
                List<T> list = o as List<T>;
                return list;
            }

            /// <summary>
            /// 反序列化JSON到给定的匿名对象.
            /// </summary>
            /// <typeparam name="T">匿名对象类型</typeparam>
            /// <param name="json">json字符串</param>
            /// <param name="anonymousTypeObject">匿名对象</param>
            /// <returns>匿名对象</returns>
            public static T DeserializeAnonymousType<T>(string json, T anonymousTypeObject)
            {
                T t = JsonConvert.DeserializeAnonymousType(json, anonymousTypeObject);
                return t;
            }
        }

        public class TimeoutWebClient : WebClient
        {
            private int _timeout;

            /// <summary>
            /// 超时时间(毫秒)
            /// </summary>
            public int Timeout
            {
                get
                {
                    return _timeout;
                }
                set
                {
                    _timeout = value;
                }
            }

            public TimeoutWebClient()
            {
                this._timeout = 60000;
            }

            public TimeoutWebClient(int timeout)
            {
                this._timeout = timeout;
            }

            protected override WebRequest GetWebRequest(Uri address)
            {
                var result = base.GetWebRequest(address);
                result.Timeout = this._timeout;
                return result;
            }
        }
    }
}