using DS.Module.Core;
using DS.Module.Core.Extensions;
using DS.WMS.Core.Code.Entity;
using DS.WMS.Core.Fee.Dtos;
using DS.WMS.Core.Fee.Entity;
using DS.WMS.Core.Fee.Interface;
using DS.WMS.Core.Flow.Dtos;
using DS.WMS.Core.Flow.Entity;
using DS.WMS.Core.Flow.Interface;
using DS.WMS.Core.Info.Entity;
using DS.WMS.Core.Op.Entity;
using DS.WMS.Core.Sys.Entity;
using Mapster;
using Microsoft.Extensions.DependencyInjection;
using SqlSugar;

namespace DS.WMS.Core.Fee.Method
{
    /// <summary>
    /// 费用审核
    /// </summary>
    public class FeeAuditService : FeeServiceBase, IFeeAuditService
    {
        const string Audit_Only = "AuditOnly=1";

        /// <summary>
        /// 待审核的状态值
        /// </summary>
        public static readonly FeeStatus[] AuditStatusArray = [FeeStatus.AuditSubmitted, FeeStatus.ApplyDeletion, FeeStatus.ApplyModification];

        //一键审核支持的类型
        static readonly string[] AuditTypes = [AuditType.FeeAudit.ToString(), AuditType.FeeModify.ToString(), AuditType.FeeDelete.ToString()];

        readonly IClientFlowInstanceService flowService;
        readonly IFeeRecordService feeService;

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="serviceProvider"></param>
        public FeeAuditService(IServiceProvider serviceProvider) : base(serviceProvider)
        {
            flowService = serviceProvider.GetRequiredService<IClientFlowInstanceService>();
            feeService = serviceProvider.GetRequiredService<IFeeRecordService>();
        }

        /// <summary>
        /// 获取费用审核列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<DataResult<List<FeeAuditBusiness>>> GetListAsync(PageRequest request)
        {
            List<FlowInstance> flowList = null;
            if (string.Equals(request.OtherQueryCondition, Audit_Only))
            {
                flowList = await GetCurrentFlowsQuery(AuditTypes).ToListAsync();

                //没有待审批的列表直接返回不再执行后续查询
                if (flowList.Count == 0)
                    DataResult<List<FeeAuditBusiness>>.PageList(0, null, MultiLanguageConst.DataQuerySuccess);
            }

            var queryList = CreateQuery(flowList);

            if (!request.QueryCondition.IsNullOrEmpty())
            {
                var whereList = Db.ConfigQuery.Context.Utilities.JsonToConditionalModels(request.QueryCondition);
                queryList = queryList.Where(whereList);
            }

            var result = await queryList.Select<FeeAuditBusiness>().ToQueryPageAsync(request.PageCondition);
            if (result.Data.Count > 0)
            {
                //关联用户名称
                var userIds = result.Data.Where(x => x.OperatorId.HasValue).Select(x => x.OperatorId.Value)
                    .Union(result.Data.Select(x => x.CreateBy))
                    .Distinct();
                var Users = await Db.Queryable<SysUser>().Where(x => userIds.Contains(x.Id)).Select(x => new { x.Id, x.UserName }).ToListAsync();
                foreach (var item in result.Data)
                {
                    item.CreateByName = Users.Find(x => x.Id == item.CreateBy)?.UserName;

                    if (item.OperatorId.HasValue)
                    {
                        item.Operator = Users.Find(x => x.Id == item.OperatorId.Value)?.UserName;
                    }
                }
            }

            return result;
        }

