#region << 版 本 注 释 >>
/*----------------------------------------------------------------
 * 命名空间：WIDESEAWCS_Tasks.ConveyorLineJob
 * 创建者：胡童庆
 * 创建时间：2024/8/2 16:13:36
 * 版本：V1.0.0
 * 描述：
 *
 * ----------------------------------------------------------------
 * 修改人：
 * 修改时间：
 * 版本：V1.0.1
 * 修改说明：
 * 
 *----------------------------------------------------------------*/
#endregion << 版 本 注 释 >>

using Autofac.Core;
using AutoMapper;
using HslCommunication;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
using Quartz;
using System.Reflection;
using WIDESEA_Common.Log;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core.Caches;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.HttpContextUser;
using WIDESEAWCS_DTO.Enum;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_IBasicInfoService;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_Model.Models.BasicInfo;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DeviceBase;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_SignalR;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory.Database;

namespace WIDESEAWCS_Tasks
{
    [DisallowConcurrentExecution]
    public class CommonConveyorLineJob :JobBase, IJob
    {
        private readonly ITaskService _taskService;
        private readonly ITaskRepository _taskRepository;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly IRouterService _routerService;
        private readonly IDt_StationManagerService _stationManagerService;
        private readonly IMapper _mapper;
        private readonly ICacheService _cacheService;
        private readonly INoticeService _noticeService;
        private static List<string>? userTokenIds;
        private static List<int>? userIds;

        public CommonConveyorLineJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IDt_StationManagerService stationManagerService, IMapper mapper, ICacheService cacheService, INoticeService noticeService, ITaskRepository taskRepository)
        {
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
            _routerService = routerService;
            _stationManagerService = stationManagerService;
            _mapper = mapper;
            _cacheService = cacheService;
            _noticeService = noticeService;
            _taskRepository = taskRepository;
        }

