using AutoMapper;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_Core.Utilities;
using WIDESEA_DTO.ERP;
using WIDESEA_DTO.Inbound;
using WIDESEA_DTO.Outbound;
using WIDESEA_External.ERPService;
using WIDESEA_External.Model;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundRepository;
using WIDESEA_IOutboundService;
using WIDESEA_IStockRepository;
using WIDESEA_IStockService;
using WIDESEA_Model.Models;

namespace WIDESEA_OutboundService
{
    public class OutboundOrderService : ServiceBase<Dt_OutboundOrder, IOutboundOrderRepository>, IOutboundOrderService
    {
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IBasicService _basicService;
        private readonly IOutboundOrderDetailRepository _outboundOrderDetailRepository;
        private readonly IStockInfoService _stockInfoService;
        private readonly IStockInfoRepository _stockInfoRepository;
        public IOutboundOrderRepository Repository => BaseDal;
        private readonly IInvokeERPService _invokeERPService;
        private readonly IOutStockLockInfoService _outStockLockInfoService;

        public OutboundOrderService(IOutboundOrderRepository BaseDal, IMapper mapper,IUnitOfWorkManage unitOfWorkManage, IBasicService basicService, IOutboundOrderDetailRepository outboundOrderDetailRepository, IStockInfoService stockInfoService,
          IStockInfoRepository stockInfoRepository, IInvokeERPService invokeERPService, IOutStockLockInfoService outStockLockInfoService) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            _basicService = basicService;
            _outboundOrderDetailRepository = outboundOrderDetailRepository;
            _stockInfoService = stockInfoService;
            _stockInfoRepository = stockInfoRepository;
            _invokeERPService = invokeERPService;
            _outStockLockInfoService = outStockLockInfoService;
        }