        //创建各项费用数据的查询并集
        internal ISugarQueryable<FeeAuditBusinessQuery> CreateQuery(List<FlowInstance>? additions)
        {
            //海运出口
            var ids1 = additions?.Where(x => x.BusinessType == BusinessType.OceanShippingExport).Select(x => x.BusinessId).ToArray();
            var query1 = TenantDb.Queryable<SeaExport, BusinessFeeStatus, FeeRecord, CodeSource, CodeSourceDetail>((s, b, f, cs, csd) => new JoinQueryInfos(
                JoinType.Left, s.Id == b.BusinessId && b.BusinessType == BusinessType.OceanShippingExport,
                JoinType.Inner, s.Id == f.BusinessId && f.BusinessType == BusinessType.OceanShippingExport && AuditStatusArray.Contains(f.FeeStatus),
                JoinType.Left, s.SourceId == cs.Id,
                JoinType.Left, s.SourceDetailId == csd.Id
                ))
                .WhereIF(ids1 != null && ids1.Length > 0, (s, b, f) => ids1.Contains(f.Id))
                .GroupBy(s => s.Id)
                .Select((s, b, f, cs, csd) => new FeeAuditBusinessQuery
                {
                    Id = s.Id,
                    AccountDate = s.AccountDate,
                    APFeeStatus = b.APFeeStatus,
                    ARFeeStatus = b.ARFeeStatus,
                    BusinessType = BusinessType.OceanShippingExport,
                    BusinessStatus = s.BusinessStatusName,
                    BusinessDate = s.BusinessDate,//业务日期
                    BLType = s.BLType,
                    CargoId = s.CargoId,
                    Carrier = s.Carrier,
                    AgencyId = s.AgentId,
                    CBM = s.CBM,
                    CntrTotal = s.CntrTotal,
                    ContractNo = s.ContractNo,
                    CreateBy = s.CreateBy,
                    CustomerId = s.CustomerId,
                    CustomerName = s.CustomerName,//委托单位
                    CustomerNo = s.CustomerNo,
                    CustomerService = s.CustomerService,
                    CustomNo = s.CustomNo,
                    CustomsNum = s.CustomsNum,
                    DangerClass = s.DangerClass,
                    Destination = s.Destination,
                    DischargePort = s.DischargePort,
                    Doc = s.Doc,
                    ETD = s.ETD,
                    Forwarder = s.Forwarder,
                    FeeId = f.FeeId,
                    FeeCustomerId = f.CustomerId,
                    FeeCustomerName = f.CustomerName,
                    GoodsName = s.GoodsName,
                    HBLNO = s.HBLNO,
                    InvoiceNo = s.InvoiceNo,
                    IsBusinessLocking = b.IsBusinessLocking,
                    IsFeeLocking = b.IsFeeLocking,
                    IssueType = s.IssueType,
                    KGS = s.KGS,
                    LoadPort = s.LoadPort,
                    MBLFrt = s.MBLFrt,
                    MBLNO = s.MBLNO,
                    Note = s.Note,
                    OperatorId = s.OperatorId,
                    OrderNo = s.OrderNo,
                    PKGS = s.PKGS,
                    ReceiptPlace = s.ReceiptPlace,
                    Remark = s.Remark,
                    SaleDeptId = s.SaleDeptId,
                    //SaleDeptName //所属部门
                    SaleId = s.SaleId,
                    SaleName = s.Sale,//揽货人
                    SourceId = s.SourceId,
                    SourceName = cs.SourceName,
                    SourceDetailId = s.SourceDetailId,
                    DetailName = csd.DetailName,
                    TradeTerm = s.TradeTerm,
                    TransitTerms = s.Service,//运输条款
                    Vessel = s.Vessel,//船名
                    Voyage = s.Voyno,//航次
                    Yard = s.Yard
                    //BusinessUnit = //经营单位
                    //ChangeOrder //更改单
                    //ChangeReason //更改单更改原因
                    //FreightRatio //运杂费比例
                    //查询：运输类型 (枚举值，暂未建立)
                    //查询：是否费用提交
                    //查询：利润减少
                });

            //海运进口
            //var ids2 = additions?.Where(x => x.BusinessType == BusinessType.OceanShippingImport).Select(x => x.BusinessId).ToArray();

            return TenantDb.UnionAll(new List<ISugarQueryable<FeeAuditBusinessQuery>> { query1 });
        }

