using Admin.NET.Application.Entity;
using Admin.NET.Application;

namespace Admin.NET.Application
{
    /// <summary>
    /// 到货单 帮助类
    /// </summary>
    public class OrderHelper
    {


        /// <summary>
        /// 公共更新 ASN单的 状态和 总的的已收货数
        /// </summary>
        /// <param name="wmsOrderAsnDetails"></param>
        /// <param name="wmsOrderAsn"></param>
        public static  void UpdateWmsOrderAsnStatus(List<WmsOrderAsnDetails> wmsOrderAsnDetails,
            WmsOrderAsn wmsOrderAsn)
        {

            var wmsOrderAsnDetailsAll = wmsOrderAsnDetails.Where(x => x.AsnId == wmsOrderAsn.Id && x.IsDelete == false).ToList();
            if (wmsOrderAsnDetailsAll?.Count <=0)
            {
                throw Oops.Oh($"ASN单号{wmsOrderAsn.AsnNo}更新状态，未获取到明细！");
            }
            else
            {   
                //汇总明细的已收货数
                var totalGoodsQuantity = wmsOrderAsnDetails.Sum(o => o.GoodsQuantity);
                if (wmsOrderAsnDetailsAll.Sum(o => o.GoodsQuantity) == 0)
                {
                    wmsOrderAsn.AsnStatus = OrderStatusEnum.新建;
                }
                else if (wmsOrderAsnDetailsAll.Sum(o => o.Quantity - o.GoodsQuantity) <= 0)
                {
                    wmsOrderAsn.AsnStatus = OrderStatusEnum.已完成;
                }
                else if (wmsOrderAsnDetailsAll.Sum(o => o.GoodsQuantity) > 0)
                {
                    wmsOrderAsn.AsnStatus = OrderStatusEnum.处理中;
                }
                //单据状态名称赋值
                wmsOrderAsn.AsnStatusName = wmsOrderAsn.AsnStatus.GetDescription();

            }
        }

        /// <summary>
        /// 公共更新 ASN单明细 状态 
        /// </summary>
        /// <param name="goodsdetail"></param>
        public static void UpdateOrderAsnDetailsStatus(WmsOrderAsnDetails goodsdetail)
        {
            if (goodsdetail.GoodsQuantity == 0)
            {

                goodsdetail.AsnStatus = OrderStatusEnum.新建;
            }
            else if (goodsdetail.GoodsQuantity >= goodsdetail.Quantity)
            {
                goodsdetail.AsnStatus = OrderStatusEnum.已完成;
            }
            else
            {
                goodsdetail.AsnStatus = OrderStatusEnum.处理中;
            }
            //明细状态名称赋值
            goodsdetail.AsnStatusName = goodsdetail.AsnStatus.GetDescription();
        }

        // <summary>
        /// 公共更新 PO单的 状态 和总的的已收货数
        /// </summary>
        /// <param name="wmsOrderAsnDetails"></param>
        /// <param name="wmsOrderAsn"></param>
        public static void UpdatOrderPurchaseStatus(List<WmsOrderPurchaseDetails> wmsOrderPurchaseDetails,
            WmsOrderPurchase wmsOrderPurchase)
        {

            var wmsOrderPurchaseDetailsAll = wmsOrderPurchaseDetails.Where(x => x.PoId == wmsOrderPurchase.Id && x.IsDelete == false).ToList();
            if (wmsOrderPurchaseDetailsAll?.Count<=0)
            {
                throw Oops.Oh($"PO单{wmsOrderPurchase.PurchaseNo}更新状态，未获取到明细！");
            }
            else
            {
                //汇总明细的已收货数
                var totalGoodsQuantity= wmsOrderPurchaseDetailsAll.Sum(o => o.GoodsQuantity);
                if (wmsOrderPurchaseDetailsAll.Sum(o => o.GoodsQuantity) == 0)
                {
                    wmsOrderPurchase.PoStatus = OrderStatusEnum.新建;
                }
                else if (wmsOrderPurchaseDetailsAll.Sum(o => o.Quantity - o.GoodsQuantity) <= 0)
                {
                
                    wmsOrderPurchase.PoStatus = OrderStatusEnum.已完成;
                }
                else if (wmsOrderPurchaseDetailsAll.Sum(o => o.GoodsQuantity) > 0)
                {
                    wmsOrderPurchase.PoStatus = OrderStatusEnum.处理中;
                }
                //单据状态名称赋值
                wmsOrderPurchase.PoStatusName = wmsOrderPurchase.PoStatus.GetDescription();

            }
        }

