using JwKdsV.Core.HttpApi;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Management;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace JwKdsV.Core.Utils
{
    public class HttpClientUtils
    {
        private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        private static object _lock = new object();

        private static Dictionary<ApiType, HttpClient> _clients = new Dictionary<ApiType, HttpClient>();

        private static HttpClient GetHttpClient(OpenApi api)
        {
            HttpClient httpClient = null;
            lock (_lock)
            {
                if (!_clients.ContainsKey(api.ApiType))
                {
                    var handler = new HttpClientHandler();
                    if (handler.SupportsAutomaticDecompression)
                    {
                        handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
                    }

                    handler.Proxy = null;
                    handler.UseProxy = false;
                    handler.UseDefaultCredentials = false;

                    OpenApi apis = OpenApiUtils.Instance.NextApi(ApiType.Business);

                    Interlocked.CompareExchange(ref httpClient, new HttpClient(handler) { BaseAddress = new Uri(apis.Url) }, null);

                    httpClient.DefaultRequestHeaders.Connection.Add("Keep-Alive");
                    httpClient.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.106 Safari/537.36");
                    httpClient.DefaultRequestHeaders.Add("Accept", "*/*");
                    httpClient.DefaultRequestHeaders.Add("Accept-Encoding", "gzip, deflate"); //声明给服务器，客户端支持gzip解压
                    httpClient.DefaultRequestHeaders.Add("Accept-Language", "zh-cn,en-us;q=0.7,en;q=0.3");
                    httpClient.DefaultRequestHeaders.Add("Pragma", "no-cache");
                    httpClient.DefaultRequestHeaders.Add("Cache-Control", "no-cache");

                    httpClient.Timeout = TimeSpan.FromMilliseconds(10000);

                    _clients[api.ApiType] = httpClient;
                }
                else
                {
                    httpClient = _clients[api.ApiType];
                }
            }
            return httpClient;
        }

        /// <summary>
        /// 指示开放平台是否可用
        /// </summary>
        /// <returns></returns>
        public static bool IsAvailable(ApiType apiType)
        {
            try
            {
                Stopwatch watch = Stopwatch.StartNew();

                bool isConnected = NetworkAvailable();
                //如果网络可用，检测开放平台
                if (isConnected)
                {
                    isConnected = OpenAvailable(apiType);
                }

                logger.Info("网络检测耗时<{0}>毫秒,结果<{1}>", watch.ElapsedMilliseconds, isConnected);

                return isConnected;
            }
            catch (Exception ex)
            {
                logger.Error(ex, "无法连接" + apiType + "开放平台");
                return false;
            }

        }

        public static bool NetworkAvailable()
        {
            //是否有可用网卡
            var networkLinkTask = Task.Factory.StartNew<bool>(() => { return NetworkUtils.IsNetworkLink(); });
            //是否连接互联网
            var connectedTask = Task.Factory.StartNew<bool>(() => { return NetworkUtils.IsConnectedToInternet(); });
            //判断是否有可用的网络
            Task.WaitAll(networkLinkTask, connectedTask);
            //网络可用:a)网卡工作;b)可以联网
            bool isConnected = networkLinkTask.Result && connectedTask.Result;
            return isConnected;
        }

        /// <summary>
        /// 开放平台sayhello
        /// </summary>
        /// <returns></returns>
        public static bool OpenAvailable(ApiType apiType)
        {
            OpenApi apis = OpenApiUtils.Instance.NextApi(apiType);
            var httpClient = GetHttpClient(apis);
            SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(apis);
            parameters.Add("method", "common.sayhello");
            parameters.Add("sign", OpenApiUtils.Instance.Sign(apis, parameters));

            var task = httpClient.PostAsync(apis.Url, new FormUrlEncodedContent(parameters));

            task.Result.EnsureSuccessStatusCode();
            return task.Result.IsSuccessStatusCode;

        }

        public static string PostAsync(OpenApi api, string url, SortedList<string, string> parameters)
        {
            Stopwatch watch = Stopwatch.StartNew();
            try
            {
                var httpClient = GetHttpClient(api);

                var task = httpClient.PostAsync(url, new FormUrlEncodedContent(parameters));
                HttpResponseMessage response = task.Result.EnsureSuccessStatusCode();
                var result = response.Content.ReadAsStringAsync();
                return result.Result;
            }
            catch (Exception ex)
            {
                string message = "调用PostAsync方法发生错误";
                if (parameters != null && parameters.ContainsKey("method"))
                {
                    message = "调用<" + parameters["method"] + ">发生错误";
                }
                logger.Error(ex, message);

                throw new Exception(message);
            }
            finally
            {
                string methodName = "NoDefined";
                if (parameters != null && parameters.ContainsKey("method"))
                {
                    methodName = parameters["method"];
                }
                logger.Info("调用<{0}>方法,耗时<{1}>毫秒", methodName, watch.ElapsedMilliseconds);
            }
        }

        public static void PosMonitor()
        {

            try
            {
                if (Global.Instance.Online && Global.Instance.StoreInfo != null)
                {

                    Stopwatch watch = Stopwatch.StartNew();

                    OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                    SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                    parameters.Add("method", "pos.monitor");

                    parameters.Add("storeId", Global.Instance.StoreInfo.StoreId);
                    parameters.Add("posNo", Global.Instance.StoreInfo.PosNo);

                    string osVersionName = GetOsVersion(Environment.OSVersion.Version);
                    string servicePack = Environment.OSVersion.ServicePack;
                    osVersionName = osVersionName + " " + servicePack;
                    parameters.Add("os", osVersionName);

                    bool is64Os = Environment.Is64BitOperatingSystem;
                    parameters.Add("osType", is64Os ? "64" : "32");
                    parameters.Add("softwareVersion", Application.ProductVersion.ToString());
                    parameters.Add("memoryTotalSize", GetPhisicalMemory().ToString());
                    parameters.Add("memoryFreeSize", GetFreePhysicalMemory().ToString());

                    string baseDir = AppDomain.CurrentDomain.BaseDirectory;
                    string diskName = baseDir.Substring(0, 1).ToUpper();//取首字母并转为大写

                    parameters.Add("diskName", diskName + ":");
                    parameters.Add("diskTotalSize", GetHardDiskSpace(diskName).ToString());
                    parameters.Add("diskFreeSize", GetHardDiskFreeSpace(diskName).ToString());
                    parameters.Add("cpuSize", Environment.ProcessorCount.ToString());

                    var ignoreParameters = new List<string>();
                    ignoreParameters.Add("os");
                    ignoreParameters.Add("osType");
                    ignoreParameters.Add("softwareVersion");
                    ignoreParameters.Add("memoryTotalSize");
                    ignoreParameters.Add("memoryFreeSize");
                    ignoreParameters.Add("diskName");
                    ignoreParameters.Add("diskTotalSize");
                    ignoreParameters.Add("diskFreeSize");
                    ignoreParameters.Add("cpuSize");

                    parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));


                    var response = PostAsync(api, api.Url, parameters);
                    if (Constant.IsSuccessful(response))
                    {

                    }
                    else
                    {

                    }

                    logger.Info("<pos.monitor>方法调用耗时<{0}>毫秒", watch.ElapsedMilliseconds);

                }


            }
            catch (Exception ex)
            {
                logger.Error(ex, "POS监控异常");
            }
        }

        /// <summary>
        /// 获取指定驱动器的空间总大小(单位为M) 
        /// </summary>
        /// <param name="diskName"></param>
        /// <returns></returns>
        public static long GetHardDiskSpace(string diskName)
        {
            long totalSize = new long();
            diskName = diskName + ":\\";
            System.IO.DriveInfo[] drives = System.IO.DriveInfo.GetDrives();
            foreach (System.IO.DriveInfo drive in drives)
            {
                if (drive.Name == diskName)
                {
                    totalSize = drive.TotalSize / (1024 * 1024);
                }
            }
            return totalSize;
        }

        /// <summary>
        /// 获取指定驱动器的剩余空间总大小(单位为M) 
        /// </summary>
        /// <param name="diskName"></param>
        /// <returns></returns>
        public static long GetHardDiskFreeSpace(string diskName)
        {
            long freeSpace = new long();
            diskName = diskName + ":\\";
            System.IO.DriveInfo[] drives = System.IO.DriveInfo.GetDrives();
            foreach (System.IO.DriveInfo drive in drives)
            {
                if (drive.Name == diskName)
                {
                    freeSpace = drive.TotalFreeSpace / (1024 * 1024);
                }
            }
            return freeSpace;
        }

        /// <summary>
        /// 获取空闲内存(单位为M) 
        /// </summary>
        /// <returns></returns>
        public static int GetFreePhysicalMemory()
        {
            long availablebytes = 0;
            try
            {


                ManagementClass mos = new ManagementClass("Win32_OperatingSystem");
                foreach (ManagementObject mo in mos.GetInstances())
                {
                    if (mo["FreePhysicalMemory"] != null)
                    {
                        availablebytes = long.Parse(mo["FreePhysicalMemory"].ToString());
                    }
                }
            }
            catch
            {
                availablebytes = 0;
            }



            return (int)(availablebytes / 1024);
        }

        /// <summary>
        /// 获取系统内存大小(单位M)
        /// </summary>
        /// <returns>内存大小</returns>
        private static int GetPhisicalMemory()
        {
            ManagementObjectSearcher searcher = new ManagementObjectSearcher();   //用于查询一些如系统信息的管理对象 
            searcher.Query = new SelectQuery("Win32_PhysicalMemory ", "", new string[] { "Capacity" });//设置查询条件 
            ManagementObjectCollection collection = searcher.Get();   //获取内存容量 
            ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();

            long capacity = 0;
            while (em.MoveNext())
            {
                ManagementBaseObject baseObj = em.Current;
                if (baseObj.Properties["Capacity"].Value != null)
                {
                    try
                    {
                        capacity += long.Parse(baseObj.Properties["Capacity"].Value.ToString());
                    }
                    catch
                    {
                        return 0;
                    }
                }
            }
            return (int)(capacity / 1024 / 1024);
        }

        private static string GetOsVersion(Version ver)
        {
            string strClient = "";
            if (ver.Major == 5 && ver.Minor == 0)
            {
                strClient = "Win2000";
            }
            else if (ver.Major == 5 && ver.Minor == 1)
            {
                strClient = "WinXP";
            }
            else if (ver.Major == 6 && ver.Minor == 0)
            {
                strClient = "WinVista";
            }
            else if (ver.Major == 6 && ver.Minor == 1)
            {
                strClient = "Win7";
            }
            else if (ver.Major == 6 && ver.Minor == 2)
            {
                strClient = "Win8+";
            }
            else if (ver.Major == 10 && ver.Minor == 0)
            {
                strClient = "Win10";
            }
            else
            {
                strClient = "未知";
            }
            return strClient;
        }

        /// <summary>
        /// 操作系统类型
        /// </summary>
        /// <returns></returns> 
        public static string GetSystemType()
        {
            string st = "";
            ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
            ManagementObjectCollection moc = mc.GetInstances();
            foreach (ManagementObject mo in moc)
            {
                st = mo["SystemType"].ToString();
            }
            return st;
        }
    }
}