        /// <summary>
        /// 获取整票审核列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<DataResult<List<FeeAuditBusiness>>> GetBizListAsync(PageRequest request)
        {
            List<FlowInstance> flowList = null;
            if (string.Equals(request.OtherQueryCondition, Audit_Only))
            {
                flowList = await GetCurrentFlowsQuery([AuditType.FeeBusiness.ToString()]).ToListAsync();

                //没有待审批的列表直接返回不再执行后续查询
                if (flowList.Count == 0)
                    DataResult<List<FeeAuditBusiness>>.PageList(0, null, MultiLanguageConst.DataQuerySuccess);
            }

            var queryList = CreateBizQuery(flowList);

            if (!request.QueryCondition.IsNullOrEmpty())
            {
                var whereList = Db.ConfigQuery.Context.Utilities.JsonToConditionalModels(request.QueryCondition);
                queryList = queryList.Where(whereList);
            }

            var result = await queryList.Select<FeeAuditBusiness>().ToQueryPageAsync(request.PageCondition);
            if (result.Data.Count > 0)
            {
                //关联用户名称
                var UserIds = result.Data.Where(x => x.OperatorId.HasValue).Select(x => x.OperatorId.Value)
                    .Union(result.Data.Select(x => x.CreateBy))
                    .Distinct();
                var Users = await Db.Queryable<SysUser>().Where(x => UserIds.Contains(x.Id)).Select(x => new { x.Id, x.UserName }).ToListAsync();
                foreach (var item in result.Data)
                {
                    item.CreateByName = Users.Find(x => x.Id == item.CreateBy)?.UserName;

                    if (item.OperatorId.HasValue)
                    {
                        item.Operator = Users.Find(x => x.Id == item.OperatorId.Value)?.UserName;
                    }
                }
            }

            return result;
        }

        //创建各项业务数据的查询并集
        internal ISugarQueryable<FeeAuditBusinessQuery> CreateBizQuery(List<FlowInstance>? additions)
        {
            //海运出口
            var ids1 = additions?.Where(x => x.BusinessType == BusinessType.OceanShippingExport).Select(x => x.BusinessId).ToArray();
            var query1 = TenantDb.Queryable<SeaExport, BusinessFeeStatus, FeeRecord, CodeSource, CodeSourceDetail>((s, b, f, cs, csd) => new JoinQueryInfos(
                JoinType.Left, s.Id == b.BusinessId && b.BusinessType == BusinessType.OceanShippingExport,
                JoinType.Inner, s.Id == f.BusinessId && f.BusinessType == BusinessType.OceanShippingExport && AuditStatusArray.Contains(f.FeeStatus),
                JoinType.Left, s.SourceId == cs.Id,
                JoinType.Left, s.SourceDetailId == csd.Id
                ))
                .WhereIF(ids1 != null && ids1.Length > 0, (s, b) => ids1.Contains(s.Id))
                .GroupBy(s => s.Id)
                .Select((s, b, f, cs, csd) => new FeeAuditBusinessQuery
                {
                    Id = s.Id,
                    AccountDate = s.AccountDate,
                    APFeeStatus = b.APFeeStatus,
                    ARFeeStatus = b.ARFeeStatus,
                    BusinessType = BusinessType.OceanShippingExport,
                    BusinessStatus = s.BusinessStatusName,
                    BusinessDate = s.BusinessDate,//业务日期
                    BLType = s.BLType,
                    CargoId = s.CargoId,
                    Carrier = s.Carrier,
                    AgencyId = s.AgentId,
                    CBM = s.CBM,
                    CntrTotal = s.CntrTotal,
                    ContractNo = s.ContractNo,
                    CreateBy = s.CreateBy,
                    CustomerId = s.CustomerId,
                    CustomerName = s.CustomerName,//委托单位
                    CustomerNo = s.CustomerNo,
                    CustomerService = s.CustomerService,
                    CustomNo = s.CustomNo,
                    CustomsNum = s.CustomsNum,
                    DangerClass = s.DangerClass,
                    Destination = s.Destination,
                    DischargePort = s.DischargePort,
                    Doc = s.Doc,
                    ETD = s.ETD,
                    Forwarder = s.Forwarder,
                    FeeId = f.FeeId,
                    FeeCustomerId = f.CustomerId,
                    FeeCustomerName = f.CustomerName,
                    GoodsName = s.GoodsName,
                    HBLNO = s.HBLNO,
                    InvoiceNo = s.InvoiceNo,
                    IsBusinessLocking = b.IsBusinessLocking,
                    IsFeeLocking = b.IsFeeLocking,
                    IssueType = s.IssueType,
                    KGS = s.KGS,
                    LoadPort = s.LoadPort,
                    MBLFrt = s.MBLFrt,
                    MBLNO = s.MBLNO,
                    Note = s.Note,
                    OperatorId = s.OperatorId,
                    OrderNo = s.OrderNo,
                    PKGS = s.PKGS,
                    ReceiptPlace = s.ReceiptPlace,
                    Remark = s.Remark,
                    SaleDeptId = s.SaleDeptId,
                    //SaleDeptName //所属部门
                    SaleId = s.SaleId,
                    SaleName = s.Sale,//揽货人
                    SourceId = s.SourceId,
                    SourceName = cs.SourceName,
                    SourceDetailId = s.SourceDetailId,
                    DetailName = csd.DetailName,
                    TradeTerm = s.TradeTerm,
                    TransitTerms = s.Service,//运输条款
                    Vessel = s.Vessel,//船名
                    Voyage = s.Voyno,//航次
                    Yard = s.Yard
                    //BusinessUnit = //经营单位
                    //ChangeOrder //更改单
                    //ChangeReason //更改单更改原因
                    //FreightRatio //运杂费比例
                    //查询：运输类型 (枚举值，暂未建立)
                    //查询：是否费用提交
                    //查询：利润减少
                });

            //海运进口


            return TenantDb.UnionAll(new List<ISugarQueryable<FeeAuditBusinessQuery>> { query1 });
        }