        /// <summary>
        /// 公共更新 PO单明细 状态 
        /// </summary>
        /// <param name="detail"></param>
        public static void UpdateOrderPurchaseDetailsStatus(WmsOrderPurchaseDetails detail)
        {
            if (detail.GoodsQuantity == 0)
            {

                detail.PoDetailStatus = OrderStatusEnum.新建;
            }
            else if (detail.GoodsQuantity >= detail.Quantity)
            {
                detail.PoDetailStatus = OrderStatusEnum.已完成;
            }
            else
            {
                detail.PoDetailStatus = OrderStatusEnum.处理中;
            }
            //明细状态名称赋值
            detail.PoDetailStatusName = detail.PoDetailStatus.GetDescription();
        }


        // <summary>
        /// 公共更新 报检单的 单据状态 
        /// </summary>
        /// <param name="wmsOrderAsnDetails"></param>
        /// <param name="wmsOrderAsn"></param>
        public static void UpdateQCOrderStatus(List<WmsOrderQcDetails> wmsQcDetails,
            WmsOrderQc wmsQc)
        {

            var wmsQcDetailsAll = wmsQcDetails.Where(x => x.QCOrderId == wmsQc.Id && x.IsDelete == false).ToList();
            if (wmsQcDetailsAll?.Count <= 0)
            {
                throw Oops.Oh($"报检单{wmsQc.QCNo}更新状态，未获取到明细！");
            }
            else
            {
                //明细总数
                var totalQcQuantity = wmsQcDetailsAll.Count();
                //新建状态的明细数量
                var newBuildQcQuantity = wmsQcDetailsAll.Count(o => o.QCOrderStatus == OrderStatusEnum.新建);
                //已完成状态的明细数量
                var completedQcQuantity = wmsQcDetailsAll.Count(o => o.QCOrderStatus == OrderStatusEnum.已完成);

                if (newBuildQcQuantity == totalQcQuantity)//全是新建状态
                {
                    wmsQc.QCOrderStatus = OrderStatusEnum.新建;
                }
                else if (completedQcQuantity == totalQcQuantity)//全部是已完成状态
                {
                    wmsQc.QCOrderStatus = OrderStatusEnum.已完成;
                 
                }
                else //处理中状态
                {
                    wmsQc.QCOrderStatus = OrderStatusEnum.处理中;
                   
                }
                //单据状态名称赋值
                wmsQc.QCOrderStatusName = wmsQc.QCOrderStatus.GetDescription();
            }
        }




        /// <summary>
        /// 行号补全
        /// 根据指定长度补全行号
        /// 生产订单是四位行号0001
        /// </summary>
        /// <param name="_EBELP"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string AutoCompleEBELP(string _EBELP, int length)
        {
            if (!string.IsNullOrEmpty(_EBELP) & length > 1)
            {
                return _EBELP.PadLeft(length, '0');
            }
            return "";
        }




