using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.ChannelsECLeagueHeadSupplierOrderGetResponse.Types.CommssionOrder.Types;
using System.Linq.Expressions;
using Furion.LinqBuilder;
using System.Linq;
using AngleSharp.Dom;
using Admin.NET.Application.CommonHelper;
namespace Admin.NET.Application;
/// <summary>
/// 下架单分配服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsTaskGroupName, Order = 100)]
public class WmsDispenseService : IDynamicApiController, ITransient
{
    /// <summary>
    /// 是否正在执行分配方法
    /// </summary>
    private static bool isRuning_Fun_Dispense = false;
    /// <summary>
    /// 是否正在执行修改分配方法
    /// </summary>
    private static bool isRuning_Fun_UpdateDispense = false;

    private static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(1, 1);
    private static SemaphoreSlim semaphoreSlimForUpdate = new SemaphoreSlim(1, 1);

    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<WmsStockQuanLock> _wmsStockQuanLockRep;
    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<WmsRecordPredDispHistory> _wmsRecordPredDispHistoryRep;
    private readonly SqlSugarRepository<V_WmsOrderMovementDetails> _v_wmsOrderMovementDetailsRep;



    public WmsDispenseService(
        SqlSugarRepository<WmsRecordPredDispHistory> wmsRecordPredDispHistoryRep,
         SqlSugarRepository<V_WmsOrderMovementDetails> v_wmsOrderMovementDetailsRep,
        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<WmsStockQuanLock> wmsStockQuanLockRep,
    SqlSugarRepository<WmsOrderSortDetails> wmsOrderSortDetailsRep,
        SqlSugarRepository<WmsOrderSort> wmsOrderSortRep,
        SqlSugarRepository<WmsOrderMovementDetails> wmsOrderMovementDetailsRep,
        SqlSugarRepository<WmsOrderMovement> wmsOrderMovementRep,
            SqlSugarRepository<WmsTask> wmsTaskRep,
        SqlSugarRepository<WmsRecordPredetermineDispense> wmsRecordPredetermineDispenseRep)
    {
        _wmsRecordPredDispHistoryRep = wmsRecordPredDispHistoryRep;
        _v_wmsOrderMovementDetailsRep = v_wmsOrderMovementDetailsRep;
        _wmsContainerSortRep = wmsContainerSortRep;
        _v_wms_stock_quanRep = v_wms_stock_quanRep;
        _v_wms_stock_quan_for_useRep = v_wms_stock_quan_for_useRep;

        //_wmsStockQuanLockRep = wmsStockQuanLockRep;
        _wmsOrderSortDetailsRep = wmsOrderSortDetailsRep;
        _wmsOrderSortRep = wmsOrderSortRep;
        _wmsOrderMovementDetailsRep = wmsOrderMovementDetailsRep;
        _wmsOrderMovementRep = wmsOrderMovementRep;
        _wmsTaskRep = wmsTaskRep;
        _wmsRecordPredetermineDispenseRep = wmsRecordPredetermineDispenseRep;
    }



    /// <summary>
    /// 自动分配
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Dispense")]
    [Description("WmsDispense/Dispense")]
    public async Task<int> Dispense(List<DispenseInput> input)
    {
        try
        {
            if (isRuning_Fun_Dispense)
            {
                throw Oops.Oh("程序正忙，请稍后再试");
            }
            await semaphoreSlim.WaitAsync();

            isRuning_Fun_Dispense = true;

            return await DispenseFaction(input);

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

    /// <summary>
    /// 取消分配
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "CancelDispenseForRecord")]
    [Description("WmsDispense/CancelDispenseForRecord")]
    public async Task<int> CancelDispenseForRecord(CancelDispenseInput input)
    {
        try
        {
            if (isRuning_Fun_Dispense)
            {
                throw Oops.Oh("程序正忙，请稍后再试");
            }
            await semaphoreSlim.WaitAsync();

            isRuning_Fun_Dispense = true;

            return await CancelDispenseForRecordFaction(input);

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


    /// <summary>
    /// 修改分配
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "UpdateDispense")]
    [Description("WmsDispense/UpdateDispense")]
    public async Task<int> UpdateDispense(UpdateDispenseInput input)
    {
        throw Oops.Oh("此方法已废弃");
        /*
        try
        {
            if (isRuning_Fun_UpdateDispense)
            {
                throw Oops.Oh("程序正忙，请稍后再试");
            }
            await semaphoreSlimForUpdate.WaitAsync();

            isRuning_Fun_UpdateDispense = true;

            return await UpdateDispenseFaction(input);

        }
        catch (Exception ex)
        {
            throw Oops.Oh(ex.Message);
        }
        finally
        {
            semaphoreSlimForUpdate.Release();
            isRuning_Fun_UpdateDispense = false;
        }
        //*/
    }



