using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO;
using WIDESEA_IInboundRepository;
using WIDESEA_IInboundService;
using WIDESEA_InboundRepository;
using WIDESEA_Model.Models;

namespace WIDESEA_InboundService
{
    public class PurchaseOrderService : ServiceBase<Dt_PurchaseOrder, IPurchaseOrderRepository>, IPurchaseOrderService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IPurchaseOrderDetailRepository _purchaseOrderDetailRepository;

        public PurchaseOrderService(IPurchaseOrderRepository BaseDal, IPurchaseOrderDetailRepository purchaseOrderDetailRepository, IUnitOfWorkManage unitOfWorkManage) : base(BaseDal)
        {
            _purchaseOrderDetailRepository = purchaseOrderDetailRepository;
            _unitOfWorkManage = unitOfWorkManage;
        }

        public WebResponseContent ReceivePurchaseOrder(PurchaseOrderModel model)
        {
            try
            {
                return model.Way switch
                {
                    1 => AddPurchaseOrder(model),
                    2 => UpdatePurchaseOrder(model),
                    3 => DeletePurchaseOrder(model),
                    4 => ClosePurchaseOrder(model),
                    _ => WebResponseContent.Instance.OK(),
                };
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        public WebResponseContent AddPurchaseOrder(PurchaseOrderModel model)
        {
            try
            {
                if (BaseDal.QueryFirst(x => x.PurchaseOrderNo == model.OrderNo) != null)
                {
                    return WebResponseContent.Instance.Error($"采购单号重复");
                }

                List<Dt_PurchaseOrderDetail> purchaseOrderDetails = new List<Dt_PurchaseOrderDetail>();
                foreach (var item in model.MList)
                {
                    Dt_PurchaseOrderDetail purchaseOrderDetail = new Dt_PurchaseOrderDetail()
                    {
                        MaterielCode = item.MCode,
                        PurchaseDetailQuantity = item.Qty,
                        PurchaseDetailStatus = PurchaseOrderDetailStatusEnum.NotReceived.ObjToInt(),
                        Unit = item.Unit,
                        WarehouseId = item.WaId,
                        RowNo = item.RowId,
                    };
                    purchaseOrderDetails.Add(purchaseOrderDetail);
                }

                Dt_PurchaseOrder purchaseOrder = new Dt_PurchaseOrder()
                {
                    OrderQuantity = model.Amount,
                    OrderDate = model.OrderDate,
                    PurchaseOrderNo = model.OrderNo,
                    PurchaseOrderStatus = PurchaseOrderStatusEnum.NotReceived.ObjToInt(),
                    PurchaseOrderType = model.Type,
                    SupplierCode = model.SCode,
                    Details = purchaseOrderDetails
                };

                Db.InsertNav(purchaseOrder).Include(x => x.Details).ExecuteCommand();

                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        public WebResponseContent UpdatePurchaseOrder(PurchaseOrderModel model)
        {
            try
            {
                Dt_PurchaseOrder purchaseOrder = Db.Queryable<Dt_PurchaseOrder>().First(x => x.PurchaseOrderNo == model.OrderNo);
                if (purchaseOrder == null)
                {
                    return WebResponseContent.Instance.Error($"未找到采购单信息");
                }
                if (purchaseOrder.Details == null || purchaseOrder.Details.Count == 0)
                {
                    return WebResponseContent.Instance.Error($"未找到采购单明细信息");
                }

                List<Dt_PurchaseOrderDetail> purchaseOrderDetails = new List<Dt_PurchaseOrderDetail>();
                List<Dt_PurchaseOrderDetail> updatePurchaseOrderDetails = new List<Dt_PurchaseOrderDetail>();
                List<int> detailIds = new List<int>();
                foreach (var item in model.MList)
                {
                    Dt_PurchaseOrderDetail? purchaseOrderDetail = purchaseOrder.Details.FirstOrDefault(x => x.RowNo == item.RowId);
                    if (purchaseOrderDetail == null)
                    {
                        purchaseOrderDetail = new Dt_PurchaseOrderDetail()
                        {
                            MaterielCode = item.MCode,
                            PurchaseDetailQuantity = item.Qty,
                            PurchaseDetailStatus = PurchaseOrderDetailStatusEnum.NotReceived.ObjToInt(),
                            Unit = item.Unit,
                            WarehouseId = item.WaId,
                            RowNo = item.RowId,
                        };
                        purchaseOrderDetails.Add(purchaseOrderDetail);
                    }
                    else
                    {
                        purchaseOrderDetail.MaterielCode = item.MCode;
                        purchaseOrderDetail.PurchaseDetailQuantity = item.Qty;
                        purchaseOrderDetail.PurchaseDetailStatus = PurchaseOrderDetailStatusEnum.NotReceived.ObjToInt();
                        purchaseOrderDetail.Unit = item.Unit;
                        purchaseOrderDetail.WarehouseId = item.WaId;
                        purchaseOrderDetail.RowNo = item.RowId;
                        updatePurchaseOrderDetails.Add(purchaseOrderDetail);
                        detailIds.Add(purchaseOrderDetail.Id);
                    }
                }

                purchaseOrder.OrderQuantity = model.Amount;
                purchaseOrder.OrderDate = model.OrderDate;
                purchaseOrder.PurchaseOrderNo = model.OrderNo;
                purchaseOrder.PurchaseOrderStatus = PurchaseOrderStatusEnum.NotReceived.ObjToInt();
                purchaseOrder.PurchaseOrderType = model.Type;
                purchaseOrder.SupplierCode = model.SCode;

                List<Dt_PurchaseOrderDetail> deletePurchaseOrderDetails = purchaseOrder.Details.Where(x => !detailIds.Contains(x.Id)).ToList();

                _unitOfWorkManage.BeginTran();
                foreach (var item in deletePurchaseOrderDetails)
                {
                    _purchaseOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.人工删除);
                }

                _purchaseOrderDetailRepository.UpdateData(updatePurchaseOrderDetails);
                _purchaseOrderDetailRepository.AddData(purchaseOrderDetails);

                BaseDal.UpdateData(purchaseOrder);
                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        public WebResponseContent DeletePurchaseOrder(PurchaseOrderModel model)
        {
            try
            {
                Dt_PurchaseOrder purchaseOrder = Db.Queryable<Dt_PurchaseOrder>().First(x => x.PurchaseOrderNo == model.OrderNo);
                if (purchaseOrder == null)
                {
                    return WebResponseContent.Instance.Error($"未找到采购单信息");
                }
                if (purchaseOrder.Details == null || purchaseOrder.Details.Count == 0)
                {
                    return WebResponseContent.Instance.Error($"未找到采购单明细信息");
                }
                Db.DeleteNav(purchaseOrder).Include(x => x.Details).ExecuteCommand();
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        public WebResponseContent ClosePurchaseOrder(PurchaseOrderModel model)
        {
            try
            {
                Dt_PurchaseOrder purchaseOrder = Db.Queryable<Dt_PurchaseOrder>().First(x => x.PurchaseOrderNo == model.OrderNo);
                if (purchaseOrder == null)
                {
                    return WebResponseContent.Instance.Error($"未找到采购单信息");
                }
                if (purchaseOrder.Details == null || purchaseOrder.Details.Count == 0)
                {
                    return WebResponseContent.Instance.Error($"未找到采购单明细信息");
                }

                _unitOfWorkManage.BeginTran();
                BaseDal.DeleteAndMoveIntoHty(purchaseOrder, OperateTypeEnum.关闭);
                foreach (var item in purchaseOrder.Details)
                {
                    _purchaseOrderDetailRepository.DeleteAndMoveIntoHty(item, OperateTypeEnum.关闭);
                }
                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
    }
}