        // <summary>
        /// 公共更新 波次单的 状态
        /// </summary>
        /// <param name="wmsOrderAsnDetails"></param>
        /// <param name="wmsOrderAsn"></param>
        public static void UpdatOrderSortStatus(List<WmsOrderSortDetails> wmsOrderOrderSortDetails,
            WmsOrderSort wmsOrderSort)
        {

            var wmsOrderPurchaseDetailsAll = wmsOrderOrderSortDetails.Where(x => x.SortId == wmsOrderSort.Id && x.IsDelete == false).ToList();
            if (wmsOrderPurchaseDetailsAll?.Count <= 0)
            {
                throw Oops.Oh($"波次单{wmsOrderSort.SortNo}更新状态，未获取到明细！");
            }
            else
            {
                //汇总明细的已下发数
                var totalIssueQuantity = wmsOrderPurchaseDetailsAll.Sum(o => o.IssueQuantity);
                //汇总明细的已拣货数
                var totalPickQuantity = wmsOrderPurchaseDetailsAll.Sum(o => o.PickQuantity);
                //汇总明细的需求数
                var totalQuantity = wmsOrderPurchaseDetailsAll.Sum(o => o.Quantity);
                if (wmsOrderPurchaseDetailsAll.Sum(o => o.IssueQuantity) == 0)
                {
                    wmsOrderSort.SortStatus = OrderStatusEnum.新建;
                }
                else if (totalPickQuantity== totalQuantity) //分拣完成，单据完结
                {

                    wmsOrderSort.SortStatus = OrderStatusEnum.已完成;
                }
                else 
                {
                    wmsOrderSort.SortStatus = OrderStatusEnum.处理中;
                }
                //单据状态名称赋值
                wmsOrderSort.SortStatusName = wmsOrderSort.SortStatus.GetDescription();

            }
        }

        /// <summary>
        /// 公共更新 波次单明细 状态 
        /// </summary>
        /// <param name="detail"></param>
        public static void updateOrderSortDetailsStatus(WmsOrderSortDetails detail)
        {
            if (detail.IssueQuantity == 0)
            {

                detail.SortDetailStatus = OrderStatusEnum.新建;
            }
            else if (detail.PickQuantity == detail.Quantity) //分拣完成，单据完结
            {
                detail.SortDetailStatus = OrderStatusEnum.已完成;
            }
            else
            {
                detail.SortDetailStatus = OrderStatusEnum.处理中;
            }
            //明细状态名称赋值
            detail.SortDetailStatusName = detail.SortDetailStatus.GetDescription();
        }


        /// <summary>
        /// 公共更新 容器分拣相信状态 
        /// </summary>
        /// <param name="detail"></param>
        public static void UpdateContainerSortStatus(WmsContainerSort detail)
        {
            if (detail.PickQuantity == 0)
            {

                detail.SortStatus = OrderStatusEnum.新建;
            }
            else if (detail.PickQuantity == detail.Quantity) //分拣完成，单据完结
            {
                detail.SortStatus = OrderStatusEnum.已完成;
            }
            else
            {
                detail.SortStatus = OrderStatusEnum.处理中;
            }
            //明细状态名称赋值
            detail.SortStatusName = detail.SortStatus.GetDescription();
        }
        



        // <summary>
        /// 公共更新 移动单的 状态
        /// </summary>
        /// <param name="wmsOrderAsnDetails"></param>
        /// <param name="wmsOrderAsn"></param>
        public static void UpdatOrderMovementStatus(List<WmsOrderMovementDetails> wmsOrderMovementDetails,
            WmsOrderMovement wmsOrderMovement)
        {

            var wmsOrderMovementDetailsAll = wmsOrderMovementDetails.Where(x => x.MovementId == wmsOrderMovement.Id && x.IsDelete == false).ToList();
            if (wmsOrderMovementDetailsAll?.Count <= 0)
            {
                throw Oops.Oh($"{wmsOrderMovement.OrderType.GetDescription()}类型移动单{wmsOrderMovement.OrderNo}更新状态，未获取到明细！");
            }
            else
            {
                if (wmsOrderMovement.OrderType == OrderTypeEnum.下架单)
                {
                    //汇总明细的已拣货数
                    var totalPickQuantity = wmsOrderMovementDetailsAll.Sum(o => o.PickQuantity);
                    //汇总明细的需求数
                    var totalQuantity = wmsOrderMovementDetailsAll.Sum(o => o.Quantity);

                    //未创建波次 = 新建
                    if (wmsOrderMovementDetailsAll.Sum(o => o.CreateWaveQuantity) == 0)
                    {
                        wmsOrderMovement.OrderStatus = OrderStatusEnum.新建;
                    }
                    else if (totalPickQuantity == totalQuantity) //分拣完成，单据完结
                    {

                        wmsOrderMovement.OrderStatus = OrderStatusEnum.已完成;
                    }
                    else
                    {
                        wmsOrderMovement.OrderStatus = OrderStatusEnum.处理中;
                    }
                }
                else
                {
                    throw Oops.Oh($"{wmsOrderMovement.OrderType.GetDescription()}类型移动单暂不支持！");
                }

            
                //单据状态名称赋值
                wmsOrderMovement.OrderStatusName = wmsOrderMovement.OrderStatus.GetDescription();

            }
        }


