using BaseOUDAL;
using YLErp.BLL;
using YLErp.DBModels.Enums;
using YLErp.Model;
using YLErp.Modules.ClientModule;
using YLErp.Modules.SalesModule;
using YLErp.Modules.TradeModule.DealModule;

namespace YLErp.Modules.ApprovalModule
{
    public class ApprovalService : YLBaseService
    {
        public ApprovalService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        /// <summary>
        /// 查询接口审批记录
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        public SearchListResult<ApprovalResult> QueryInterfaceApproval(ApprovalReq req)
        {
            if (req.optDateEnd < DateTime.MaxValue.Date)
            {
                req.optDateEnd = req.optDateEnd.AddDays(1);
            }
            var query = DbContext.ApprovalResult.Where(O => O.OptDate >= req.optDateStart && O.OptDate < req.optDateEnd);
            if (req.type != 0)
            {
                query = query.Where(O => O.type == req.type);
            }
            if (req.linkStatus.HasValue)
            {
                if (req.linkStatus.Value)
                {
                    query = query.Where(O => O.LinkCode != "");
                }
                else
                {
                    query = query.Where(O => O.LinkCode == "");
                }
            }
            if (!string.IsNullOrWhiteSpace(req.linkCode))
            {
                query = query.Where(O => O.LinkCode == req.linkCode);
            }
            return query.ToSearchList(req);
        }

        /// <summary>
        /// 执行交易审批操作
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        private TradeOpenResult TradeApproval(TradeOpenReqModel req)
        {
            var tradeResult = new TradeOpenService(UserInfo).UpdateTradeProcessLog(req);

            if ((tradeResult.RetCode == TradeOpenRetCode.None && string.IsNullOrWhiteSpace(tradeResult.ErrorMsg)) || tradeResult.RetCode == TradeOpenRetCode.Success)
            {
                if (req.status == "pass")
                {
                    var trade = tradeResult.Trade;

                    //生成确认书
                    if (PS.Config.IsAutoGenerateContracts && (trade.TradeStatus == ConsTrade.确认成交 || ConsTrade.TradeCompleteStatus.Contains(trade.TradeStatus)))
                    {
                        var contractType = "其它";
                        if (trade.TradeStatus == ConsTrade.确认成交 && trade.HasPartialUnWind != 1)
                        {
                            contractType = "确认书";
                        }
                        //修改销售提成的状态
                        new SalesCommissionDataService(this).SetCommissionVaild(trade.id);
                        new TradeContractGenerateService(this).GenerateContractsAsync(new List<int> { req.tradeId }, contractType);
                    }
                }
            }
            return tradeResult;
        }

