using LogLibrary.Log;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;

namespace WIDESEA_Common;

public class HttpsClient
{
    private const int Timeout = 60 * 1000;
    private static readonly LogFactory LogFactory = new LogFactory();

    // 封装一个用HttpClient发送GET请求的方法有参数
    public static async Task<string> GetAsync(string url, Dictionary<string, object> parameters)
    {
        // 记录请求参数
        LogRequestParameters(parameters, url);

        // 将参数拼接到URL中
        string queryString = string.Join("&", parameters.Select(x => $"{x.Key}={x.Value}"));
        url += "?" + queryString;

        // 创建HttpClient实例
        using (HttpClient client = new HttpClient())
        {
            // 发送GET请求并获取响应
            HttpResponseMessage response = await client.GetAsync(url);

            // 确保响应成功
            response.EnsureSuccessStatusCode();

            // 读取响应内容
            string responseBody = await response.Content.ReadAsStringAsync();

            // 记录响应参数
            LogResponseParameters(responseBody, url);

            // 返回响应内容
            return responseBody;
        }
    }

    // 用于追踪每个请求的调用次数和最后请求时间。
    private static readonly Dictionary<string, (int Count, DateTime LastRequestTime)> requestTracker = new();
    // 封装一个用HttpClient发送Post请求的方法有参数
    public static async Task<string> PostAsync(string url, Dictionary<string, object> parameters)
    {
        try
        {
            //// 创建一个新的字典，排除 RequestTime 和 SessionId
            //var filteredParameters = parameters.Where(p => p.Key != "RequestTime" && p.Key != "SessionId").ToDictionary(p => p.Key, p => p.Value);

            //string requestKey = $"{url}:{JsonConvert.SerializeObject(filteredParameters)}";
            //// 检查请求次数和时间限制
            //if (requestTracker.TryGetValue(requestKey, out var requestInfo))
            //{
            //    if (requestInfo.Count >= 5 && DateTime.Now < requestInfo.LastRequestTime.AddMinutes(3))
            //    {
            //        // 如果请求次数超过限制且未超过10分钟，抛出异常
            //        throw new InvalidOperationException("请求次数已达到限制，请稍后再试。");
            //    }
            //}

            //// 更新请求跟踪信息
            //if (requestTracker.ContainsKey(requestKey))
            //{
            //    requestTracker[requestKey] = (requestInfo.Count + 1, DateTime.Now);
            //}
            //else
            //{
            //    requestTracker[requestKey] = (1, DateTime.Now);
            //}


            // 记录请求参数
            LogRequestParameters(parameters, url);

            // 创建HttpClient实例
            using (HttpClient client = new HttpClient())
            {
                // 将参数转换为FormUrlEncodedContent
                string content = JsonConvert.SerializeObject(parameters);

                //client.Timeout = TimeSpan.from;

                var request = new HttpRequestMessage(HttpMethod.Post, url);

                request.Content = new StringContent(content, Encoding.UTF8, "application/json");
                //var content = new FormUrlEncodedContent(ConvertToKeyValuePairs(parameters));
                //// 发送POST请求并获取响应
                //HttpResponseMessage response = await client.PostAsync(url, content);
                HttpResponseMessage response = await client.SendAsync(request);

                // 确保响应成功
                response.EnsureSuccessStatusCode();

                // 读取响应内容
                string responseBody = await response.Content.ReadAsStringAsync();

                // 记录响应参数
                LogResponseParameters(responseBody, url);

                // 返回响应内容
                return responseBody;
            }
        }
        catch (Exception ex)
        {
            LogErrorParameters(ex.StackTrace,ex.Message, url);
            return ex.Message;
        }
        
    }

    public static T Post<T>(string url, object parm, string rquestName = "") where T : class
    {
        HttpWebResponse response = null;
        StreamReader resultReader = null;
        string responseContent = string.Empty;
        try
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Timeout = Timeout;
            request.Method = "POST";
            request.ContentType = "application/json; charset=UTF-8";
            parm = parm ?? "";
            byte[] data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(parm));
            request.ContentLength = data.Length;
            using (Stream newStream = request.GetRequestStream())
            {
                newStream.Write(data, 0, data.Length);
            }
            ;

            response = (HttpWebResponse)request.GetResponse();
            Stream webStream = response.GetResponseStream();
            if (webStream == null)
            {
                throw new Exception("Network error");
            }

            int statsCode = (int)response.StatusCode;
            resultReader = new StreamReader(webStream, Encoding.UTF8);
            responseContent = resultReader.ReadToEnd();

            if (response != null)
                response.Close();
            if (resultReader != null)
                resultReader.Close();

            if (statsCode != 200)
            {
                throw new Exception("异常，响应码：" + statsCode.ToString());
            }

            
            return JsonConvert.DeserializeObject<T>(responseContent);
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }
    private static void LogErrorParameters(string errorInfo,string errormessage , string url = "")
    {
        StringBuilder builder = new StringBuilder();
        builder.Append(Environment.NewLine);
        builder.Append("---------------------------------------------");
        builder.Append(Environment.NewLine);
        builder.Append("url:" + url + "异常数据行: " + JsonConvert.SerializeObject(errorInfo));
        builder.Append("url:" + url + "异常信息: " + JsonConvert.SerializeObject(errormessage));
        LogFactory.GetLog("API接口异常信息").Error(true, builder);
    }
    private static void LogRequestParameters(Dictionary<string, object> parameters, string url = "")
    {
        StringBuilder builder = new StringBuilder();
        builder.Append(Environment.NewLine);
        builder.Append("---------------------------------------------");
        builder.Append(Environment.NewLine);
        builder.Append("url:" + url + "请求参数: " + JsonConvert.SerializeObject(parameters));
        LogFactory.GetLog("API接口").Info(true, builder);
    }

    private static void LogResponseParameters(string responseBody, string url = "")
    {
        StringBuilder builder = new StringBuilder();
        builder.Append(Environment.NewLine);
        builder.Append("url:" + url + "响应参数: " + responseBody);
        builder.Append(Environment.NewLine);
        builder.Append("---------------------------------------------");
        builder.Append(Environment.NewLine);
        LogFactory.GetLog("API接口").Info(true, builder);
    }

    

    private static IEnumerable<KeyValuePair<string, string>> ConvertToKeyValuePairs(Dictionary<string, object> parameters)
    {
        foreach (var kvp in parameters)
        {
            yield return new KeyValuePair<string, string>(kvp.Key, kvp.Value?.ToString());
        }
    }

}