using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundRepository;
using WIDESEA_IOutboundService;
using WIDESEA_IRecordService;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;
using WIDESEA_OutboundRepository;

namespace WIDESEA_OutboundService
{
    public class MesPPOutboundOrderService : ServiceBase<Dt_MesPPOutboundOrder, IMesPPOutboundOrderRepository>, IMesPPOutboundOrderService
    {
        private readonly IBasicRepository _basicRepository;
        private readonly IStockService _stockService;
        private readonly IOutStockLockInfoService _outStockLockInfoService;
        private readonly IBasicService _basicService;
        private readonly IRecordService _recordService;

        public IMesPPOutboundOrderRepository Repository => BaseDal;

        public MesPPOutboundOrderService(IMesPPOutboundOrderRepository BaseDal, IBasicRepository basicRepository, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IBasicService basicService, IRecordService recordService) : base(BaseDal)
        {
            _basicRepository = basicRepository;
            _stockService = stockService;
            _outStockLockInfoService = outStockLockInfoService;
            _basicService = basicService;
            _recordService = recordService;
        }
        #region PP出库（旧）
        //public (List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPOutboundOrder mesPPOutboundOrder)
        //{
        //    List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

        //    List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
        //    List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();

        //    float originalNeedQuantity = mesPPOutboundOrder.OrderQuantity;

        //    float needQuantity = originalNeedQuantity;

        //    List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPOutboundOrder.MaterialCode, "", mesPPOutboundOrder.Details.FirstOrDefault()?.CarrierCode ?? "",mesPPOutboundOrder.WarehouseId);
        //    if (!stockInfos.Any())
        //    {
        //        throw new Exception($"未找到可分配库存");
        //    }
        //    List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPOutboundOrder.MaterialCode, needQuantity, out float residueQuantity);
        //    mesPPOutboundOrder.LockQuantity += needQuantity - residueQuantity;
        //    outStocks.AddRange(autoAssignStocks);
        //    float assignQuantity = needQuantity - residueQuantity;

        //    float orderQuantity = mesPPOutboundOrder.OrderQuantity;
        //    for (int j = 0; j < autoAssignStocks.Count; j++)
        //    {
        //        float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

        //        float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

        //        float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
        //        if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
        //        {
        //            float orderDetailNeedQuantity = mesPPOutboundOrder.OrderQuantity - detailAssignQuantity;
        //            if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
        //            {
        //                mesPPOutboundOrder.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
        //                Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
        //                outStockLockInfos.Add(outStockLockInfo);
        //            }
        //            else
        //            {
        //                Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], mesPPOutboundOrder.OrderQuantity - mesPPOutboundOrder.LockQuantity);
        //                outStockLockInfos.Add(outStockLockInfo);
        //                mesPPOutboundOrder.LockQuantity = mesPPOutboundOrder.OrderQuantity;
        //                break;
        //            }
        //        }
        //    }
        //    locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

        //    return (outStocks, mesPPOutboundOrder, outStockLockInfos, locationInfos);
        //}


        //public (List<Dt_StockInfo>, Dt_MesPPCutOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPCutOutboundOrder mesPPOutboundOrder, Dt_MesPPCutOutboundOrderDetail mesPPCutOutboundOrderDetail)
        //{
        //    List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

        //    List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
        //    List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
        //    //Dt_MesPPCutOutboundOrder outboundOrder = BaseDal.Db.Queryable<Dt_MesPPCutOutboundOrder>().Where(x=>x.Id==mesPPOutboundOrder.OrderId).First();
        //    float originalNeedQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;

        //    float needQuantity = originalNeedQuantity;

        //    List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPCutOutboundOrderDetail.MaterielCode,  "", mesPPOutboundOrder.WarehouseId);
        //    if (!stockInfos.Any())
        //    {
        //        throw new Exception($"未找到可分配库存");
        //    }
        //    List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPCutOutboundOrderDetail.MaterielCode, needQuantity, out float residueQuantity);
        //    mesPPCutOutboundOrderDetail.LockQuantity += needQuantity - residueQuantity;
        //    outStocks.AddRange(autoAssignStocks);
        //    float assignQuantity = needQuantity - residueQuantity;

        //    float orderQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;
        //    for (int j = 0; j < autoAssignStocks.Count; j++)
        //    {
        //        float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

        //        float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

