using BaseOUDAL;
using NPOI.SS.Formula.Functions;
using Qdp.Foundation.Utilities;
using YLErp.DBModels;
using YLErp.DBModels.Consts;
using YLErp.DBModels.Enums;
using YLErp.Model;
using YLErp.Modules.ApiModule;
using YLErp.Modules.TradeDalModule;
using YLErp.Modules.UnderlyingModule;
using static YLErp.ConsGlobal;

namespace YLErp.Modules.TradeModule
{
    /// <summary>
    /// 交易OA服务
    /// </summary>
    public class TradeOAService : YLBaseService
    {
        private static readonly IYcLogger logger = LogFactory.GetLogger<TradeOAService>();

        public TradeOAService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        public TradeOAService(YLBaseService baseService) : base(baseService)
        {
        }

        /// <summary>
        /// 处理单个交易的OA提交
        /// </summary>
        /// <param name="tradeId">交易ID</param>
        /// <returns>处理结果</returns>
        public async Task<TradeOAResult> ProcessSingleOAAsync(int tradeId)
        {
            try
            {
                // 获取交易信息
                var trade = DbContext.trade.FirstOrDefault(x => x.id == tradeId);
                if (trade == null)
                {
                    return new TradeOAResult { TradeId = tradeId, Success = false, Message = "未找到交易信息" };
                }

                // 获取交易确认书信息
                var tcr = DbContext.trade_contract_r.Where(t => t.Type == ContractTypeEnum.Trade && t.IsValid && t.TradeId == tradeId)
                    .FirstOrDefault();
                trade_contract_document tdoc = null;
                if (tcr != null)
                {
                    tdoc = DbContext.trade_contract_document.Where(t => t.Code == tcr.ContractCode && t.Type == tcr.Type).FirstOrDefault();
                }

                // 将之前的OA记录设置为无效
                var existingOAResults = DbContext.tradeContractOaResult.Where(x => x.trade_id == tradeId && x.is_valid == true).ToList();
                foreach (var existingResult in existingOAResults)
                {
                    existingResult.is_valid = false;
                    existingResult.SetOpt(UserInfo);
                }


                // 创建OA结果记录
                var oaResult = new trade_contract_oa_result
                {
                    trade_id = tradeId,
                    contract_code = tcr?.ContractCode,
                    status = "提交中",
                    is_valid = true,
                };
                oaResult.SetOpt(UserInfo);
                DbContext.tradeContractOaResult.Add(oaResult);
                await DbContext.SaveChangesAsync();

                // 调用OA接口
                var oaResp = await CallOAInterfaceAsync(trade, tcr?.ContractCode, tdoc, oaResult.id);
                if (oaResp != null && oaResp.code == 0)
                {
                    oaResult.status = "提交成功";
                    oaResult.oa_fileid = oaResp.data?.requestid;
                    oaResult.oa_msg = oaResp.data?.msg ?? "提交成功";
                }
                else
                {
                    oaResult.status = "提交失败";
                    oaResult.oa_msg = oaResp?.data?.msg ?? "OA接口调用失败";
                }
                await DbContext.SaveChangesAsync();

                return new TradeOAResult { TradeId = tradeId, Success = oaResult.status == "提交成功", Message = oaResult.oa_msg };
            }
            catch (Exception ex)
            {
                logger.Error($"处理交易ID {tradeId} 的OA时发生错误: {ex.Message}", ex);
                return new TradeOAResult { TradeId = tradeId, Success = false, Message = $"提交OA失败: {ex.Message}" };
            }
        }

