using HslCommunication.WebSocket;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using SqlSugar;
using StackExchange.Profiling.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.CodeConfigEnum;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_IBasicService;
using WIDESEA_ICheckService;
using WIDESEA_IOutboundService;
using WIDESEA_Model.Models;
using WIDESEA_Model.Models.Basic;
using WIDESEA_Model.Models.Check;

namespace WIDESEA_CheckService
{

    public class ReCheckOrderService : ServiceBase<Dt_ReCheckOrder, IRepository<Dt_ReCheckOrder>>, IReCheckOrderService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly WebSocketServer _webSocketServer;
        private readonly ILogger<ReCheckOrderService> _logger;
        private readonly IMaterielInfoService _materielInfoService;
        public readonly IOutboundService _outboundService;
        public IRepository<Dt_ReCheckOrder> Repository => BaseDal;
        public ReCheckOrderService(IRepository<Dt_ReCheckOrder> BaseDal, IUnitOfWorkManage unitOfWorkManage, WebSocketServer webSocketServer, ILogger<ReCheckOrderService> logger, IOutboundService outboundService, IMaterielInfoService materielInfoService) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _webSocketServer = webSocketServer;
            _logger = logger;
            _outboundService = outboundService;
            _materielInfoService = materielInfoService;
        }

        public async Task<WebResponseContent> ReceiveReCheckOrder(Dt_ReCheckOrder models, int operateType)
        {
            try
            {
                return operateType switch
                {
                    1 =>await AddReCheckOrder(models),
                    2 =>await UpdateReCheckOrder(models),
                    3 => DeleteReCheckOrder(models),

                    _ => WebResponseContent.Instance.OK(),
                };
            }
            catch (Exception ex)
            {
                _logger.LogInformation("ReCheckOrderService ReceiveReCheckOrder:  " + ex.Message);
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        public async Task<WebResponseContent> AddReCheckOrder(Dt_ReCheckOrder model)
        {
            try
            {
                List<Dt_ReCheckOrder> reCheckOrders = BaseDal.Db.Queryable<Dt_ReCheckOrder>().Where(x => x.MaterielCode == model.MaterielCode && x.BatchNo == model.BatchNo).ToList();
                if (reCheckOrders.Count() == 3)
                {
                    return WebResponseContent.Instance.Error($"该物料和批次已经重检了三次，不允许再进行重检");
                }
                if (BaseDal.QueryFirst(x => x.OrderNo == model.OrderNo) != null)
                {
                    return WebResponseContent.Instance.Error($"{model.OrderNo}单号重复");
                }
  
                var materielInfo = _materielInfoService.Db.Queryable<Dt_MaterielInfo>().First(x => model.MaterielCode.Equals(x.MaterielCode));

                model.Creater = "MES";
                model.CreateDate = DateTime.Now;
                model.MaterielName = materielInfo?.MaterielName ?? "";
                var stockDetailIds = BaseDal.Db.Queryable<Dt_StockInfoDetail>()
                .Where(x => x.MaterielCode == model.MaterielCode && x.BatchNo == model.BatchNo && x.ValidDate !=null)
                .Select(x => x.Id)
                .ToList();

                if (stockDetailIds.Count > 0)
                {
                    BaseDal.Db.Updateable<Dt_StockInfoDetail>()
                        .SetColumns(x => x.Status == StockStatusEmun.手动冻结.ObjToInt())
                        .Where(x => stockDetailIds.Contains(x.Id))
                        .ExecuteCommand();
                }
                BaseDal.AddData(model);
                var outboundOrders = ConvertToOutboundOrders(model);
             
                await _outboundService.OutboundOrderService.ReceiveOutboundOrder(outboundOrders, 1);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _logger.LogInformation("ReCheckOrderService AddReCheckOrder:  " + ex.Message);
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        public async Task<WebResponseContent> UpdateReCheckOrder(Dt_ReCheckOrder model)
        {
            try
            {
                List<Dt_ReCheckOrder> reCheckOrders = BaseDal.Db.Queryable<Dt_ReCheckOrder>().Where(x=>x.MaterielCode == model.MaterielCode && x.BatchNo == model.BatchNo).ToList();
               
                var recheckOrder = Db.Queryable<Dt_ReCheckOrder>().Where(x => x.OrderNo == model.OrderNo).First();
                if (recheckOrder == null)
                {
                    return WebResponseContent.Instance.Error($"未找到单信息");
                }
                var isupdate = false;
                if (recheckOrder.SignSeq == model.SignSeq)
                {
                    isupdate = true;    
                }
                if (model.Result == 1 && recheckOrder.SignSeq != model.SignSeq)
                {
                    var stockDetailIds = BaseDal.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.MaterielCode == model.MaterielCode && x.BatchNo == model.BatchNo && x.ValidDate != null && (x.Status == (int)StockStatusEmun.手动冻结 ||x.Status == (int)StockStatusEmun.重检中))
                    .Select(x => x.Id)
                    .ToList();

                    if (stockDetailIds.Count > 0)
                    {
                        var datevaliDate = BaseDal.Db.Queryable<Dt_MaterialExpirationDate>().Where(x => x.MaterialCode.Contains(model.MaterielCode.Substring(0, 6))).First();
                        if(datevaliDate == null)
                        {
                            return WebResponseContent.Instance.Error($"该物料未找到MES推送的有效期数据，请先推送该物料的有效期数据");
                        }
                        BaseDal.Db.Updateable<Dt_StockInfoDetail>()
                            .SetColumns(x => x.Status == StockStatusEmun.入库完成.ObjToInt())
                            .Where(x => stockDetailIds.Contains(x.Id) && x.Status == (int)StockStatusEmun.手动冻结)
                            .ExecuteCommand();

                        //计算当前复检单据结果时间
                        DateTime newDate;

                        if (1 == reCheckOrders.Count())
                        {
                            //单据结果推送时间+物料复检延长时间与有效期做对比，谁大取谁
                            newDate = Convert.ToDateTime(DateTime.Now).AddDays(Convert.ToDouble(datevaliDate.OneExtensionDays));
                            BaseDal.Db.Updateable<Dt_StockInfoDetail>()
                            .SetColumns(x => x.ValidDate == SqlFunc.IIF(x.ValidDate > newDate, x.ValidDate, newDate))
                            .Where(x => stockDetailIds.Contains(x.Id))
                            .ExecuteCommand();
                        }
                        else if (2 == reCheckOrders.Count())
                        {
                            newDate = Convert.ToDateTime(DateTime.Now).AddDays(Convert.ToDouble(datevaliDate.TwoExtensionDays));
                            BaseDal.Db.Updateable<Dt_StockInfoDetail>()
                            .SetColumns(x => x.ValidDate == SqlFunc.IIF(x.ValidDate > newDate, x.ValidDate, newDate))
                            .Where(x => stockDetailIds.Contains(x.Id))
                            .ExecuteCommand();
                        }
                        else if (3 == reCheckOrders.Count())
                        {
                            newDate = Convert.ToDateTime(DateTime.Now).AddDays(Convert.ToDouble(datevaliDate.ThreeExtensionDays));
                            BaseDal.Db.Updateable<Dt_StockInfoDetail>()
                            .SetColumns(x => x.ValidDate == SqlFunc.IIF(x.ValidDate > newDate, x.ValidDate, newDate))
                            .Where(x => stockDetailIds.Contains(x.Id))
                            .ExecuteCommand();
                        }
                    }
                }
                recheckOrder.OrderNo = model.OrderNo;
                recheckOrder.MaterielCode = model.MaterielCode;
                recheckOrder.BatchNo = model.BatchNo;
                recheckOrder.Unit = model.Unit;
                recheckOrder.Result = model.Result;
                recheckOrder.InspectionNumber = model.InspectionNumber;
                recheckOrder.SignSeq = model.SignSeq;
                recheckOrder.Qty = model.Qty;
                recheckOrder.WarehouseCode = model.WarehouseCode;
                recheckOrder.FactoryArea = model.FactoryArea;
                recheckOrder.Modifier = "MES";
                recheckOrder.ModifyDate = DateTime.Now;
                var materielInfo = _materielInfoService.Db.Queryable<Dt_MaterielInfo>().First(x => model.MaterielCode.Equals(x.MaterielCode));
                recheckOrder.MaterielName= materielInfo?.MaterielName??"";

                BaseDal.UpdateData(recheckOrder);

                if (isupdate)
                {
                    _outboundService.OutboundOrderService.Db.Deleteable<Dt_OutboundOrder>().Where(x => x.OrderNo == model.OrderNo).ExecuteCommand();
                    _outboundService.OutboundOrderDetailService.Db.Deleteable<Dt_OutboundOrderDetail>()
                     .Where(p => SqlFunc.Subqueryable<Dt_OutboundOrder>().Where(s => s.Id == p.OrderId && s.OrderNo == model.OrderNo).Any()).ExecuteCommand();

                    var outboundOrders = ConvertToOutboundOrders(model);
                    await _outboundService.OutboundOrderService.ReceiveOutboundOrder(outboundOrders, 1);
                }         
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _logger.LogInformation("ReCheckOrderService UpdateReCheckOrder:  " + ex.Message);
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        public WebResponseContent DeleteReCheckOrder(Dt_ReCheckOrder model)
        {
            try
            {

                var recheckOrder = Db.Queryable<Dt_ReCheckOrder>().Where(x => x.OrderNo == model.OrderNo).First();
                if (recheckOrder == null)
                {
                    return WebResponseContent.Instance.Error($"未找到单信息");
                }

                BaseDal.DeleteData(recheckOrder);

                _outboundService.OutboundOrderService.Db.Deleteable<Dt_OutboundOrder>().Where(x => x.OrderNo == model.OrderNo).ExecuteCommand();
                _outboundService.OutboundOrderDetailService.Db.Deleteable<Dt_OutboundOrderDetail>()
                 .Where(p => SqlFunc.Subqueryable<Dt_OutboundOrder>().Where(s => s.Id == p.OrderId && s.OrderNo == model.OrderNo).Any()).ExecuteCommand();


                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _logger.LogInformation("ReCheckOrderService DeleteReCheckOrder:  " + ex.Message);
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }



        public Dt_OutboundOrder ConvertToOutboundOrders(Dt_ReCheckOrder reCheckOrder)
        {

            var outboundOrder = new Dt_OutboundOrder()
            {
                WarehouseId = 0,
                OrderNo = reCheckOrder.OrderNo,
                UpperOrderNo = reCheckOrder.OrderNo,
                OrderType = InOrderTypeEnum.ReCheck.ObjToInt(),
                OrderStatus = 0,
                CreateType = 0,
                BusinessType = "30",
                IsBatch = 0,
                FactoryArea = reCheckOrder.FactoryArea,
                Remark = "",
                DepartmentCode = "",
                DepartmentName = "",
                ReturnToMESStatus = 5,
                Details = new List<Dt_OutboundOrderDetail>()
            };
            outboundOrder.Details.Add(
                     new Dt_OutboundOrderDetail
                     {
                         OrderId = 0,
                         MaterielCode = reCheckOrder.MaterielCode,
                         MaterielName = "",
                         BatchNo = reCheckOrder.BatchNo,
                         OrderQuantity = reCheckOrder.Qty,
                         BarcodeQty = (decimal)reCheckOrder.Qty,
                         BarcodeUnit = reCheckOrder.Unit,
                         LockQuantity = 0,
                         lineNo = "",
                         OverOutQuantity = 0,
                         OrderDetailStatus = 0,
                         Unit = reCheckOrder.Unit,
                         RowNo = 0,
                         SupplyCode = "",
                         WarehouseCode = reCheckOrder.WarehouseCode,
                     }
                );
            return outboundOrder;
        }

    }
}