using Admin.NET.Application.CommonHelper;
using Admin.NET.Application.Entity;
using Admin.NET.Application.TransferDto;
using DocumentFormat.OpenXml.Drawing;
using DocumentFormat.OpenXml.Spreadsheet;
using Furion.DatabaseAccessor;
using System.Collections.Generic;
using System.Data;
using System.Linq;

namespace Admin.NET.Application;
/// <summary>
/// 容器分拣信息服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsTaskGroupName, Order = 100)]
public class WmsIssueService : IDynamicApiController, ITransient
{
    /// <summary>
    /// 是否正在执行下发方法
    /// </summary>
    private static bool isRuning_Fun_Issue = false;
    private static SemaphoreSlim semaphoreSlimIssue = new SemaphoreSlim(1, 1);

    private readonly UserManager _userManager;
    private readonly SqlSugarRepository<WmsContainerSort> _wmsContainerSortRep;
    private readonly SqlSugarRepository<v_wms_stock_quan> _v_wms_stock_quanRep;
    private readonly SqlSugarRepository<v_wms_stock_quan_for_use> _v_wms_stock_quan_for_useRep;
    private readonly SqlSugarRepository<WmsOrderSortDetails> _wmsOrderSortDetailsRep;
    private readonly SqlSugarRepository<WmsOrderSort> _wmsOrderSortRep;
    private readonly SqlSugarRepository<WmsOrderMovementDetails> _wmsOrderMovementDetailsRep;
    private readonly SqlSugarRepository<WmsOrderMovement> _wmsOrderMovementRep;
    private readonly SqlSugarRepository<WmsTask> _wmsTaskRep;
    private readonly SqlSugarRepository<WmsRecordPredetermineDispense> _wmsRecordPredetermineDispenseRep;
    private readonly SqlSugarRepository<WmsStockQuan> _wmsStockQuanRep;
    private readonly SqlSugarRepository<WmsRecordTrans> _wmsRecordTransRep;

    private readonly SqlSugarRepository<WmsBaseBusinessType> _WmsBaseBusinessTypeRep;
    private readonly SqlSugarRepository<WmsBasePlace> _wmsPlaceRep;

    private readonly SqlSugarRepository<WmsLogAction> _wmsLogActionRep;

    private readonly SqlSugarRepository<WmsConfigUnshelveStrategy> _wmsConfigUnshelveStrategyRep;
    private readonly SqlSugarRepository<WmsConfigUnshelveStrategyChoose> _wmsConfigUnshelveStrategyChooseRep;
    private readonly SqlSugarRepository<WmsConfigUnshelveStrategyRange> _wmsConfigUnshelveStrategyRangeRep;
    private readonly SqlSugarRepository<v_wms_config_unshelve_strategy_range> _v_wms_config_unshelve_strategy_rangeRep;

    private readonly SqlSugarRepository<v_empty_place> _v_empty_placeRep;
    private readonly SqlSugarRepository<WmsBasePlace> _wmsBasePlaceRep;
    public WmsIssueService(

        UserManager userManager,
        SqlSugarRepository<WmsStockQuan> wmsStockQuanRep,
          SqlSugarRepository<WmsRecordPredetermineDispense> wmsRecordPredetermineDispenseRep,
        SqlSugarRepository<WmsContainerSort> wmsContainerSortRep,
        SqlSugarRepository<v_wms_stock_quan> v_wms_stock_quanRep,

        SqlSugarRepository<v_wms_stock_quan_for_use> v_wms_stock_quan_for_useRep,
    SqlSugarRepository<WmsOrderSortDetails> wmsOrderSortDetailsRep,
        SqlSugarRepository<WmsOrderSort> wmsOrderSortRep,
        SqlSugarRepository<WmsOrderMovementDetails> wmsOrderMovementDetailsRep,
        SqlSugarRepository<WmsOrderMovement> wmsOrderMovementRep,
            SqlSugarRepository<WmsTask> wmsTaskRep,
            SqlSugarRepository<WmsRecordTrans> wmsRecordTransRep,
            SqlSugarRepository<WmsBaseBusinessType> WmsBaseBusinessTypeRep,
            SqlSugarRepository<WmsBasePlace> wmsPlaceRep,
            SqlSugarRepository<WmsLogAction> wmsLogActionRep,
            SqlSugarRepository<WmsConfigUnshelveStrategy> wmsConfigUnshelveStrategyRep,
            SqlSugarRepository<WmsConfigUnshelveStrategyChoose> wmsConfigUnshelveStrategyChooseRep,
            SqlSugarRepository<WmsConfigUnshelveStrategyRange> wmsConfigUnshelveStrategyRangeRep,
            SqlSugarRepository<v_empty_place> v_empty_placeRep,
            SqlSugarRepository<WmsBasePlace> wmsBasePlaceRep,
            SqlSugarRepository<v_wms_config_unshelve_strategy_range> v_wms_config_unshelve_strategy_rangeRep
            )
    {

        _userManager = userManager;
        _wmsStockQuanRep = wmsStockQuanRep;
        _wmsContainerSortRep = wmsContainerSortRep;
        _v_wms_stock_quanRep = v_wms_stock_quanRep;
        _v_wms_stock_quan_for_useRep = v_wms_stock_quan_for_useRep;
        _wmsOrderSortDetailsRep = wmsOrderSortDetailsRep;
        _wmsOrderSortRep = wmsOrderSortRep;
        _wmsOrderMovementDetailsRep = wmsOrderMovementDetailsRep;
        _wmsOrderMovementRep = wmsOrderMovementRep;
        _wmsTaskRep = wmsTaskRep;
        _wmsRecordPredetermineDispenseRep = wmsRecordPredetermineDispenseRep;
        _wmsRecordTransRep = wmsRecordTransRep;
        _WmsBaseBusinessTypeRep = WmsBaseBusinessTypeRep;
        _wmsPlaceRep = wmsPlaceRep;
        _wmsLogActionRep = wmsLogActionRep;
        _wmsConfigUnshelveStrategyRep = wmsConfigUnshelveStrategyRep;
        _wmsConfigUnshelveStrategyChooseRep = wmsConfigUnshelveStrategyChooseRep;
        _wmsConfigUnshelveStrategyRangeRep = wmsConfigUnshelveStrategyRangeRep;
        _v_empty_placeRep = v_empty_placeRep;
        _wmsBasePlaceRep = wmsBasePlaceRep;
        _v_wms_config_unshelve_strategy_rangeRep = v_wms_config_unshelve_strategy_rangeRep;
    }



    /// <summary>
    /// 下发
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Issue")]
    [Description("WmsIssue/Issue")]
    [UnitOfWork]
    public async Task<int> Issue(List<IssueInput> input)
    {
        //if (input.Count > 1) throw Oops.Oh("波次单下发数量超过1");
        try
        {
            if (isRuning_Fun_Issue)
            {
                throw Oops.Oh("程序正忙，请稍后再试");
            }
            await semaphoreSlimIssue.WaitAsync();

            isRuning_Fun_Issue = true;

            return await TaskIssue(input);

        }
        catch (Exception ex)
        {
            throw Oops.Oh(ex.Message);
        }
        finally
        {
            semaphoreSlimIssue.Release();
            isRuning_Fun_Issue = false;
        }
    }




