using JSMachine.WMS.App.Dto;
using JSMachine.WMS.App.Dto.Enum;
using JSMachine.WMS.App.IService;
using JSMachine.WMS.App.ServiceImpl;
using JSMachine.WMS.Business.Common.IService;
using JSMachine.WMS.Business.Common.ServiceImpl;
using JSMachine.WMS.Business.StockOut.IService;
using JSMachine.WMS.Common.Cache;
using JSMachine.WMS.Domain.Entity;
using JSMachine.WMS.Infrastructure;
using JSMachine.WMS.Infrastructure.Helper;
using JSMachine.WMS.Job.Enum;
using JSMachine.WMS.Job.JobAttributes;
using JSMachine.WMS.PLC.ModbusImpl.Elevator.ModbusIO.Read;
using JSMachine.WMS.PLC.ModbusImpl.Elevator.Model;
using Newtonsoft.Json;
using Quartz;

namespace JSMachine.WMS.Job.Job
{
    [DisallowConcurrentExecution]
    [PersistJobDataAfterExecution]
    [Job(Name = nameof(ElevatorOutJob)
        , Group = nameof(ElevatorOutJob) + "_Group"
        , Description = "提升机监控作业"
        , ScheduleType = ScheduleType.Simple
        , IntervalMilliSeconds = 500
        , RepeatCount = 0
        , StartTimeStr = null)]
    public class ElevatorOutJob : IJob
    {
        private static readonly IElevatorPlcQueueService ElevatorPlcQueueService = GlobalServericeProvidor.GetService<IElevatorPlcQueueService>();
        private static readonly ICommonService CommonService = GlobalServericeProvidor.GetService<ICommonService>();
        private static readonly IERPTaskService ERPTaskService = GlobalServericeProvidor.GetService<IERPTaskService>();
        private static readonly IAGVTaskService AGVTaskService = GlobalServericeProvidor.GetService<IAGVTaskService>();
        private static readonly IStorageRackService StorageRackService = GlobalServericeProvidor.GetService<IStorageRackService>();
        private static readonly IERPTaskService ErpTaskService = GlobalServericeProvidor.GetService<IERPTaskService>();
        private static readonly IStockOutService StockOutService= GlobalServericeProvidor.GetService<IStockOutService>();
        private static readonly IElevatorCountService ElevatorCountService = GlobalServericeProvidor.GetService<IElevatorCountService>();

        /// <summary>
        /// 1号提升机1号取货通道前一个允许取货状态
        /// </summary>
        private static bool PreElevatorOneChannelOneAllowPickUp = false;
        /// <summary>
        /// 1号提升机2号取货通道前一个允许取货状态
        /// </summary>
        private static bool PreElevatorOneChannelTwAollowPickUp = false;
        /// <summary>
        /// 2号提升机1号取货通道前一个允许取货状态
        /// </summary>
        private static bool PreElevatorTwoChannelOneAllowPickUp = false;
        /// <summary>
        /// 2号提升机2号取货通道前一个允许取货状态
        /// </summary>
        private static bool PreElevatorTwoChannelTwoAllowPickUp = false;