        /// <summary>
        /// 根据查询条件获取费用明细
        /// </summary>
        /// <param name="id">业务ID</param>
        /// <param name="businessType">业务类型</param>
        /// <param name="query"></param>
        /// <returns></returns>
        public async Task<DataResult<List<FeeAuditItem>>> GetFeesAsync(long id, BusinessType businessType, string query)
        {
            var query1 = TenantDb.Queryable<FeeRecord>().Where(f => f.BusinessId == id &&
                f.BusinessType == businessType && AuditStatusArray.Contains(f.FeeStatus))
                .InnerJoin<SeaExport>((f, s) => f.BusinessId == s.Id)
                .LeftJoin<InfoClient>((f, s, i) => f.CustomerId == i.Id)
                .Select((f, s, i) => new FeeAuditItemQuery
                {
                    Id = f.Id,
                    BusinessId = f.BusinessId,
                    BusinessType = f.BusinessType,
                    FeeStatus = f.FeeStatus,
                    FeeType = f.FeeType,
                    FeeId = f.FeeId,
                    FeeName = f.FeeName,
                    FeeEnName = f.FeeEnName,
                    FeeCustomerId = f.CustomerId,
                    CustomerName = s.CustomerName,
                    CustomerFullName = i.Description, //结算对象全称
                    CustomerType = f.CustomerType,
                    CustomerTypeText = f.CustomerTypeText,
                    Unit = f.Unit,
                    UnitText = f.UnitText,
                    UnitPrice = f.UnitPrice,
                    TaxUnitPrice = f.TaxUnitPrice,
                    Quantity = f.Quantity,
                    TaxRate = f.TaxRate,
                    NoTaxAmount = f.NoTaxAmount,
                    Amount = f.Amount,
                    Currency = f.Currency,
                    CurrencyText = f.CurrencyText,
                    ExchangeRate = f.ExchangeRate,
                    AccTaxRate = f.AccTaxRate,//销项汇率
                    Remark = f.Remark,
                    IsAdvancedPay = f.IsAdvancedPay,//是否垫付
                    IsInvoice = f.IsInvoice, //是否开发票
                    //FRT
                    CommissionRate = f.CommissionRate, //佣金比率
                    CreateBy = f.CreateBy,
                    CreateTime = f.CreateTime,
                    SettlementAmount = f.SettlementAmount,//结算金额
                    InvoiceAmount = f.InvoiceAmount,//开票金额
                    OrderAmount = f.OrderAmount,//申请金额
                    InvoiceNum = f.InvoiceNum,//发票号
                    Tax = f.Tax,//税额
                    DebitNo = f.DebitNo,//对账编号
                    SaleOrg = f.SaleOrg,
                    Reason = f.Reason,

                    CustomerNo = s.CustomerNo,
                    Vessel = s.Vessel,
                    Voyage = s.Voyno,
                    SaleId = s.SaleId,
                    CustomerId = s.CustomerId,
                    BusinessDate = s.BusinessDate,
                    SourceId = s.SourceId,
                    AccountDate = s.AccountDate,
                    OperatorId = s.OperatorId
                });

            var queryList = TenantDb.UnionAll(new List<ISugarQueryable<FeeAuditItemQuery>> { query1 });

            if (!query.IsNullOrEmpty())
            {
                var whereList = Db.ConfigQuery.Context.Utilities.JsonToConditionalModels(query);
                queryList = queryList.Where(whereList);
            }
            var list = await queryList.Select<FeeAuditItem>().ToListAsync();

            if (list.Count > 0)
            {
                //关联用户名称
                var UserIds = list.Select(x => x.CreateBy).Distinct();
                var Users = Db.Queryable<SysUser>().Where(x => UserIds.Contains(x.Id)).Select(x => new { x.Id, x.UserName }).ToList();
                foreach (var item in list)
                {
                    item.CreateByName = Users.Find(x => x.Id == item.CreateBy)?.UserName;
                }
            }

            var result = DataResult<List<FeeAuditItem>>.Success(list);
            result.Count = list.Count;
            return result;
        }