        /// <summary>
        /// 接口审批自动关联系统记录
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public bool ApprovalResult(ApprovalResult obj, out string message)
        {
            var optStatus = true;
            var useSave = true;
            try
            {
                switch (obj.type)
                {
                    case 1://交易审批状态变更
                        var tradeInfo = base.DbContext.trade.Where(O => O.TradeNumber == obj.code).FirstOrDefault();
                        if (tradeInfo == null || tradeInfo.id <= 0)
                        {
                            throw new ServiceException("未查询到匹配的编号,请确保交易编号正确");
                        }
                        if (tradeInfo.TradeStatus != ConsTrade.审批中 && tradeInfo.TradeStatus != ConsTrade.行权待复核 && tradeInfo.TradeStatus != ConsTrade.平仓待复核 && tradeInfo.TradeStatus != ConsTrade.互换待复核)
                        {
                            throw new ServiceException($"当前交易状态为:{tradeInfo.TradeStatus},不可操作");
                        }
                        var tradeResult = TradeApproval(new TradeOpenReqModel
                        {
                            tradeId = tradeInfo.id,
                            status = obj.status ? "pass" : "reject",
                            comments = "",
                            ignoreMoneyCheck = false,
                        });
                        if ((tradeResult.RetCode == TradeOpenRetCode.None && string.IsNullOrWhiteSpace(tradeResult.ErrorMsg)) || tradeResult.RetCode == TradeOpenRetCode.Success)
                        {
                            message = "操作成功";
                            //记录审核日志
                            DbContext.TradeAuditLog.Add(new TradeAuditLog
                            {
                                TradeId = tradeInfo.id,
                                Changes = $"历史备注:{tradeInfo.Comments}",
                                DataType = "00",
                                OptId = UserId,
                                OptName = UserName,
                                OptDate = OptDate,
                                OptType = "关联审批",
                                AuditFlag = TradeAuditFlag.operation
                            });
                            tradeInfo.Comments = obj.remark;
                            return optStatus;
                        }
                        throw new ServiceException(tradeResult.ErrorMsg);
                    case 2://客户审批状态变更
                        using (var db = DbContextFactory.GetClientDbContext(UserInfo))
                        {
                            var clientInfo = db.client.Where(O => O.Name == obj.code).FirstOrDefault();
                            if (clientInfo == null)
                            {
                                throw new ServiceException("未查询到匹配的客户,请确保客户名称正确");
                            }
                            if (clientInfo.ApprovalStatus != "审批中")
                            {
                                throw new ServiceException($"当前客户状态为:{clientInfo.ProcessStatus},审批状态为：{clientInfo.ApprovalStatus}不可操作");
                            }
                            var msg = new ClientProcessLogService(UserInfo).UpdateProcessLog(clientInfo.id, obj.status ? "pass" : "reject", "");
                            if (msg?.Trim() != "提交成功")
                            {
                                throw new ServiceException(msg);
                            }
                            message = "操作成功";
                            //记录审核日志
                            db.ClientAuditLog.Add(new ClientAuditLog
                            {
                                ClientId = clientInfo.id,
                                Changes = $"历史备注:{clientInfo.Remark}",
                                OptId = UserId,
                                OptName = UserName,
                                OptDate = OptDate,
                                DataType = "00",
                                OptType = "关联审批"
                            });
                            clientInfo.Remark = obj.remark;
                            db.SaveChanges();
                            return optStatus;

                        }
                    case 3://资金审批状态变更
                        var cashInfo = DbContext.ClientCashInCashOut.Where(e => e.ValidState != "InValid" && e.Number == obj.code).FirstOrDefault();
                        if (cashInfo == null)
                        {
                            throw new ServiceException("未查询到匹配的资金记录,请确保资金编号正确");
                        }
                        if (cashInfo.State != "未确认")
                        {
                            throw new ServiceException($"当前资金状态为:{cashInfo.State},不可操作");
                        }
                        executeCashApproval(cashInfo, obj.status);
                        DbContext.clientcash_log.Add(new ClientCashLog
                        {
                            CashId = cashInfo.id,
                            OptType = "关联审批",
                            Changes = $"历史备注:{cashInfo.Comments}",
                            OptId = UserId,
                            OptName = UserName,
                            OptDate = DateTime.Now,
                        });
                        cashInfo.Comments = obj.remark;
                        message = "操作成功";
                        return optStatus;
                    default:
                        useSave = false;
                        throw new ServiceException("未知操作类型");
                }
            }
            catch (Exception ex)
            {
                optStatus = false;
                obj.errorMsg = ex.Message.Length > 200 ? ex.Message.Substring(0, 200) : ex.Message;
                message = useSave ? "信息已接收" : ex.Message;
                return optStatus;
            }
            finally
            {
                if (useSave)
                {
                    obj.LinkCode = optStatus ? obj.code : "";
                    obj.errorMsg = obj.errorMsg ?? "";
                    obj.OptDate = DateTime.Now;
                    obj.OptId = UserInfo.UserId;
                    obj.OptName = UserInfo.UserName;
                    DbContext.ApprovalResult.Add(obj);
                    DbContext.SaveChanges();
                }
            }
        }

