using AngleSharp.Dom;
using DS.Module.Core;
using DS.Module.Core.Constants;
using DS.Module.Core.Data;
using DS.Module.Core.Extensions;
using DS.Module.DjyRulesEngine;
using DS.Module.DjyServiceStatus;
using DS.Module.MQ;
using DS.Module.RedisModule;
using DS.Module.SqlSugar;
using DS.Module.UserModule;
using DS.WMS.Core.Code.Dtos;
using DS.WMS.Core.Code.Entity;
using DS.WMS.Core.Fee.Entity;
using DS.WMS.Core.HangfireJob.Interface;
using DS.WMS.Core.Info.Entity;
using DS.WMS.Core.Op.Dtos;
using DS.WMS.Core.Op.Entity;
using DS.WMS.Core.Op.Interface;
using DS.WMS.Core.Sys.Entity;
using DS.WMS.Core.Sys.Interface;
using DS.WMS.Core.Sys.Method;
using DS.WMS.Core.TaskPlat.Dtos;
using Hangfire;
using LanguageExt;
using Mapster;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using NLog;
using SqlSugar;
using Logger = NLog.Logger;

namespace DS.WMS.Core.Op.Method;

public partial class SeaExportService : ISeaExportService
{
    private readonly IServiceProvider _serviceProvider;
    private readonly ISqlSugarClient db;
    private readonly IUser user;
    private readonly ISaasDbService saasService;
    private readonly ICommonService commonService;
    private static readonly Logger _logger = LogManager.GetCurrentClassLogger();
    private readonly ISeaExportCommonService seaComService;
    private readonly IWebHostEnvironment _environment;
    private readonly IDjyServiceStatusService _djyServiceStatusService;
    private readonly IRuleEngineService _ruleEngineService; 
    private readonly IOpJobService opJobService;
    private readonly IConfigService _configService;
    private readonly ISysCacheService _sysCacheService;
    private readonly IRabbitMQService _rabbitMQService;
    private readonly IRedisService _redisBaseService;
    


    const string CONST_MAPPING_MODULE = "BOOK_OR_CLOSING";
    const string CONST_MAPPING_MODULE_ROUTE = "BOOK_OR_CLOSING_RT";
    const string CONST_MAPPING_MODULE_VOLTA = "BOOK_CLOSING_VOLTA";
    const string CONST_MAPPING_MODULE_INTTRA = "INTTRA_EDI";

    private const string PrintRecentListTypeKey = "booking_print_recent_list";

    const string CONST_TSL_EDI_URL = "tsl_edi_declare_url";
    const string CONST_TSL_TYPE_CODE = "TslWeb";
    const string CONST_ONE_SOFILE_CATE_CODE = "one_so_file_template";
    const string PRINT_DATASOURCE_KEY = "booking_order";

    
    /// <summary>
    ///
    /// </summary>
    /// <param name="serviceProvider"></param>
    public SeaExportService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
        db = _serviceProvider.GetRequiredService<ISqlSugarClient>();
        user = _serviceProvider.GetRequiredService<IUser>();
        saasService = _serviceProvider.GetRequiredService<ISaasDbService>();
        commonService = _serviceProvider.GetRequiredService<ICommonService>();
        seaComService = _serviceProvider.GetRequiredService<ISeaExportCommonService>();
        _environment = _serviceProvider.GetRequiredService<IWebHostEnvironment>();
        //_printService = _serviceProvider.GetRequiredService<IPrintService>();

