using MES.Service.Models;
using Microsoft.IdentityModel.Tokens;
using NewPdaSqlServer.Controllers;
using NewPdaSqlServer.DB;
using NewPdaSqlServer.Dto.service;
using NewPdaSqlServer.entity;
using NewPdaSqlServer.util;
using Newtonsoft.Json;
using SqlSugar;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using static Azure.Core.HttpHeader;
using System.Security.Cryptography;
using System.Collections.Generic;
using System.Linq;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;

namespace NewPdaSqlServer.service.QC;

public class OAJyService : RepositoryNoEntity
{
    private readonly HttpClient _client = new HttpClient();

    private const string APPID = "303233EF-AC39-40C1-8364-AC989C6258A5";
    private const string SECRET = "30b41949-bcfb-48f8-9847-feb6e043fe72";
    // private const string SPK = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApobID/gwmD9OofMG1gEcE94NCMeTYUq1cam/7ADZmxHCVpF143GaHWhqDdY0TTVbcUElsQ71DzAG2j3itWlIJBK5fVGwCo3sPpAvUDdKMh+Uivcp7yxdy/IDRA/PS4JARuEyM4cVJLhIOU2KnSlbIkheeoDkDgfaxu9kKrWnozJLiYraVTVDz9PdRX7fQdP+Zu/xB9txAGw4kvOm9HwgrzaSRdZEhisTJ5yyoNW/dLXtWKXA0cKhKOOIFu12TOrv/It6hl1ShTUuy79Pa51M9Oc2dEfVs1tluNXPWo1uFXQbBaJxdqZEJJlK7iW2uQFIao2O4XFHYThwy2+6116LtwIDAQAB";
    private const string HOST = "http://192.168.1.149:8099";

    private const string SPK = @"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApobID/gwmD9OofMG1gEcE94NCMeTYUq1cam/7ADZmxHCVpF143GaHWhqDdY0TTVbcUElsQ71DzAG2j3itWlIJBK5fVGwCo3sPpAvUDdKMh+Uivcp7yxdy/IDRA/PS4JARuEyM4cVJLhIOU2KnSlbIkheeoDkDgfaxu9kKrWnozJLiYraVTVDz9PdRX7fQdP+Zu/xB9txAGw4kvOm9HwgrzaSRdZEhisTJ5yyoNW/dLXtWKXA0cKhKOOIFu12TOrv/It6hl1ShTUuy79Pa51M9Oc2dEfVs1tluNXPWo1uFXQbBaJxdqZEJJlK7iW2uQFIao2O4XFHYThwy2+6116LtwIDAQAB";