        /// <summary>
        /// 接口审批手动关联系统记录
        /// </summary>
        /// <param name="approvalResultId">接口审批记录Id</param>
        /// <param name="code">要关联的系统记录代码</param>
        /// <returns></returns>
        public TradeCheckResult ApprovalResult(int approvalResultId, string code, string additionalProcessing)
        {
            TradeCheckResult result = null;
            var approvalInfo = DbContext.ApprovalResult.Where(O => O.id == approvalResultId).FirstOrDefault();
            if (approvalInfo == null)
            {
                throw new ServiceException("审批记录不存在,请刷新后重试");
            }
            switch (approvalInfo.type)
            {
                case 1:
                    result = TradeApproval(approvalInfo, code, additionalProcessing);
                    break;
                case 2:
                    result = ClientApproval(approvalInfo, code);
                    break;
                case 3:
                    result = CashApproval(approvalInfo, code);
                    break;
                default:
                    result = new TradeCheckResult() { success = false, message = "未知操作类型" };
                    break;
            }
            return result;
        }

        /// <summary>
        /// 交易审批状态
        /// </summary>
        /// <param name="approvalInfo">接口审批信息</param>
        /// <param name="code">要关联的系统记录代码</param>
        /// <returns></returns>
        private TradeCheckResult TradeApproval(ApprovalResult approvalInfo, string code, string additionalProcessing)
        {
            TradeCheckResult result = null;
            var trade = DbContext.trade.Where(O => O.TradeNumber == code).FirstOrDefault();
            if (trade == null)
            {
                throw new ServiceException("未查询到匹配的交易记录,请确保交易编号正确");
            }
            try
            {
                if (trade.TradeStatus == ConsTrade.审批中 || trade.TradeStatus == ConsTrade.行权待复核 || trade.TradeStatus == ConsTrade.平仓待复核 || trade.TradeStatus == ConsTrade.互换待复核)
                {
                    var tradeResult = TradeApproval(new TradeOpenReqModel
                    {
                        tradeId = trade.id,
                        status = approvalInfo.status ? "pass" : "reject",
                        comments = "",
                        ignoreMoneyCheck = additionalProcessing == tradeBLL.LackOfMoney,
                    });
                    //如果客户缺少资金而交易特批已开启
                    if (tradeResult.RetCode == TradeOpenRetCode.LackOfMoney && (valuedateBLL.SystemDate.SpecialOperateForTrade == 1))
                    {
                        result = new TradeCheckResult() { proccessType = "AdditionalProcessing", type = tradeBLL.LackOfMoney, message = tradeResult.ErrorMsg, success = false };
                    }
                    else if ((tradeResult.RetCode == TradeOpenRetCode.None && string.IsNullOrWhiteSpace(tradeResult.ErrorMsg)) || tradeResult.RetCode == TradeOpenRetCode.Success)
                    {
                        result = new TradeCheckResult() { success = true };
                    }
                    else
                    {
                        result = new TradeCheckResult() { success = false, message = tradeResult.ErrorMsg };
                    }
                }
                else
                {
                    result = new TradeCheckResult() { success = true };
                }
            }
            finally
            {
                if (result.success)
                {
                    //记录审核日志
                    DbContext.TradeAuditLog.Add(new TradeAuditLog
                    {
                        TradeId = trade.id,
                        Changes = $"历史备注:{trade.Comments}",
                        DataType = "00",
                        OptId = UserId,
                        OptName = UserName,
                        OptDate = OptDate,
                        OptType = "关联审批",
                        AuditFlag = TradeAuditFlag.operation
                    });
                    approvalInfo.LinkCode = code;
                    trade.Comments = approvalInfo.remark;
                    DbContext.SaveChanges();
                }
            }
            return result;
        }