        // <summary>
        /// 公共更新 DO的 状态
        /// </summary>
        /// <param name="UpdatOrderDeliverStatus"></param>
        /// <param name="UpdatOrderDeliverStatus"></param>
        public static void UpdatOrderDeliverStatus(List<WmsOrderDeliverDetails> wmsOrderDeliverDetails,
            WmsOrderDeliver wmsOrderMovement)
        {

            var wmsOrderMovementDetailsAll = wmsOrderDeliverDetails.Where(x => x.DoId == wmsOrderMovement.Id && x.IsDelete == false).ToList();
            if (wmsOrderMovementDetailsAll?.Count <= 0)
            {
                throw Oops.Oh($"{wmsOrderMovement.OrderType.GetDescription()}类型DO单{wmsOrderMovement.DeliverNo}更新状态，未获取到明细！");
            }
            else
            {
                if (wmsOrderMovement.OrderType == OrderTypeEnum.DO单)
                {
                    //汇总明细的已发货数
                    var totalPickQuantity = wmsOrderMovementDetailsAll.Sum(o => o.DeliverQuantity);
                    //汇总明细的需求数
                    var totalQuantity = wmsOrderMovementDetailsAll.Sum(o => o.Quantity);

                    //未创建波次 = 新建
                    if (wmsOrderMovementDetailsAll.Sum(o => o.CreateMovementQuantity) == 0)
                    {
                        wmsOrderMovement.DoStatus = OrderStatusEnum.新建;
                    }
                    else if (totalPickQuantity == totalQuantity) //发货完成，单据完结
                    {

                        wmsOrderMovement.DoStatus = OrderStatusEnum.已完成;
                    }
                    else
                    {
                        wmsOrderMovement.DoStatus = OrderStatusEnum.处理中;
                    }
                }
                else
                {
                    throw Oops.Oh($"{wmsOrderMovement.OrderType.GetDescription()}类型移动单暂不支持！");
                }

                //单据状态名称赋值
                wmsOrderMovement.DoStatusName = wmsOrderMovement.DoStatus.GetDescription();

            }
        }

        /// <summary>
        /// 公共更新 移动单明细 状态 
        /// </summary>
        /// <param name="detail"></param>
        public static void UpdateOrderMovementDetailsStatus(WmsOrderMovementDetails detail)
        {

            if (detail.CreateWaveQuantity == 0)
            {

                detail.OrderStatus = OrderStatusEnum.新建;
            }
            else if (detail.PickQuantity == detail.Quantity) //分拣完成，单据完结
            {
                detail.OrderStatus = OrderStatusEnum.已完成;
            }
            else
            {
                detail.OrderStatus = OrderStatusEnum.处理中;
            }

            //明细状态名称赋值
            detail.OrderStatusName = detail.OrderStatus.GetDescription();
        }


        /// <summary>
        /// 公共更新 Do明细 状态 
        /// </summary>
        /// <param name="detail"></param>
        public static void UpdateOrderDeliverDetailsStatus(WmsOrderDeliverDetails detail)
        {

            if (detail.CreateMovementQuantity == 0)
            {

                detail.DoDetailStatus = OrderStatusEnum.新建;
            }
            else if (detail.DeliverQuantity == detail.Quantity) //发货完成，单据完结
            {
                detail.DoDetailStatus = OrderStatusEnum.已完成;
            }
            else
            {
                detail.DoDetailStatus = OrderStatusEnum.处理中;
            }

            //明细状态名称赋值
            detail.DoDetailStatusName = detail.DoDetailStatus.GetDescription();
        }


