using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.MaterielEnum;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.ERP;
using WIDESEA_IBasicRepository;
using WIDESEA_IInboundRepository;
using WIDESEA_IInboundService;
using WIDESEA_InboundRepository;
using WIDESEA_IStockRepository;
using WIDESEA_Model.Models;

namespace WIDESEA_InboundService
{
    public class ReturnBSTOrderService : ServiceBase<Dt_ReturnBSTOrder, IReturnBSTOrderRepository>, IReturnBSTOrderService
    {
        public IReturnBSTOrderRepository Repository => BaseDal;
        private IUnitOfWorkManage _unitOfWorkManage;
        private IBasicRepository _basicRepository;
        private IStockInfoRepository _stockInfoRepository;
        private IReturnBSTOrderDetailRepository _returnBSTOrderDetailRepository;
        private IMapper _mapper;

        public ReturnBSTOrderService(IReturnBSTOrderRepository BaseDal,IUnitOfWorkManage unitOfWorkManage,IBasicRepository basicRepository, IStockInfoRepository stockInfoRepository, IReturnBSTOrderDetailRepository returnBSTOrderDetailRepository, IMapper mapper) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _basicRepository = basicRepository;
            _stockInfoRepository = stockInfoRepository;
            _returnBSTOrderDetailRepository = returnBSTOrderDetailRepository;
            _mapper = mapper;
        }
        /// <summary>
        /// 接收博思通退料信息
        /// </summary>
        /// <returns></returns>
        public WebResponseContent ReceiveReturnOrder(List<BSTReturnOrderDTO> bSTReturnOrderDTOs)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                List<Dt_ReturnBSTOrder> OldreturnBSTOrders = BaseDal.Db.Queryable<Dt_ReturnBSTOrder>().Includes(x => x.Details).ToList();
                List<Dt_StockInfo> ExiststockInfos = _stockInfoRepository.QueryData(x=>x.WarehouseId==WarehouseEnum.LLDOldCache.ObjToInt());
                //新增
                List<BSTReturnOrderDTO> bSTReturnOrderDTOsAdd = bSTReturnOrderDTOs.Where(x => x.Way == 1).ToList();
                //修改
                List<BSTReturnOrderDTO> bSTReturnOrderDTOsUpdate = bSTReturnOrderDTOs.Where(x => x.Way == 2).ToList();
                //删除
                List<BSTReturnOrderDTO> bSTReturnOrderDTOsDel = bSTReturnOrderDTOs.Where(x => x.Way == 3).ToList();
                //获取所有物料 
                List<Dt_MaterielInfo> materielInfos = _basicRepository.MaterielInfoRepository.QueryData(x => x.WarehouseId == WarehouseEnum.LLDYL.ObjToInt() && x.MaterielInvOrgId == MaterielInvOrgEnum.老厂.ObjToInt() && x.MaterialSourceId != 0);