        public async Task Execute(IJobExecutionContext context)
        {
            List<ElevatorPlcStatus> elevatorPlcStatuses = await ElevatorStatusRead.ReadAllElevatorStatus();

            if (elevatorPlcStatuses.IsNullOrEmpty())
            {
                LogHelper.Warn($"出库：读取提升机PLC信号失败");
                return;
            }

            ElevatorPlcStatus elevatorStatusOne = elevatorPlcStatuses.First(p => p.ElevatorNo == 1);
            ElevatorPlcStatus elevatorStatusTwo = elevatorPlcStatuses.First(p => p.ElevatorNo == 2);

            if (!PreElevatorOneChannelOneAllowPickUp && elevatorStatusOne.StockOutPickupChanelOne)
            {
                LogHelper.Info($"出库：1号提升机1016出库通道可以取货");

                _ = ElevatorCountService.IncrementCount(1, 1016);

                List<ElevatorPlcQueueDto> elevatorQueue = await ElevatorPlcQueueService
                                                                .GetListByExpression(p =>
                                                                    p.ElevatorNo == 1 && p.ElevatorChannel == 2011,
                                                                    nameof(ElevatorPlcQueueDto.CreationTime),
                                                                    SqlSugar.OrderByType.Asc);
                if (!elevatorQueue.IsNullOrEmpty())
                {
                    ElevatorPlcQueueDto destQueue = elevatorQueue.First();

                    await HandlePickup(destQueue);
                }
                else
                {
                    LogHelper.Warn($"出库：1号提升机1016出库通道可以取货，但是PLC队列没有信息");
                }

                PreElevatorOneChannelOneAllowPickUp = elevatorStatusOne.StockOutPickupChanelOne;
                return;
            }
            else
            {
                PreElevatorOneChannelOneAllowPickUp = elevatorStatusOne.StockOutPickupChanelOne;
            }

            if (!PreElevatorOneChannelTwAollowPickUp && elevatorStatusOne.StockOutPickupChanelTwo)
            {
                LogHelper.Info($"出库：1号提升机1006号出库通道可以取货");

                _ = ElevatorCountService.IncrementCount(1, 1006);

                List<ElevatorPlcQueueDto> elevatorQueue = await ElevatorPlcQueueService
                                                               .GetListByExpression(p =>
                                                                   p.ElevatorNo == 1 && p.ElevatorChannel == 2001,
                                                                   nameof(ElevatorPlcQueueDto.CreationTime),
                                                                   SqlSugar.OrderByType.Asc);
                if (!elevatorQueue.IsNullOrEmpty())
                {
                    ElevatorPlcQueueDto destQueue = elevatorQueue.First();

                    await HandlePickup(destQueue);
                }
                else
                {
                    LogHelper.Warn($"出库：一号提升机1006号出库通道可以取货，但是PLC队列没有信息");
                }

                PreElevatorOneChannelTwAollowPickUp = elevatorStatusOne.StockOutPickupChanelTwo;
                return;
            }
            else
            {
                PreElevatorOneChannelTwAollowPickUp = elevatorStatusOne.StockOutPickupChanelTwo;
            }

            if (!PreElevatorTwoChannelOneAllowPickUp && elevatorStatusTwo.StockOutPickupChanelOne)
            {
                LogHelper.Info($"出库：2号提升机1016出库通道可以取货");

                _ = ElevatorCountService.IncrementCount(2, 1016);

                List<ElevatorPlcQueueDto> elevatorQueue = await ElevatorPlcQueueService
                                                               .GetListByExpression(p =>
                                                                   p.ElevatorNo == 2 && p.ElevatorChannel == 2011,
                                                                   nameof(ElevatorPlcQueueDto.CreationTime),
                                                                   SqlSugar.OrderByType.Asc);
                if (!elevatorQueue.IsNullOrEmpty())
                {
                    ElevatorPlcQueueDto destQueue = elevatorQueue.First();

                    await HandlePickup(destQueue);
                }
                else
                {
                    LogHelper.Warn($"出库：二号提升机1016出库通道可以取货，但是PLC队列没有信息");
                }

                PreElevatorTwoChannelOneAllowPickUp = elevatorStatusTwo.StockOutPickupChanelOne;
                return;
            }
            else
            {
                PreElevatorTwoChannelOneAllowPickUp = elevatorStatusTwo.StockOutPickupChanelOne;
            }

            if (!PreElevatorTwoChannelTwoAllowPickUp && elevatorStatusTwo.StockOutPickupChanelTwo)
            {
                LogHelper.Info($"出库：二号提升机1006出库通道可以取货");

                _ = ElevatorCountService.IncrementCount(2, 1006);

                List<ElevatorPlcQueueDto> elevatorQueue = await ElevatorPlcQueueService
                                                               .GetListByExpression(p =>
                                                                   p.ElevatorNo == 2 && p.ElevatorChannel == 2001,
                                                                   nameof(ElevatorPlcQueueDto.CreationTime),
                                                                   SqlSugar.OrderByType.Asc);
                if (!elevatorQueue.IsNullOrEmpty())
                {
                    ElevatorPlcQueueDto destQueue = elevatorQueue.First();

                    await HandlePickup(destQueue);
                }
                else
                {
                    LogHelper.Warn($"出库：二号提升机1006出库通道可以取货，但是PLC队列没有信息");
                }

                PreElevatorTwoChannelTwoAllowPickUp = elevatorStatusTwo.StockOutPickupChanelTwo;
                return;
            }
            else
            {
                PreElevatorTwoChannelTwoAllowPickUp = elevatorStatusTwo.StockOutPickupChanelTwo;
            }
        }

