using YLErp.BLL;
using YLErp.BLL.Eod;
using YLErp.Model.Enum;
using YLErp.Modules.SystemModule;

namespace YLErp.Modules.TradeModule.DealModule
{
    /// <summary>
    /// 交易复核审批操作
    /// </summary>
    public class TradeCheckService : TradeServiceBase
    {
        public TradeCheckService(YLBaseService baseService) : base(baseService)
        {
        }

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


        /// <summary>
        /// 
        /// </summary>
        public TradeCheckResult TradeCheck(OtcOptionTradeFull req, string additionalProcessing)
        {
            var tradeConv = TradeConverter.ConvertOptionTrade(req);
            return TradeCheck(tradeConv, additionalProcessing);
        }

        public TradeCheckResult TradeCheck(trade req, string additionalProcessing)
        {
            if (req is null)
            {
                throw new ArgumentNullException(nameof(req));
            }

            var dbTrade = base.DbContext.trade.Find(req.id);

            if (dbTrade == null)
            {
                throw new ServiceException("系统中没有此交易");
            }
            if (dbTrade.CheckStatus == 1)
            {
                throw new ServiceException("已经复核,不需要再次复核");
            }

            dbTrade.MetaDic = DbContext.TradeMeta.Where(a => a.TradeId == req.id).ToDictionary(a => a.MetaKey, a => a.MetaValue);

            tradeBLL.SetFieldsByTradeType(dbTrade);

            if (!req.PremiumPayDate.HasValue)
            {
                req.PremiumPayDate = req.TradeDate;
            }

            if (req.TradeType == "价差期权")
            {
                var errMsg = SpreadOptionValidator.Validate(req);
                if (!string.IsNullOrEmpty(errMsg))
                {
                    throw new ServiceException(errMsg);
                }
            }

            var diffList = TradeCheckUtil.GetDiffs(dbTrade, req);

            if (diffList?.Count > 0)
            {
                return new TradeCheckResult { diffList = diffList, message = "交易复核失败!" };
            }
            var ignoreMoneyCheck = (valuedateBLL.SystemDate.SpecialOperateForTrade == 1) &&
                                   additionalProcessing == tradeBLL.LackOfMoney;

            if (!ignoreMoneyCheck && !RealtimePnlCalc.TradeCanBeConfirm(dbTrade.ClientId, dbTrade, out var errorMsg))
            {
                string message;
                if (PS.Config.Is申万)
                {
                    message = "交易复核:复核数据正确," + errorMsg;
                }
                else
                {
                    var client = DataCacheProvider.GetClientDataSource().GetData(dbTrade.ClientId);
                    message = $"交易复核:复核数据正确,客户:{client?.Name},交易编号:{dbTrade.TradeNumber},{errorMsg}";
                }

                //如果客户缺少资金而交易特批已开启
                if (valuedateBLL.SystemDate.SpecialOperateForTrade == 1)
                {
                    return new TradeCheckResult
                    {
                        success = true,
                        proccessType = "AdditionalProcessing",
                        type = tradeBLL.LackOfMoney,
                        message = message,
                        specialOperateForTrade = true
                    };
                }

                return new TradeCheckResult { message = message };
            }
            if (PS.Config.Company != Configuration.CompanyEnum.国海)
            {
                dbTrade.CheckStatus = Convert.ToInt32(TradeCheckEnum.StatusOfNew);
            }

            DbContext.SaveChanges();
            // 如果是审批组
            var tradeProcess = TradeProcess();
            var orderIdCount = tradeProcess.Where(x => x.order == dbTrade.ProcessOrderId);//判断是否有分支
            int processOrderNode = orderIdCount.Count() > 1 ? dbTrade.ProcessOrderBranch : 0;
            if (orderIdCount.Count() == 1)
            {
                processOrderNode = orderIdCount.First().node ?? 0;
            }
            var ruleTypes = tradeProcess.FirstOrDefault(o => o.order == dbTrade.ProcessOrderId &&o.node== processOrderNode && o.processType == "TradeProcess").ruleType;
            var passStatus = 0;
            if (ruleTypes != null && ruleTypes.Contains("1"))
            {
                passStatus = new ApprovalProcessService(OptUser).CheckTradeApprovalStep(dbTrade, OptUser.UserId, true);

            }

            var result = new TradeOpenService(this).UpdateTradeProcessLog(new TradeOpenReqModel
            {
                tradeId = dbTrade.id,
                status = "pass",
                comments = "交易复核审批成功",
                ignoreMoneyCheck = true,
                notNeedOperationHistory = true
            });

            if (result.RetCode != TradeOpenRetCode.Success && !string.IsNullOrWhiteSpace(result.ErrorMsg))
            {
                return new TradeCheckResult { message = result.ErrorMsg };
            }


            //删掉trade_check相关的复核数据
            DeleteTradeCheck(dbTrade.id);

            //生成文档
            if (PS.Config.IsAutoGenerateContracts && dbTrade.TradeStatus == ConsTrade.确认成交 && dbTrade.TradeType != "远期")
            {
                new TradeContractGenerateService(this).GenerateContractsAsync(new List<int> { dbTrade.id }, "确认书");
            }

            if (PS.Config.Is宏源)
            {
                var optType = "";
                if (req.MetaDic.ContainsKey("volLimit"))
                {
                    optType = "审核波动率为:" + req.MetaDic["volLimit"];
                }


                DbContext.TradeAuditLog.Add(new TradeAuditLog
                {
                    TradeId = dbTrade.id,
                    AuditFlag = TradeAuditFlag.operation,
                    OptType = optType,
                    Changes = string.Empty,
                    DataType = "00",
                    OptId = UserId,
                    OptName = UserName,
                    OptDate = OptDate
                });
            }
            new SalesModule.SalesCommissionDataService(OptUser).SetCommissionVaild(req.id);
            new TradeConfirmService(this).EditReportStatus(req.id);

            SaveTradeOperationHistory(dbTrade, ignoreMoneyCheck ? "交易特批-交易复核成功" : "交易复核成功");

            return new TradeCheckResult { success = true, message = "复核审批成功!" };
        }