                List<Dt_ReturnBSTOrder> returnAddBSTOrders = new List<Dt_ReturnBSTOrder>();
                List<Dt_ReturnBSTOrder> returnUpdateBSTOrders  = new List<Dt_ReturnBSTOrder>();
                List<Dt_ReturnBSTOrder> returnDeleteBSTOrders = new List<Dt_ReturnBSTOrder>();
                List<Dt_ReturnBSTOrderDetail> returnBSTOrderDetailsDel = new List<Dt_ReturnBSTOrderDetail>();
                List<Dt_StockInfo> stockInfosUpdate = new List<Dt_StockInfo>();
                //新增
                if (bSTReturnOrderDTOsAdd.Count > 0)
                {
                    //判断单据
                    Dt_ReturnBSTOrder? ExistAddReturn = OldreturnBSTOrders.FirstOrDefault(x => bSTReturnOrderDTOsAdd.Select(x => x.PaperWreturnId).Contains(x.PaperWreturnId));
                    if (ExistAddReturn != null)
                    {
                        return content.Error($"退料单{nameof(BSTReturnOrderDTO.PaperWreturnId)}:{ExistAddReturn.PaperWreturnId}已存在");
                    }
                    List<BSTReturnOrderDTOItem> bSTReturnOrderDTOItemsAdd = bSTReturnOrderDTOsAdd.SelectMany(x => x.BstPaperWreturnDetails).ToList();
                    //判断是否存在物料
                    BSTReturnOrderDTOItem? bSTReturnOrderDTOItem = bSTReturnOrderDTOItemsAdd.FirstOrDefault(x => !materielInfos.Select(x => x.MaterialSourceId).Contains(x.MaterialId));
                    if (bSTReturnOrderDTOItem != null)
                    {
                        return content.Error($"退料{nameof(bSTReturnOrderDTOItem.Barcode)}:{bSTReturnOrderDTOItem.Barcode}物料{nameof(BSTReturnOrderDTOItem.MaterialId)}:{bSTReturnOrderDTOItem.MaterialId}不存在");
                    }
                    //验证退料条码是否在库存中
                    var ExiststockInfo = bSTReturnOrderDTOItemsAdd.FirstOrDefault(x => !ExiststockInfos.Select(x => x.PalletCode).Contains(x.Barcode));
                    if (ExiststockInfo != null)
                    {
                        return content.Error($"退料条码{nameof(ExiststockInfo.Barcode)}:{ExiststockInfo.Barcode}物料未在老厂暂存区");
                    }
                    //获取对应库存修正库存数量
                    List<Dt_StockInfo> returnStockinfos = ExiststockInfos.Where(x => bSTReturnOrderDTOItemsAdd.Select(x => x.Barcode).Contains(x.PalletCode)).ToList();
                    foreach (var item in bSTReturnOrderDTOsAdd)
                    {
                        if (bSTReturnOrderDTOsUpdate.FirstOrDefault(x => x.PaperWreturnId == item.PaperWreturnId) != null)
                        {
                            continue;
                        }
                        List<Dt_ReturnBSTOrderDetail> bSTOrderDetails = item.BstPaperWreturnDetails.Select(x => _mapper.Map<Dt_ReturnBSTOrderDetail>(x)).ToList();
                        Dt_ReturnBSTOrder returnBSTOrder = _mapper.Map<Dt_ReturnBSTOrder>(item);
                        returnBSTOrder.Details = bSTOrderDetails;
                        returnAddBSTOrders.Add(returnBSTOrder);
                    }
                }
                //更新
                if (bSTReturnOrderDTOsUpdate.Count > 0)
                {
                    //存在的采购单
                    List<Dt_ReturnBSTOrder>? ExistreturnBSTOrders = OldreturnBSTOrders.Where(x => bSTReturnOrderDTOsUpdate.Select(x => x.PaperWreturnId).Contains(x.PaperWreturnId)).Distinct().ToList();

                    foreach (var item in bSTReturnOrderDTOsUpdate)
                    {
                        Dt_ReturnBSTOrder? returnBSTOrderUpdate = ExistreturnBSTOrders.FirstOrDefault(x => x.PaperWreturnId == item.PaperWreturnId);
                        //如果订单已存在则进行更改
                        if (returnBSTOrderUpdate != null)
                        {
                            if (returnBSTOrderUpdate.ReturnOrderStatus != InOrderStatusEnum.未开始.ObjToInt())
                            {
                                return content.Error($"退料{nameof(returnBSTOrderUpdate.PaperWreturnId)}:{returnBSTOrderUpdate.PaperWreturnId}订单退料入库中，不可更改");
                            }
                            returnBSTOrderDetailsDel.AddRange(returnBSTOrderUpdate.Details);

                            //更新
                            List<Dt_ReturnBSTOrderDetail> bSTOrderDetails = item.BstPaperWreturnDetails.Select(x => _mapper.Map<Dt_ReturnBSTOrderDetail>(x)).ToList();
                            bSTOrderDetails.ForEach(x =>
                            {
                                x.ReturnBSTOrderId = returnBSTOrderUpdate.Id;
                            });
                            returnBSTOrderUpdate.Details = bSTOrderDetails;
                            returnBSTOrderUpdate.PaperWreturnId = item.PaperWreturnId;
                            returnBSTOrderUpdate.PaperWreturnNo = item.PaperWreturnNo;
                            returnBSTOrderUpdate.EmployeeName = item.EmployeeName;
                            returnBSTOrderUpdate.WreturnDate = DateTimeOffset.FromUnixTimeMilliseconds(item.WreturnDate).DateTime;
                            returnUpdateBSTOrders.Add(returnBSTOrderUpdate);
                        }
                        else //如果不存在则进行新增
                        {
                            List<Dt_ReturnBSTOrderDetail> bSTOrderDetails = item.BstPaperWreturnDetails.Select(x => _mapper.Map<Dt_ReturnBSTOrderDetail>(x)).ToList();
                            Dt_ReturnBSTOrder returnBSTOrder = _mapper.Map<Dt_ReturnBSTOrder>(item);
                            returnBSTOrder.Details = bSTOrderDetails;
                            returnAddBSTOrders.Add(returnBSTOrder);
                        }
                    }

                }
                //删除
                if (bSTReturnOrderDTOsDel.Count > 0)
                {
                    
                }
                //更新数据
                _unitOfWorkManage.BeginTran();
                BaseDal.Db.InsertNav(returnAddBSTOrders).Include(x => x.Details).ExecuteCommand();
                _returnBSTOrderDetailRepository.DeleteData(returnBSTOrderDetailsDel);
                BaseDal.Db.UpdateNav(returnUpdateBSTOrders).Include(x => x.Details).ExecuteCommand();
                _unitOfWorkManage.CommitTran();
                content.OK("接收成功");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                content.Error(ex.Message);
            }
            return content;
        }
    }
}