using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
namespace Admin.NET.Application;
/// <summary>
/// 波次单服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsOrderGroupName, Order = 100)]
public class WmsOrderSortService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsOrderSort> _rep;
    private readonly SqlSugarRepository<WmsOrderSortDetails> _WmsOrderSortDetailsRep;
    private readonly SqlSugarRepository<WmsOrderMovement> _WmsOrderMovementRep;
    private readonly SqlSugarRepository<WmsOrderMovementDetails> _WmsOrderMovementDetailsRep;
    private readonly SqlSugarRepository<WmsOrderDeliverDetails> _WmsOrderDeliverDetailsRep;
    private readonly SqlSugarRepository<WmsOrderDeliver> _WmsOrderDeliverRep;

    public WmsOrderSortService(SqlSugarRepository<WmsOrderSort> rep,  
        SqlSugarRepository<WmsOrderSortDetails> wmsOrderSortDetailsRep,
        SqlSugarRepository<WmsOrderMovement> WmsOrderMovementRep,
        SqlSugarRepository<WmsOrderMovementDetails> WmsOrderMovementDetailsRep,
        SqlSugarRepository<WmsOrderDeliverDetails> wmsOrderDeliverDetailsRep,
        SqlSugarRepository<WmsOrderDeliver> wmsOrderDeliverRep)
    {
        _rep = rep;
        _WmsOrderSortDetailsRep = wmsOrderSortDetailsRep;
        _WmsOrderMovementRep = WmsOrderMovementRep;
        _WmsOrderMovementDetailsRep = WmsOrderMovementDetailsRep;
        _WmsOrderDeliverDetailsRep = wmsOrderDeliverDetailsRep;
        _WmsOrderDeliverRep = wmsOrderDeliverRep;
    }

    /// <summary>
    /// 分页查询波次单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    [Description("WmsOrderSort/Page")]
    public async Task<SqlSugarPagedList<WmsOrderSortOutput>> Page(WmsOrderSortInput input)
    {
        var query = CommonPageFilter(input);
        return await query
               .OrderBy(x => x.SortStatus).OrderByDescending(x => x.CreateTime)
           // .OrderBuilder(input, "", "Id")
            .ToPagedListAsync(input.Page, input.PageSize);
    }

    /// <summary>
    /// 不分页查询波次单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    [Description("WmsOrderSort/List")]
    public async Task<List<WmsOrderSortOutput>> List([FromQuery] WmsOrderSortInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").Select<WmsOrderSortOutput>().ToListAsync();
    }

    /// <summary>
    /// 增加波次单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [Description("WmsOrderSort/Add")]
    public async Task<long> Add(AddWmsOrderSortInput input)
    {
        var entity = input.Adapt<WmsOrderSort>();

        //重复性验证
        await CheckExist(entity);

        await _rep.InsertAsync(entity);
        return entity.Id;
    }

    /// <summary>
    /// 取消波次单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    [Description("WmsOrderSort/Delete")]
    public async Task Delete(DeleteWmsOrderSortInput input)
    {
     
        var entity = await _rep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
        if (entity.SortStatus != OrderStatusEnum.新建)
        {
            throw Oops.Oh($"{entity.SortNo}单据状态是{entity.SortStatusName}，不允许取消波次");
        }
        //----------主表单据-状态变取消
        entity.SortStatus = OrderStatusEnum.已取消;
        entity.SortStatusName =GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.已取消);
        var OrderDetails = await _WmsOrderSortDetailsRep.AsQueryable()
                       .Where(x => x.SortId == entity.Id)
                       .Where(u => u.IsDelete == false)
                       .Select<WmsOrderSortDetails>()
                       .ToListAsync();
        //-----------波次单-取消明细-状态变取消
        List<WmsOrderSortDetails> deleteWareOrderDetails = new List<WmsOrderSortDetails>();
        var deleteList = OrderDetails.Where(x => x.IsDelete == false).ToList();
        foreach (var item in deleteList)
        {
            if (item.SortDetailStatus != OrderStatusEnum.新建)
            {
                throw Oops.Oh($"物料{item.MaterialCode}的状态是{item.SortDetailStatusName}，不允许取消波次");
            }
            if (item.IssueQuantity > 0)
            {
                throw Oops.Oh($"物料{item.MaterialCode}已下发，不允许取消波次");
            }
            item.SortDetailStatus = OrderStatusEnum.已取消;
            item.SortDetailStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.已取消);
            deleteWareOrderDetails.Add(item);
        }

        //-------------寻找更新下架单物料明细 单号
        List<string> queryCodeList = deleteList.Select(v => v.RelationNo).Distinct().ToList();

        List<WmsOrderMovementDetails> UpdateWmsOrderMovementDetailsList = new List<WmsOrderMovementDetails>();
        var handleList = await _WmsOrderMovementDetailsRep.GetListAsync(u => queryCodeList.Contains(u.MovementNo) && u.IsDelete == false);
        if (handleList == null || handleList.Count<=0)
        {
            throw Oops.Oh($"没有查到需要更新的下架单物料明细");
        }

        //下架单-明细状态 -改 新建|执行中 波次数量回退
        foreach (var item in handleList)
        {
            if (item.OrderStatus == OrderStatusEnum.已取消 || item.OrderStatus == OrderStatusEnum.已关闭)
            {
                throw Oops.Oh($"物料{item.MaterialCode}状态{item.OrderStatusName}，不允许取消波次");
            }
            //波次单存在的物料
            var itemBoc = deleteWareOrderDetails.FirstOrDefault(x => x.MaterialCode == item.MaterialCode && x.RelationNoLineNumber == item.LineNumber && x.RelationNo == item.MovementNo);
            if (itemBoc != null)
            {
                if (itemBoc.Quantity < 0)
                {
                    throw Oops.Oh($"物料{item.MaterialCode}下架单号{item.MovementNo}下架单行号{item.LineNumber}，数量小于0！");
                }
                item.CreateWaveQuantity -= itemBoc.Quantity;
                if (item.CreateWaveQuantity <= 0)
                {
                    item.OrderStatus = OrderStatusEnum.新建;
                    item.OrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
                }
                else
                {
                    item.OrderStatus = OrderStatusEnum.处理中;
                    item.OrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
                }
                if (item.CreateWaveQuantity < 0)
                {
                    throw Oops.Oh($"物料{item.MaterialCode}下架单号{item.MovementNo}下架单行号{item.LineNumber}，波次数量小于0！");
                }
                UpdateWmsOrderMovementDetailsList.Add(item);
            }
        }


        //下架单-主表状态 - 新建|处理中
        List<WmsOrderMovement> UpdateWmsOrderMovementList = new List<WmsOrderMovement>();
        var handleListXjdMain = await _WmsOrderMovementRep.GetListAsync(u => queryCodeList.Contains(u.OrderNo) && u.IsDelete == false);
        if (handleListXjdMain.Count <= 0)
        {
            throw Oops.Oh($"没有查到需要更新的下架单单号");
        }

        var handleListXjdDetails = await _WmsOrderMovementDetailsRep.GetListAsync(u => queryCodeList.Contains(u.MovementNo) && u.IsDelete == false);

        foreach (var item in handleListXjdMain)
        {
            if (item.OrderStatus == OrderStatusEnum.已取消 || item.OrderStatus == OrderStatusEnum.已关闭)
            {
                throw Oops.Oh($"下架单{item.OrderNo}状态{item.OrderStatusName}，不允许取消波次");
            }

            var totalXjdDetailStatusWc = handleListXjdDetails.Where(x => x.MovementNo == item.OrderNo && x.OrderStatus == OrderStatusEnum.已完成).Count();
            var totalXjdDetailStatus = handleListXjdDetails.Where(x => x.MovementNo == item.OrderNo && x.OrderStatus == OrderStatusEnum.处理中).Count();
            var changeXjdDetailStatus = UpdateWmsOrderMovementDetailsList.Where(x => x.MovementNo == item.OrderNo && x.OrderStatus == OrderStatusEnum.新建).Count();
            if (totalXjdDetailStatus <= changeXjdDetailStatus && totalXjdDetailStatusWc<=0)
            {
                item.OrderStatus = OrderStatusEnum.新建;
                item.OrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
            }
            else
            {
                item.OrderStatus = OrderStatusEnum.处理中;
                item.OrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
            }
            UpdateWmsOrderMovementList.Add(item);
        }


        //-------- ly 绑定的DO  波次数 和 状态回退 已关闭的DO单不允许取消------------
        var WmsOrderDeliverDetailsArr = new List<WmsOrderDeliverDetails>();
        var WmsOrderDeliverArr = new List<WmsOrderDeliver>();
        List<string> queryCodeListForDo = handleListXjdDetails.Where(v => !string.IsNullOrWhiteSpace(v.RelationNo)).Select(v => v.RelationNo).Distinct().ToList();
        if (queryCodeListForDo.Count > 0)
        {
            var handleListForDo = await _WmsOrderDeliverDetailsRep.GetListAsync(u => queryCodeListForDo.Contains(u.DoNo) && u.IsDelete == false);

            foreach (var w in handleListForDo)
            {
                //下架单物料
                var item = handleListXjdDetails.FirstOrDefault(x => x.MaterialCode == w.MaterialCode && x.RelationNoLineNumber == w.DoLineNumber && x.RelationNo == w.DoNo);
              
                if (item != null )
                {
                    //波次物料 - 回退数量
                    var itemBc = deleteWareOrderDetails.FirstOrDefault(x => x.MaterialCode == item.MaterialCode && x.RelationNoLineNumber == item.LineNumber && x.RelationNo == item.MovementNo);
                    if (itemBc != null)
                    {
                        var hasUseBoQty = w.CreateMovementQuantity;
                        w.CreateMovementQuantity = w.CreateMovementQuantity - itemBc.Quantity;
                        if (w.CreateMovementQuantity < 0)
                        {
                            throw Oops.Oh($"创建失败：DO单号{w.DoNo},物料编号{w.MaterialCode},DO行号{w.DoLineNumber},订单数{w.Quantity},已创建的波次数{hasUseBoQty},无可用回退数量{itemBc.Quantity}!");
                        }
                        if (w.CreateMovementQuantity <= 0)
                        {
                            w.DoDetailStatus = OrderStatusEnum.新建;
                            w.DoDetailStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
                        }
                        else
                        {
                            w.DoDetailStatus = OrderStatusEnum.处理中;
                            w.DoDetailStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
                        }
                        WmsOrderDeliverDetailsArr.Add(w);
                    }
                }
            }
       
            if (WmsOrderDeliverDetailsArr.Count > 0)
            {
                var handleListForDoMain = await _WmsOrderDeliverRep.GetListAsync(u => queryCodeListForDo.Contains(u.DeliverNo) && u.IsDelete == false);
                if (handleListForDoMain == null || handleListForDoMain.Count <= 0)
                {
                    throw Oops.Oh("创建失败：没有找到主DO订单单号");
                }
                var handleListForDoOld = await _WmsOrderDeliverDetailsRep.GetListAsync(u => queryCodeListForDo.Contains(u.DoNo) && u.IsDelete == false);

                foreach (var w in handleListForDoMain)
                {
                    if (w.DoStatus == OrderStatusEnum.处理中)
                    {
                        var totalDoStatusWc = handleListForDoOld.Where(x => x.DoNo == w.DeliverNo && x.IsDelete == false && x.DoDetailStatus == OrderStatusEnum.已完成).Count();
                        var totalDoStatus = handleListForDoOld.Where(x => x.DoNo == w.DeliverNo && x.IsDelete == false && x.DoDetailStatus == OrderStatusEnum.处理中).Count();
                        var changeStatus = WmsOrderDeliverDetailsArr.Where(x => x.DoNo == w.DeliverNo && x.IsDelete == false && x.DoDetailStatus == OrderStatusEnum.新建).Count();
                        var qtybcs = totalDoStatus - changeStatus; //所有处理中 - 撤回的处理中
                        if (qtybcs <= 0 && totalDoStatusWc<=0)
                        {
                            w.DoStatus = OrderStatusEnum.新建;
                            w.DoStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
                        }
                        else
                        {
                            w.DoStatus = OrderStatusEnum.处理中;
                            w.DoStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
                        }
                        WmsOrderDeliverArr.Add(w);
                    }
                }
            }
            //------------更新DO----------

        }

        try
        {
            await _rep.AsTenant().BeginTranAsync();
            if (entity != null)
            {
                await _rep.UpdateAsync(entity);   //更新波次单-主表状态
            }
            if (deleteWareOrderDetails.Count > 0)
            {
                await _WmsOrderSortDetailsRep.UpdateRangeAsync(deleteWareOrderDetails); //更新波次单-明细状态
            }
            if (UpdateWmsOrderMovementList.Count > 0)
            {
                await _WmsOrderMovementRep.UpdateRangeAsync(UpdateWmsOrderMovementList);   //更新下架单-主表状态 - 新建
            }
            if (UpdateWmsOrderMovementDetailsList.Count > 0)
            {
                await _WmsOrderMovementDetailsRep.UpdateRangeAsync(UpdateWmsOrderMovementDetailsList); //更新下架单-明细状态 - 新建|执行中 波次数
            }
            if (WmsOrderDeliverArr.Count > 0)
            {
                await _WmsOrderDeliverRep.UpdateRangeAsync(WmsOrderDeliverArr);  //更新DO单主表
            }
            if (WmsOrderDeliverDetailsArr.Count > 0)
            {
                await _WmsOrderDeliverDetailsRep.UpdateRangeAsync(WmsOrderDeliverDetailsArr);  //更新DO单明细表 - 新建|执行中 波次数
            }
            await _rep.AsTenant().CommitTranAsync();
        }
        catch
        {
            await _rep.AsTenant().RollbackTranAsync();
            throw;
        }
    }

    /// <summary>
    /// 更新波次单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [Description("WmsOrderSort/Update")]
    public async Task Update(UpdateWmsOrderSortInput input)
    {
        var entity = input.Adapt<WmsOrderSort>();

        //重复性验证
        await CheckExist(entity,true);

        await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
    }

    /// <summary>
    /// 获取波次单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    [Description("WmsOrderSort/Detail")]
    public async Task<WmsOrderSort> Detail([FromQuery] QueryByIdWmsOrderSortInput input)
    {
        return await _rep.GetFirstAsync(u => u.Id == input.Id);
    }






    #region 私有方法

    /// <summary>
    /// 公共查询波次单条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<WmsOrderSortOutput> CommonPageFilter(WmsOrderSortInput input)
    {

        //ly0802-关联单号查询
        List<string> queryOderNosForRelationNos = null;
        if (!string.IsNullOrEmpty(input.RelationNo))
        {
           queryOderNosForRelationNos = _WmsOrderSortDetailsRep.AsQueryable()
                .Where(x => x.RelationNo == input.RelationNo).Select(x => x.SortNo).Distinct().ToList();
        }

        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.SortNo.Contains(input.SearchKey.Trim())
                || u.OrderTypeName.Contains(input.SearchKey.Trim())
                || u.BusinessTypeName.Contains(input.SearchKey.Trim())
                || u.SortStatusName.Contains(input.SearchKey.Trim())
                || u.ErpOrderNo.Contains(input.SearchKey.Trim())
                || u.RelationNo.Contains(input.SearchKey.Trim())
                || u.Remarks.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
            )
            .WhereIF(!string.IsNullOrWhiteSpace(input.SortNo), u => u.SortNo.Contains(input.SortNo.Trim()))
            .WhereIF(input.OrderType.HasValue, u => u.OrderType == input.OrderType)
            .WhereIF(!string.IsNullOrWhiteSpace(input.OrderTypeName), u => u.OrderTypeName.Contains(input.OrderTypeName.Trim()))
            .WhereIF(input.BusinessType.HasValue, u => u.BusinessType == input.BusinessType)
            .WhereIF(!string.IsNullOrWhiteSpace(input.BusinessTypeName), u => u.BusinessTypeName.Contains(input.BusinessTypeName.Trim()))
            .WhereIF(input.OrderSocure.HasValue, u => u.OrderSocure == input.OrderSocure)
            .WhereIF(input.SortStatus.HasValue, u => u.SortStatus == input.SortStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.SortStatusName), u => u.SortStatusName.Contains(input.SortStatusName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpOrderNo), u => u.ErpOrderNo.Contains(input.ErpOrderNo.Trim()))
            .WhereIF(queryOderNosForRelationNos != null, u => queryOderNosForRelationNos.Contains(u.SortNo))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Remarks), u => u.Remarks.Contains(input.Remarks.Trim()))
            .Select<WmsOrderSortOutput>();
        return query;
       }

        /// <summary>
        /// 重复性验证
        /// </summary>
        /// <param name="input">验证对象</param>
        /// <param name="isEdit">是否是编辑</param>
        /// <returns></returns>
        private async Task CheckExist( WmsOrderSort input,bool isEdit=false)
        {
           


            //没有配置组合校验，不需要验重

           
            //没有配置单独校验，不需要验重
       }

       /// <summary>
        /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
        /// </summary>
        /// <param name="inputs"></param>
        /// <returns></returns>
        private async Task CheckExisitForImport(List<WmsOrderSort> inputs)
        { 
            if (inputs?.Count <= 0)
            {
                throw Oops.Oh($"导入数据不能为空");
            }
            //根据组合校验验证表格中中是否已存在相同数据  
                      






          
           //根据单独校验验证表格中中是否已存在相同数据  
           
           
           
        }
     #endregion

}