        /// <summary>
        /// 收到取货完成信号
        /// 根据二楼的提升机队列，生成一楼的AgvTask
        /// 生成一楼的agvTask
        /// </summary>
        /// <param name="elevatorQue"></param>
        /// <returns></returns>
        private async Task HandlePickup(ElevatorPlcQueueDto elevatorQue)
        {
            AGVTaskDto agvTaskSecondFloor = await AGVTaskService.GetSingalByExpression(p => p.Id == elevatorQue.AgvTaskId);
            if (agvTaskSecondFloor == null)
            {
                LogHelper.Error($"AgvTask {elevatorQue.AgvTaskId} 不存在");
                return;
            }
            
            //获取起点  提升机库位信息
            StorageRackDto startWarehouseFirstFloor = await StorageRackService.GetElevatorWareHouse(
                                                        elevatorQue.ElevatorNo, elevatorQue.ElevatorChannel == 2001 ? 1006 : 1016);

            //计算终点出库码头
            StorageRackDto destWarehouseFirstFloor = await StockOutService.CalculateDestWarehouse_SaleOut(agvTaskSecondFloor.Transport);
            if (destWarehouseFirstFloor == null)
            {
                LogHelper.Warn($"一楼没有可用的库位，AgvTask {agvTaskSecondFloor.Id} 对应的一楼任务无法生成");

                _ = ErpTaskService.UpdateTaskMsg(agvTaskSecondFloor.ErpTaskId, "一楼库位不足，请确保码头无货后在pda上点击清空码头按钮");
                return;
            }

            ERPTaskDto erpTask = await ERPTaskService.GetSingalByExpression(p => p.Id == agvTaskSecondFloor.ErpTaskId);
            if (erpTask == null)
            {
                LogHelper.Error($"出库关联的ERP任务 {agvTaskSecondFloor.ErpTaskId} 不存在");
                return;
            }

            startWarehouseFirstFloor.BingdingMaterial(new StorageRackDto.MateriaInfo
            {
                BarCode = agvTaskSecondFloor.BarCode,
                MateriaBatch = agvTaskSecondFloor.MateriaBatch,
                MateriaName = agvTaskSecondFloor.MateriaName,
                MateriaType = agvTaskSecondFloor.MateriaType,
                MateriaCode = agvTaskSecondFloor.MateriaCode,
                MateriaNum = agvTaskSecondFloor.MateriaNum.ToString(),
                OrderNo = agvTaskSecondFloor.OrderNo
            });

           
            await CommonService.CreateAndInsertAgvTask(new Business.Common.Models.AgvTaskCreationParam
            {
                StartPosition = startWarehouseFirstFloor,
                EndPosition = destWarehouseFirstFloor,
                ErpTaskId = erpTask.Id,
                StockOutWharf = erpTask.Transport,
                TaskType = erpTask.TaskType
            });

            bool bRetTwo = await ElevatorPlcQueueService.DeleteById(elevatorQue.Id);
            bool bRetThree = await StorageRackService.Lock(destWarehouseFirstFloor);

            LogHelper.Info($"出库任务已生成，提升机队列被删除，队列原始信息 {JsonConvert.SerializeObject(elevatorQue)}");

        }
    }
}