        /// <summary>
        /// 客户审批状态
        /// </summary>
        /// <param name="approvalInfo">接口审批信息</param>
        /// <param name="code">要关联的系统记录代码</param>
        /// <returns></returns>
        private TradeCheckResult ClientApproval(ApprovalResult approvalInfo, string code)
        {
            TradeCheckResult result = null;
            try
            {

                using (var db = DbContextFactory.GetClientDbContext(UserInfo))
                {
                    var clientInfo = db.client.Where(O => O.Name == code).FirstOrDefault();
                    if (clientInfo == null)
                    {
                        throw new ServiceException("未查询到匹配的客户,请确保客户名称正确");
                    }
                    if (clientInfo.ApprovalStatus == "审批中")
                    {
                        var msg = new ClientProcessLogService(UserInfo).UpdateProcessLog(clientInfo.id, approvalInfo.status ? "pass" : "reject", "");
                        result = new TradeCheckResult { success = msg?.Trim() == "提交成功", message = msg };
                        if (!result.success)
                        {
                            throw new ServiceException(msg);
                        }
                    }
                    else
                    {
                        result = new TradeCheckResult() { success = true };
                        //记录审核日志
                        db.ClientAuditLog.Add(new ClientAuditLog
                        {
                            ClientId = clientInfo.id,
                            Changes = $"历史备注:{clientInfo.Remark}",
                            OptId = UserId,
                            OptName = UserName,
                            OptDate = OptDate,
                            DataType = "00",
                            OptType = "关联审批"
                        });
                    }
                    approvalInfo.LinkCode = code;
                    clientInfo.Remark = approvalInfo.remark;
                    db.SaveChanges();
                    DbContext.SaveChanges();
                }
            }
            catch (Exception ex)
            {
                result = new TradeCheckResult() { success = false, message = ex.Message };
            }
            return result;
        }

        /// <summary>
        /// 资金审批状态
        /// </summary>
        /// <param name="approvalInfo">接口审批信息</param>
        /// <param name="code">要关联的系统记录代码</param>
        /// <returns></returns>
        private TradeCheckResult CashApproval(ApprovalResult approvalInfo, string code)
        {
            TradeCheckResult result = null;
            try
            {
                var cashInfo = DbContext.ClientCashInCashOut.Where(e => e.ValidState != "InValid" && e.Number == code).FirstOrDefault();
                if (cashInfo == null)
                {
                    throw new ServiceException("未查询到匹配的资金记录,请确保资金编号正确");
                }
                if (cashInfo.State == "未确认")
                {
                    executeCashApproval(cashInfo, approvalInfo.status);
                }
                DbContext.clientcash_log.Add(new ClientCashLog
                {
                    CashId = cashInfo.id,
                    OptType = "关联审批",
                    Changes = $"历史备注:{cashInfo.Comments}",
                    OptId = UserId,
                    OptName = UserName,
                    OptDate = DateTime.Now,
                });
                cashInfo.Comments = approvalInfo.remark;
                approvalInfo.LinkCode = code;
                DbContext.SaveChanges();
                result = new TradeCheckResult() { success = true };
            }
            catch (Exception ex)
            {
                result = new TradeCheckResult() { success = false, message = ex.Message };
            }
            return result;
        }

        private void executeCashApproval(ClientCashInCashOut cashInfo, bool status)
        {
            var service = new ClientCashInCashOutDataService(UserInfo);
            var ids = new[] { cashInfo.id };
            if (status)
            {
                service.ExcuteEntryExit(ids,null);
                if (cashInfo.Action == ClientCashInCashOut.人工操作_其他)
                {
                    var tradeBuySell = DbContext.trade.Where(O => O.id == cashInfo.TradeId).Select(O => O.BuySell).FirstOrDefault();
                    var tc = new trade_cash
                    {
                        ValidState = "Valid",
                        Status = TradeCashStatusEnum.已执行,
                        ValueDate = cashInfo.HappenDate.Value,
                        TradeId = cashInfo.TradeId ?? 0,
                        TradeType = tradeBuySell,
                        ExceciseType = "现金",
                        Amount = cashInfo.Money.Value * -1,
                        HappenedDate = cashInfo.HappenDate,
                        OptId = UserId,
                        OptName = UserName,
                        OptDate = DateTime.Now,
                        Action = ClientCashInCashOut.人工操作_其他
                    };
                    DbContext.trade_cash.Add(tc);

                    //记录审核日志
                    DbContext.TradeAuditLog.Add(new TradeAuditLog
                    {
                        TradeId = cashInfo.TradeId ?? 0,
                        DataType = "00",
                        OptId = UserId,
                        OptName = UserName,
                        OptDate = OptDate,
                        OptType = "关联审批",
                        AuditFlag = TradeAuditFlag.operation
                    });
                }
            }
            else
            {
                var msg = service.ClientCashInCashOutReject(ids).ToString();
                if (msg.Contains("拒绝失败"))
                {
                    throw new ServiceException($"{msg}");
                }
            }
        }
    }
}