    #region 私有方法


    /// <summary>
    /// 波次单下发
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private async Task<int> TaskIssue(List<IssueInput> input)
    {
        /*
         * 1. 获取所有要下发的波次单、明细
         * 2.校验波次单是否存在、单据状态、波次单明细剩余可下发数（考虑一个波次单明细是否可以多次下发）
         * 3.获取所有要下发的下架单、明细
         * 4.校验下架单是否存在、单据状态
         * 5.根据库位、批次、容器查询库存（查询库存视图：根据容器分组）
         * 7.计算可用库存=实际库存-锁定库存， 校验库存是否足够下发。
         * 8.库存根据容器 库位 入库时间排序（使用遵循先进先出原则） 
         *   目前库存没有 排属性的应用
         * 9.循环库存，判断每个容器的物料是否足够下发，不够就循环下一个容器。
         * 10.校验库存容器是否存在未完成的调度任务，存在就不能下发 
         *  
         * 11.更新波次单
        */

        //下架策略
        /**
         *1.获取所有物料 生效的 下架策略
         *2. 根据优先级循环处理策略
         *3.先进先出（天）：先按照入库时间（年-月-日）格式排序 升序
         *4.先进先出（小时）：先按照入库时间（年-月-日-时）格式排序 升序
         *5.满托推荐：按照 容器号分组 
             5.1 物料在一个容器库存正好= 下发的库存的 先出
             5.2 物料在一个容器库存> 下发的库存的先出
             5.3 物料在一个容器库存< 下发的库存的先出
             
         *6.半托推荐：按照 容器号分组 ，库存最少的先出
         * 
         * 
         * 
         */


        //新增事务记录
        List<WmsRecordTrans> addWmsRecordTransList = new List<WmsRecordTrans>();
        //新增操作履历
        List<WmsLogAction> addWmsLogActionList = new List<WmsLogAction>();
        var addWmsTaskList = new List<WmsTask>();//新增的下架任务
        var addWmsContainerSortList = new List<WmsContainerSort>();//新增的分拣信息

        var updateWmsOrderSortDetailsList = new List<WmsOrderSortDetails>();//修改的波次单明细
        var updateWmsOrderSortList = new List<WmsOrderSort>();//修改的波次单
        //TODO 添加事务记录

        List<string> sortNoList = input.Select(x => x.SortNo).ToList();

        if (sortNoList.Distinct().Count() > 1)
        {
            throw Oops.Oh("一次只能操作一个波次单下发");
        }

        // 获取所有波次单

        //Expression<Func<WmsOrderSort, bool>> predicate = u => sortNoList.Contains(u.SortNo);
        var allWmsOrderSortList = await _wmsOrderSortRep.GetListAsync(u => sortNoList.Contains(u.SortNo));
        if (allWmsOrderSortList?.Count <= 0)
        {
            throw Oops.Oh("波次单不存在");
        }

        //获取波次单所有明细
        var allOrderSortDetails = await _wmsOrderSortDetailsRep.GetListAsync(u => sortNoList.Contains(u.SortNo));
        if (allOrderSortDetails?.Count <= 0)
        {
            throw Oops.Oh("波次单明细不存在");
        }

        //本次下发波次单明细
        var currentOrderSortDetails = allOrderSortDetails.Where(u => input.Select(x => x.SortDetailsId).Contains(u.Id)).ToList();



        if (currentOrderSortDetails?.Count <= 0)
        {
            throw Oops.Oh("本次下发的波次单明细不存在");
        }

        //    获取业务类型
        BusinessTypeEnum businessTypeEnum = BusinessTypeEnum.波次下发;
        var wmsBaseBusinessType = BusinessTypeHelper.GetBusinessTypeInfoFromDB((int)businessTypeEnum, _WmsBaseBusinessTypeRep);


        var movementDetailsKeyList = currentOrderSortDetails.Select(x => x.RelationNo + x.RelationNoLineNumber).ToList();
        List<string> materialCodeList = currentOrderSortDetails.Select(x => x.MaterialCode).Distinct().ToList();

        var db_movementDetailsList = await _wmsOrderMovementDetailsRep.GetListAsync(x => movementDetailsKeyList.Contains(x.MovementNo + x.LineNumber));
        var queryOrderIds = db_movementDetailsList.Select(x => x.MovementId).Distinct().ToList();
        var orderMovementList = await _wmsOrderMovementRep.GetListAsync(x => queryOrderIds.Contains(x.Id));

        //查询 所有该物料的 分配表的所有可用数据
        var db_all_wmsRecordPredetermineDispenseList = await _wmsRecordPredetermineDispenseRep.GetListAsync(x => x.PDRecordType == PDRecordTypeEnum.分配 && x.PDRecordStatus == PDRecordStatusEnum.已分配
            && materialCodeList.Contains(x.MaterialCode)
        );



        ////获取可操作下发的库存信息-（未排除锁定库存）库存状态已上架、质检状态合格、非虚拟库位
        //var queryParam = ExpressionHelper.GetStockQuanForIssueOutTask();
        //queryParam.And(x => materialCodeList.Contains(x.MaterialCode));
        //var allStockQuanList = await _v_wms_stock_quanRep.GetListAsync(queryParam);

        ////根据物料编码获取物料跟踪码的可用库存信息-已排除掉分配、下发锁定库存
        var allStockQuanUseList = await _v_wms_stock_quan_for_useRep.GetListAsync(x => materialCodeList.Contains(x.MaterialCode));

        var allContainerCodeList = allStockQuanUseList.Select(s => s.ContainerCode).ToList();
        //获取所有库存视图信息 添加事务记录用
        List<v_wms_stock_quan> allStockQuanViewList = await _v_wms_stock_quanRep.GetListAsync(x => allContainerCodeList.Contains(x.ContainerCode));


        if (allStockQuanViewList?.Count <= 0)
        {
            throw Oops.Oh("所有物料都没有库存");
        }










        //获取库存库位相信
        var placeCodeList = allStockQuanViewList.Select(s => s.PlaceCode).Distinct().ToList();
        var allPlaeList = await _wmsPlaceRep.GetListAsync(u => placeCodeList.Contains(u.PlaceCode) && u.IsDelete == false);

        #region 验证

        var validateInput = GetWmsOrderMovementDetailsForIssueInput(input, currentOrderSortDetails, allWmsOrderSortList, orderMovementList, db_movementDetailsList);
        await StockQuanHelper.ValdiateStock(1, validateInput, _wmsOrderMovementDetailsRep, _v_wms_stock_quan_for_useRep);

        #endregion

        var containerCodeList = allStockQuanUseList.Select(s => s.ContainerCode).ToList();
        //获取库存未完成的调度任务
        var allTaskList = await _wmsTaskRep.GetListAsync(x => x.TaskStatus != TaskStatusEnum.已完成 && x.TaskStatus != TaskStatusEnum.已取消 && x.IsDelete == false && containerCodeList.Contains(x.ContainerCode));





        //获取物料下架策略
        #region 获取物料下架策略

        //获取生效的下架策略物料范围
        List<v_wms_config_unshelve_strategy_range> allUnshelveStrategyRangeList = await ConfigUnshelveStrategyHelper.GetUseUnshelveStrategyRangeList(_v_wms_config_unshelve_strategy_rangeRep, materialCodeList);
        //获取生效的下架策略选项
        List<WmsConfigUnshelveStrategyChoose> allUnshelveStrategyChooseList = await ConfigUnshelveStrategyHelper.GetUnshelveStrategyChooseListByRange(_wmsConfigUnshelveStrategyChooseRep, allUnshelveStrategyRangeList);

        #endregion

        foreach (var inputItem in input)
        {


            var item = currentOrderSortDetails.FirstOrDefault(x => x.Id == inputItem.SortDetailsId);
            WmsOrderSort sortOrder = allWmsOrderSortList.FirstOrDefault(p => p.SortNo == item.SortNo);
            //TODO 校验波次单状态
            if (sortOrder == null)
            {
                throw Oops.Oh("本次下发的波次单不存在");
            }

            WmsOrderMovement movementOrder = orderMovementList.FirstOrDefault(p => p.OrderNo == item.RelationNo);
            if (movementOrder == null)
            {
                throw Oops.Oh("本次下发关联的下架单不存在");
            }
            //TODO 校验下架单状态
            var sortMovementDetails = db_movementDetailsList.FirstOrDefault(f => f.MovementNo == item.RelationNo && f.LineNumber == item.RelationNoLineNumber);
            if (sortMovementDetails == null)
            {
                throw Oops.Oh("本次下发关联的下架单明细不存在");
            }


            if (string.IsNullOrWhiteSpace(movementOrder.ToPlaceCode) && string.IsNullOrWhiteSpace(movementOrder.ToAreaCode))
            {
                throw Oops.Oh($"{movementOrder.OrderTypeName}类型移动单{movementOrder.OrderNo}目标库区、目标库位不能同时为空");
            }


            if (string.IsNullOrWhiteSpace(movementOrder.ToPlaceCode))
            {

                var handle = FindEmptyPlaceServiceFactory.GetHandle(MaterialClassifyFlagEnum.物料, _v_empty_placeRep, _wmsBasePlaceRep, _wmsTaskRep);
                var emptyPlaceList = await handle.MainFindMultiEmptyLocation(new FindEmptyPlaceInput() { AreaList = new List<string>() { movementOrder.ToAreaCode } });


                var returnPlaceCode = emptyPlaceList.FirstOrDefault();

                if (returnPlaceCode == null)
                {
                    throw Oops.Oh($"库区{movementOrder.ToAreaCode}没有可推荐库位！");
                }

                movementOrder.ToPlaceCode = returnPlaceCode.PlaceCode;
                movementOrder.ToPlaceName = returnPlaceCode.PlaceName;
            }








            #region 处理下发

            #region 验证下发需求数

            decimal issueQuantity = item.IssueQuantity ?? 0M;//波次单的历史下发数量

            decimal allQuantity = item.Quantity - issueQuantity;//当前未下发数量
            decimal occQuantity = inputItem.SendQuantity;//当前实际下发数量
            if (allQuantity <= 0)
            {
                throw Oops.Oh("波次单" + item.SortNo + "行号" + item.LineNumber + "物料编号" + item.MaterialCode + $"已全部下发");
            }
            if (occQuantity > allQuantity)
            {
                throw Oops.Oh("波次单" + item.SortNo + "行号" + item.LineNumber + "物料编号" + item.MaterialCode + $"本次下发需求数量{occQuantity}大于未下发数{allQuantity}");
            }
            #endregion


            // 根据物料找出库存列表中数量大于0的库存
            var allMaterialStockQuanList = allStockQuanUseList.Where(x => (x.Quantity) > 0 && x.MaterialCode == item.MaterialCode)
           //// 如果传入了物料批次号，则筛选出批次号相同的库存项
           //.Where(!string.IsNullOrEmpty(item.Batch), x => x.Batch == item.Batch)
           //.Where(!string.IsNullOrEmpty(item.ErpCode), x => x.ErpCode == item.ErpCode)
           .ToList();




            //处理后未下发的数量，多个同一个物料多个库存数据的情况，循环处理下发
            decimal currentIssueQuantity = occQuantity;


            #region 处理分配

            //分配原则：1、优先按照分配的库存搞  2、其次按照入库时间搞
            var find_db_wmsRecordPredetermineDispenseList = db_all_wmsRecordPredetermineDispenseList.Where(x => (x.MovementNo + x.MovementLineNumber) == (sortMovementDetails.MovementNo + sortMovementDetails.LineNumber)).ToList();
            foreach (var preDisRecord in find_db_wmsRecordPredetermineDispenseList)
            {
                var aa = allMaterialStockQuanList.Where(x => x.SNCode == preDisRecord.SNCode).FirstOrDefault();
                if (aa == null)
                {
                    throw Oops.Oh("物料编号" + preDisRecord.MaterialCode + $"的分配记录(跟踪码{preDisRecord.SNCode})在库存中不存在");
                }
                if (aa.Quantity < preDisRecord.Quantity)
                {
                    throw Oops.Oh("物料编号" + preDisRecord.MaterialCode + $",跟踪码{preDisRecord.SNCode}的库存数量{aa.Quantity}小于分配数量{preDisRecord.Quantity},请检查");
                }

                var _remark = $"波次下发，分配抵消,波次单{inputItem.SortNo}";

                decimal changeQty = 0;
                if (preDisRecord.Quantity >= currentIssueQuantity)
                {
                    changeQty = currentIssueQuantity;
                    currentIssueQuantity = 0;
                }
                else
                {
                    changeQty = preDisRecord.Quantity;
                    currentIssueQuantity = currentIssueQuantity - changeQty;//剩下的待下发的数量
                }
                preDisRecord.Quantity -= changeQty;

                //扣减库存
                aa.Quantity -= changeQty;
                aa.ActionRemark = _remark;
                if (preDisRecord.Quantity == 0)
                {
                    //修改分配表
                    PredetermineDispenseHelper.SetPDRecordStatus(preDisRecord, PDRecordStatusEnum.已取消);
                }

                preDisRecord.Remarks = _remark;

                //修改移动单上的预配数 
                if ((sortMovementDetails.PredetermineQuantity - changeQty) < 0)
                {
                    sortMovementDetails.PredetermineQuantity = 0;
                }
                else
                {
                    sortMovementDetails.PredetermineQuantity -= changeQty;
                }


                CommonDoForIssue(_WmsBaseBusinessTypeRep, addWmsTaskList, aa, item, changeQty, movementOrder, sortMovementDetails, addWmsContainerSortList, sortOrder);

            }


            #endregion


            var sortStockQuanList = GetSortStockQuanListByStrategy(allUnshelveStrategyRangeList, allUnshelveStrategyChooseList, item, db_all_wmsRecordPredetermineDispenseList, sortMovementDetails, currentIssueQuantity, allMaterialStockQuanList);
            var old_Count = allMaterialStockQuanList.Count();
            allMaterialStockQuanList = sortStockQuanList.Adapt<List<v_wms_stock_quan_for_use>>();//复制排序后的对象
            var new_Count = allMaterialStockQuanList.Count();
            if (old_Count != new_Count)
            {
                throw Oops.Oh($"排序后数量不对，排序前数量{old_Count}，排序后数量{new_Count}");
            }



            ////同一个物料尽量从同一个库位取 
            //if (allMaterialStockQuanList?.Count() <= 0)
            //{
            //    //缺料
            //    throw Oops.Oh("物料编号" + item.MaterialCode + $"库存数量不足,下发需求数量:{occQuantity},库存可用数量:0");
            //}
            ////这里的Quantity 没有排除掉其他单据的分配锁定库存
            //var usedQty = allMaterialStockQuanList.Where(o => o.MaterialCode == item.MaterialCode).Sum(x => x.Quantity);
            //if (usedQty < occQuantity)
            //{
            //    throw Oops.Oh("物料编号" + item.MaterialCode + $"库存数量不足,下发需求数量:{occQuantity},库存可用数量:{usedQty}");
            //}




            foreach (var stockQuanItem in allMaterialStockQuanList)
            {
                //别的单子占用该跟踪号的数量,需要排除掉 别人占用的分配记录数据
                decimal other_PredetermineQuery_Qty = GetOtherPredetermineQuery(db_all_wmsRecordPredetermineDispenseList, sortMovementDetails, stockQuanItem);

                //库位属性是 封存和禁出的，不能操作下架
                if (stockQuanItem.PlaceStatus == PlaceStatusEnum.封存)
                {
                    throw Oops.Oh($"库位编号{stockQuanItem.PlaceCode}库位属性是{PlaceStatusEnum.封存.GetDescription()}");
                }
                if (stockQuanItem.PlaceStatus == PlaceStatusEnum.禁出)
                {
                    throw Oops.Oh($"库位编号{stockQuanItem.PlaceCode}库位属性是{PlaceStatusEnum.禁出.GetDescription()}");
                }
                //校验容器是否 有未完成的任务。
                if (allTaskList.Any(a => a.ContainerCode.Equals(stockQuanItem.ContainerCode)))
                {
                    throw Oops.Oh($"容器{stockQuanItem.ContainerCode}存在未完成的调用任务");
                }


                if (currentIssueQuantity > 0)
                {

                    //当前物料可用库存
                    var currentUsedQuantity = stockQuanItem.Quantity - other_PredetermineQuery_Qty;
                    currentUsedQuantity = currentUsedQuantity <= 0 ? 0 : currentUsedQuantity;
                    if (currentUsedQuantity <= 0)
                    {
                        continue;
                    }





                    //循环库存信息 处理下发数
                    decimal changQty = 0M;//实际本次分拣数量
                    if (currentUsedQuantity >= currentIssueQuantity)//下发数量小于等于库存
                    {
                        changQty = currentIssueQuantity;
                        currentIssueQuantity = 0;//全部下发，不在处理

                    }
                    else
                    {
                        //当前下发数未能完全下发，累计下发数
                        changQty = currentUsedQuantity;
                        currentIssueQuantity = currentIssueQuantity - currentUsedQuantity;

                    }

                    //修改移动单上的预配数 
                    if ((sortMovementDetails.PredetermineQuantity - changQty) < 0)
                    {
                        sortMovementDetails.PredetermineQuantity = 0;
                    }
                    else
                    {
                        sortMovementDetails.PredetermineQuantity -= changQty;
                    }


                    CommonDoForIssue(_WmsBaseBusinessTypeRep, addWmsTaskList, stockQuanItem, item, changQty, movementOrder, sortMovementDetails, addWmsContainerSortList, sortOrder);

                    if (currentIssueQuantity == 0)
                    {
                        break;
                    }


                }
                else
                {
                    break;
                }
            }

            if (currentIssueQuantity > 0)
            {
                throw Oops.Oh("物料编号" + item.MaterialCode + $"库存数量不足");

            }

            //更新波次单的已下发数量

            decimal lastIssueQuantity = issueQuantity + occQuantity;//波次单的历史下发数量
            item.IssueQuantity += occQuantity;//累计下发数
            item.OffShelvesQuantity += occQuantity;//下发完成就认为已下架

            //更新波次单明细的状态
            OrderHelper.updateOrderSortDetailsStatus(item);
            updateWmsOrderSortDetailsList.Add(item);

            //更新下架单明细的 下架数
            sortMovementDetails.OffShelvesQuantity += occQuantity;

            #endregion
        }

        foreach (var item in allWmsOrderSortList)
        {
            var updateOrderSortDetails = allOrderSortDetails.Where(w => w.SortId == item.Id).ToList();
            ////计算 波次单单的状态 
            OrderHelper.UpdatOrderSortStatus(updateOrderSortDetails, item);
            updateWmsOrderSortList.Add(item);
        }





        if (addWmsContainerSortList?.Count <= 0)
        {


            throw Oops.Oh("没有可下发的物料，库存全部不足");

        }

        if (addWmsTaskList?.Count <= 0)
        {
            throw Oops.Oh("下架任务创建失败");
        }


        //把容器上的库存都锁定
        var queryContainerCodeList = addWmsContainerSortList.Select(x => x.ContainerCode).Distinct().ToList();
        var stockQunList = await _wmsStockQuanRep.GetListAsync(x => queryContainerCodeList.Contains(x.ContainerCode));
        foreach (var item in stockQunList)
        {
            string recordTransRemarks = $"波次下发";
            LockInfo freezeInfo = new LockInfo()
            {
                LockReason = "波次下发",
                LockTime = DateTime.Now,
                LockUser = _userManager.RealName,//登录人的真实姓名
                LockStatus = LockStatusEnum.已锁定,//
            };
            StockQuanHelper.UpdateStockLockStatus(item, freezeInfo);


            #region  转移库存添加事务、操作日志

            TransferOtherDetail transferOtherDetail = new TransferOtherDetail()
            {
                RelationNo = sortNoList[0],//波次单号
                RelationNoLineNumber = string.Empty,
                Remarks = recordTransRemarks,

            };


            //根据库存跟踪码视图可以查询到信息
            //获取源库存信息
            var sourceStockView = StockQuanHelper.GetVMmsStockQuan(allStockQuanViewList, item.SNCode);

            //update by liuwq 20240730
            //获取目标库位
            //波次下发 库存没有变更库位，目标库位还是源库位，调度任务处理后才会变更库位
            var oldToPlace = BaseInfoHelper.GetPlace(sourceStockView.PlaceCode, allPlaeList);




            //新增事务记录
            WmsRecordTrans addWmsRecordTrans = LogRecordHelper.CreateWmsRecordTrans(wmsBaseBusinessType, sourceStockView, item, oldToPlace, transferOtherDetail);


            addWmsRecordTransList.Add(addWmsRecordTrans);

            //新增操作日志
            WmsLogAction wareActionLog = LogActionHelper.CreateWmsLogAction(item.Id, recordTransRemarks, $"锁定库存跟踪码{item.SNCode}");
            addWmsLogActionList.Add(wareActionLog);
            #endregion

        }


        //  var _tenant = _wmsContainerSortRep.AsTenant();
        try
        {
            #region 事务内执行操作
            await _wmsContainerSortRep.InsertRangeAsync(addWmsContainerSortList);

            await _wmsTaskRep.InsertRangeAsync(addWmsTaskList);
            await _wmsOrderSortRep.UpdateRangeAsync(updateWmsOrderSortList);
            await _wmsOrderSortDetailsRep.UpdateRangeAsync(updateWmsOrderSortDetailsList);


            //新增事务记录、收货记录、操作日志
            await _wmsLogActionRep.InsertRangeAsync(addWmsLogActionList);
            await _wmsRecordTransRep.InsertRangeAsync(addWmsRecordTransList);

            //更新庫存
            await _wmsRecordPredetermineDispenseRep.UpdateRangeAsync(db_all_wmsRecordPredetermineDispenseList);//更新分配表
            //把容器上的库存都锁定
            await _wmsStockQuanRep.UpdateRangeAsync(stockQunList);

            await _wmsOrderMovementDetailsRep.UpdateRangeAsync(db_movementDetailsList);

            #endregion

            //     await _tenant.CommitTranAsync();
        }
        catch (Exception ex)
        {

            //    await _tenant.RollbackTranAsync();
            throw;
        }



        return 1;
    }


