using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core;
using WIDESEA_IInboundRepository;
using WIDESEA_IInboundService;
using WIDESEA_Model.Models;
using WIDESEA_DTO.ERP;
using WIDESEA_Core.BaseRepository;
using WIDESEA_IBasicRepository;
using WIDESEA_IOutboundService;
using WIDESEA_Common.OrderEnum;
using SqlSugar.Extensions;
using WIDESEA_Common.CommonEnum;

namespace WIDESEA_InboundService
{
    public class ReturnOrderService : ServiceBase<Dt_ReturnOrder, IReturnOrderRepository>, IReturnOrderService
    {
        public IReturnOrderRepository Repository => BaseDal;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IBasicRepository _basicRepository;
        private readonly IOutboundService _outboundService;
        private readonly IInboundRepository _inboundRepository;
        public ReturnOrderService(IReturnOrderRepository BaseDal,IUnitOfWorkManage unitOfWorkManage,IBasicRepository basicRepository,
        IOutboundService outboundService,IInboundRepository inboundRepository) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _basicRepository = basicRepository;
            _outboundService = outboundService;
            _inboundRepository = inboundRepository;
        }
        /// <summary>
        /// 获取退料单
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        public WebResponseContent GetReturnOrders(SaveModel saveModel)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                int pageNo = saveModel.MainData["pageNo"].ObjToInt();
                string? orderNo = saveModel.MainData["orderNo"].ToString();
                int warehouseId = saveModel.MainData["warehouseId"].ObjToInt();
                List<Dt_ReturnOrder> returnOrders = new List<Dt_ReturnOrder>();
                if (string.IsNullOrEmpty(orderNo))
                {
                    returnOrders = Db.Queryable<Dt_ReturnOrder>().Where(x => x.ReturnOrderStatus < ReturnOrderStatusEnum.Returning.ObjToInt() && x.WarehouseId == warehouseId).OrderByDescending(x => x.CreateDate).ToPageList(pageNo, 5);
                }
                else
                {
                    returnOrders = Db.Queryable<Dt_ReturnOrder>().Where(x => (x.OrderNo.Contains(orderNo)) && x.ReturnOrderStatus < ReturnOrderStatusEnum.Returning.ObjToInt() && x.WarehouseId == warehouseId).OrderByDescending(x => x.CreateDate).ToPageList(pageNo, 5);
                }