    #region 私有方法


    /// <summary>
    /// 自动分配/指定库存分配
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private async Task<int> DispenseFaction(List<DispenseInput> input)
    {

        /**
         * 获取分配物料库存信息
         * 获取当前分配锁定库存信息
         * 校验可用库存-历史分配锁定库存 是否满足分配
         * 新增分配锁定库存
         * 修改下架单明细分配数
         * 新增事务
         * 新增操作日期
         */

        if (input.First().Flag != 1 && input.First().Flag != 2)
        {
            throw Oops.Oh("分配标记不正确");
        }
        bool isHandFlag = false;
        if (input.First().Flag == 2)
        {
            isHandFlag = true;
            //明细不能为空
            foreach (var item in input)
            {
                if (item.dispenseDetailsForHand?.Count <= 0)
                {
                    throw Oops.Oh("下架单" + item.MovementNo + "行号" + item.LineNumber + "物料编号" + item.MaterialCode + $"分配的明细不能为空");
                }
                item.SendQuantity = item.dispenseDetailsForHand.Sum(x => x.DispenseQuantity);
            }
        }

        //var addWmsStockQuanLockList = new List<WmsStockQuanLock>();//新增的锁定库存信息
        //var updateWmsStockQuanLockList = new List<WmsStockQuanLock>();//修改的锁定库存信息


        var updateWmsOrderMoveDetailsList = new List<WmsOrderMovementDetails>();//修改的移动单明细
        var updateWmsOrderMoveList = new List<WmsOrderMovement>();//修改的移动单
        var addWmsRecordPredetermineDispenseList = new List<WmsRecordPredetermineDispense>();

        List<string> moveNoList = input.Select(s => s.MovementNo).ToList();
        var allWmsOrderSortList = await _wmsOrderMovementRep.GetListAsync(u => moveNoList.Contains(u.OrderNo));
        if (allWmsOrderSortList?.Count <= 0)
        {
            throw Oops.Oh("下架单不存在");
        }

        //获取下架单所有明细
        var allOrderSortDetails = await _wmsOrderMovementDetailsRep.GetListAsync(u => moveNoList.Contains(u.MovementNo));
        if (allOrderSortDetails?.Count <= 0)
        {
            throw Oops.Oh("下架单明细不存在");
        }

        // 查找物料库存
        List<string> materialCodeList = input.Select(x => x.MaterialCode).Distinct().ToList();


        //获取本次操作的下架单和下架单明细

        var currentMovementDetailsKeyList = input.Select(x => x.MovementNo + x.LineNumber).ToList();
        var currentMovementDetailsList = await _wmsOrderMovementDetailsRep.GetListAsync(x => currentMovementDetailsKeyList.Contains(x.MovementNo + x.LineNumber));
        var v_currentMovementDetailsList = await _v_wmsOrderMovementDetailsRep.GetListAsync(x => currentMovementDetailsKeyList.Contains(x.MovementNo + x.LineNumber));

        var queryOrderIds = currentMovementDetailsList.Select(x => x.MovementId).Distinct().ToList();
        var currentOrderMovementList = await _wmsOrderMovementRep.GetListAsync(x => queryOrderIds.Contains(x.Id));



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


        //获取下架单明细的物料预配锁定库存
        //var allDetailsPredetermineList = await _wmsStockQuanLockRep.GetListAsync(x => x.LockType == LockTypeEnum.预配 && x.IsDelete == false);
        var allDetailsPredetermineList = await LockStroreHelper.GetPreListAsync(materialCodeList, _wmsOrderMovementDetailsRep);



        foreach (var inputItem in input)
        {


            WmsOrderMovement movementOrder = currentOrderMovementList.FirstOrDefault(p => p.OrderNo == inputItem.MovementNo);
            if (movementOrder == null)
            {
                throw Oops.Oh("本次分配的下架单不存在");
            }
            //TODO 校验下架单状态
            var movementDetails = currentMovementDetailsList.FirstOrDefault(x => x.MovementNo == inputItem.MovementNo && x.LineNumber == inputItem.LineNumber);
            if (movementDetails == null)
            {
                throw Oops.Oh("本次分配的下架单明细不存在");
            }
            var v_movementDetails = v_currentMovementDetailsList.FirstOrDefault(x => x.MovementNo == inputItem.MovementNo && x.LineNumber == inputItem.LineNumber);
            if (v_movementDetails == null)
            {
                throw Oops.Oh("本次分配的下架单明细不存在");
            }

            if (!isHandFlag)
            {
                #region 处理自动分配
                decimal historyDispenseQuantity = v_movementDetails.DispenseQuantity;//下架单的历史分配数量

                decimal allQuantity = movementDetails.Quantity - historyDispenseQuantity;//下架单明细剩余可分配数量
                decimal occQuantity = inputItem.SendQuantity;//当前实际分配数量
                if ((occQuantity) <= 0)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"(本次分配数{occQuantity})不能小于等于0");
                }
                if (allQuantity <= 0)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"已全部分配");
                }
                if (occQuantity > allQuantity)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"本次分配数量{occQuantity}大于剩余可分配数{allQuantity}");
                }



                // 根据物料找出库存列表中数量大于0的库存
                List<string> querySNList = new List<string>();
                if (isHandFlag)
                {
                    querySNList = inputItem.dispenseDetailsForHand.Select(x => x.SNCode).ToList();
                }
                var findStockQuanList = allStockQuanUseList.Where(x => x.AvailableQty > 0 && x.MaterialCode == movementDetails.MaterialCode)
                .WhereIF(querySNList.Count > 0, x => querySNList.Contains(x.SNCode)) // 支持 手动分配的情况 【Editby shaocx,2024-07-12】
               .OrderBy(x => x.ContainerCode).ThenBy(x => x.PlaceCode).ThenBy(x => x.RecordInsertTime).ToList();
                if (findStockQuanList?.Count == 0)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"没有找到可分配的库存");
                }

                //寻找库存原则：按照先入先出原则 RecordInsertTime 排升序

                //物料跟踪码可用库存-没有排除预配锁定库存
                var sumQty = findStockQuanList.Sum(x => x.AvailableQty);


                var itemMovementDetailsKey = inputItem.MovementNo + inputItem.LineNumber;

                //获取当前下架单明细的物料预配锁定库存
                var currentDetailsPredetermine = allDetailsPredetermineList.Where(x => itemMovementDetailsKey.Equals(x.MovementNo + x.LineNumber)).ToList();

                //获取其他下架单明细的物料预配锁定库存
                var otherDetailsPredetermineList = allDetailsPredetermineList.Where(x => !itemMovementDetailsKey.Equals(x.MovementNo + x.LineNumber)).ToList();
                //其他单据预配锁定库存
                var orherPredetermineQty = otherDetailsPredetermineList.Sum(u => u.Quantity);
                orherPredetermineQty = orherPredetermineQty < 0 ? 0 : orherPredetermineQty;

                //当前可分配库存要排除掉其他单据预配锁定库存
                if (sumQty < occQuantity - orherPredetermineQty)
                {
                    throw Oops.Oh("物料编号" + movementDetails.MaterialCode + $"库存数量不足,分配数量:{occQuantity},库存可用数量:{sumQty}");
                }

                //处理后未分配的数量，多个同一个物料多个库存数据的情况，循环处理下发
                decimal currentDispenseQuantity = occQuantity;
                decimal changeQty = 0;//本次变更数量

                List<string> snCodeList = new List<string>();//下发的库存SNCode，存在使用多个情况
                foreach (var stockQuanItem in findStockQuanList)
                {
                    if (currentDispenseQuantity > 0)
                    {
                        //当前物料波次锁定库存
                        var currentStockQuanLockQty = findStockQuanList.Where(x => x.SNCode == stockQuanItem.SNCode)
                            .Sum(x => x.Quantity);
                        //当前物料可用库存
                        var currentUsedQuantity = stockQuanItem.AvailableQty;

                        //循环库存信息 处理下发数
                        if (currentUsedQuantity >= currentDispenseQuantity)//分配数量小于等于库存
                        {
                            changeQty = currentDispenseQuantity;
                            currentDispenseQuantity = 0;//全部分配，不在处理
                        }
                        else
                        {
                            changeQty = currentUsedQuantity;
                            //当前分配数未能完全分配，累计分配数
                            currentDispenseQuantity = currentDispenseQuantity - currentUsedQuantity;
                        }
                        //累计使用的库存跟踪码
                        snCodeList.Add(stockQuanItem.SNCode);


                        //创建分配记录
                        var addWmsRecordPredetermineDispense = CommonCreateWmsRecordPredetermineDispense(movementDetails, changeQty, stockQuanItem);


                        addWmsRecordPredetermineDispenseList.Add(addWmsRecordPredetermineDispense);


                        if (currentDispenseQuantity == 0)
                        {
                            break;
                        }


                    }
                    else
                    {
                        break;
                    }

                }
                if (currentDispenseQuantity > 0)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"(本次需求分配数{occQuantity})，还剩余{currentDispenseQuantity}未分配");
                }

                v_movementDetails.DispenseQuantity += occQuantity;//累计分配数

                /*
                //处理当前下架单明细实际使用的预配锁定库存
                //根据分配数扣减预配锁定库存的锁定使用数
                decimal currentPredetermineLockQty = occQuantity;
                if (currentDetailsPredetermine?.Count == 0)
                {
                    ////创建锁定库存
                    var addWmsStockQuanLock = LockStroreHelper.CommonCreateWmsStockQuanLockForPredetermine(movementDetails, occQuantity);
                    addWmsStockQuanLockList.Add(addWmsStockQuanLock);
                }
                else
                {
                    currentDetailsPredetermine.First().Quantity += occQuantity;
                    updateWmsStockQuanLockList.Add(currentDetailsPredetermine.First());
                }
                //*/

                //预配数等于分配数

                if (movementDetails.PredetermineQuantity < v_movementDetails.DispenseQuantity)
                {
                    movementDetails.PredetermineQuantity = v_movementDetails.DispenseQuantity;
                }


                movementOrder.IsDispense = true;//标记为已分配
                updateWmsOrderMoveList.Add(movementOrder);//更新下架单
                updateWmsOrderMoveDetailsList.Add(movementDetails);//更新下架单明细
                #endregion
            }
            else
            {
                #region 处理指定库存分配
                decimal historyDispenseQuantity = v_movementDetails.DispenseQuantity;//下架单的历史分配数量

                decimal allQuantity = movementDetails.Quantity - historyDispenseQuantity;//下架单明细剩余可分配数量
                decimal occQuantity = inputItem.SendQuantity;//当前实际分配数量
                if ((occQuantity) <= 0)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"(本次分配数{occQuantity})不能小于等于0");
                }
                if (allQuantity <= 0)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"已全部分配");
                }
                if (occQuantity > allQuantity)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"本次分配数量{occQuantity}大于剩余可分配数{allQuantity}");
                }



                // 根据物料找出库存列表中数量大于0的库存
                List<string> querySNList = new List<string>();
                if (isHandFlag)
                {
                    querySNList = inputItem.dispenseDetailsForHand.Select(x => x.SNCode).ToList();
                }
                var findStockQuanList = allStockQuanUseList.Where(x => x.AvailableQty > 0 && x.MaterialCode == movementDetails.MaterialCode)
                .WhereIF(querySNList.Count > 0, x => querySNList.Contains(x.SNCode)) // 支持 手动分配的情况 【Editby shaocx,2024-07-12】
               .OrderBy(x => x.ContainerCode).ThenBy(x => x.PlaceCode).ThenBy(x => x.RecordInsertTime).ToList();
                if (findStockQuanList?.Count == 0)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"没有找到可分配的库存");
                }
                if (findStockQuanList.Count != inputItem.dispenseDetailsForHand.Count)
                {
                    throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $",寻找的库存条数{findStockQuanList.Count}不等于预期处理条数{inputItem.dispenseDetailsForHand.Count}");
                }


                //物料跟踪码可用库存-没有排除预配锁定库存
                var sumQty = findStockQuanList.Sum(x => x.AvailableQty);


                var itemMovementDetailsKey = inputItem.MovementNo + inputItem.LineNumber;

                //获取当前下架单明细的物料预配锁定库存
                var currentDetailsPredetermine = allDetailsPredetermineList.Where(x => itemMovementDetailsKey.Equals(x.MovementNo + x.LineNumber)).ToList();

                //获取其他下架单明细的物料预配锁定库存
                var otherDetailsPredetermineList = allDetailsPredetermineList.Where(x => !itemMovementDetailsKey.Equals(x.MovementNo + x.LineNumber)).ToList();
                //其他单据预配锁定库存
                var orherPredetermineQty = otherDetailsPredetermineList.Sum(u => u.Quantity);
                orherPredetermineQty = orherPredetermineQty < 0 ? 0 : orherPredetermineQty;

                //当前可分配库存要排除掉其他单据预配锁定库存
                if (sumQty < occQuantity - orherPredetermineQty)
                {
                    throw Oops.Oh("物料编号" + movementDetails.MaterialCode + $"库存数量不足,分配数量:{occQuantity},库存可用数量:{sumQty}");
                }





                foreach (var stockQuanItem in findStockQuanList)
                {//这里的每次循环就是处理 每个指定库存的数据 

                    var singleDispenseDetailsItem = inputItem.dispenseDetailsForHand.Where(x => x.SNCode == stockQuanItem.SNCode).FirstOrDefault();

                    decimal currentDispenseQuantity = singleDispenseDetailsItem.DispenseQuantity;

                    //当前物料波次锁定库存
                    var currentStockQuanLockQty = findStockQuanList.Where(x => x.SNCode == stockQuanItem.SNCode)
                        .Sum(x => x.Quantity);
                    //当前物料可用库存
                    var currentUsedQuantity = stockQuanItem.AvailableQty;

                    //循环库存信息 处理下发数
                    if (currentUsedQuantity >= currentDispenseQuantity)//分配数量小于等于库存
                    {//正常

                    }
                    else
                    {
                        throw Oops.Oh("物料编号" + movementDetails.MaterialCode + $"计算库存数量不足,分配数量:{currentDispenseQuantity},库存可用数量:{currentUsedQuantity}");
                    }



                    //创建分配记录
                    var addWmsRecordPredetermineDispense = CommonCreateWmsRecordPredetermineDispense(movementDetails, currentDispenseQuantity, stockQuanItem);


                    addWmsRecordPredetermineDispenseList.Add(addWmsRecordPredetermineDispense);



                }


                v_movementDetails.DispenseQuantity += occQuantity;//累计分配数

                /*
                //处理当前下架单明细实际使用的预配锁定库存
                //根据分配数扣减预配锁定库存的锁定使用数
                decimal currentPredetermineLockQty = occQuantity;
                if (currentDetailsPredetermine?.Count == 0)
                {
                    ////创建锁定库存
                    var addWmsStockQuanLock = LockStroreHelper.CommonCreateWmsStockQuanLockForPredetermine(movementDetails, occQuantity);
                    addWmsStockQuanLockList.Add(addWmsStockQuanLock);
                }
                else
                {
                    currentDetailsPredetermine.First().Quantity += occQuantity;
                    updateWmsStockQuanLockList.Add(currentDetailsPredetermine.First());
                }
                //*/

                //预配数等于分配数

                if (movementDetails.PredetermineQuantity < v_movementDetails.DispenseQuantity)
                {
                    movementDetails.PredetermineQuantity = v_movementDetails.DispenseQuantity;
                }


                movementOrder.IsDispense = true;//标记为已分配
                updateWmsOrderMoveList.Add(movementOrder);//更新下架单
                updateWmsOrderMoveDetailsList.Add(movementDetails);//更新下架单明细
                #endregion
            }
        }

        //处理分配历史表
        List<WmsRecordPredDispHistory> addWmsRecordPredDispHistoryList = addWmsRecordPredetermineDispenseList.Adapt<List<WmsRecordPredDispHistory>>();
        foreach (var item in addWmsRecordPredDispHistoryList)
        {
            item.Remarks = "分配操作";
        }

        var _tenant = _wmsOrderMovementDetailsRep.AsTenant();

        try
        {
            #region 事务内执行操作

            //await _wmsStockQuanLockRep.InsertRangeAsync(addWmsStockQuanLockList);
            //await _wmsStockQuanLockRep.UpdateRangeAsync(updateWmsStockQuanLockList);


            await _wmsOrderMovementDetailsRep.UpdateRangeAsync(updateWmsOrderMoveDetailsList);
            await _wmsOrderMovementRep.UpdateRangeAsync(updateWmsOrderMoveList);
            await _wmsRecordPredetermineDispenseRep.InsertRangeAsync(addWmsRecordPredetermineDispenseList);
            await _wmsRecordPredDispHistoryRep.InsertRangeAsync(addWmsRecordPredDispHistoryList);
            #endregion

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

            await _tenant.RollbackTranAsync();
            throw;
        }








        return 1;
    }



    /// <summary>
    /// 取消分配
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private async Task<int> CancelDispenseForRecordFaction(CancelDispenseInput input)
    {

        //var addWmsStockQuanLockList = new List<WmsStockQuanLock>();//新增的锁定库存信息

        List<v_wms_stock_quan_for_use> allStockQuanUseList = new List<v_wms_stock_quan_for_use>();//选择分配的可用库存信息


        //获取当前修改的分配记录
        List<WmsRecordPredetermineDispense> updateRecordList = await _wmsRecordPredetermineDispenseRep.GetListAsync(u => u.MovementNo == input.MovementNo);

        WmsRecordPredetermineDispense updateRecord = updateRecordList.FirstOrDefault(u => u.Id == input.Id);
        if (updateRecord == null)
        {
            throw Oops.Oh($"下架单{updateRecord.MovementNo}不存在");
        }

        #region 处理旧的的分配


        //取消要修改的分配记录
        updateRecord.PDRecordStatus = PDRecordStatusEnum.已取消;
        updateRecord.PDRecordStatusName = PDRecordStatusEnum.已取消.GetDescription();
        updateRecord.Remarks = "取消分配";



        #endregion

        WmsOrderMovementDetails movementDetails = await _wmsOrderMovementDetailsRep.AsQueryable().FirstAsync(p => p.MovementNo == updateRecord.MovementNo && p.LineNumber == updateRecord.MovementLineNumber);
        if (movementDetails == null)
        {
            throw Oops.Oh($"下架单{updateRecord.MovementNo}的行号{updateRecord.MovementLineNumber}不存在");
        }
        V_WmsOrderMovementDetails v_movementDetails = await _v_wmsOrderMovementDetailsRep.AsQueryable().FirstAsync(p => p.MovementNo == updateRecord.MovementNo && p.LineNumber == updateRecord.MovementLineNumber);
        if (v_movementDetails == null)
        {
            throw Oops.Oh($"下架单{updateRecord.MovementNo}的行号{updateRecord.MovementLineNumber}不存在");
        }
        v_movementDetails.DispenseQuantity -= updateRecord.Quantity;
        if (v_movementDetails.DispenseQuantity < 0)
        {
            throw Oops.Oh($"下架单{updateRecord.MovementNo}的行号{updateRecord.MovementLineNumber}的已分配数量{v_movementDetails.DispenseQuantity}不能小于要取消的分配数量{updateRecord.Quantity}");
        }

        WmsOrderMovement movementOrder = await _wmsOrderMovementRep.AsQueryable().FirstAsync(p => p.OrderNo == updateRecord.MovementNo);
        if (movementOrder == null)
        {
            throw Oops.Oh($"下架单{updateRecord.MovementNo}不存在");
        }
        //判断如果没有任何分配记录了，就更新状态
        if (updateRecordList.Where(x => x.PDRecordStatus == PDRecordStatusEnum.已分配).Count() > 0)
        {

        }
        else
        {
            movementOrder.IsDispense = false;//标记为未分配
        }


        //处理分配历史表
        WmsRecordPredDispHistory addWmsRecordPredDispHistory = updateRecord.Adapt<WmsRecordPredDispHistory>();
        addWmsRecordPredDispHistory.Id = Yitter.IdGenerator.YitIdHelper.NextId();
        addWmsRecordPredDispHistory.Quantity = -addWmsRecordPredDispHistory.Quantity;
        addWmsRecordPredDispHistory.Remarks = "取消分配";


        var _tenant = _wmsOrderMovementRep.AsTenant();

        try
        {
            #region 事务内执行操作

            await _wmsOrderMovementRep.UpdateAsync(movementOrder);
            await _wmsOrderMovementDetailsRep.UpdateAsync(movementDetails);

            //await _wmsStockQuanLockRep.InsertRangeAsync(addWmsStockQuanLockList);

            await _wmsRecordPredetermineDispenseRep.UpdateAsync(updateRecord);

            await _wmsRecordPredDispHistoryRep.InsertAsync(addWmsRecordPredDispHistory);
            #endregion

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

            await _tenant.RollbackTranAsync();
            throw;
        }








        return 1;
    }



    /// <summary>
    /// 修改分配 验证分配操作入参
    /// </summary>
    /// <param name="input"></param>
    /// <param name="allStockQuanUseList"></param>
    /// <param name="updateRecord"></param>
    /// <returns></returns>

    private async Task<WmsRecordPredetermineDispense> ValidateInput(UpdateDispenseInput input, List<v_wms_stock_quan_for_use> allStockQuanUseList)
    {

        //一次只能编辑一个分配记录

        if (string.IsNullOrWhiteSpace(input.SNCode))
        {
            throw Oops.Oh("分配的库存跟踪码不能为空");
        }


        if (input.Id <= 0)
        {

            throw Oops.Oh("要修改的分配记录不能为空");
        }
        //获取当前修改的分配记录
        WmsRecordPredetermineDispense updateRecord = await _wmsRecordPredetermineDispenseRep.GetFirstAsync(u => u.Id == input.Id);

        if (updateRecord == null)
        {
            throw Oops.Oh("分配记录不存在");
        }


        //TODO 暂不支持修改分配数
        //if (input.SendQuantity <= 0)
        //{
        //    throw Oops.Oh("修改后的分配数量必须大于0");
        //}


        // 查找物料库存
        List<string> snCodeList = ParamHelper.GetStringParamToList(input.SNCode);


        if (updateRecord.PDRecordStatus != PDRecordStatusEnum.已分配)
        {
            throw Oops.Oh($"分配记录状态是{updateRecord.PDRecordStatus.GetDescription()}");
        }

        //根据物料编码获取物料跟踪码的可用库存信息）
        var stockQuanUseList = await _v_wms_stock_quan_for_useRep.GetListAsync(x => snCodeList.Contains(x.SNCode));
        if (stockQuanUseList?.Count <= 0)
        {
            throw Oops.Oh("修改分配的库存跟踪码未获取到可用库存");
        }

        allStockQuanUseList.AddRange(stockQuanUseList);
        return updateRecord;
    }





    ///// <summary>
    ///// 移动单分配
    ///// </summary>
    ///// <param name="input"></param>
    ///// <returns></returns>
    //private async Task<int> LockMovePredetermine(List<WmsOrderMovePredetermineInput> input)
    //{



    //    var addWmsStockQuanLockList = new List<WmsStockQuanLock>();//新增的锁定库存信息
    //    var updateWmsOrderMoveDetailsList = new List<WmsOrderMovementDetails>();//修改的移动单明细
    //    var updateWmsOrderMoveList = new List<WmsOrderMovement>();//修改的移动单
    //    //TODO 添加事务记录

    //    List<string> sortNoList = input.Select(x => x.movementNo).ToList();
    //    // 获取所有波次单

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

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

    //    //本次下发波次单明细
    //    var currentOrderSortDetails = allOrderSortDetails.Where(u => input.Select(x => x.Id).Contains(u.Id)).ToList();
    //    if (currentOrderSortDetails?.Count <= 0)
    //    {
    //        throw Oops.Oh("本次操作的下架单明细不存在");
    //    }


    //    // 查找物料库存
    //    List<string> materialCodeList = currentOrderSortDetails.Select(x => x.MaterialCode).Distinct().ToList();

    //    //获取可操作下发的库存信息-（未排除锁定库存）库存状态已上架、质检状态合格、非虚拟库位
    //    var queryParam = ExpressionHelper.GetStockQuanForIssueOutTask();
    //    queryParam.And(x => materialCodeList.Contains(x.MaterialCode));
    //    var allStockQuanList = await _v_wms_stock_quanRep.GetListAsync(queryParam);
    //    if (allStockQuanList?.Count <= 0)
    //    {
    //        throw Oops.Oh("所有物料都没有库存");
    //    }

    //    //获取所有物料锁定库存
    //    var allStockQuanLockList = await _wmsStockQuanLockRep.GetListAsync(x => materialCodeList.Contains(x.MaterialCode));
    //    //波次下发物料锁定库存
    //    var allStockQuanLockForSortList = allStockQuanLockList.Where(x => x.LockType == LockTypeEnum.分配 && x.IsDelete == false).ToList();
    //    //TODO 分配分配锁定库存

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

    //    foreach (var inputItem in input)
    //    {
    //        var item = currentOrderSortDetails.FirstOrDefault(x => x.Id == inputItem.Id);

    //        WmsOrderMovement movementOrder = orderMovementList.FirstOrDefault(p => p.OrderNo == item.MovementNo);
    //        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("本次分配的下架单明细不存在");
    //        }
    //        #region 处理下发
    //        decimal issueQuantity = item.PredetermineQuantity ;//下架单的历史分配数量

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

    //        // 根据物料找出库存列表中数量大于0的库存
    //        var findStockQuanList = allStockQuanList.Where(x => (x.Quantity) > 0 && x.MaterialCode == item.MaterialCode)
    //       .OrderBy(x => x.ContainerCode).ThenBy(x => x.PlaceCode).ThenBy(x => x.RecordInsertTime).ToList();
    //        //寻找库存原则：按照先入先出原则 RecordInsertTime 排升序
    //        //同一个物料尽量从同一个库位取 
    //        if (findStockQuanList.Count() <= 0)
    //        {
    //            //缺料
    //            throw Oops.Oh("物料编号" + item.MaterialCode + $"库存数量不足,分配需求数量:{occQuantity},库存可用数量:0");
    //        }

    //        var sumQty = findStockQuanList.Where(o => o.MaterialCode == item.MaterialCode).Sum(x => x.Quantity);
    //        //波次下发 实际锁定库存
    //        var lockQtyForSort = allStockQuanLockForSortList.Where(o => o.MaterialCode == item.MaterialCode).Sum(x => x.Quantity);
    //        //TODO 去掉分配分配锁定库存
    //        var usedQty = (sumQty - lockQtyForSort) <= 0 ? 0 : (sumQty - lockQtyForSort);
    //        if (usedQty < occQuantity)
    //        {
    //            throw Oops.Oh("物料编号" + item.MaterialCode + $"库存数量不足,分配需求数量:{occQuantity},库存可用数量:{usedQty}");
    //        }

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

    //        List<string> snCodeList = new List<string>();//下发的库存SNCode，存在使用多个情况
    //        foreach (var stockQuanItem in findStockQuanList)
    //        {
    //            //库位属性是 封存和禁出的，不能操作下架
    //            if (stockQuanItem.PlaceStatus == PlaceStatusEnum.封存)
    //            {
    //                throw Oops.Oh($"库位编号{stockQuanItem.PlaceCode}库位属性是{PlaceStatusEnum.封存.GetDescription()}");
    //            }
    //            if (stockQuanItem.PlaceStatus == PlaceStatusEnum.禁出)
    //            {
    //                throw Oops.Oh($"库位编号{stockQuanItem.PlaceCode}库位属性是{PlaceStatusEnum.禁出.GetDescription()}");
    //            }

    //            if (currentDispenseQuantity > 0)
    //            {
    //                //当前物料波次锁定库存
    //                var currentStockQuanLockQty = allStockQuanLockForSortList.Where(x => x.SNCode == stockQuanItem.SNCode).Sum(x => x.Quantity);
    //                //当前物料可用库存
    //                var currentUsedQuantity = (stockQuanItem.Quantity - currentStockQuanLockQty);
    //                currentUsedQuantity = currentUsedQuantity <= 0 ? 0 : currentUsedQuantity;

    //                //循环库存信息 处理下发数
    //                if (currentUsedQuantity >= currentDispenseQuantity)//下发数量小于等于库存
    //                {

    //                    currentDispenseQuantity = 0;//全部下发，不在处理

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

    //                }
    //                //累计使用的库存跟踪码
    //                snCodeList.Add(stockQuanItem.SNCode);



    //                //创建锁定库存
    //                var addWmsStockQuanLock = CommonCreateWmsStockQuanLock(item, occQuantity, stockQuanItem);

    //                //创建分拣信息
    //                var addWmsContainerSort = CommonCreateWmsContainerSort(item, movementOrder, sortMovementDetails, occQuantity, addWmsStockQuanLock);





    //                addWmsStockQuanLockList.Add(addWmsStockQuanLock);

    //                if (currentDispenseQuantity == 0)
    //                {
    //                    break;
    //                }


    //            }
    //            else
    //            {
    //                break;
    //            }
    //        }

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

    //        }

    //        //更新波次单的已下发数量
    //        item.SNCode = string.Join(",", snCodeList.Distinct().ToList());

    //        decimal lastIssueQuantity = issueQuantity + occQuantity;//下架单单的历史分配数
    //        item.PredetermineQuantity = lastIssueQuantity;//累计分配数

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

    //        #endregion
    //    }

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



    //    if (addWmsContainerSortList?.Count <= 0)
    //    {


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

    //    }



    //    var _tenant = _wmsContainerSortRep.AsTenant();

    //    try
    //    {
    //        #region 事务内执行操作
    //        await _wmsStockQuanLockRep.InsertRangeAsync(addWmsStockQuanLockList);
    //        await _wmsOrderSortRep.UpdateRangeAsync(updateWmsOrderSortList);
    //        await _wmsOrderSortDetailsRep.UpdateRangeAsync(updateWmsOrderSortDetailsList);
    //        #endregion

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

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








    //    return 1;
    //}








    /// <summary>
    /// 创建记录分配信息-新建分配用
    /// </summary>
    /// <param name="item"></param>
    /// <param name="changeQty"></param>
    /// <param name="stockQuanItem"></param>
    /// <returns></returns>
    private static WmsRecordPredetermineDispense CommonCreateWmsRecordPredetermineDispense(WmsOrderMovementDetails item, decimal changeQty, v_wms_stock_quan_for_use stockQuanItem)
    {

        return new WmsRecordPredetermineDispense()
        {
            Id = Yitter.IdGenerator.YitIdHelper.NextId(),
            PDRecordType = PDRecordTypeEnum.分配,
            PDRecordTypeName = PDRecordTypeEnum.分配.GetDescription(),
            PDRecordStatus = PDRecordStatusEnum.已分配,
            PDRecordStatusName = PDRecordStatusEnum.已分配.GetDescription(),
            MaterialCode = item.MaterialCode,
            MaterialName = item.MaterialName,
            Quantity = changeQty,
            MovementLineNumber = item.LineNumber,//下架单行号
            MovementNo = item.MovementNo,//下架单号
            SNCode = stockQuanItem.SNCode,//用于分配的库存跟踪码
            Batch = stockQuanItem.Batch,//批次号
            SupplierBatch = stockQuanItem.SupplierBatch,//供应商批次号
            AreaCode = stockQuanItem.AreaCode,//库区编码
            AreaName = stockQuanItem.AreaName,//库区名称
            PlaceCode = stockQuanItem.PlaceCode,
            PlaceName = stockQuanItem.PlaceName,
            ContainerCode = stockQuanItem.ContainerCode,
            ContainerName = stockQuanItem.ContainerName,
            Remarks = "",

        };
    }







    #endregion




}