        /// <summary>
        /// 按费用批量审核
        /// </summary>
        /// <param name="yesOrNo">审批结果：1=通过，2=驳回</param>
        /// <param name="remark">备注</param>
        /// <param name="idArray">待审批的费用ID</param>
        /// <returns></returns>
        public async Task<DataResult> AuditAsync(int yesOrNo, string remark, params long[] idArray)
        {
            var fees = await TenantDb.Queryable<FeeRecord>().Where(x => idArray.Contains(x.Id)).Select(x => new
            {
                x.Id,
                x.FeeName,
                x.FeeStatus,
                x.FlowId
            }).ToListAsync();

            if (fees.Count == 0)
                return DataResult.Failed("未能获取费用信息");

            if (fees.Exists(x => !x.FlowId.HasValue))
                return DataResult.Failed("提交数据中包含不在审批流程中的费用");

            if (fees.Exists(x => !AuditStatusArray.Contains(x.FeeStatus)))
                return DataResult.Failed("提交数据中包含不在待审批状态的费用");

            var flowIds = fees.Select(x => x.FlowId.GetValueOrDefault());
            var flows = await Db.Queryable<FlowInstance>().Where(x => flowIds.Contains(x.Id)).ToListAsync();
            if (flows.Count == 0)
                return DataResult.Failed("未能获取审批工作流");

            if (flows.Exists(x => !x.MakerList.Contains(User.UserId)))
                return DataResult.Failed("所选费用包含不属于当前用户权限范围内的审批，禁止提交");

            List<string> list = [];
            foreach (var fee in fees)
            {
                var flow = flows.Find(x => x.Id == fee.FlowId.Value);
                if (flow == null)
                {
                    continue;
                }

                var result = flowService.AuditFlowInstance(new FlowAuditInfo
                {
                    Instance = flow,
                    Status = yesOrNo,
                    AuditNote = remark
                });

                if (!result.Succeeded)
                {
                    list.Add(fee.FeeName);
                }
            }

            if (list.Count > 0)
                return DataResult.Failed($"部分费用审批失败：{string.Join("、", list)}");

            return DataResult.Success;
        }