        /// <summary>
        /// 更新盘点单明细的盘点状态
        /// </summary>
        /// <param name="checkOrderDetails"></param>
        /// <param name="checkStatus"></param>
        public static void UpdateInventoryCheckOrderDetailsCheckStatus(WmsInventoryCheckOrderDetails checkOrderDetails, CheckStatusEnum checkStatus)
        {
            checkOrderDetails.CheckStatus= checkStatus;
            checkOrderDetails.CheckStatusName = checkStatus.GetDescription();
        }

        /// <summary>
        /// 更新盘点单明细的盘点结果
        /// </summary>
        /// <param name="checkOrderDetails"></param>
        /// <param name="checkStatus"></param>
        public static void UpdateInventoryCheckOrderDetailsCheckResult(WmsInventoryCheckOrderDetails checkOrderDetails, CheckResultEnum checkResult)
        {
            checkOrderDetails.CheckResult = checkResult;
            checkOrderDetails.CheckResultName = checkResult.GetDescription();
        }


        /// <summary>
        /// 
        /// 更新盘点单明细的盘点操作分类
        /// </summary>
        /// <param name="checkOrderDetails"></param>
        /// <param name="checkOperatorClassify"></param>
        public static void UpdateInventoryCheckOrderDetailsCheckOperatorClassify(WmsInventoryCheckOrderDetails checkOrderDetails, CheckOperatorClassifyEnum checkOperatorClassify)
        {
            checkOrderDetails.CheckOperatorClassify = checkOperatorClassify;
            checkOrderDetails.CheckOperatorClassifyName = checkOperatorClassify.GetDescription();
        }


        ///// <summary>
        ///// 盘点单判断盘点是否有差异
        ///// </summary>
        ///// <param name="checkOrderDetailsList"></param>
        ///// <returns></returns>
        //public static bool CheckDifferenceForInventoryCheckOrder(List<WmsInventoryCheckOrderDetails> checkOrderDetailsList)
        //{
        //    bool isCheckDifference = false;
        //    if (checkOrderDetailsList.Any(a => a.CheckResult == CheckResultEnum.盘亏 || a.CheckResult == CheckResultEnum.盘盈))
        //    {
        //        isCheckDifference = true;
        //    }
        //    return isCheckDifference;
        //}



        /// <summary>
        /// 根据单号规则创建单号 update by  liuwq
        /// </summary>
        /// <returns></returns>
        public static async Task<string> CreateOrderNoByRuleCommon(OrderTypeEnum orderTypeEnum, int businessType, SqlSugarRepository<WmsOrderMovement> _wmsOrderMovement, SqlSugarRepository<WmsConfigNoRule> _WmsNoCreateRuleRep, SqlSugarRepository<WmsConfigSerialSN> _repSNRep)
        {
            // 获取当前时间
            DateTime currentTime = DateTime.Now;

            // 格式化为年月日字符串
            string formattedDate = currentTime.ToString("yyyyMMdd");

            //按照单号规则生成单号 - 查找最新的创建的一条单据记录
            var newestOrder = await _wmsOrderMovement.AsQueryable().Where(p => p.OrderType == orderTypeEnum).Where(p => p.OrderNo.Contains(formattedDate)).OrderBy(it => it.CreateTime, OrderByType.Desc)
                                 .FirstAsync();
            //按照单号规则生成单号
            var OrderNoSjd = await SerialUtilOrder.GetSerialOrder(orderTypeEnum, _WmsNoCreateRuleRep, _repSNRep, businessType, newestOrder == null ? null : newestOrder.OrderNo);
            if (OrderNoSjd == null || OrderNoSjd == "")
            {
                OrderNoSjd = Yitter.IdGenerator.YitIdHelper.NextId().ToString();
            }

            return OrderNoSjd;
        }


    }
}