        //        float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
        //        if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
        //        {
        //            float orderDetailNeedQuantity = mesPPCutOutboundOrderDetail.OrderQuantity - detailAssignQuantity;
        //            if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
        //            {
        //                mesPPCutOutboundOrderDetail.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
        //                Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, mesPPCutOutboundOrderDetail, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
        //                outStockLockInfos.Add(outStockLockInfo);
        //            }
        //            else
        //            {
        //                Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, mesPPCutOutboundOrderDetail, autoAssignStocks[j], mesPPCutOutboundOrderDetail.OrderQuantity - mesPPCutOutboundOrderDetail.LockQuantity);
        //                outStockLockInfos.Add(outStockLockInfo);
        //                mesPPCutOutboundOrderDetail.LockQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;
        //                break;
        //            }
        //        }
        //    }
        //    locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

        //    return (outStocks, mesPPCutOutboundOrderDetail, outStockLockInfos, locationInfos);
        //}
        #endregion


        /// <summary>
        /// PP大卷出库（新）
        /// </summary>
        /// <param name="mesPPOutboundOrder"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public (List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignPPStockOutbound(Dt_MesPPOutboundOrder mesPPOutboundOrder)
        {
            List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();

            float originalNeedQuantity = mesPPOutboundOrder.OrderQuantity;

            float needQuantity = originalNeedQuantity;
            //获取库存
            List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseablePPStocks(mesPPOutboundOrder.MaterialCode, "", mesPPOutboundOrder.WarehouseId);
            if (!stockInfos.Any())
            {
                throw new Exception($"未找到可分配库存");
            }
            List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundPPStocks(stockInfos, mesPPOutboundOrder.MaterialCode, needQuantity, out float residueQuantity);
            if (residueQuantity > 0)
            {
                throw new Exception($"库存不足");
            }
            autoAssignStocks.OrderBy(x => x.Details.FirstOrDefault()?.StockQuantity).ToList();
            outStocks.AddRange(autoAssignStocks);
            for (int j = 0; j < autoAssignStocks.Count; j++)
            {
                float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

                float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

                float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
                if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
                {
                    float orderDetailNeedQuantity = mesPPOutboundOrder.OrderQuantity - detailAssignQuantity;
                    if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
                    {
                        mesPPOutboundOrder.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                    }
                    else
                    {
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], mesPPOutboundOrder.OrderQuantity - mesPPOutboundOrder.LockQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                        mesPPOutboundOrder.LockQuantity = mesPPOutboundOrder.OrderQuantity;
                        break;
                    }
                }
            }
            locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

            return (outStocks, mesPPOutboundOrder, outStockLockInfos, locationInfos);
        }

        /// <summary>
        /// PP小卷出库（新）
        /// </summary>
        /// <param name="mesPPOutboundOrder"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public (List<Dt_StockInfo>, List<Dt_MesPPCutOutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignPPCutStockOutbound(Dt_MesPPCutOutboundOrder mesPPCutOutboundOrder,List<Dt_MesPPCutOutboundOrderDetail> mesPPCutOutboundOrderDetails)
        {
            List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();

            foreach (var item in mesPPCutOutboundOrderDetails)
            {
                float originalNeedQuantity = item.OrderQuantity;

                float needQuantity = originalNeedQuantity;
                //获取库存
                List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseablePPStocks(item.MaterialCode, "", mesPPCutOutboundOrder.WarehouseId);
                if (!stockInfos.Any())
                {
                    throw new Exception($"未找到可分配库存");
                }
                List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundPPStocks(stockInfos, item.MaterialCode, needQuantity, out float residueQuantity,item.TargetAddressCode);
                if (residueQuantity > 0)
                {
                    throw new Exception($"库存不足");
                }
                autoAssignStocks.OrderBy(x => x.Details.FirstOrDefault()?.StockQuantity).ToList();
                outStocks.AddRange(autoAssignStocks);
                for (int j = 0; j < autoAssignStocks.Count; j++)
                {
                    float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == item.MaterialCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

                    float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == item.MaterialCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

                    float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
                    if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
                    {
                        float orderDetailNeedQuantity = item.OrderQuantity - detailAssignQuantity;
                        if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
                        {
                            item.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
                            Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfos(mesPPCutOutboundOrder, item, autoAssignStocks[j]);
                            outStockLockInfos.Add(outStockLockInfo);
                        }
                        else
                        {
                            Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfos(mesPPCutOutboundOrder, item , autoAssignStocks[j]);
                            outStockLockInfos.Add(outStockLockInfo);
                            item.LockQuantity = item.OrderQuantity;
                            break;
                        }
                    }
                }
            }
            locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

            return (outStocks, mesPPCutOutboundOrderDetails, outStockLockInfos, locationInfos);
        }
    }
}