using JSMachine.WMS.App.Dto;
using JSMachine.WMS.App.Dto.Enum;
using JSMachine.WMS.App.IService;
using JSMachine.WMS.App.ServiceImpl;
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 Microsoft.IdentityModel.Tokens;
using Newtonsoft.Json;
using NLog;
using Quartz;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;

namespace JSMachine.WMS.Job.Job
{
    [DisallowConcurrentExecution]
    [PersistJobDataAfterExecution]
    [Job(Name = nameof(ElevatorJob)
        , Group = nameof(ElevatorJob) + "_Group"
        , Description = "提升机监控作业"
        , ScheduleType = ScheduleType.Simple
        , IntervalMilliSeconds = 500
        , RepeatCount = 0
        , StartTimeStr = null)]
    /// <summary>
    /// 周期读取提升机 PLC 状态，依据边沿信号处理取货、队列和计数业务。
    /// </summary>
    public class ElevatorJob : IJob
    {
        private static readonly IElevatorPlcQueueService ElevatorPlcQueueService = GlobalServericeProvidor.GetService<IElevatorPlcQueueService>();
        private static readonly IAGVTaskService AGVTaskService = GlobalServericeProvidor.GetService<IAGVTaskService>();
        private static readonly IStorageRackService StorageRackService = GlobalServericeProvidor.GetService<IStorageRackService>();
        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;

        /// <summary>
        /// 执行一次提升机状态轮询，并处理新产生的取货信号。
        /// </summary>
        /// <param name="context">Quartz 作业上下文。</param>
        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.StockInPickupChannelOne)
            {
                LogHelper.Warn("入库：1号提升机通道2014可以取货");

                _ = ElevatorCountService.IncrementCount(1, 2014);

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

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

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

            if (!PreElevatorOneChannelTwAollowPickUp && elevatorStatusOne.StockInPickupChannelTwo)
            {
                LogHelper.Warn("入库：1号提升机通道2004可以取货");

                _ = ElevatorCountService.IncrementCount(1, 2004);

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

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

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

            if (!PreElevatorTwoChannelOneAllowPickUp && elevatorStatusTwo.StockInPickupChannelOne)
            {
                LogHelper.Warn("入库：2号提升机通道2014可以取货");

                _ = ElevatorCountService.IncrementCount(2, 2014);

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

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

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

            if (!PreElevatorTwoChannelTwoAllowPickUp && elevatorStatusTwo.StockInPickupChannelTwo)
            {
                LogHelper.Warn("入库：2号提升机通道2004可以取货");

                _ = ElevatorCountService.IncrementCount(2, 2004);

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

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

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

        private async Task HandlePickup(ElevatorPlcQueueDto elevatorQue)
        {
            AGVTaskDto agvTask = await AGVTaskService.GetSingalByExpression(p => p.Id == elevatorQue.AgvTaskId);
            if (agvTask == null)
            {
                LogHelper.Error($"从PLC队列中获取的 AgvTask {elevatorQue.AgvTaskId} 不存在");
                return;
            }

            StorageRackDto startWarehouseSecondFloor = await StorageRackService
                .GetElevatorWareHouse(elevatorQue.ElevatorNo, elevatorQue.ElevatorChannel == 1001 ? 2004 : 2014);

            StockInSecondFloorCache.StockInSecondFloorQue.Enqueue(new AllowPickUpInfo
            {
                AgvTask = agvTask,
                ElevatorPlcQueue = elevatorQue,
                StartWarehouseSecondFloor = startWarehouseSecondFloor
            });
        }
    }
}