                content.OK(data: returnOrders);
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 获取接收退料单
        /// </summary>
        public WebResponseContent ReturnOrder(ErpReturnOrderDTO model)
        {
            try
            {
                return model.Way switch
                {
                    1 => AddReturnOrder(model),
                    2 => UpdateReturnOrder(model),
                    3 => DeleteReturnOrder(model),
                    _ => WebResponseContent.Instance.Error($"操作类型不存在,Way:{model.Way}"),
                };
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        /// <summary>
        /// 新建退料单
        /// </summary>
        public WebResponseContent AddReturnOrder(ErpReturnOrderDTO model)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                if (BaseDal.QueryFirst(x => x.OrderNo == model.OrderNo) != null) 
                {
                    return content.Error($"退料单号{model.OrderNo}已存在!");
                }
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == model.WaCode);
                if (warehouse == null)
                {
                    return content.Error($"未找到仓库信息");
                }
                List<Dt_ReturnOrderDetail> returnOrderDetails = new List<Dt_ReturnOrderDetail>();
                foreach (var item in model.Issitem)
                {
                    //判断发料单号
                    Dt_OutboundOrder outboundOrder = _outboundService.OutboundOrderService.Repository.Db.Queryable<Dt_OutboundOrder>().Where(x=>x.UpFLOrderNo==item.PickCode).Includes(x=>x.Details).First() ?? throw new Exception($"申请单号(发料单){item.PickCode}不存在");
                    
                    foreach (var pickitem in item.PickList)
                    {
                        Dt_OutboundOrderDetail outboundOrderDetail = outboundOrder.Details.Find(x => x.MaterielCode == pickitem.MCode) ?? throw new Exception($"{item.PickCode}申请单号中物料{pickitem.MCode}不存在");
                        //获取对应出库单详情
                        Dt_OutStockLockInfo outStockLockInfo = _outboundService.OutboundStockLockInfoService.Repository.QueryFirst(x => x.OrderDetailId == outboundOrderDetail.Id);
                        
                        Dt_ReturnOrderDetail returnOrderDetail = new Dt_ReturnOrderDetail()
                        {
                            PickCode = item.PickCode,
                            ApplyRow = item.ApplyRow ?? 0,
                            RowId = item.RowId,
                            OrderDetailStatus = ReturnOrderStatusEnum.NotReturn.ObjToInt(),
                            MCode = pickitem.MCode,
                            MaterielName = outboundOrderDetail.MaterielName,
                            MaterielSpec = outboundOrderDetail.MaterielSpec ?? "",
                            BatchNo = outStockLockInfo.BatchNo,
                            Qty = pickitem.Qty,
                            ReturnQty = pickitem.ReturnQty,
                            OverReturnQty = 0,
                            Unit = pickitem.Unit,
                            Code = pickitem.Code
                        };
                        returnOrderDetails.Add(returnOrderDetail);
                    }
                }
                Dt_ReturnOrder returnOrder = new Dt_ReturnOrder()
                {
                    OrderNo=model.OrderNo,
                    WarehouseId=warehouse.WarehouseId,
                    ReturnOrderType=model.OrderType,
                    ReturnOrderStatus=ReturnOrderStatusEnum.NotReturn.ObjToInt(),
                    UploadStatus= WhetherEnum.False.ObjToInt(),
                    IsDev=model.IsDev,
                    Remark=model.Note,
                    Details= returnOrderDetails
                };
                Db.InsertNav(returnOrder).Include(x => x.Details).ExecuteCommand();

                content.OK("成功");
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 修改退料单
        /// </summary>
        public WebResponseContent UpdateReturnOrder(ErpReturnOrderDTO model)
        {
            WebResponseContent content = new WebResponseContent();
            return content;
        }
        /// <summary>
        /// 删除退料单
        /// </summary>
        public WebResponseContent DeleteReturnOrder(ErpReturnOrderDTO model)
        {
            WebResponseContent content = new WebResponseContent();
            return content;
        }
        /// <summary>
        /// 确认退库根据退库单生成入库单
        /// </summary>
        /// <returns></returns>
        public WebResponseContent IsReturnCreateInOrder(int returnId)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ReturnOrder returnOrder = Db.Queryable<Dt_ReturnOrder>().Where(x => x.Id == returnId).Includes(x => x.Details).First();
                if (returnOrder==null)
                {
                    return content.Error("未找到退料该信息");
                }
                if (returnOrder.Details==null || returnOrder.Details.Count<=0)
                {
                    return content.Error("未找到该退料单信息");
                }
                if (returnOrder.ReturnOrderStatus!=ReturnOrderStatusEnum.NotReturn.ObjToInt())
                {
                    return content.Error("该退料单已完成或退料中");
                }
                //判断是否创建入库单
                Dt_InboundOrder InboundOld = _inboundRepository.InboundOrderRepository.QueryFirst(x=>x.UpperOrderNo== returnOrder.OrderNo);
                if (InboundOld!=null)
                {
                    return content.Error($"该退料单{returnOrder.OrderNo}已生成入库单号{InboundOld.InboundOrderNo}");
                }
                List<Dt_InboundOrderDetail> inboundOrderDetails = new List<Dt_InboundOrderDetail>();
                foreach (var item in returnOrder.Details)
                {
                    Dt_InboundOrderDetail orderDetail = new Dt_InboundOrderDetail()
                    {
                        MaterielCode=item.MCode,
                        BatchNo=item.BatchNo,
                        OrderQuantity=item.ReturnQty,
                        ReceiptQuantity=0,
                        OverInQuantity=0,
                        OrderDetailStatus= OrderDetailStatusEnum.New.ObjToInt(),
                        Unit=item.Unit,
                        RowNo=item.RowId,
                        MaterielName=item.MaterielName,
                        MaterielSpec=item.MaterielSpec,
                    };
                    inboundOrderDetails.Add(orderDetail);
                }
                Dt_InboundOrder inboundOrder = new Dt_InboundOrder()
                {
                    WarehouseId=returnOrder.WarehouseId,
                    UpperOrderNo=returnOrder.OrderNo,
                    SupplierId="",
                    OrderType= InOrderTypeEnum.Return.ObjToInt(),
                    OrderStatus= InOrderStatusEnum.未开始.ObjToInt(),
                    CreateType = OrderCreateTypeEnum.UpperSystemPush.ObjToInt(),
                    Remark=returnOrder.Remark,
                    Details= inboundOrderDetails
                };
                returnOrder.ReturnOrderStatus=ReturnOrderStatusEnum.Returning.ObjToInt();
                _unitOfWorkManage.BeginTran();
                BaseDal.UpdateData(returnOrder);
                Db.InsertNav(inboundOrder).Include(x=>x.Details).ExecuteCommand();
                _unitOfWorkManage.CommitTran();
                return content.OK("成功");
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
    }
}