    /// <summary>
    /// 根据策略排序
    /// </summary>
    /// <param name="allUnshelveStrategyRangeList"></param>
    /// <param name="allUnshelveStrategyChooseList"></param>
    /// <param name="item"></param>
    /// <param name="db_all_wmsRecordPredetermineDispenseList"></param>
    /// <param name="sortMovementDetails"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <param name="org_allMaterialStockQuanList">原始的对象</param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> GetSortStockQuanListByStrategy(List<v_wms_config_unshelve_strategy_range> allUnshelveStrategyRangeList, List<WmsConfigUnshelveStrategyChoose> allUnshelveStrategyChooseList,
        WmsOrderSortDetails item, List<WmsRecordPredetermineDispense> db_all_wmsRecordPredetermineDispenseList, WmsOrderMovementDetails sortMovementDetails, decimal currentIssueQuantity,
        List<v_wms_stock_quan_for_use> org_allMaterialStockQuanList)
    {
        //这里不才走变更库存信息，仅仅排序，所以必须是复制对象，而不是直接修改对象
        List<StockForUnshelveStrategy> allMaterialStockQuanList = org_allMaterialStockQuanList.Adapt<List<StockForUnshelveStrategy>>();//复制对象
        foreach (var item2 in allMaterialStockQuanList)
        {
            item2.HanlerQty = item2.Quantity;
        }

        //策略是否可用
        bool isUseStrategy = false;

        List<StockForUnshelveStrategy> findStockQuanList = new List<StockForUnshelveStrategy>();

        List<v_wms_config_unshelve_strategy_range> currentUnshelveStrategyRangeList = allUnshelveStrategyRangeList.Where(w => w.MaterialCode == item.MaterialCode).ToList();
        List<WmsConfigUnshelveStrategyChoose> currentUnshelveStrategyChooseList = new List<WmsConfigUnshelveStrategyChoose>();
        if (currentUnshelveStrategyRangeList?.Count > 0)
        {
            if (currentUnshelveStrategyRangeList.Where(w => w.MaterialCode == item.MaterialCode).Select(s => s.StrategyCode).Distinct().Count() > 1)
            {
                throw Oops.Oh($"物料编号" + item.MaterialCode + "存在多个下架策略,请检查");
            }
            //当前物料下架策略选项-- 根据优先级升序排序 级别越小 越优先
            var allChooseList = allUnshelveStrategyChooseList.OrderBy(x => x.Priority).Where(w => w.StrategyCode == currentUnshelveStrategyRangeList[0].StrategyCode && w.IsDelete == false).ToList();
            if (allChooseList?.Count <= 0)
            {
                //throw Oops.Oh($"下架策略{currentUnshelveStrategyRangeList[0].StrategyCode}物料编号" + item.MaterialCode + "下架策略选项不存在");
                return UseDefaultOrderForIssue(allMaterialStockQuanList, ref findStockQuanList);
            }

            currentUnshelveStrategyChooseList.AddRange(allChooseList);

            //if (currentUnshelveStrategyChooseList.Count() > 1)
            //{
            //    throw Oops.Oh($"下架策略{currentUnshelveStrategyRangeList[0].StrategyCode}物料编号" + item.MaterialCode + "存在多个下架策略选项,请检查");
            //}

            isUseStrategy = true;

        }
        //有下架策略
        if (isUseStrategy == true)
        {


            List<v_wms_stock_quan_for_use> groupStockQuanList = new List<v_wms_stock_quan_for_use>();


            //库存数使用Quantity ,不使用可用库存AvailableQty
            //循环扣减掉其他单据的分配占用的库存数，上面先完成了分逻辑，这里拿到的就是当前单据物料可以使用的库存数
            foreach (var allItem in allMaterialStockQuanList)
            {
                //别的单子占用该跟踪号的数量,需要排除掉 别人占用的分配记录数据
                decimal other_PredetermineQuery_Qty = GetOtherPredetermineQuery(db_all_wmsRecordPredetermineDispenseList, sortMovementDetails, allItem);
                allItem.HanlerQty -= other_PredetermineQuery_Qty;
            }

            var firstUnshelveStrategyChoose = currentUnshelveStrategyChooseList[0].StrategyOption;
            StrategyOptionEnum secondUnshelveStrategyChoose = 0;
            if (currentUnshelveStrategyChooseList.Count >= 2)
            {
                secondUnshelveStrategyChoose = currentUnshelveStrategyChooseList[1].StrategyOption;
            }


            //共 7种情况
            switch (firstUnshelveStrategyChoose)
            {
                case StrategyOptionEnum.整拖优先:
                    if (secondUnshelveStrategyChoose != 0)
                    {
                        if (secondUnshelveStrategyChoose == StrategyOptionEnum.先进先出_天)
                        {
                            FullContiner_FIFOByDay_OrderForIssue(allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
                        }
                        else
                        {
                            throw Oops.Oh($"策略有问题，第二项不是 先进先出_天");
                        }
                    }
                    else
                    {
                        FullContiner_OrderForIssue(allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
                    }

                    break;
                case StrategyOptionEnum.零散优先:
                    if (secondUnshelveStrategyChoose != 0)
                    {
                        if (secondUnshelveStrategyChoose == StrategyOptionEnum.先进先出_天)
                        {
                            HalfContiner_FIFOByDay_OrderForIssue(allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
                        }
                        else
                        {
                            throw Oops.Oh($"策略有问题，第二项不是 先进先出_天");
                        }
                    }
                    else
                    {
                        HalfContiner_OrderForIssue(allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
                    }
                    break;
                case StrategyOptionEnum.先进先出_天:
                    if (secondUnshelveStrategyChoose != 0)
                    {
                        if (secondUnshelveStrategyChoose == StrategyOptionEnum.整拖优先)
                        {
                            FIFOByDay_FullContiner_OrderForIssue(allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
                        }
                        else if (secondUnshelveStrategyChoose == StrategyOptionEnum.零散优先)
                        {
                            FIFOByDay_HalfContiner_OrderForIssue(allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
                        }
                        else
                        {
                            throw Oops.Oh($"策略有问题，第二项不是 满托推荐或半满推荐");
                        }
                    }
                    else
                    {
                        FIFOByDay_OrderForIssue(allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
                    }
                    break;
                default:
                    throw Oops.Oh($"暂不支持");
            }
        }
        else//没有下架策略
        {
            return UseDefaultOrderForIssue(allMaterialStockQuanList, ref findStockQuanList);
        }

        return findStockQuanList;
    }

    /// <summary>
    /// 默认的下架策略-先进先出
    /// </summary>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> UseDefaultOrderForIssue(List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList)
    {
        var lastResult = allMaterialStockQuanList.OrderBy(o => o.RecordInsertTime).ToList();
        findStockQuanList.AddRange(lastResult);
        return findStockQuanList;
    }


    #region 满托推荐=>先入先出(天)的下架策略

    /// <summary>
    /// 满托推荐=>先入先出(天)的下架策略 (2)
    /// </summary>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> FullContiner_FIFOByDay_OrderForIssue(List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        return Common_FullContiner_First_OrderForIssue(2, allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
    }
    /// <summary>
    /// 满托推荐的下架策略 (1)
    /// </summary>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> FullContiner_OrderForIssue(List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        return Common_FullContiner_First_OrderForIssue(1, allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
    }

    /// <summary>
    /// 满托推荐的下架策略 (1)
    /// 满托推荐=>先入先出(天)的下架策略 (2)
    /// </summary>
    /// <param name="flag">1:满托推荐的下架策略 2:满托推荐=>先入先出(天)的下架策略</param>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> Common_FullContiner_First_OrderForIssue(int flag, List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        var group = allMaterialStockQuanList.GroupBy(g => new { g.ContainerCode, g.MaterialCode });

        var lastResult1 = group.Where(w => w.Sum(x => x.Quantity) == currentIssueQuantity);
        if (flag == 2)
        {
            lastResult1 = lastResult1.OrderBy(x => x.Min(y => Convert.ToInt32(y.RecordInsertTime.ToString("yyyyMMdd"))));
        }
        foreach (var item in lastResult1)
        {
            findStockQuanList.AddRange(item.ToList());
        }

        var lastResult2 = group.Where(w => w.Sum(x => x.Quantity) > currentIssueQuantity).OrderByDescending(x => x.Sum(y => y.Quantity));
        if (flag == 2)
        {
            lastResult2 = lastResult2.OrderBy(x => x.Min(y => Convert.ToInt32(y.RecordInsertTime.ToString("yyyyMMdd"))));
        }
        foreach (var item in lastResult2)
        {
            findStockQuanList.AddRange(item.ToList());
        }

        var lastResult3 = group.Where(w => w.Sum(x => x.Quantity) < currentIssueQuantity).OrderByDescending(x => x.Sum(y => y.Quantity));
        if (flag == 2)
        {
            lastResult3 = lastResult3.OrderBy(x => x.Min(y => Convert.ToInt32(y.RecordInsertTime.ToString("yyyyMMdd"))));
        }
        foreach (var item in lastResult3)
        {
            findStockQuanList.AddRange(item.ToList());
        }


        return findStockQuanList;
    }

    #endregion

    #region 半满推荐=>先入先出(天)的下架策略


    /// <summary>
    /// 半满推荐=>先入先出(天)的下架策略 (2)
    /// </summary>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> HalfContiner_FIFOByDay_OrderForIssue(List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        return Common_HalfContiner_First_OrderForIssue(2, allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
    }
    /// <summary>
    ///半满推荐的下架策略 (1)
    /// </summary>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> HalfContiner_OrderForIssue(List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        return Common_HalfContiner_First_OrderForIssue(1, allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
    }

    /// <summary>
    /// (1)半满推荐的下架策略 
    /// (2) 半满推荐=>先入先出(天)的下架策略 
    /// </summary>
    /// <param name="flag"></param>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> Common_HalfContiner_First_OrderForIssue(int flag, List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        var group = allMaterialStockQuanList.GroupBy(g => new { g.ContainerCode, g.MaterialCode });

        var lastResult3 = group.Where(w => w.Sum(x => x.Quantity) < currentIssueQuantity).OrderBy(x => x.Sum(y => y.Quantity));
        if (flag == 2)
        {
            lastResult3 = lastResult3.OrderBy(x => x.Min(y => Convert.ToInt32(y.RecordInsertTime.ToString("yyyyMMdd"))));
        }
        foreach (var item in lastResult3)
        {
            findStockQuanList.AddRange(item.ToList());
        }

        var lastResult1 = group.Where(w => w.Sum(x => x.Quantity) == currentIssueQuantity);
        if (flag == 2)
        {
            lastResult1 = lastResult1.OrderBy(x => x.Min(y => Convert.ToInt32(y.RecordInsertTime.ToString("yyyyMMdd"))));
        }
        foreach (var item in lastResult1)
        {
            findStockQuanList.AddRange(item.ToList());
        }

        var lastResult2 = group.Where(w => w.Sum(x => x.Quantity) > currentIssueQuantity).OrderBy(x => x.Sum(y => y.Quantity));
        if (flag == 2)
        {
            lastResult2 = lastResult2.OrderBy(x => x.Min(y => Convert.ToInt32(y.RecordInsertTime.ToString("yyyyMMdd"))));
        }
        foreach (var item in lastResult2)
        {
            findStockQuanList.AddRange(item.ToList());
        }



        return findStockQuanList;
    }



    #endregion

    #region 先入先出(天)的

    /// <summary>
    /// 只有 先入先出(天)
    /// </summary>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> FIFOByDay_OrderForIssue(List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        return Common_FIFOByDay_First_OrderForIssue(0, allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
    }

    /// <summary>
    /// 先入先出(天)=>其次满托
    /// </summary>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> FIFOByDay_FullContiner_OrderForIssue(List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        return Common_FIFOByDay_First_OrderForIssue(1, allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
    }

    /// <summary>
    /// 先入先出(天)=>其次半托
    /// </summary>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> FIFOByDay_HalfContiner_OrderForIssue(List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        return Common_FIFOByDay_First_OrderForIssue(2, allMaterialStockQuanList, ref findStockQuanList, currentIssueQuantity);
    }

    /// <summary>
    /// 公共-先入先出(天)的
    /// </summary>
    /// <param name="flag">0:只有FIFODay 1：其次满托 2：其次半托</param>
    /// <param name="allMaterialStockQuanList"></param>
    /// <param name="findStockQuanList"></param>
    /// <param name="currentIssueQuantity"></param>
    /// <returns></returns>
    private static List<StockForUnshelveStrategy> Common_FIFOByDay_First_OrderForIssue(int flag, List<StockForUnshelveStrategy> allMaterialStockQuanList, ref List<StockForUnshelveStrategy> findStockQuanList, decimal currentIssueQuantity)
    {
        var groupByDay = allMaterialStockQuanList.GroupBy(g => new { g.RecordInsertTime.Date });

        //groupByDay 是按照 入库时间(天）分组
        if (flag == 2 || flag == 1)
        {
            foreach (var item in groupByDay)
            {
                //在每个(天)分组中，再寻找相同天的优先满托或半托出库的

                if (flag == 1)
                {
                    Common_HalfContiner_First_OrderForIssue(1, item.ToList(), ref findStockQuanList, currentIssueQuantity);
                }
                if (flag == 2)
                {
                    Common_HalfContiner_First_OrderForIssue(1, item.ToList(), ref findStockQuanList, currentIssueQuantity);
                }
            }
        }
        else
        {
            groupByDay = groupByDay.OrderBy(o => o.Key.Date);
            foreach (var item in groupByDay)
            {
                findStockQuanList.AddRange(item.ToList());
            }
        }

        return findStockQuanList;
    }


    #endregion


    /// <summary>
    /// 根据分拣明细获取下架策略选项
    /// </summary>
    /// <param name="allUnshelveStrategyRangeList"></param>
    /// <param name="allUnshelveStrategyChooseList"></param>
    /// <param name="item"></param>
    /// <returns></returns>

    private static List<WmsConfigUnshelveStrategyChoose> GetUnshelveStrategyChooseListBySortDetails(List<v_wms_config_unshelve_strategy_range> allUnshelveStrategyRangeList, List<WmsConfigUnshelveStrategyChoose> allUnshelveStrategyChooseList, WmsOrderSortDetails item)
    {
        List<v_wms_config_unshelve_strategy_range> currentUnshelveStrategyRangeList = allUnshelveStrategyRangeList.Where(w => w.MaterialCode == item.MaterialCode).ToList();
        List<WmsConfigUnshelveStrategyChoose> currentUnshelveStrategyChooseList = new List<WmsConfigUnshelveStrategyChoose>();
        if (currentUnshelveStrategyRangeList?.Count > 0)
        {
            if (currentUnshelveStrategyRangeList.Where(w => w.MaterialCode == item.MaterialCode).Select(s => s.StrategyCode).Distinct().Count() > 1)
            {
                throw Oops.Oh($"物料编号" + item.MaterialCode + "存在多个下架策略,请检查");
            }
            //当前物料下架策略选项-- 根据优先级升序排序 级别越小 越优先
            var allChooseList = allUnshelveStrategyChooseList.OrderBy(x => x.Priority).Where(w => w.StrategyCode == currentUnshelveStrategyRangeList[0].StrategyCode && w.IsDelete == false).ToList();
            if (currentUnshelveStrategyChooseList?.Count <= 0)
            {
                throw Oops.Oh($"下架策略{currentUnshelveStrategyRangeList[0].StrategyCode}物料编号" + item.MaterialCode + "下架策略选项不存在");
            }

            ////if (currentUnshelveStrategyChooseList.Count() > 1)
            ////{
            ////    throw Oops.Oh($"下架策略{currentUnshelveStrategyRangeList[0].StrategyCode}物料编号" + item.MaterialCode + "存在多个下架策略选项,请检查");
            ////}

            currentUnshelveStrategyChooseList.AddRange(allChooseList);

        }

        return currentUnshelveStrategyChooseList;
    }

    private static decimal GetOtherPredetermineQuery(List<WmsRecordPredetermineDispense> db_all_wmsRecordPredetermineDispenseList, WmsOrderMovementDetails sortMovementDetails, v_wms_stock_quan_for_use stockQuanItem)
    {
        return db_all_wmsRecordPredetermineDispenseList.Where(x => (x.MovementNo + x.MovementLineNumber) != (sortMovementDetails.MovementNo + sortMovementDetails.LineNumber)
         && x.MaterialCode == stockQuanItem.MaterialCode
         && x.SNCode == stockQuanItem.SNCode
        ).Sum(x => x.Quantity);
    }

    /// <summary>
    /// 获取校验下发参数对象
    /// </summary>
    /// <param name="input"></param>
    /// <param name="currentOrderSortDetails"></param>
    /// <param name="allWmsOrderSortList"></param>
    /// <param name="orderMovementList"></param>
    /// <param name="movementDetailsList"></param>
    /// <returns></returns>
    private static List<WmsOrderMovementDetailsForIssueInput> GetWmsOrderMovementDetailsForIssueInput(List<IssueInput> input, List<WmsOrderSortDetails> currentOrderSortDetails, List<WmsOrderSort> allWmsOrderSortList,
        List<WmsOrderMovement> orderMovementList, List<WmsOrderMovementDetails> movementDetailsList
        )
    {
        List<WmsOrderMovementDetailsForIssueInput> result = new List<WmsOrderMovementDetailsForIssueInput>();
        foreach (var inputItem in input)
        {
            var item = currentOrderSortDetails.FirstOrDefault(x => x.Id == inputItem.SortDetailsId);
            WmsOrderSort sortOrder = allWmsOrderSortList.FirstOrDefault(p => p.SortNo == item.SortNo);
            //TODO 校验波次单状态
            if (sortOrder == null)
            {
                throw Oops.Oh("本次下发的波次单不存在");
            }

            WmsOrderMovement movementOrder = orderMovementList.FirstOrDefault(p => p.OrderNo == item.RelationNo);
            if (movementOrder == null)
            {
                throw Oops.Oh("本次下发关联的下架单不存在");
            }
            //TODO 校验下架单状态
            var sortMovementDetails = movementDetailsList.FirstOrDefault(f => f.MovementNo == item.RelationNo && f.LineNumber == item.RelationNoLineNumber);
            if (sortMovementDetails == null)
            {
                throw Oops.Oh("本次下发关联的下架单明细不存在");
            }

            WmsOrderMovementDetailsForIssueInput res = sortMovementDetails.Adapt<WmsOrderMovementDetailsForIssueInput>();
            res.SendQuantity = inputItem.SendQuantity;

            result.Add(res);
        }
        return result;
    }


    /// <summary>
    /// 波次下發統一處理
    /// </summary>
    /// <param name="addWmsTaskList"></param>
    /// <param name="stockQuanItem"></param>
    /// <param name="item"></param>
    /// <param name="changeQty"></param>
    /// <param name="movementOrder"></param>
    /// <param name="sortMovementDetails"></param>
    /// <param name="addWmsContainerSortList"></param>
    private static void CommonDoForIssue(SqlSugarRepository<WmsBaseBusinessType> _WmsBaseBusinessTypeRep, List<WmsTask> addWmsTaskList, v_wms_stock_quan_for_use stockQuanItem,
        WmsOrderSortDetails item, decimal changeQty,
     WmsOrderMovement movementOrder, WmsOrderMovementDetails sortMovementDetails, List<WmsContainerSort> addWmsContainerSortList, WmsOrderSort sortOrder)
    {
        //创建锁定库存
        var addWmsStockQuanLock = CommonCreateWmsStockQuanLock(item, changeQty, stockQuanItem);

        //创建分拣信息
        var addWmsContainerSort = CommonCreateWmsContainerSort(item, movementOrder, sortMovementDetails, changeQty, addWmsStockQuanLock);
        addWmsContainerSortList.Add(addWmsContainerSort);

        //创建下架调度任务
        var addWmsTask = CommonCreateWmsTask(_WmsBaseBusinessTypeRep, sortOrder.SortNo, movementOrder, stockQuanItem);

        //同一个容易创建一个 下架任务即可
        CreateWmsTask(addWmsTaskList, addWmsTask, stockQuanItem);

    }

    /// <summary>
    /// 公共創建調度任務
    /// </summary>
    /// <param name="addWmsTaskList"></param>
    /// <param name="addWmsTask"></param>
    /// <param name="stockQuanItem"></param>
    private static void CreateWmsTask(List<WmsTask> addWmsTaskList, WmsTask addWmsTask, v_wms_stock_quan_for_use stockQuanItem)
    {
        //同一个容易创建一个 下架任务即可
        if (!addWmsTaskList.Any(a => a.ContainerCode == stockQuanItem.ContainerCode))
        {
            addWmsTaskList.Add(addWmsTask);
        }
    }







    /// <summary>
    /// 创建下架调度任务公共方法
    /// </summary>
    /// <param name="orderNo"></param>
    /// <param name="moveTypeEnum"></param>
    /// <param name="movementOrder"></param>
    /// <param name="stockQuanItem"></param>
    /// <returns></returns>
    private static WmsTask CommonCreateWmsTask(SqlSugarRepository<WmsBaseBusinessType> _WmsBaseBusinessTypeRep, string orderNo, WmsOrderMovement movementOrder, v_wms_stock_quan_for_use stockQuanItem)
    {

        string toPlaceCode = movementOrder.ToPlaceCode;
        string toAreaCode = movementOrder.ToAreaCode;


        var businessTypeInfo = BusinessTypeHelper.GetBusinessTypeInfoFromDB((int)movementOrder.BusinessType, _WmsBaseBusinessTypeRep);
        return new WmsTask()
        {
            MoveType = businessTypeInfo.MoveType,
            MoveTypeName = businessTypeInfo.MoveTypeName,
            BusinessType = businessTypeInfo.BusinessTypeValue,
            BusinessTypeName = businessTypeInfo.BusinessTypeName,

            ContainerCode = stockQuanItem.ContainerCode,

            SourcePlaceCode = stockQuanItem.PlaceCode,//下架单指定的源库位

            ToPlaceCode = toPlaceCode,//下架单指定的目标库位
            ToAreaCode = toAreaCode,//下架单指定的目标库区
            IsFlagFinish = false,
            OrderNo = orderNo,//创建任务的单据号 
            RelationNo = movementOrder.OrderNo,//下架单号
            TaskDescribe = businessTypeInfo.BusinessTypeName,
            TaskStatus = TaskStatusEnum.新建,
            TaskStatusName = TaskStatusEnum.新建.GetDescription(),
            TaskNo = Yitter.IdGenerator.YitIdHelper.NextId().ToString(),
            TaskPriority = 0,
            IssueTime = DateTime.Now,
            TaskName = businessTypeInfo.BusinessTypeName


        };



    }

    /// <summary>
    /// 创建锁定库存信息公共方法
    /// </summary>
    /// <param name="addWmsStockQuanLockList">锁定库存信息集合</param>
    /// <param name="item">波次单明细对象</param>
    /// <param name="currentIssueQuantity">下发数</param>
    /// <param name="stockQuanItem">库存视图对象</param>
    private static StockQuanLockOutput CommonCreateWmsStockQuanLock(WmsOrderSortDetails item, decimal occQuantity, v_wms_stock_quan_for_use stockQuanItem)
    {

        return new StockQuanLockOutput()
        {
            ContainerCode = stockQuanItem.ContainerCode,
            ContainerName = stockQuanItem.ContainerName,
            MaterialCode = stockQuanItem.MaterialCode,
            MaterialName = stockQuanItem.MaterialName,
            Quantity = occQuantity,
            Batch = stockQuanItem.Batch,
            SupplierBatch = stockQuanItem.SupplierBatch,
            SNCode = stockQuanItem.SNCode,
            ErpCode = stockQuanItem.ErpCode,
            AreaCode = stockQuanItem.AreaCode,
            AreaName = stockQuanItem.AreaName,
            PlaceCode = stockQuanItem.PlaceCode,
            PlaceName = stockQuanItem.PlaceName,
            SortNo = item.SortNo,
            SortNoLineNumber = item.LineNumber,
            RelationNoLineNumber = item.RelationNoLineNumber,
            RelationNo = item.RelationNo,


        };
    }

    /// <summary>
    /// 创建分拣信息公共方法
    /// </summary>
    /// <param name="addWmsContainerSortList">分拣信息集合</param>
    /// <param name="item">波次单明细对象</param>
    /// <param name="movementOrder">移动单对象</param>
    /// <param name="sortMovementDetails">移动单明细对象</param>
    /// <param name="occQuantity">下发数</param>
    /// <param name="stockQuanLock">锁定库存对象</param>
    private static WmsContainerSort CommonCreateWmsContainerSort(WmsOrderSortDetails item, WmsOrderMovement movementOrder,
        WmsOrderMovementDetails sortMovementDetails, decimal occQuantity, StockQuanLockOutput stockQuanLock)
    {
        return new WmsContainerSort()
        {
            StockQuanLockId = 0,
            ContainerCode = stockQuanLock.ContainerCode,
            MaterialCode = stockQuanLock.MaterialCode,
            MaterialName = stockQuanLock.MaterialName,
            Quantity = occQuantity,
            ErpCode = stockQuanLock.ErpCode,
            RelationNo = item.RelationNo,
            RelationNoLineNumber = item.RelationNoLineNumber,
            RelationDetailsId = sortMovementDetails.Id,
            Batch = stockQuanLock.Batch,
            SupplierBatch = stockQuanLock.SupplierBatch,
            SNCode = stockQuanLock.SNCode,
            SortDetailsId = item.Id,
            SortNo = item.SortNo,
            SortNoLineNumber = item.LineNumber,
            SortStatus = OrderStatusEnum.新建,
            SortStatusName = OrderStatusEnum.新建.GetDescription(),
            RelationOrderType = movementOrder.OrderType,
            RelationOrderTypeName = movementOrder.OrderType.GetDescription()
        };
    }

    #endregion




}