        public WebResponseContent ReceiveOutOrder(ErpOutOrderDTO model)
        {
            try
            {
                Dt_MaterielInfo materielInfo = _basicService.MaterielInfoService.Repository.QueryFirst(x => x.MaterielCode == model.MCode);
                if (materielInfo == null)
                {
                    return WebResponseContent.Instance.Error($"未找到该物料信息");
                }

                Dt_Warehouse warehouse = _basicService.WarehouseService.Repository.QueryFirst(x => x.WarehouseCode == model.WaId);
                if (warehouse == null)
                {
                    return WebResponseContent.Instance.Error($"未找到该仓库信息");
                }

                Dt_OutboundOrder oldOutboundOrder = BaseDal.Db.Queryable<Dt_OutboundOrder>().Where(x => x.UpperOrderNo == model.OrderNo).Includes(x => x.Details).First();

                if (model.Way == 1)
                {
                    if (oldOutboundOrder != null)
                    {
                        if (oldOutboundOrder.Details.FirstOrDefault(x => x.RowNo == Convert.ToInt32(model.RowNo)) != null)
                        {
                            return WebResponseContent.Instance.Error($"该明细行号已存在");
                        }
                        if (oldOutboundOrder.WarehouseId != warehouse.WarehouseId)
                        {
                            return WebResponseContent.Instance.Error($"仓库不一致");
                        }
                        else
                        {
                            Dt_OutboundOrderDetail outboundOrderDetail = new Dt_OutboundOrderDetail()
                            {
                                RowNo = Convert.ToInt32(model.RowNo),
                                BatchNo = model.MLot,
                                MaterielCode = model.MCode,
                                MaterielName = materielInfo.MaterielName,
                                OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt(),
                                OrderQuantity = model.Qty,
                                OrderId = oldOutboundOrder.Id
                            };
                            List<Dt_StockInfo>? stockInfos = new List<Dt_StockInfo>();
                            //ERP上传测试仓领料单更新对应库存状态
                            if (warehouse.WarehouseCode == WarehouseEnum.HA64.ToString())
                            {
                                WebResponseContent responseContent = TestOutStocksUpdate(warehouse, model);
                                if (!responseContent.Status)
                                {
                                    return responseContent;
                                }
                                stockInfos = responseContent.Data as List<Dt_StockInfo>;
                            }
                            _unitOfWorkManage.BeginTran();
                            if (stockInfos.Count>0)
                            {
                                _stockInfoRepository.UpdateData(stockInfos);
                                //测试架库给ERP上报出库完成
                                if (!TestOutBack(stockInfos, warehouse, model).Status)
                                {
                                    _unitOfWorkManage.RollbackTran();
                                    return WebResponseContent.Instance.Error($"测试架出库上报失败");
                                }
                            }
                            _outboundOrderDetailRepository.AddData(outboundOrderDetail);
                            _unitOfWorkManage.CommitTran();
                        }
                    }
                    else
                    {
                        Dt_OutboundOrderDetail outboundOrderDetail = new Dt_OutboundOrderDetail()
                        {
                            RowNo = Convert.ToInt32(model.RowNo),
                            BatchNo = model.MLot,
                            MaterielCode = model.MCode,
                            MaterielName = materielInfo.MaterielName,
                            OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt(),
                            OrderQuantity = model.Qty,
                        };

                        Dt_OutboundOrder outboundOrder = new Dt_OutboundOrder()
                        {
                            UpperOrderNo = model.OrderNo,
                            OrderStatus = OutOrderStatusEnum.未开始.ObjToInt(),
                            OrderType = OutOrderTypeEnum.Issue.ObjToInt(),
                            CreateType = OrderCreateTypeEnum.UpperSystemPush.ObjToInt(),
                            WarehouseId = warehouse.WarehouseId,
                            Details = new List<Dt_OutboundOrderDetail> { outboundOrderDetail }
                        };
                        List<Dt_StockInfo>? stockInfos = new List<Dt_StockInfo>();
                        //ERP上传测试仓领料单更新对应库存状态
                        if (warehouse.WarehouseCode == WarehouseEnum.HA64.ToString())
                        {
                            WebResponseContent responseContent = TestOutStocksUpdate(warehouse, model);
                            if (!responseContent.Status)
                            {
                                return responseContent;
                            }
                            stockInfos = responseContent.Data as List<Dt_StockInfo>;
                        }
                        _unitOfWorkManage.BeginTran();
                        if (stockInfos.Count > 0)
                        {
                            _stockInfoRepository.UpdateData(stockInfos);
                            //测试架库给ERP上报出库完成
                            if (!TestOutBack(stockInfos, warehouse, model).Status)
                            {
                                _unitOfWorkManage.RollbackTran();
                                return WebResponseContent.Instance.Error($"测试架出库上报失败");
                            } 
                        }
                        Db.InsertNav(outboundOrder).Include(x => x.Details).ExecuteCommand();
                        _unitOfWorkManage.CommitTran();
                        
                    }
                }
                else if (model.Way == 2)
                {
                    if (oldOutboundOrder == null)
                    {
                        return WebResponseContent.Instance.Error($"未找到该出库单");
                    }
                    Dt_OutboundOrderDetail? outboundOrderDetail = oldOutboundOrder.Details.FirstOrDefault(x => x.RowNo == Convert.ToInt32(model.RowNo));
                    if (outboundOrderDetail == null)
                    {
                        return WebResponseContent.Instance.Error($"未找到该明细行号信息");
                    }
                    if (outboundOrderDetail.OrderDetailStatus != OrderDetailStatusEnum.New.ObjToInt())
                    {
                        return WebResponseContent.Instance.Error($"该明细不可修改");
                    }
                    outboundOrderDetail = new Dt_OutboundOrderDetail()
                    {
                        RowNo = Convert.ToInt32(model.RowNo),
                        BatchNo = model.MLot,
                        MaterielCode = model.MCode,
                        MaterielName = materielInfo.MaterielName,
                        OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt(),
                        OrderQuantity = model.Qty,
                    };

                    _outboundOrderDetailRepository.UpdateData(outboundOrderDetail);
                }
                else if (model.Way == 3)
                {
                    if (oldOutboundOrder == null)
                    {
                        return WebResponseContent.Instance.Error($"未找到该出库单");
                    }
                }

                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        /// <summary>
        /// 更改出库单库存状态
        /// </summary>
        /// <param name="warehouse"></param>
        /// <param name="model"></param>
        /// <returns></returns>
        public WebResponseContent TestOutStocksUpdate(Dt_Warehouse warehouse, ErpOutOrderDTO model)
        {
            try
            {
                //获取出库单库存
                List<Dt_StockInfo> stockInfos = _stockInfoRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.WarehouseId == warehouse.WarehouseId).OrderBy(x => x.CreateDate).Includes(x => x.Details).Where(x => x.Details.Any(x => x.MaterielCode == model.MCode)).Take((int)(model.Qty)).ToList();
                if (model.Qty > stockInfos.Count)
                {
                    return WebResponseContent.Instance.Error($"物料:{model.MCode}库存不足");
                }
                //更改状态
                stockInfos.ForEach(x =>
                {
                    x.StockStatus = StockStatusEmun.入库完成.ObjToInt();
                });
                return WebResponseContent.Instance.OK("成功", stockInfos);
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        ///推送测试架出库
        public WebResponseContent TestOutBack(List<Dt_StockInfo> stockInfos,Dt_Warehouse warehouse, ErpOutOrderDTO model)
        {
            try
            {
                //测试架库给ERP上报出库完成
                List<ERPOutPickDetail> pickDetails = stockInfos.Select(x => new ERPOutPickDetail()
                {
                    Lotno = x.Details[0].BatchNo,
                    Qty = x.Details[0].StockQuantity
                }).ToList();
                ERPOutPick outPick = new ERPOutPick()
                {
                    Rowindex = model.RowNo,
                    Material = model.MCode,
                    Qty = model.Qty,
                    Dataitem = pickDetails
                };
                ERPOutboundModel inboundModel = new ERPOutboundModel()
                {
                    Way = 1,
                    UniqueTag = model.OrderNo,
                    Code = model.OrderNo,
                    WarehouseCode = warehouse.WarehouseCode,
                    Docremark = "",
                    Deptno = model.DepartmentCode,
                    DeptName = model.DepartmentName,
                    Createtime = DateTime.Now,
                    Createuser = "WMS",
                    Picklist = new List<ERPOutPick>() { outPick },
                };
                string response = _invokeERPService.InvokeOutboundOrderApi(inboundModel);
                ErpRequestContent requestContent=response.DeserializeObject<ErpRequestContent>();
                if (requestContent.res==1)
                {
                    
                    return WebResponseContent.Instance.OK(requestContent.Data);
                }
                else
                {
                    return WebResponseContent.Instance.Error(requestContent.Data);
                }
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        //public WebResponseContent FeedbackOutbondIssue(List<Dt_OutStockLockInfo> outStockLockInfos)
        //{
        //    ERPPickItemModel
        //}
    }
}