        public async Task Execute(IJobExecutionContext context)
        {
            try
            {
                CommonConveyorLine conveyorLine = (CommonConveyorLine)context.JobDetail.JobDataMap.Get("JobParams");
                if (conveyorLine != null)
                {
                    // 获取所有站点管理器
                    List<Dt_StationManager> stationManagers = _stationManagerService.GetAllStationByDeviceCode(conveyorLine.DeviceCode);

                    // 并行处理每个子设备
                    var tasks = stationManagers.Select(station => ProcessDeviceAsync(conveyorLine, station)).ToList();

                    await Task.WhenAll(tasks);
                }

            }
            catch (Exception ex)
            {
                Console.Out.WriteLine(nameof(CommonConveyorLineJob) + ":" + ex.ToString());
            }
            return;
        }
        private Task ProcessDeviceAsync(CommonConveyorLine conveyorLine, Dt_StationManager station)
        {
            try
            {
                ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(station.stationName);
                if (command != null)
                {
                    #region 调用事件总线通知前端

                    // 获取缓存中的用户信息
                    var tokenInfos = _cacheService.Get<List<UserInfo>>("Cache_UserToken");
                    if (tokenInfos != null && tokenInfos.Any())
                    {
                        userTokenIds = tokenInfos.Select(x => x.Token_ID).ToList();
                        userIds = tokenInfos.Select(x => x.UserId).ToList();
                    }

                    #endregion 调用事件总线通知前端

                    // 将交互信号转换为布尔数组
                    var writeInteractiveSignal = command.InteractiveSignal;
                    var structs = BitConverter.GetBytes(writeInteractiveSignal).Reverse().ToArray().ToBoolArray();
                    // 获取设备协议详情
                    List<DeviceProtocolDetailDTO>? deviceProtocolDetails = conveyorLine.DeviceProtocolDetailDTOs.Where(x => x.DeviceProParamName == nameof(ConveyorLineTaskCommand.InteractiveSignal)).ToList();

                    if (deviceProtocolDetails != null)
                    {
                        foreach (var item in deviceProtocolDetails)
                        {
                            int itemValue = Convert.ToInt32(item.ProtocalDetailValue);
                            if (structs[itemValue] == true)
                            {
                                // 获取处理方法

                                MethodInfo? method = GetType().GetMethod(item.ProtocolDetailType);
                                if (method != null)
                                {
                                    method.Invoke(this, new object[] { conveyorLine, station.stationName });
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                WriteInfo(conveyorLine.DeviceName, ex.Message);
            }
            return Task.CompletedTask;
        }
        /// <summary>
        /// 生成取货任务，放至上料位
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="command">读取的请求信息</param>Request outbound
        /// <param name="childDeviceCode">子设备编号</param>
        public async Task RequestInbound(CommonConveyorLine conveyorLine, string childDeviceCode)
        {
            try
            {
                // 输出信息，表示站台请求取货
                var log = $"【{conveyorLine._deviceName}】站台【{childDeviceCode}】请求取货";
                ConsoleHelper.WriteWarningLine(log);
                // 推送通知到前端SignIR
                await _noticeService.Logs(userTokenIds, new { conveyorLine.DeviceName, log = log, time = DateTime.Now.ToString("G"), color = "Red" });
                WriteInfo(conveyorLine.DeviceName, log);

                // 获取所有任务源地址
                List<string> task = _taskService.QueryConveyorLineTaskSourceAddress();

                // 根据设备编号和任务源地址查询所有未执行的任务
                List<Dt_StationManager> childDeviceCodes = _stationManagerService.QuerypLatform(conveyorLine.DeviceCode, task);  //对应每个ip找全部的下料站点与垫板回收点站台点


                foreach (var item in childDeviceCodes)
                {
                    ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(item.stationName);
                    if (command != null)
                    {
                        var structs = BitConverter.GetBytes(command.InteractiveSignal).Reverse().ToArray().ToBoolArray();
                        if (structs[1])
                        {
                            if (item.stationMaterial == (int)AgvStationEnum.PadRecycle)
                            {
                                RequestHcdbst(conveyorLine, item.stationArea, item.stationName, item.stationRemark);
                                return;
                            }
                            else
                            {
                                Dt_Task taskDTO = new Dt_Task()
                                {
                                    TaskNum = _taskRepository.GetTaskNo().Result,
                                    Grade = 1,
                                    Roadway = item.stationArea.ToString(),
                                    SourceAddress = childDeviceCode,
                                    TargetAddress = item.stationName,
                                    TaskState = (int)AGVTaskStatusEnum.AGVNew,
                                    TaskType = item.stationMaterial,
                                };
                                _taskService.ReceiveWMSTask(new List<Dt_Task> { taskDTO });
                                return;
                            }
                        }
                        else
                        {
                            WriteInfo(conveyorLine.DeviceName, $"站台{item.stationName}状态不可用{structs[2]}");
                        }
                    }
                    else
                    {
                        WriteInfo(conveyorLine.DeviceName, $"通讯连接错误，{item.stationName}未找到读取模块地址");
                    }
                }

            }
            catch (Exception ex)
            {
                WriteInfo(conveyorLine.DeviceName, ex.Message);
            }
        }

        /// <summary>
        /// 根据agv下料任务，把料放至上料口或缓存位
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="childDeviceCode">子设备编号</param>
        public void RequestOutbound(CommonConveyorLine conveyorLine, string childDeviceCode)
        {
            try
            {
                List<Dt_StationManager> station = _stationManagerService.QuerypLatformarer(conveyorLine.DeviceCode);
                foreach (var item in station)
                {
                    ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(item.stationName);
                    if (command != null)
                    {
                        var structs = BitConverter.GetBytes(command.InteractiveSignal).Reverse().ToArray().ToBoolArray();
                        if (structs[2])
                        {
                            if (item.stationMaterial == (int)AgvStationEnum.BoardLoad)
                            {
                                //Dt_Task agvstack= _taskService.QueryConveyorLineTaskRoadway(AGVStationitem.stationArea);
                                //if(agvstack != null)
                                //{
                                //    _taskService.UpdateTargetAddress(agvstack.TaskId, AGVStationitem.stationName);
                                //}
                                //else
                                //{
                                //    //去找缓存区库存
                                //    RequestHcst(conveyorLine, AGVStationitem.stationArea, AGVStationitem.stationName, AGVStationitem.stationRemark);
                                //}
                            }
                        }
                        else
                        {
                            WriteInfo(conveyorLine.DeviceName, $"站台{item.stationName}状态不可用{structs[2]}");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                WriteInfo(conveyorLine.DeviceName, ex.Message);
            }
        }

        public void RequestHcst(CommonConveyorLine conveyorLine,int Station_Area,string Station_names,string Station_remark)
        {
            List<Dt_StationManager> AGVStationListdata = _stationManagerService.QuerypLatformmaterial(Station_Area);   //查出缓存位
            if (Station_remark != null)   //找寻对应的放货站台
            {
                AGVStationListdata = _stationManagerService.QuerypStation_Area2(Station_remark);
            }
            foreach (var item in AGVStationListdata)
            {
                ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(item.stationName);
                if (command != null)
                {
                    var structs = BitConverter.GetBytes(command.InteractiveSignal).Reverse().ToArray().ToBoolArray();
                    if (structs[1])
                    {
                        if (_taskService.QueryConveyorLinetaeersuadd(item.stationName))
                        {
                            Dt_Task taskDTO = new Dt_Task()
                            {
                                TaskNum = _taskRepository.GetTaskNo().Result,
                                Grade = 1,
                                Roadway = item.stationArea.ToString(),
                                SourceAddress = item.stationName,
                                CurrentAddress = item.stationName,
                                TaskState = (int)TaskInStatusEnum.InNew,
                                TaskType = (int)item.stationMaterial,
                                TargetAddress = Station_names,
                                NextAddress = Station_names,
                            };
                            _taskService.ReceiveWMSTask(new List<Dt_Task> { taskDTO });
                        }
                    }
                    else
                    {
                        WriteInfo(conveyorLine.DeviceName,  $"通讯连接错误，{item.stationName}未找到读取模块地址");
                    }
                }
            }
        }

        public void RequestHcdbst(CommonConveyorLine conveyorLine, int Station_Area, string Station_names,string Station_remark)
        {
            List<Dt_StationManager> AGVStationListdata = _stationManagerService.QuerypStation_Area(Station_Area);   //查出缓存位
            if(Station_remark !=null)   //找寻对应的放货站台
            {
                AGVStationListdata= _stationManagerService.QuerypStation_Area2(Station_remark);
            }
            
            foreach (var item in AGVStationListdata)
            {
                ConveyorLineTaskCommand command = conveyorLine.ReadCustomer<ConveyorLineTaskCommand>(item.stationName);
                if (command != null)
                {
                    var structs = BitConverter.GetBytes(command.InteractiveSignal).Reverse().ToArray().ToBoolArray();
                    if (structs[1])
                    {
                        if (_taskService.QueryConveyorLinetaeersuadd(item.stationName))
                        {
                            Dt_Task taskDTO = new Dt_Task()
                            {
                                TaskNum = _taskRepository.GetTaskNo().Result,
                                Grade = 1,
                                Roadway = item.stationArea.ToString(),
                                SourceAddress = Station_names,
                                CurrentAddress = Station_names,
                                TaskState = (int)TaskInStatusEnum.InNew,
                                TaskType = (int)item.stationMaterial,
                                TargetAddress = item.stationName,
                                NextAddress = item.stationName,
                            };
                            _taskService.ReceiveWMSTask(new List<Dt_Task> { taskDTO });
                        }
                    }
                    else
                    {
                        WriteInfo(conveyorLine.DeviceName, $"读取放货信号为：{structs[2]}");
                    }
                }
            }
        }

        /// <summary>
        /// 输送线交互完成
        /// </summary>
        /// <param name="conveyorLine">输送线实例对象</param>
        /// <param name="childDeviceCode">子设备编号</param>
        /// <param name="ProtocalDetailValue">线体当前bool读取偏移地址</param>
        /// <param name="value">值</param>
        public void ConveyorLineSendFinish(CommonConveyorLine conveyorLine, string childDeviceCode)
        {
            DeviceProDTO? devicePro = conveyorLine.DeviceProDTOs.Where(x => x.DeviceProParamType == nameof(DeviceCommand) && x.DeviceChildCode == childDeviceCode && x.DeviceProParamName == "WriteInteractiveSignal").OrderBy(x => x.DeviceProOffset).FirstOrDefault();

            conveyorLine.Communicator.Write(devicePro.DeviceProAddress, true);
        }
    }
}