        _djyServiceStatusService = _serviceProvider.GetRequiredService<IDjyServiceStatusService>();
        _ruleEngineService = _serviceProvider.GetRequiredService<IRuleEngineService>();
        opJobService = _serviceProvider.GetRequiredService<IOpJobService>();
        _configService = _serviceProvider.GetRequiredService<IConfigService>();
        _rabbitMQService = _serviceProvider.GetRequiredService<IRabbitMQService>();
        _redisBaseService = _serviceProvider.GetRequiredService<IRedisService>();
    }

    /// <summary>
    /// 列表
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    public async Task<DataResult<SeaExportListRes>> GetListByPage(PageRequest request)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        //启用海运出口列表可视数据权限
        var query = commonService.GetVisibleDataRuleFilter<SeaExport>(tenantDb);

        var orgList = db.Queryable<SysOrg>().Where(x => x.Status == StatusEnum.Enable);
        //序列化查询条件
        var whereList = db.ConfigQuery.Context.Utilities.JsonToConditionalModels(request.QueryCondition);
        //var result = tenantDb.Queryable<SeaExport>()
        var statusList = tenantDb.Queryable<BookingStatus>().Select<BookingStatusRes>().ToList();
        var result = query
           .InnerJoin<BusinessFeeStatus>((a, b) => a.Id == b.BusinessId)
            //.LeftJoin<SysOrg>((a, b, c) => a.SaleOrgId == c.Id, "shippingweb8_dev.sys_org")
            //.LeftJoin<SysOrg>((a, b, c) => a.SaleDeptId == c.Id, "shippingweb8_dev.sys_org")
            .Select((a, b) => new SeaExportRes()
            { 
                //SaleDeptName = c.OrgName,
            },
                true)//true表示 其余字段自动映射，根据字段名字
                     //.Select<SeaExportRes>()
                     .MergeTable()
                     .Mapper(it =>
                     {
                         it.BookingStatus = statusList.Where(x => x.BusinessId == it.Id).ToList();
                         //it.BookingStatus = tenantDb.Queryable<BookingStatus>().Where(x => x.BusinessId == it.Id).Select<BookingStatusRes>().ToList();

                     }) 
            .Where(whereList);
        //.ToQueryPageAsync(request.PageCondition);
        var list = result.ToList();
        var data = await result.ToQueryPageAsync(request.PageCondition);

        var totalData = new SeaExportDataTotalRes()
        {
            MainCount = list.Where(x => x.ParentId == 0).Count(),
            PartCount = list.Where(x => x.ParentId != 0).Count(),
            ReturnCount = 0,
            TEU = list.Sum(x => x.TEU),
            PKGS = list.Sum(x => x.PKGS),
            CBM = list.Sum(x => x.CBM),
            KGS = list.Sum(x => x.KGS),
            Cntr1 = list.Sum(x => x.Cntr1),
            Cntr2 = list.Sum(x => x.Cntr2),
            Cntr3 = list.Sum(x => x.Cntr3),
            Cntr4 = list.Sum(x => x.Cntr4),
            Cntr5 = list.Sum(x => x.Cntr5),
            Cntr6 = list.Sum(x => x.Cntr6),
            Cntr7 = list.Sum(x => x.Cntr7),
            Cntr8 = list.Sum(x => x.Cntr8),
            Cntr9 = list.Sum(x => x.Cntr9),
            Cntr10 = list.Sum(x => x.Cntr10),
            OtherCntr = list.Sum(x => x.OtherCntr),

        };
        var res = new SeaExportListRes()
        {
            List = data.Data,
            TotalCount = list.Count(),
            DataTotal = totalData
        };
        return await Task.FromResult(DataResult<SeaExportListRes>.Success(res, MultiLanguageConst.DataQuerySuccess));
    }

    /// <summary>
    /// 海运出口分单列表
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    public async Task<DataResult<List<SeaExportRes>>> GetSeaExportPartList(PageRequest request)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        //序列化查询条件
        var whereList = db.ConfigQuery.Context.Utilities.JsonToConditionalModels(request.QueryCondition);
        var result = await tenantDb.Queryable<SeaExport>().Where(a => a.ParentId == 0)
            .InnerJoin<BusinessFeeStatus>((a, b) => a.Id == b.BusinessId)
            .Select<SeaExportRes>()
            .MergeTable()
            .Where(whereList).ToQueryPageAsync(request.PageCondition);

        return result;
    }


    /// <summary>
    /// 获取海运出口日志
    /// </summary>
    /// <param name="id">业务Id</param>
    /// <returns></returns>
    public async Task<DataResult<List<OpBusinessLogRes>>> GetSeaExportLogList(string id)
    {

        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = await tenantDb.Queryable<OpBusinessLog>()
            .Where(a => a.BusinessId == long.Parse(id))
            .Select<OpBusinessLogRes>()
            .ToListAsync();
        return await Task.FromResult(DataResult<List<OpBusinessLogRes>>.Success(data, MultiLanguageConst.DataQuerySuccess));
    }
    /// <summary>
    /// 编辑
    /// </summary>
    /// <param name="req"></param>
    /// <returns></returns>
    public async Task<DataResult> EditSeaExport(SeaExportReq req)
    {
        var dbScope = (SqlSugarScope)db;
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        tenantDb.QueryFilter.Clear<IOrgId>();
        if (req.Id == 0)
        {
            if (req.BLType != "拼箱分票" && !string.IsNullOrEmpty(req.MBLNO) && tenantDb.Queryable<SeaExport>().Where(x => x.MBLNO == req.MBLNO.Trim()).Any())
            {
                return await Task.FromResult(DataResult.Failed("海运出口信息主提单号已存在!", MultiLanguageConst.SeaExportMBLNOExist));
            }
            if (!string.IsNullOrEmpty(req.HBLNO) &&tenantDb.Queryable<SeaExport>().Where(x => x.HBLNO == req.HBLNO.Trim()).Any())
            {
                return await Task.FromResult(DataResult.Failed("海运出口信息分提单号已存在!", MultiLanguageConst.SeaExportHBLNOExist));
            }
            //TODO  会计期间不允许小于已结转期间
            if (req.CloseDocDate.IsNotNull() && req.ETD.IsNotNull() && req.CloseDocDate > req.ETD)
            {
                return await Task.FromResult(DataResult.Failed("截单日期不允许大于开船日期!", MultiLanguageConst.SeaExportCloseDocDateLimit));
            }
            if (req.ClosingDate.IsNotNull() && req.ETD.IsNotNull() && req.ClosingDate > req.ETD)
            {
                return await Task.FromResult(DataResult.Failed("截港日期不允许大于开船日期!", MultiLanguageConst.SeaExportCloseDateLimit));
            }
            //var sequence = commonService.GetSequenceNext<SeaExport>();
            //if (!sequence.Succeeded)
            //{
            //    return await Task.FromResult(DataResult.Failed(sequence.Message, MultiLanguageConst.SequenceSetNotExist));
            //}
            //
            var sequence = await commonService.GetSequenceNextAsync<SeaExport>(tenantDb, user,req.SaleId,req.ETD);
            if (!sequence.Succeeded)
            {
                return await Task.FromResult(DataResult.Failed(sequence.Message, MultiLanguageConst.SequenceSetNotExist));
            }

            var data = req.Adapt<SeaExport>();
            data.CustomerNo = sequence.Data;
            #region 处理箱型箱量
            if (req.CtnInfo.Count > 0)
            {
                //处理箱型箱量
                data = seaComService.UpdateSeaExportCtnInfo(data, req.CtnInfo);
            }
            #endregion

            #region 更新结算方式及结算日期
            //更新结算方式及结算日期
            var stlInfo = seaComService.GetCustomerStlInfo(new CustomerStlReq() { CustomerId = req.CustomerId, ETD = req.ETD, SaleId = req.SaleId });

            if (!stlInfo.Succeeded)
            {
                return await Task.FromResult(DataResult.Failed(stlInfo.Message));
            }
            data.StlName = stlInfo.Data.StlName;
            data.StlDate = stlInfo.Data.StlDate;
            data.AccountDate = stlInfo.Data.AccountDate;
            #endregion

            #region 回写商品信息  
            var goodid = WriteBackGoods(data, tenantDb);
            data.GoodsId = goodid;
            #endregion

            //判断是否订阅运踪目的港起运港标识
            if (!string.IsNullOrEmpty(data.MBLNO))
            {
                data.IsBookingYZ = "1";
                 
            }
            else
            {
                data.IsBookingYZ = "0"; 
            }
            try
            {
                //开启事务
                await dbScope.Ado.BeginTranAsync();
                var entity = await tenantDb.Insertable(data).ExecuteReturnEntityAsync();

                //处理订单联系人信息
                DealBusinessOrderContact(entity, tenantDb);

                if (req.CtnInfo.IsNotNull() && req.CtnInfo.Count > 0)
                {
                    foreach (var item in req.CtnInfo)
                    {
                        var ctn = item.Adapt<OpCtn>();
                        ctn.BSNO = entity.Id.ToString();
                        await tenantDb.Insertable(ctn).ExecuteCommandAsync();
                    }
                }
                if (req.CtnPriceInfo.IsNotNull() && req.CtnPriceInfo.Count > 0)
                {
                    foreach (var item in req.CtnPriceInfo)
                    {
                        var price = item.Adapt<BusinessCtnPrice>();
                        price.BusinessId = entity.Id;
                        await tenantDb.Insertable(price).ExecuteCommandAsync();
                    }
                }
                if (req.EdiInfo.IsNotNull())
                {
                    var edi = req.EdiInfo.Adapt<SeaExportEdi>();
                    edi.BusinessId = entity.Id;
                    await tenantDb.Insertable(edi).ExecuteCommandAsync();

                }
                #region 初始化费用状态表
                var feeStatus = BusinessFeeStatus.Init(entity.Id);
                await tenantDb.Insertable(feeStatus).ExecuteCommandAsync();
                #endregion
                //return DataResult.Successed("添加成功!", entity.Id, MultiLanguageConst.DataCreateSuccess);
                await dbScope.Ado.CommitTranAsync();
                return await Task.FromResult(DataResult.Successed("添加成功!", entity.Id, MultiLanguageConst.DataCreateSuccess));
            }
            catch (Exception ex)
            {
                await dbScope.Ado.RollbackTranAsync();
                await ex.LogAsync(db);
                return await Task.FromResult(DataResult.Failed("添加失败!" + ",请联系管理员!"));
            }
        }
        else
        {
            if (req.BLType != "拼箱分票" && !string.IsNullOrEmpty(req.MBLNO) && tenantDb.Queryable<SeaExport>().Where(x => x.Id != req.Id && x.MBLNO == req.MBLNO.Trim()).Any())
            {
                return await Task.FromResult(DataResult.Failed("海运出口信息主提单号已存在!", MultiLanguageConst.SeaExportMBLNOExist));
            }
            if (!string.IsNullOrEmpty(req.HBLNO) && tenantDb.Queryable<SeaExport>().Where(x => x.Id != req.Id && x.HBLNO == req.HBLNO.Trim()).Any())
            {
                return await Task.FromResult(DataResult.Failed("海运出口信息分提单号已存在!", MultiLanguageConst.SeaExportHBLNOExist));
            }
            //添加操作权限
            //var operationRule = commonService.GetOperationRuleConditional<SeaExport>();
            //var info = await tenantDb.Queryable<SeaExport>().Where(x => x.Id == req.Id).WhereFilterOperationRule(operationRule).FirstAsync();
            var info = await tenantDb.Queryable<SeaExport>().Where(x => x.Id == req.Id).FirstAsync();
            var oldOrder = info.Adapt<SeaExport>();
            var feeStatus = await tenantDb.Queryable<BusinessFeeStatus>().Where(x => x.BusinessId == req.Id).FirstAsync();

            if (feeStatus.IsNotNull() && (bool)feeStatus.IsBusinessLocking)
            {
                return await Task.FromResult(DataResult.Failed("海运出口信息业务已锁定!", MultiLanguageConst.SeaExportBusinessLock));
            }
            info = req.Adapt(info);
            //TODO  会计期间不允许小于已结转期间
            if (info.CloseDocDate.IsNotNull() && info.CloseDocDate > info.ETD)
            {
                return await Task.FromResult(DataResult.Failed("截单日期不允许大于开船日期!", MultiLanguageConst.SeaExportCloseDocDateLimit));
            }
            if (info.ClosingDate.IsNotNull() && info.ClosingDate > info.ETD)
            {
                return await Task.FromResult(DataResult.Failed("截港日期不允许大于开船日期!", MultiLanguageConst.SeaExportCloseDateLimit));
            }
            #region 处理箱型箱量
            if (req.CtnInfo.Count > 0)
            {
                //处理箱型箱量
                info = seaComService.UpdateSeaExportCtnInfo(info, req.CtnInfo);
            }
            #endregion
            #region 更新结算方式及结算日期
            //更新结算方式及结算日期
            var stlInfo = seaComService.GetCustomerStlInfo(new CustomerStlReq() { CustomerId = req.CustomerId, ETD = req.ETD, SaleId = req.SaleId });

            if (!stlInfo.Succeeded)
            {
                return await Task.FromResult(DataResult.Failed(stlInfo.Message));
            }
            info.StlName = stlInfo.Data.StlName;
            info.StlDate = stlInfo.Data.StlDate;
            info.AccountDate = stlInfo.Data.AccountDate;
            #endregion

            #region 复制单据单号重新赋值
            if (string.IsNullOrEmpty(info.CustomerNo))
            {
                var sequence = await commonService.GetSequenceNextAsync<SeaExport>(tenantDb, user, req.SaleId, req.ETD);
                if (!sequence.Succeeded)
                {
                    return await Task.FromResult(DataResult.Failed(sequence.Message, MultiLanguageConst.SequenceSetNotExist));
                }
                info.CustomerNo = sequence.Data;
            }

            #endregion

            #region 回写商品信息  
            var goodid = WriteBackGoods(info, tenantDb);
            info.GoodsId = goodid;
            #endregion

            //判断是否订阅运踪目的港起运港标识
            if (!string.IsNullOrEmpty(info.MBLNO))
            {
                info.IsBookingYZ = "1";

            }
            else
            {
                info.IsBookingYZ = "0";
            }
            try
            {
                //开启事务
                await dbScope.Ado.BeginTranAsync();
                info.Note = "正常编辑";
                await tenantDb.Updateable(info).EnableDiffLogEvent().ExecuteCommandAsync();//.IgnoreColumns(ignoreAllNullColumns: true)

                await seaComService.SaveSeaExportLogAsync(new SeaExportSaveLog()
                {
                    OperateType = "Update",
                    OldOrder = oldOrder,
                    NewOrder = info,
                    SourceCode = "NormalEdit",
                    SourceName = "正常编辑",
                }, tenantDb);
                //处理订单联系人信息
                DealBusinessOrderContact(info, tenantDb);

                if (req.CtnInfo.IsNotNull() && req.CtnInfo.Count > 0)
                {
                    var ctnList = await tenantDb.Queryable<OpCtn>().Where(x => x.BSNO == req.Id.ToString()).ToListAsync();
                    foreach (var item in req.CtnInfo)
                    {
                        if (item.Id == 0)
                        {
                            var ctn = item.Adapt<OpCtn>();
                            ctn.BSNO = info.Id.ToString();
                            await tenantDb.Insertable(ctn).ExecuteCommandAsync();
                        }
                        else
                        {
                            var ctn = ctnList.First(x => x.Id == item.Id);
                            ctn = item.Adapt(ctn);
                            await tenantDb.Updateable(ctn).ExecuteCommandAsync();
                        }

                    }
                }

                if (req.CtnPriceInfo.IsNotNull() && req.CtnPriceInfo.Count > 0)
                {
                    var priceList = await tenantDb.Queryable<BusinessCtnPrice>().Where(x => x.BusinessId == req.Id).ToListAsync();
                    foreach (var item in req.CtnPriceInfo)
                    {

                        if (item.IsNotNull() && item.Id == 0)
                        {
                            var price = item.Adapt<BusinessCtnPrice>();
                            price.BusinessId = info.Id;
                            await tenantDb.Insertable(price).ExecuteCommandAsync();
                        }
                        else
                        {
                            var price = priceList.First(x => x.Id == item.Id);
                            price = item.Adapt(price);
                            await tenantDb.Updateable(price).ExecuteCommandAsync();
                        }

                    }
                }
                if (req.EdiInfo.IsNotNull())
                {
                    var edi = await tenantDb.Queryable<SeaExportEdi>().Where(x => x.BusinessId == req.Id).FirstAsync();
                    if (edi.IsNull())
                    {
                        var ediInfo = req.EdiInfo.Adapt<SeaExportEdi>();
                        ediInfo.BusinessId = req.Id;
                        await tenantDb.Insertable(ediInfo).ExecuteCommandAsync();
                    }
                    else
                    {
                        var ediInfo = req.EdiInfo.Adapt(edi);
                        await tenantDb.Updateable(ediInfo).ExecuteCommandAsync();
                    }


                }
                #region 处理未初始化费用状态表
                if (feeStatus.IsNull())
                {
                    feeStatus = BusinessFeeStatus.Init(req.Id);
                    await tenantDb.Insertable(feeStatus).ExecuteCommandAsync();
                }
                #endregion
                //return DataResult.Successed("更新成功!", MultiLanguageConst.DataUpdateSuccess);
                await dbScope.Ado.CommitTranAsync();
                return await Task.FromResult(DataResult.Successed("更新成功!", MultiLanguageConst.DataUpdateSuccess));
            }
            catch (Exception ex)
            {
                await dbScope.Ado.RollbackTranAsync();
                await ex.LogAsync(db);
                return await Task.FromResult(DataResult.Failed("更新失败!" + ",请联系管理员!"));
            }
        }
    }

    /// <summary>
    /// 回写商品信息
    /// </summary>
    /// <param name="seaExport"></param>
    /// <param name="sqlSugarScope"></param>
    /// <returns></returns>
    public long WriteBackGoods(SeaExport seaExport, SqlSugarScopeProvider sqlSugarScope) {

        if (seaExport.GoodsId == 0)
        {
            var data = new CodeGoods()
            {
                GoodsCode = seaExport.HSCode,
                GoodName = seaExport.GoodsName,
                HSCode = seaExport.HSCode
            };
            var checkInfo = sqlSugarScope.Queryable<CodeGoods>().Where(x => x.HSCode == seaExport.HSCode && x.GoodName ==seaExport.GoodsName).First();
            if (checkInfo.IsNotNull())
            { 
                return checkInfo.Id;
            }
            else
            {
                var entity = sqlSugarScope.Insertable(data).RemoveDataCache($"{SqlSugarCacheConst.Goods}{user.TenantId}").ExecuteReturnEntityAsync();

                seaExport.GoodsId = entity.Id;
                return entity.Id;
            }
            
        }
        else
        {
            var info = sqlSugarScope.Queryable<CodeGoods>().Where(x => x.Id == seaExport.GoodsId).First();

            if (info.IsNull())
            {
                throw new Exception("商品信息不存在!");
            }
            info.GoodName = seaExport.GoodsName;
            info.HSCode = seaExport.HSCode;

            sqlSugarScope.Updateable(info).RemoveDataCache($"{SqlSugarCacheConst.Goods}{user.TenantId}").IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommand();
            
            return info.Id;
        } 
    }
    //public async Task<DataResult<CodeGoods>> SaveCheckCodeGood(string goodName,string code)
    //{
    //    DateTime? stlDate;
    //    DateTime etd;
    //    var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
    //    if (goodName.IsNull() || code.IsNull())
    //    {
    //        return await Task.FromResult(DataResult<CodeGoods>.Failed("商品名称或HsCode不能为空!"));
    //    }
    //    if (tenantDb.Queryable<CodeGoods>().Where(x=>x.HSCode == code).Any)
    //    {

    //    } 

    //    var accDate = tenantDb.Queryable<InfoClientAccountDate>().First(x => x.ClientId == req.CustomerId && etd >= x.BeginDate && etd <= x.EndDate);

    //    if (accDate.IsNull())
    //    {
    //        return DataResult<CustomerStlRes>.Success(new CustomerStlRes()
    //        {
    //            StlName = "票结",
    //            StlDate = req.ETD,
    //            AccountDate = Convert.ToDateTime(req.ETD).ToString("yyyy-MM")
    //        });
    //    }
    //    else
    //    {
    //        return DataResult<CustomerStlRes>.Failed("该委托单位未设置账期类型!");
    //    }


    //}
    /// <summary>
    /// 处理订单联系人信息
    /// </summary>
    /// <param name="seaExport"></param>
    /// <param name="sqlSugarScope"></param>
    private void DealBusinessOrderContact(SeaExport seaExport, SqlSugarScopeProvider sqlSugarScope)
    {
        var contactLists = sqlSugarScope.Queryable<BusinessOrderContact>().Where(x => x.BusinessId == seaExport.Id).ToList();

        var addList = new List<BusinessOrderContact>();
        var delList = new List<BusinessOrderContact>();
        if (seaExport.CustomerId != 0)
        {
            var delContrllers = contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "controller" && x.CustomerId != seaExport.CustomerId).ToList();
            if (delContrllers.Count > 0)
            {
                delList.AddRange(delContrllers);
            }
            var defaultContact = sqlSugarScope.Queryable<InfoClientContact>().Where(x => x.ClientId == seaExport.CustomerId && x.IsDefault == true).First();
            if (defaultContact.IsNotNull())
            {
                if (!contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "controller" && x.Name == defaultContact.Name).Any())
                {
                    addList.Add(new BusinessOrderContact()
                    {
                        BusinessId = seaExport.Id,
                        CustomerId = seaExport.CustomerId,
                        CustomerName = seaExport.CustomerName,
                        CustomerType = "controller",
                        CustomerTypeName = "委托单位",
                        Name = defaultContact.Name,
                        Tel = defaultContact.Tel,
                        Mobile = defaultContact.Mobile,
                        Email = defaultContact.Email,
                        CustomerContactId = defaultContact.Id
                    });
                }
            } 
        }
        if (seaExport.TruckerId != 0)
        {
            var delTrucks = contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "truck" && x.CustomerId != seaExport.TruckerId).ToList();
            if (delTrucks.Count > 0)
            {
                delList.AddRange(delTrucks);
            }
            var defaultContact = sqlSugarScope.Queryable<InfoClientContact>().Where(x => x.ClientId == seaExport.TruckerId && x.IsDefault == true).First();
            if (defaultContact.IsNotNull())
            {
                if (!contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "truck" && x.Name == defaultContact.Name).Any())
                {
                    addList.Add(new BusinessOrderContact()
                    {
                        BusinessId = seaExport.Id,
                        CustomerId = seaExport.TruckerId,
                        CustomerName = seaExport.Trucker,
                        CustomerType = "truck",
                        CustomerTypeName = "车队",
                        Name = defaultContact.Name,
                        Mobile = defaultContact.Mobile,
                        Tel = defaultContact.Tel,
                        Email = defaultContact.Email,
                        CustomerContactId = defaultContact.Id
                    });
                }
            }
        }
        if (seaExport.YardId != 0)
        {
            var delYards = contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "yard" && x.CustomerId != seaExport.YardId).ToList();
            if (delYards.Count > 0)
            {
                delList.AddRange(delYards);
            }
            var defaultContact = sqlSugarScope.Queryable<InfoClientContact>().Where(x => x.ClientId == seaExport.YardId && x.IsDefault == true).First();
            if (defaultContact.IsNotNull())
            {
                if (!contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "yard" && x.Name == defaultContact.Name).Any())
                {
                    addList.Add(new BusinessOrderContact()
                    {
                        BusinessId = seaExport.Id,
                        CustomerId = seaExport.YardId,
                        CustomerName = seaExport.Yard,
                        CustomerType = "yard",
                        CustomerTypeName = "场站",
                        Name = defaultContact.Name,
                        Mobile = defaultContact.Mobile,
                        Tel = defaultContact.Tel,
                        Email = defaultContact.Email,
                        CustomerContactId = defaultContact.Id
                    });
                }
            }
        }
        if (seaExport.ForwarderId != 0)
        {
            var delForwarders = contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "booking" && x.CustomerId != seaExport.ForwarderId).ToList();
            if (delForwarders.Count > 0)
            {
                delList.AddRange(delForwarders);
            }
            var defaultContact = sqlSugarScope.Queryable<InfoClientContact>().Where(x => x.ClientId == seaExport.ForwarderId && x.IsDefault == true).First();
            if (defaultContact.IsNotNull())
            {
                if (!contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "booking" && x.Name == defaultContact.Name).Any())
                {
                    addList.Add(new BusinessOrderContact()
                    {
                        BusinessId = seaExport.Id,
                        CustomerId = seaExport.ForwarderId,
                        CustomerName = seaExport.Forwarder,
                        CustomerType = "booking",
                        CustomerTypeName = "订舱公司",
                        Name = defaultContact.Name,
                        Mobile = defaultContact.Mobile,
                        Tel = defaultContact.Tel,
                        Email = defaultContact.Email,
                        CustomerContactId = defaultContact.Id
                    });
                }
            }
        }
        if (seaExport.ShipperCnId != 0)
        {
            var delShipperCns = contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "shippercn" && x.CustomerId != seaExport.ShipperCnId).ToList();
            if (delShipperCns.Count > 0)
            {
                delList.AddRange(delShipperCns);
            }
            var defaultContact = sqlSugarScope.Queryable<InfoClientContact>().Where(x => x.ClientId == seaExport.ShipperCnId && x.IsDefault == true).First();
            if (defaultContact.IsNotNull())
            {
                if (!contactLists.Where(x => x.BusinessType == BusinessType.OceanShippingExport && x.CustomerType == "shippercn" && x.Name == defaultContact.Name).Any())
                {
                    addList.Add(new BusinessOrderContact()
                    {
                        BusinessId = seaExport.Id,
                        CustomerId = (long)seaExport.ShipperCnId,
                        CustomerName = seaExport.ShipperCn,
                        CustomerType = "shippercn",
                        CustomerTypeName = "国内发货人",
                        Name = defaultContact.Name,
                        Mobile = defaultContact.Mobile,
                        Tel = defaultContact.Tel,
                        Email = defaultContact.Email,
                        CustomerContactId = defaultContact.Id
                    });
                }
            }
        }
        if (addList.Count > 0)
            sqlSugarScope.Insertable(addList).ExecuteCommand();
        if (delList.Count > 0)
            sqlSugarScope.Deleteable(delList).ExecuteCommand();
    }


    /// <summary>
    /// 详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<DataResult<SeaExportRes>> GetSeaExportInfo(string id)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        tenantDb.QueryFilter.Clear<IOrgId>();
        var data = await tenantDb.Queryable<SeaExport>()
            .Where(a => a.Id == long.Parse(id))
            .Select<SeaExportRes>()
            .Mapper(it =>
            {
                var edi = tenantDb.Queryable<SeaExportEdi>().First(x => x.BusinessId == it.Id);

                if (edi != null)
                    it.EdiInfo = edi.Adapt<SeaExportEdiRes>();

                it.CtnInfo = tenantDb.Queryable<OpCtn>().Where(x => x.BSNO == it.Id.ToString()).Select<OpCtnRes>().ToList();
                it.CtnPriceInfo = tenantDb.Queryable<BusinessCtnPrice>().Where(x => x.BusinessId == it.Id).Select<BusinessCtnPriceRes>().ToList();

                //it.FormSetList = tenantDb.Queryable<CodeFormSet>().Where(x => x.PermissionName == "海运出口-详情").Select<CodeFormSetRes>().ToList();

                it.BusinessLogList = tenantDb.Queryable<OpBusinessLog>().Where(x => x.BusinessId == it.Id)
                .Select<OpBusinessLogRes>()
                .Mapper(a =>
                {
                    a.Details = tenantDb.Queryable<OpBusinessLogDetail>().Where(x => x.Pid == a.Id).ToList();
                })
                .ToList();

                it.OrderContactList = tenantDb.Queryable<BusinessOrderContact>().Where(x => x.BusinessId == it.Id).Select<BusinessOrderContactRes>().ToList();


                //it.DischargePortCountry = tenantDb.Queryable<CodePort>().Where(x => x.Id == it.DischargePortId).Select(x => x.CountryName).First();
            })
            .FirstAsync();
        return await Task.FromResult(DataResult<SeaExportRes>.Success(data, MultiLanguageConst.DataQuerySuccess));
    }
    /// <summary>
    /// 批量更新
    /// </summary>
    /// <param name="req"></param>
    /// <returns></returns>
    public async Task<DataResult> SeaExportBatchEdit(SeaExportBatchEditReq req)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        if (req.Ids.Count == 0)
        {
            return DataResult.Failed("海运出口批量编辑未勾选!", MultiLanguageConst.SeaExportBatchEditNoSelect);
        }
        if (tenantDb.Queryable<SeaExport>().Where(x => !req.Ids.Contains(x.Id)).Any().IsNull())
        {
            return DataResult.Failed("不存在的海运出口信息!", MultiLanguageConst.SeaExportExist);
        }
        if (tenantDb.Queryable<BusinessFeeStatus>().Where(x => req.Ids.Contains(x.BusinessId) && x.IsBusinessLocking == true).Any())
        {
            return DataResult.Failed("海运出口信息业务已锁定!", MultiLanguageConst.SeaExportBusinessLock);
        }

        if (req.AccountDate.IsNotNull())
        {
            if (tenantDb.Queryable<BusinessFeeStatus>().Where(x => req.Ids.Contains(x.BusinessId) && x.IsFeeLocking == true).Any())
            {
                return DataResult.Failed("海运出口信息费用已锁定!", MultiLanguageConst.SeaExportFeeLock);
            }
        }
        var orderList = await tenantDb.Queryable<SeaExport>().Where(x => req.Ids.Contains(x.Id)).ToListAsync();

        var dic = req.GetPropertiesArray();

        foreach (var item in orderList)
        {
            var oldOrder = item.Adapt<SeaExport>();
            var info = req.Adapt(item);
            info.Note = "批量更新";
            await tenantDb.Updateable(info).UpdateColumns(dic).EnableDiffLogEvent().ExecuteCommandAsync();

            await seaComService.SaveSeaExportLogAsync(new SeaExportSaveLog()
            {
                OperateType = "Update",
                OldOrder = oldOrder,
                NewOrder = info,
                SourceCode = "BatchEdit",
                SourceName = "批量更新",
            }, tenantDb);
        }

        return DataResult.Successed("更新成功!", MultiLanguageConst.DataUpdateSuccess);
    }


    /// <summary>
    /// 业务单据单票复制
    /// </summary>
    /// <param name="id">业务Id</param>
    /// <returns></returns>
    public DataResult SeaExportCopy(string id)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var info = tenantDb.Queryable<SeaExport>().Where(x => x.Id == long.Parse(id)).First();
        if (info.IsNullOrEmpty())
        {
            return DataResult.Failed("海运出口信息不存在!", MultiLanguageConst.SeaExportNotExist);
        }
        //获取表单复制模板
        var template = tenantDb.Queryable<CodeFormCopy>().Where(x => x.PermissionId == 1772509201441099776).First();
        //var sequence =  commonService.GetSequenceNextAsync<SeaExport>(tenantDb, user, info.SaleId).GetAwaiter().GetResult();
        //if (!sequence.Succeeded)
        //{
        //    return DataResult.Failed(sequence.Message, MultiLanguageConst.SequenceSetNotExist);
        //}

        var data = new SeaExport();
        if (template.IsNullOrEmpty())
        {
            data = info.Adapt(data);
            data.Id = 0;
            data.ParentId = 0;
            //data.IsBusinessLocking = false;
            //data.IsFeeLocking = false;
            //data.CustomerNo = sequence.Data;
            data.BusinessStatusName = "";
            data.CustomerNo = "";
            var entity = tenantDb.Insertable(data).ExecuteReturnEntity();


            #region 初始化费用状态表
            var feeStatus = BusinessFeeStatus.Init(entity.Id);
            tenantDb.Insertable(feeStatus).ExecuteCommand();
            #endregion
            return DataResult.Successed("复制成功!", entity.Id, MultiLanguageConst.DataCopySuccess);
        }
        else
        {

            data = info.Adapt(data);
            data.Id = 0;
            data.ParentId = 0;
            data.CustomerNo = "";
            data.BusinessStatusName = "";
            //data.IsBusinessLocking = false;
            //data.IsFeeLocking = false;
            //data.CustomerNo = sequence.Data;

            var list0 = template.CopyFields.Split(",");
            var list1 = new List<string>();
            foreach (var item in list0)
            {
                list1.Add(item.ToUpperCamelCase());
            }
            list1.Add("IsBusinessLocking");
            list1.Add("IsFeeLocking");
            //list1.Add("CustomerNo");
            var insertColumns = list1.ToArray();
            //insertColumns.AddRange(["Id", "ParentId", "IsBusinessLocking", "IsFeeLocking", "CustomerNo"]);
            var entity = tenantDb.Insertable(data).InsertColumns(insertColumns).ExecuteReturnEntity();
            #region 初始化费用状态表
            var feeStatus = BusinessFeeStatus.Init(entity.Id);
            tenantDb.Insertable(feeStatus).ExecuteCommand();
            #endregion
            return DataResult.Successed("复制成功!", entity.Id, MultiLanguageConst.DataCopySuccess);
        }


    }



    #region 删除


    /// <summary>
    /// 业务单据删除
    /// </summary>
    /// <param name="id">业务Id</param>
    /// <returns></returns>
    public DataResult SeaExportDel(string id)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var info = tenantDb.Queryable<SeaExport>().Where(x => x.Id == long.Parse(id)).First();
        if (info.IsNullOrEmpty())
        {
            return DataResult.Failed("海运出口信息不存在!", MultiLanguageConst.SeaExportNotExist);
        }

        if (tenantDb.Queryable<SeaExport>().Where(x => x.ParentId == long.Parse(id)).Any())
        {
            return DataResult.Failed("海运出口存在分票信息，不能删除!", MultiLanguageConst.SeaExportPartExist);
        }
        if (tenantDb.Queryable<FeeRecord>().Where(x => x.BusinessId == long.Parse(id)).Any())
        {
            return DataResult.Failed("海运出口存在费用信息，不能删除!", MultiLanguageConst.SeaExportFeeExist);
        }

        if (tenantDb.Queryable<BusinessFeeStatus>().Where(x => x.BusinessId == long.Parse(id) && x.IsBusinessLocking == true).Any())
        {
            return DataResult.Failed("海运出口信息业务已锁定!", MultiLanguageConst.SeaExportBusinessLock);
        }

        if (tenantDb.Queryable<BusinessFeeStatus>().Where(x => x.BusinessId == long.Parse(id) && x.IsFeeLocking == true).Any())
        {
            return DataResult.Failed("海运出口信息费用已锁定!", MultiLanguageConst.SeaExportFeeLock);
        }

        info.Deleted = true;
        info.DeleteTime = DateTime.Now;
        info.DeleteBy = long.Parse(user.UserId);
        tenantDb.Updateable(info).ExecuteCommand();
        //tenantDb.Deleteable(info).IsLogic().ExecuteCommand("Deleted");

        return DataResult.Successed("删除成功!", MultiLanguageConst.DataDelSuccess);
    }

    /// <summary>
    /// 业务单据删除
    /// </summary>
    /// <param name="req">业务Ids</param>
    /// <returns></returns>
    public DataResult SeaExportBatchDel(IdModel req)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        if (req.Ids.Length == 0)
        {
            return DataResult.Failed("海运出口批量操作未勾选!", MultiLanguageConst.SeaExportBatchOpNoSelect);
        }
        if (tenantDb.Queryable<SeaExport>().Where(x => req.Ids.Contains(x.Id)).Any().IsNull())
        {
            return DataResult.Failed("不存在的海运出口信息!", MultiLanguageConst.SeaExportExist);
        }
        if (tenantDb.Queryable<BusinessFeeStatus>().Where(x => req.Ids.Contains(x.BusinessId) && x.IsBusinessLocking == true).Any())
        {
            return DataResult.Failed("海运出口信息业务已锁定!", MultiLanguageConst.SeaExportBusinessLock);
        }

        if (tenantDb.Queryable<BusinessFeeStatus>().Where(x => req.Ids.Contains(x.BusinessId) && x.IsFeeLocking == true).Any())
        {
            return DataResult.Failed("海运出口信息费用已锁定!", MultiLanguageConst.SeaExportFeeLock);
        }

        if (tenantDb.Queryable<SeaExport>().Where(x => req.Ids.Contains(x.ParentId)).Any())
        {
            return DataResult.Failed("海运出口存在分票信息，不能删除!", MultiLanguageConst.SeaExportPartExist);
        }
        if (tenantDb.Queryable<FeeRecord>().Where(x => req.Ids.Contains(x.BusinessId)).Any())
        {
            return DataResult.Failed("海运出口存在费用信息，不能删除!", MultiLanguageConst.SeaExportFeeExist);
        }

        var list = tenantDb.Queryable<SeaExport>().Where(x => req.Ids.Contains(x.Id)).ToList();

        //tenantDb.Deleteable(list).IsLogic().ExecuteCommand("Deleted");
        //tenantDb.Deleteable<SeaExport>(list).IsLogic().ExecuteCommand("Deleted");
        foreach (var item in list)
        {
            item.Deleted = true;
            item.DeleteTime = DateTime.Now;
            item.DeleteBy = long.Parse(user.UserId);
            tenantDb.Updateable(item).ExecuteCommand();
        }

        return DataResult.Successed("删除成功!", MultiLanguageConst.DataDelSuccess);
    }
    #endregion




    /// <summary>
    /// 订单及货运动态
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    public async Task<DataResult<List<BookingStatusLogRes>>> GetBookingStatusLogList(PageRequest request)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        //序列化查询条件
        var whereList = db.ConfigQuery.Context.Utilities.JsonToConditionalModels(request.QueryCondition);
        var result = await tenantDb.Queryable<BookingStatusLog>()
            .Select<BookingStatusLogRes>()
            .Mapper(async it =>
            {
                it.detail = await tenantDb.Queryable<BookingStatusLogDetail>().Where(x => x.PId == it.Id).Select<BookingStatusLogDetailDto>().ToListAsync();
            }
            ).Where(whereList).ToQueryPageAsync(request.PageCondition);

        return result;
    }

    #region 检索订单信息（如果当前为拆、合票，内包含分票信息）
    /// <summary>
    /// 检索订单信息（如果当前为拆、合票，内包含分票信息）
    /// </summary>
    /// <param name="mblNo">提单号</param>
    /// <returns></returns>
    public async Task<DataResult<SeaExportOrderExtension>> SearchOrderInfo(string mblNo)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);

        SeaExportOrderExtension model = new SeaExportOrderExtension
        {
            otherOrderList = new List<SeaExportOrderExtensionSubInfo>()
        };
        /*
             1、先用主提单号检索，如果没有取到结果，再用订舱编号检索。
             2、是拆票的，找到主票和其他分票，并返回当前订单的完整详情。
             3、是合票的，找到主票和其他分票，并返回当前订单的完整详情。
             */
        var orderList = await tenantDb.Queryable<SeaExport>()
            .Where(a => (a.MBLNO == mblNo || a.OrderNo == mblNo) && a.Deleted == false && (a.ParentId == null || a.ParentId == 0)).ToListAsync();

        var currOrder = orderList.FirstOrDefault(a => a.MBLNO == mblNo);

        //这里如果是拆票记录，则默认用拆票的第一票作为当前票的对应记录
        if (currOrder == null && orderList.Any(b => b.SplitOrMergeFlag == 1))
        {
            var maxChar = orderList.Select(a =>
            {
                var startIndx = a.CustomerNo.Length;
                return a.MBLNO.Substring(startIndx);
            }).Min();

            var custNo = orderList.FirstOrDefault().CustomerNo;
            currOrder = orderList.FirstOrDefault(a => a.MBLNO == $"{custNo}{maxChar}");
        }

        if (currOrder != null)
        {
            model.currOrder = currOrder.Adapt<SeaExportRes>();
            model.splitOrMergeFlag = currOrder.SplitOrMergeFlag;

            if (currOrder.SplitOrMergeFlag > 0)
            {
                //拆票
                if (currOrder.SplitOrMergeFlag == 1)
                {
                    //如果分单号和订舱编号不一致表示分票已经改成正式的提单号
                    if (!currOrder.HBLNO.Equals(currOrder.OrderNo))
                    {
                        model.finalMBLNo = currOrder.HBLNO;
                    }

                    model.orderNo = currOrder.OrderNo;

                    //找到所有相关的分票
                    var list = await tenantDb.Queryable<SeaExport>().Filter(null, true)
                        .Where(a => a.OrderNo == mblNo && a.Deleted == false && a.Id != currOrder.Id && (a.ParentId == null || a.ParentId == 0)).ToListAsync();

                    model.otherOrderList = list.Select(b => new SeaExportOrderExtensionSubInfo
                    {
                        Id = b.Id,
                        OrderNo = b.OrderNo,
                        MBLNO = b.MBLNO,
                        HBLNO = b.HBLNO
                    }).ToList();
                }
                else if (currOrder.SplitOrMergeFlag == 2)
                {
                    //合票
                    if (currOrder.OrderNo.Equals(currOrder.HBLNO))
                    {
                        //如果订舱编号和分单号一致，表示当前为主合票信息
                        model.isMaster = true;
                        model.masterId = currOrder.Id;
                        model.orderNo = currOrder.MBLNO;
                    }

                    //找到所有相关的分票
                    var list = await tenantDb.Queryable<SeaExport>().Filter(null, true)
                        .Where(a => a.HBLNO == currOrder.HBLNO && a.Deleted == false && a.Id != currOrder.Id && (a.ParentId == null || a.ParentId == 0)).ToListAsync();

                    model.otherOrderList = list.Select(b => new SeaExportOrderExtensionSubInfo
                    {
                        Id = b.Id,
                        OrderNo = b.OrderNo,
                        MBLNO = b.MBLNO,
                        HBLNO = b.HBLNO
                    }).ToList();

                    var masterOrder = model.otherOrderList.FirstOrDefault(x => x.OrderNo == x.HBLNO);

                    if (masterOrder != null)
                    {
                        model.masterId = masterOrder.Id;
                        model.orderNo = masterOrder.OrderNo;
                    }
                }
            }
        }
        else
        {
            return DataResult<SeaExportOrderExtension>.FailedData(model);
        }


        return DataResult<SeaExportOrderExtension>.Success(model);
    }
    #endregion
}