    public static class RsaHelper
    {
        public static string Encrypt(string plainText, string publicKeyPem)
        {
            //// 将PEM格式的公钥转换为XML格式
            //var rsa = RSA.Create();
            //rsa.ImportFromPem(publicKeyPem);  // 使用.NET 5+ 内置PEM解析方法

            //var parameters = rsa.ExportParameters(false);
            //string publicKeyXml = $"<RSAKeyValue><Modulus>{Convert.ToBase64String(parameters.Modulus)}</Modulus><Exponent>{Convert.ToBase64String(parameters.Exponent)}</Exponent></RSAKeyValue>";

            //using var rsaProvider = new RSACryptoServiceProvider();
            //rsaProvider.FromXmlString(publicKeyXml);  // 使用转换后的XML格式公钥

            //var data = Encoding.UTF8.GetBytes(plainText);
            //var encrypted = rsaProvider.Encrypt(data, false);
            //return Convert.ToBase64String(encrypted);

            RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKeyPem));
            string XML = string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
            Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
            Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
            string encryptedContent = string.Empty;
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                rsa.FromXmlString(XML);
                byte[] encryptedData = rsa.Encrypt(Encoding.Default.GetBytes(plainText), false);
                encryptedContent = Convert.ToBase64String(encryptedData);
            }
            return encryptedContent;
        }
    }

    public string PostDataSSL(string url,
            Dictionary<string, string> parameters,
            Dictionary<string, string> headers)
    {
        var request = new HttpRequestMessage(HttpMethod.Post, url);

        foreach (var header in headers)
        {
            request.Headers.Add(header.Key, header.Value);
        }

        // 如果需要表单参数
        if (parameters.Count > 0)
        {
            request.Content = new FormUrlEncodedContent(parameters);
        }

        var response = _client.SendAsync(request).Result;
        return response.Content.ReadAsStringAsync().Result;
    }

    public string GetToken()
    {

        var userId = "1268";
        var encryptedUserId = RsaHelper.Encrypt(userId, SPK);
        ;
        var headers = new Dictionary<string, string>
        {
            ["appid"] = APPID,
            ["secret"] = RsaHelper.Encrypt(SECRET, SPK),
            ["userId"] = encryptedUserId
        };

        try
        {
            var response = PostDataSSL($"{HOST}/api/ec/dev/auth/applytoken",
                new Dictionary<string, string>(), headers);

            if (!string.IsNullOrEmpty(response))
            {
                var res = JsonConvert.DeserializeObject<dynamic>(response);
                if (res.status == "true")
                {
                    return res.token.ToString();
                }
            }
            return "token不存在！";
        }
        catch (Exception ex)
        {
            // 建议使用ILogger记录日志
            return ex.Message;
        }
    }


    //public string GetOaKqInfo(Uri url, string token, string userId)
    //{
    //    try
    //    {
    //        ServicePointManager.ServerCertificateValidationCallback += (s, cert, chain, sslPolicyErrors) => true;
    //        ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

    //        var request = WebRequest.Create(url) as HttpWebRequest;
    //        request.Method = "POST";
    //        request.Timeout = 20000;  // 20秒超时
    //        request.ContentType = "application/x-www-form-urlencoded; charset=utf-8";  // 明确指定编码

    //        // 添加调试头信息
    //        request.Headers.Add("appid", APPID);
    //        request.Headers.Add("token", token);
    //        request.Headers.Add("userId", userId);

    //        // 构建带时区的日期参数
    //        var postData = new StringBuilder();
    //        var dateParam = DateTime.Now.AddDays(-1).ToString("yyyy-MM-ddTHH:mm:sszzz");
    //        postData.AppendFormat("KQSDATE={0}&KQEDATE={1}",
    //            Uri.EscapeDataString(dateParam),
    //            Uri.EscapeDataString(dateParam));

    //        byte[] byteData = Encoding.UTF8.GetBytes(postData.ToString());  // 改用UTF8编码

    //        // 更完善的请求写入
    //        using (var stream = request.GetRequestStream())
    //        {
    //            stream.Write(byteData, 0, byteData.Length);
    //        }

    //        // 处理HTTP错误状态码
    //        using (var response = request.GetResponse() as HttpWebResponse)
    //        {
    //            if (response.StatusCode != HttpStatusCode.OK)
    //            {
    //                throw new WebException($"服务器返回错误状态码: {(int)response.StatusCode} {response.StatusDescription}");
    //            }

    //            using (var stream = response.GetResponseStream())
    //            using (var reader = new StreamReader(stream, Encoding.UTF8))
    //            {
    //                return reader.ReadToEnd();
    //            }
    //        }
    //    }
    //    catch (WebException ex) when (ex.Response is HttpWebResponse response)
    //    {
    //        // 记录详细错误信息
    //        var errorStream = response.GetResponseStream();
    //        using (var reader = new StreamReader(errorStream))
    //        {
    //            string errorDetails = reader.ReadToEnd();
    //            throw new Exception($"请求失败 [Status: {response.StatusCode}]: {errorDetails}", ex);
    //        }
    //    }
    //    catch (Exception ex)
    //    {
    //        throw new Exception($"请求异常: {ex.Message}", ex);
    //    }
    //}


    public dynamic SubmitIQCToOA(dynamic query)
    {
        try
        {
            // 参数校验
            if (query == null) throw new ArgumentNullException(nameof(query), "参数对象不能为null");
            //if (query.workflowId == null) throw new ArgumentException("workflowId不能为空");
            //if (query.mainData == null) throw new ArgumentException("mainData不能为空");

            // 转换动态参数
            //var mainDataDict = ((IEnumerable<KeyValuePair<string, object>>)query.mainData)
            //    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

            Dictionary<string, object> mainDataDict = null;

            Dictionary<string, object> detailDataDict = null;
            //if (query.detailData != null)
            //{
            //    detailDataDict = ((IEnumerable<KeyValuePair<string, object>>)query.detailData)
            //        .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
            //}
    
            // 加密处理
            var userId = "1268";
            var encryptedUserId = RsaHelper.Encrypt(userId, SPK);
            string strToken = GetToken();


            // 替换原有的测mainDataDict试数据构建
            mainDataDict = BuildMainDataFromQuery(query);

    
            // 调用方法增加userid请求头
            var result = SubmitWorkflowRequest(
                token: strToken,
                workflowId: 379,
                mainData: mainDataDict,
                requestName: "MES->OA测试流程标题",
                otherParams:null,
                remark:"Test",
                requestLevel:"",
                encryptedUserId: encryptedUserId  // 新增参数
            );
            return result;
        }
        catch (Exception ex)
        {
            // 更详细的错误处理
            return new {
                status = -1,
                message = $"完整错误信息：{ex.ToString()}"  // 显示完整堆栈
            };
        }
    }

    // 修改方法签名
    public dynamic SubmitWorkflowRequest(
        string token, 
        int workflowId,
        Dictionary<string, object> mainData,
        string encryptedUserId,  // 用户id
        Dictionary<string, object> detailData = null,
        Dictionary<string, object> otherParams = null,
        string remark = "",
        string requestLevel = "",
        string requestName = "默认流程标题")
    {
        try
        {
            ServicePointManager.ServerCertificateValidationCallback += (s, cert, chain, sslPolicyErrors) => true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            var url = new Uri($"{HOST}/api/workflow/paService/doCreateRequest");
            var request = WebRequest.Create(url) as HttpWebRequest;
            request.Method = "POST";
            request.Timeout = 20000;
            request.ContentType = "application/x-www-form-urlencoded";  // 修改为JSON格式

            // 构建请求头
            request.Headers.Set("appid", APPID);
            request.Headers.Set("token", token);
            request.Headers.Set("Content-Type", "application/x-www-form-urlencoded");
            request.Headers.Set("userId", encryptedUserId);
            // 假设需要加密的userid从其他地方获取，这里需要补充获取逻辑

            // 构建请求体
            var requestBody = new Dictionary<string, object>
            {
                //["userId"] = "1268",
                ["workflowId"] = workflowId,
                ["mainData"] = new List<Dictionary<string, object>> { mainData }, // 包装成数组
                ["detailData"] = null,
                ["otherParams"] = otherParams ?? new Dictionary<string, object>(),
                ["remark"] = remark,
                ["requestLevel"] = requestLevel,
                ["requestName"] = requestName
            };

            // 序列化请求体
            var jsonBody = JsonConvert.SerializeObject(requestBody);
            byte[] byteData = Encoding.UTF8.GetBytes(jsonBody);

            // 发送请求
            using (var stream = request.GetRequestStream())
            {
                stream.Write(byteData, 0, byteData.Length);
            }

            // 处理响应
            using (var response = request.GetResponse() as HttpWebResponse)
            {
                using (var stream = response.GetResponseStream())
                using (var reader = new StreamReader(stream, Encoding.UTF8))
                {
                    var responseJson = reader.ReadToEnd();
                    var result = JsonConvert.DeserializeObject<dynamic>(responseJson);
                    
                    // 添加状态码检查
                    if (response.StatusCode != HttpStatusCode.OK || result.code != "SUCCESS")
                    {
                        throw new Exception($"流程提交失败：{result.errMsg}");
                    }
                    
                    return new
                    {
                        code = result.code,
                        data = result.data,
                        errMsg = result.errMsg
                    };
                }
            }
        }
        catch (WebException ex) when (ex.Response is HttpWebResponse response)
        {
            using (var stream = response.GetResponseStream())
            using (var reader = new StreamReader(stream))
            {
                var errorDetails = reader.ReadToEnd();
                throw new Exception($"请求失败 [Status: {response.StatusCode}]: {errorDetails}");
            }
        }
        catch (Exception ex)
        {
            throw new Exception($"流程提交异常: {ex.Message}");
        }
    }


    // 新增的构建方法
    private Dictionary<string, object> BuildMainDataFromQuery(dynamic query)
    {
        var mainData = new Dictionary<string, object>
        {
            // 表结构定义
            ["tableDBName"] = "formtable_main_33",
            ["workflowRequestTableRecords"] = new List<Dictionary<string, object>>
            {
                new Dictionary<string, object>
                {
                    ["recordOrder"] = 0,
                    ["workflowRequestTableFields"] = new List<Dictionary<string, object>>
                    {
                        new Dictionary<string, object> { ["fieldName"] = "wlbm", ["fieldValue"] = "1.01.01.001" },
                        new Dictionary<string, object> { ["fieldName"] = "khgys", ["fieldValue"] = "陈雪年" },
                        new Dictionary<string, object> { ["fieldName"] = "jzmcwlmc", ["fieldValue"] = "顶盖" },
                        new Dictionary<string, object> { ["fieldName"] = "bhgpqxms", ["fieldValue"] = "外观不合格，尺寸不合格，颜色不符合" },
                        new Dictionary<string, object> { ["fieldName"] = "dhdhmes", ["fieldValue"] = "MES001" }
                    }
                }
            }
        };

        return mainData;
    }

    // 辅助方法用于安全添加属性
    private void TryAddProperty(Dictionary<string, object> dict, string key, object value)
    {
        if (value != null)
        {
            dict[key] = value;
        }
    }
}