        /// <summary>
        /// 本票审核（一键审核当前登录用户的所有待审核项）
        /// </summary>
        /// <param name="yesOrNo">审批结果：1=通过，2=驳回</param>
        /// <param name="remark">备注</param>
        /// <returns></returns>
        public async Task<DataResult> AuditAsync(int yesOrNo, string remark)
        {
            var recordIds = await GetCurrentFlowsQuery(AuditTypes).Select(x => x.BusinessId).ToArrayAsync();
            //没有待审批的列表直接返回不再执行后续查询
            if (recordIds.Length == 0)
                return DataResult.Failed("当前暂无待审批的费用");

            return await AuditAsync(yesOrNo, remark, recordIds);
        }

        /// <summary>
        /// 按业务批量审核
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<DataResult> AuditAsync(BizAuditRequest request)
        {
            var flowList = await GetCurrentFlowsQuery(AuditTypes).ToListAsync();
            var query = CreateQuery(flowList);

            if (!request.QueryCondition.IsNullOrEmpty())
            {
                var whereList = Db.ConfigQuery.Context.Utilities.JsonToConditionalModels(request.QueryCondition);
                query = query.Where(whereList);
            }

            var bizList = await query.Select(x => new BizAuditItem { Id = x.Id, BusinessType = x.BusinessType }).ToArrayAsync();
            //取所选业务与过滤条件所产生的并集
            var intersects = request.Items.Intersect(bizList);
            if (!intersects.Any())
                return DataResult.Failed("暂无符合当前查询条件的待审批费用");

            var list1 = intersects.Select(x => x.Id).ToList();
            var list2 = intersects.Select(x => x.BusinessType).Distinct().ToList();

            var recordIds = await TenantDb.Queryable<FeeRecord>().Where(x =>
                list1.Contains(x.BusinessId) && list2.Contains(x.BusinessType) && AuditStatusArray.Contains(x.FeeStatus))
                .Select(x => x.Id).ToArrayAsync();

            //没有待审批的列表直接返回不再执行后续查询
            if (recordIds.Length == 0)
                return DataResult.Failed("暂无符合当前查询条件的待审批费用");

            return await AuditAsync(request.Result, request.Remark, recordIds);
        }

        /// <summary>
        /// 整单审核
        /// </summary>
        /// <param name="request">审批请求</param>
        /// <returns></returns>
        public async Task<DataResult> AuditBusinessAsync(BizAuditRequest request)
        {
            var gpList = request.Items.GroupBy(x => x.BusinessType).ToList();
            foreach (var gp in gpList)
            {
                var bIdArr = gp.Select(x => x.Id).ToArray();
                var bizList = await TenantDb.Queryable<BusinessFeeStatus>().Where(x => bIdArr.Contains(x.BusinessId) && x.BusinessType == gp.Key)
                .Select(x => new
                {
                    x.Id,
                    x.BillAuditStatus,
                    x.FlowId
                }).ToListAsync();

                if (bizList.Count == 0)
                    return DataResult.Failed("未能获取业务信息");

                if (!bizList.Any(x => x.FlowId.HasValue))
                    return DataResult.Failed("业务未处于审批流程中");

                if (bizList.Any(x => x.BillAuditStatus != BillAuditStatus.AuditSubmitted))
                    return DataResult.Failed("业务的审批状态不正确");

                var fIdArr = bizList.Select(x => x.FlowId).ToArray();
                string auditType = AuditType.FeeBusiness.ToString();
                var flows = await Db.Queryable<FlowInstance>().Where(x => fIdArr.Contains(x.Id) && x.AuditType == auditType).ToListAsync();

                if (flows.Count == 0)
                    return DataResult.Failed("未能获取审批工作流");

                if (flows.Any(x => !x.MakerList.Contains(User.UserId)))
                    continue;

                foreach (var flow in flows)
                {
                    var result = flowService.AuditFlowInstance(new FlowAuditInfo
                    {
                        Instance = flow,
                        Status = request.Result,
                        AuditNote = request.Remark
                    });

                    if (!result.Succeeded)
                    {
                        //todo:记录未能成功审核的数据
                    }
                }

            }

            return DataResult.Success;
        }