        public bool TradeScaleCheck(int eid, bool isContinue = false)
        {
            var trade = DbContext.trade.Find(eid);
            var passStatus = new ApprovalProcessService(OptUser).CheckTradeApprovalStep(trade, OptUser.UserId);
            switch (passStatus)
            {
                case -3: throw new ServiceException("当前存在分支交易审批流程，检测到申请人不满足任意一个分支进入条件，无法提交审批，请更换申请人或调整审批组");
                case -2: throw new ServiceException("未进行字段审核");
                case -1:
                    if (!isContinue)
                    {
                        return false;
                    }
                    break;
                case 1:
                    break;
                case 0:
                    new SalesModule.SalesCommissionDataService(OptUser).SetCommissionVaild(trade.id);
                    new TradeConfirmService(this).EditReportStatus(trade.id);
                    var result = new TradeOpenService(this).UpdateTradeProcessLog(new TradeOpenReqModel
                    {
                        tradeId = eid,
                        status = "pass",
                        comments = "交易复核审批成功",
                        ignoreMoneyCheck = true,
                        notNeedOperationHistory = true
                    });
                    break;
            }
            DbContext.SaveChanges();
            return true;
        }

        public TradeCheckResult TradeGroupCheck(OtcOptionTradeFull reqFull)
        {
            var req = TradeConverter.ConvertOptionTrade(reqFull);
            if (req is null)
            {
                throw new ArgumentNullException(nameof(req));
            }

            var dbTrade = base.DbContext.trade.Find(req.id);

            if (dbTrade == null)
            {
                throw new ServiceException("系统中没有此交易");
            }
            if (dbTrade.CheckStatus == 1)
            {
                throw new ServiceException("已经复核,不需要再次复核");
            }

            tradeBLL.SetFieldsByTradeType(dbTrade);

            if (!req.PremiumPayDate.HasValue)
            {
                req.PremiumPayDate = req.TradeDate;
            }
            else if (req.PremiumPayDate < req.TradeDate && req.PremiumPayDate > req.ExerciseDate)
            {
                throw new ServiceException("权利金应付日必须介于交易日与到期日之间!");
            }

            var diffList = TradeCheckUtil.GetDiffs(dbTrade, req);

            if (diffList?.Count > 0)
            {
                return new TradeCheckResult { diffList = diffList, message = "交易复核失败!" };
            }

            dbTrade.CheckStatus = Convert.ToInt32(TradeCheckEnum.StatusOfNew);
            DbContext.SaveChanges();

            var result = new TradeOpenService(this).UpdateTradeProcessLog(new TradeOpenReqModel
            {
                tradeId = dbTrade.id,
                status = "pass",
                comments = "交易复核审批成功",
                ignoreMoneyCheck = true,
                notNeedOperationHistory = true
            });

            if (result.RetCode != TradeOpenRetCode.Success && !string.IsNullOrWhiteSpace(result.ErrorMsg))
            {
                return new TradeCheckResult { message = result.ErrorMsg };
            }

            //删掉trade_check相关的复核数据
            DeleteTradeCheck(dbTrade.id);

            //生成文档
            if (PS.Config.IsAutoGenerateContracts && dbTrade.TradeStatus == ConsTrade.确认成交 && dbTrade.TradeType != "远期")
            {
                new TradeContractGenerateService(this).GenerateContractsAsync(new List<int> { dbTrade.id }, "确认书");
            }

            SaveTradeOperationHistory(dbTrade, "交易复核成功");

            return new TradeCheckResult { success = true, message = "复核审批成功!" };
        }

        /// <summary>
        /// 
        /// </summary>
        public void DeleteTradeCheck(int tradeId)
        {
            var tradeCheck = tradeId > 0
                    ? DbContext.trade_check.FirstOrDefault(t => t.TradeId == tradeId && t.ValidState != "InValid")
                    : null;

            if (tradeCheck != null)
            {
                SetDBModelOpt(tradeCheck);
                tradeCheck.ValidState = "InValid";
                DbContext.SaveChanges();
            }
        }
    }

    /// <summary>
    /// 交易检查结果(字段大小写不要改变以与前端对应)
    /// </summary>
    public class TradeCheckResult
    {
        public bool success { get; set; }
        public string proccessType { get; set; }
        public string type { get; set; }
        public int TrialDataId { get; set; }
        public string message { get; set; }
        public HashSet<string> diffList { get; set; }
        public bool specialOperateForTrade { get; set; }
    }
}