        /// <summary>
        /// 上传附件到OA系统
        /// </summary>
        /// <param name="filePath">文件路径</param>
        /// <returns>附件ID列表</returns>
        private async Task<List<string>> UploadAttachmentAsync(string filePath)
        {
            try
            {
                // 从配置文件读取上传配置
                var oaConfigSection = AppManager.GetConfiguration().GetSection("oa_confg");
                var uploadUrl = oaConfigSection["UploadUrl"];
                var systemToken = oaConfigSection["SystemToken"];

                if (string.IsNullOrEmpty(uploadUrl))
                {
                    logger.Error("OA接口配置中UploadUrl为空");
                    throw new Exception("OA接口配置中上传地址为空");
                }
                if (string.IsNullOrEmpty(systemToken))
                {
                    logger.Error("OA接口配置中SystemToken为空");
                    throw new Exception("OA接口配置中上传令牌为空");
                }

                if (!File.Exists(filePath))
                {
                    logger.Error($"附件文件不存在：{filePath}");
                    throw new Exception("附件文件不存在");
                }

                // 创建multipart/form-data请求
                using (var httpClient = new HttpClient())
                using (var form = new MultipartFormDataContent())
                {
                    // 添加文件
                    var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
                    var fileName = Path.GetFileName(filePath);
                    form.Add(new StreamContent(fileStream), "file", fileName);

                    // 添加systemToken
                    form.Add(new StringContent(systemToken), "systemToken");

                    // 发送请求
                    var response = await httpClient.PostAsync(uploadUrl, form);
                    var responseContent = await response.Content.ReadAsStringAsync();

                    logger.Info($"附件上传接口返回: {responseContent}");

                    // 解析响应
                    try
                    {
                        var uploadResponse = JsonHelper.Deserialize<UploadAttachmentResponse>(responseContent);
                        if (uploadResponse != null)
                        {
                            if (uploadResponse.code == "0" && uploadResponse.data != null)
                            {
                                // 提取annexId
                                var annexIds = uploadResponse.data.Select(item => item.annexId).ToList();
                                logger.Info($"成功上传附件，获取到{annexIds.Count}个附件ID");
                                return annexIds;
                            }
                            else
                            {
                                logger.Error($"附件上传失败：{uploadResponse.status}，code：{uploadResponse.code}");
                                throw new Exception($"附件上传失败：{uploadResponse.status}");
                            }
                        }
                        else
                        {
                            logger.Error("附件上传响应解析为空");
                            throw new Exception("附件上传响应解析失败");
                        }
                    }
                    catch (Exception ex)
                    {
                        logger.Error($"解析附件上传响应失败：{ex.Message}，响应内容：{responseContent}", ex);
                        throw new Exception($"解析附件上传响应失败：{ex.Message}");
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error($"上传附件时发生异常：{ex.Message}", ex);
                throw;
            }
        }

        /// <summary>
        /// 调用OA接口
        /// </summary>
        /// <param name="trade">交易信息</param>
        /// <param name="contractCode">合同编号</param>
        /// <param name="tdoc">交易确认书文档</param>
        /// <param name="oaResultId">OA结果记录ID</param>
        /// <returns>是否成功</returns>
        private async Task<GuoLianOAResponse> CallOAInterfaceAsync(trade trade, string contractCode, trade_contract_document tdoc, int oaResultId)
        {
            try
            {
                // 获取OA配置
                var oaConfigSection = AppManager.GetConfiguration().GetSection("oa_confg");
                var baseUrl = oaConfigSection["BaseUrl"];
                var subUrl = oaConfigSection["SubUrl"];
                var systemToken = oaConfigSection["SystemToken"];
                var systemName = oaConfigSection["SystemName"];
                var isNextFlow = oaConfigSection["IsNextFlow"] ?? "0";
                var flowId = oaConfigSection["FlowId"];

                if (string.IsNullOrEmpty(baseUrl))
                {
                    logger.Error("OA接口配置中BaseUrl为空");
                    return new GuoLianOAResponse() { code = -1, data = new GuoLianOAData { msg = "OA接口配置中地址为空" } };
                }
                if (string.IsNullOrEmpty(systemToken))
                {
                    logger.Error("OA接口配置中SystemToken为空");
                    return new GuoLianOAResponse() { code = -1, data = new GuoLianOAData { msg = "OA接口配置中SystemToken为空" } };
                }

                // 处理附件
                List<string> annexIds = null;
                if (tdoc != null && !string.IsNullOrEmpty(tdoc.AbsolutePath))
                {
                    try
                    {
                        annexIds = await UploadAttachmentAsync(tdoc.AbsolutePath);
                        logger.Info($"成功上传附件并获取到annexId：{string.Join(", ", annexIds)}");
                    }
                    catch (Exception ex)
                    {
                        logger.Error($"上传附件失败：{tdoc.AbsolutePath}，错误：{ex.Message}", ex);
                        return new GuoLianOAResponse() { code = -1, data = new GuoLianOAData { msg = "上传附件失败" } };
                    }
                }

                // 构建dataMap
                var dataMap = new
                {
                    title = $"固定收益部申请【{contractCode}】TRS交易确认书",
                    urgentLevel = "正常",
                    applyDate = DateTime.Now.ToString("yyyyMMdd"),
                    applicant = UserInfo.UserName,
                    applicantComp = "国联民生证券总部",
                    contractType = "业务",
                    businessType = "金融交易类合同（除股票质押式回购业务部分购回、购回协议）",
                    contractSecretLevel = "一般",
                    contractUrgentLevel = "一般",
                    //去除后缀
                    contractName = Path.GetFileNameWithoutExtension(tdoc.FileName),
                    isRelatedTransaction = "否",
                    partyAType = "企业",
                    partyA = trade.ClientName,
                    partyBType = "企业",
                    partyB = "国联民生证券股份有限公司",
                    partyASmsNotify = "否",
                    partyBSmsNotify = "否",
                    contractAmount = trade.OriginalStockEqvNotional,
                    contractBeginDate = trade.StartDate?.ToString("yyyyMMdd"),
                    contractEndDate = trade.ExerciseDate?.ToString("yyyyMMdd"),
                    currency = "人民币",
                    contractSignDate = DateTime.Now.ToString("yyyyMMdd"),
                    signIntegrityAgreement = "无需签订",
                    contractBackground = $"我司与{trade.ClientName}已完成NAFMII协议签署，并开展TRS交易：{contractCode}，参与标的{trade.UnderlyingCode} {trade.UnderlyingName}，参与标的数量面额{trade.OriginalStockEqvNotional}元人民币",
                    // 使用annexId替代Base64编码
                    annexIds = annexIds
                };

                // 构建查询参数（不包含dataMap，dataMap放在请求体中）
                // 注意：Java后端使用驼峰命名，参数名需与后端@RequestParam注解的名称一致
                var query =
                    $"flowId={Uri.EscapeDataString(flowId)}" +
                    $"&isNextFlow={Uri.EscapeDataString(isNextFlow ?? string.Empty)}" +
                    $"&systemToken={Uri.EscapeDataString(systemToken)}" +
                    $"&systemName={Uri.EscapeDataString(systemName ?? string.Empty)}";

                var requestUrl = subUrl.Contains("?") ? $"{subUrl}&{query}" : $"{subUrl}?{query}";
                logger.Info($"国联OA接口URL: {requestUrl}");

                // 调用OA接口 (POST请求，dataMap放在请求体中)
                var httpClient = new HttpClientWrap(baseUrl);
                var response = httpClient.PostJson(requestUrl, dataMap, null);

                logger.Info($"国联OA接口返回: {response}");

                // 解析响应
                var responseObj = JsonHelper.Deserialize<GuoLianOAResponse>(response);
                return responseObj;
            }
            catch (Exception ex)
            {
                logger.Error($"调用OA接口时发生异常，交易ID：{trade.id}，异常信息：{ex.Message}", ex);
                return new GuoLianOAResponse() { code = -2, data = new GuoLianOAData { msg = $"调用OA接口时发生异常: {ex.Message}" } };
            }
        }
    }

}