        /// <summary>
        /// 设置业务费用锁定状态
        /// </summary>
        /// <param name="items">业务信息</param>
        /// <returns></returns>
        public async Task<DataResult> SetFeeLockingAsync(IEnumerable<BusinessFeeStatus> items)
        {
            int rows = await TenantDb.Updateable<BusinessFeeStatus>(items)
                .WhereColumns(x => new { x.BusinessId, x.BusinessType })
                .UpdateColumns(x => new { x.IsFeeLocking })
                .ExecuteCommandAsync();

            return rows > 0 ? DataResult.Success : DataResult.Failed("更新失败");
        }

        /// <summary>
        /// 根据审批结果更新审批状态
        /// </summary>
        /// <param name="callback">回调信息</param>
        /// <returns></returns>
        public async Task<DataResult> UpdateStatusAsync(FlowCallback callback)
        {
            var auditType = callback.AuditType.ToEnum<AuditType>();
            FeeRecord fee = null;
            BusinessFeeStatus biz = null;
            if (auditType == AuditType.FeeBusiness)
            {
                biz = await TenantDb.Queryable<BusinessFeeStatus>().Where(x => x.Id == callback.BusinessId && x.BusinessType == callback.BusinessType)
                    .Select(x => new BusinessFeeStatus
                    {
                        Id = x.Id,
                        BusinessId = x.BusinessId,
                        BillAuditStatus = x.BillAuditStatus
                    }).FirstAsync();
                if (biz == null)
                    return DataResult.Failed("未能找到业务信息，更新状态失败", MultiLanguageConst.Operation_Failed);
            }
            else
            {
                fee = await TenantDb.Queryable<FeeRecord>().Where(x => x.Id == callback.BusinessId && x.BusinessType == callback.BusinessType).Select(
                x => new FeeRecord { Id = x.Id, FeeStatus = x.FeeStatus }).FirstAsync();
                if (fee == null)
                    return DataResult.Failed("未能找到费用记录，更新状态失败", MultiLanguageConst.Operation_Failed);

                fee.Reason = callback.RejectReason;
            }

            long UserId = long.Parse(User.UserId);
            DateTime dtNow = DateTime.Now;
            await TenantDb.Ado.BeginTranAsync();
            try
            {
                switch (auditType)
                {
                    case AuditType.FeeAudit:
                        fee.AuditBy = UserId;
                        fee.AuditOperator = User.UserName;
                        fee.AuditDate = dtNow;

                        if (callback.FlowStatus == FlowStatusEnum.Approve)
                        {
                            fee.FeeStatus = FeeStatus.AuditPassed;
                            fee.Reason = string.Empty;
                        }
                        else if (callback.FlowStatus == FlowStatusEnum.Reject)
                            fee.FeeStatus = FeeStatus.RejectSubmission;

                        await TenantDb.Updateable(fee).UpdateColumns(x => new
                        {
                            x.FeeStatus,
                            x.AuditBy,
                            x.AuditOperator,
                            x.AuditDate,
                            x.Reason,
                            x.FlowId
                        }).ExecuteCommandAsync();
                        break;

                    case AuditType.FeeModify:
                        //申请修改审核成功需要回填费用信息
                        if (callback.FlowStatus == FlowStatusEnum.Approve)
                        {
                            var fm = await TenantDb.Queryable<FeeModification>().Where(x => x.FeeRecordId == fee.Id).OrderByDescending(x => x.CreateTime).FirstAsync();
                            if (fm == null)
                                return DataResult.Failed("未找到费用修改信息，更新失败", MultiLanguageConst.Operation_Failed);

                            var entity = fm.Adapt<FeeRecord>();
                            entity.Id = fm.FeeRecordId;
                            entity.FeeStatus = FeeStatus.AuditPassed;
                            entity.Reason = callback.RejectReason;
                            entity.UpdateBy = UserId;
                            entity.UpdateTime = dtNow;
                            //全表更新
                            await TenantDb.Updateable(entity).IgnoreColumns(
                                 x => new { x.AuditBy, x.AuditDate, x.AuditOperator, x.SubmitBy, x.SubmitDate }).ExecuteCommandAsync();

                            //逻辑删除暂存数据
                            fm.Deleted = true;
                            fm.DeleteTime = dtNow;
                            fm.DeleteBy = UserId;
                            await TenantDb.Updateable(fm).UpdateColumns(x => new
                            {
                                x.DeleteBy,
                                x.Deleted,
                                x.DeleteTime
                            }).ExecuteCommandAsync();
                        }
                        else if (callback.FlowStatus == FlowStatusEnum.Reject)
                        {
                            fee.FeeStatus = FeeStatus.RejectApplication;
                            await TenantDb.Updateable(fee).UpdateColumns(x => new
                            {
                                x.FeeStatus,
                                x.Reason,
                                x.FlowId
                            }).ExecuteCommandAsync();
                        }

                        break;

                    case AuditType.FeeDelete:
                        if (callback.FlowStatus == FlowStatusEnum.Approve)
                        {
                            fee.Deleted = true;
                            fee.DeleteBy = UserId;
                            fee.DeleteTime = dtNow;

                            await TenantDb.Updateable(fee).UpdateColumns(x => new
                            {
                                x.DeleteBy,
                                x.Deleted,
                                x.DeleteTime,
                                x.Reason,
                                x.FlowId
                            }).ExecuteCommandAsync();

                            //TenantDb.Deleteable(fee).ExecuteCommandAsync();
                        }
                        else
                        {
                            fee.FeeStatus = FeeStatus.RejectApplication;

                            await TenantDb.Updateable(fee).UpdateColumns(x => new
                            {
                                x.FeeStatus,
                                x.Reason,
                                x.FlowId
                            }).ExecuteCommandAsync();
                        }
                        break;

                    case AuditType.FeeBusiness:
                        FeeStatus status = FeeStatus.RejectSubmission;
                        if (callback.FlowStatus == FlowStatusEnum.Approve)
                        {
                            biz.BillAuditStatus = BillAuditStatus.AuditPassed;
                            status = FeeStatus.AuditPassed;
                        }
                        else if (callback.FlowStatus == FlowStatusEnum.Reject)
                        {
                            biz.BillAuditStatus = BillAuditStatus.Rejected;
                        }

                        await TenantDb.Updateable(biz).UpdateColumns(x => new
                        {
                            x.BillAuditStatus,
                            x.FlowId
                        }).ExecuteCommandAsync();

                        await TenantDb.Updateable<FeeRecord>()
                            .SetColumns(x => x.FeeStatus == status)
                            .SetColumns(x => x.FlowId == null)
                            .SetColumns(x => x.AuditBy == UserId)
                            .SetColumns(x => x.AuditOperator == User.UserName)
                            .SetColumns(x => x.AuditDate == dtNow)
                            .Where(x => x.BusinessId == biz.BusinessId && x.BusinessType == callback.BusinessType &&
                            (x.FeeStatus == FeeStatus.Entering || x.FeeStatus == FeeStatus.RejectSubmission)).ExecuteCommandAsync();

                        break;
                    default:
                        return DataResult.Failed("费用未处于审批状态，更新失败", MultiLanguageConst.Operation_Failed);
                }

                //驳回申请则逻辑删除关联工作流
                if (callback.FlowStatus == FlowStatusEnum.Reject)
                {
                    await Db.Updateable(new FlowInstance
                    {
                        Id = callback.InstanceId,
                        Deleted = true,
                        DeleteBy = 0,
                        DeleteTime = DateTime.Now
                    }).UpdateColumns(x => new { x.Deleted, x.DeleteBy, x.DeleteTime }).ExecuteCommandAsync();
                }

                await TenantDb.Ado.CommitTranAsync();
                return DataResult.Successed("提交成功!", MultiLanguageConst.DataUpdateSuccess);
            }
            catch (Exception ex)
            {
                await TenantDb.Ado.RollbackTranAsync();
                await ex.LogAsync(Db);
                return DataResult.Failed("提交失败!", MultiLanguageConst.Operation_Failed);
            }
            finally
            {
                await feeService.WriteBackStatusAsync(callback.BusinessId, callback.BusinessType.Value);
            }
        }

    }
}