using Autofac.Core;
using HslCommunication;
using HslCommunication.Core;
using HslCommunication.WebSocket;
using Microsoft.Extensions.Hosting;
using Microsoft.VisualBasic.FileIO;
using Newtonsoft.Json;
using Quartz;
using SixLabors.ImageSharp.PixelFormats;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Communicator;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DeviceBase;
using WIDESEAWCS_QuartzJob.StackerCrane.Enum;
using WIDESEAWCS_Tasks.OHT;

namespace WIDESEAWCS_Tasks
{
    [DisallowConcurrentExecution]
    public class ZXJJob : JobBase, IJob
    {
        public static bool W_ZXJ_Heat = true;
        public static bool W_TC_Heat = true;
        private readonly ITaskService _taskService;
        WebSocketServer _webSocketServer;
        private readonly Idt_ErrormsginfoService _ErrormsginfoService;
        public ZXJJob(ITaskService taskService, WebSocketServer webSocketServer,Idt_ErrormsginfoService errormsginfoService)
        {
            _taskService = taskService;//注入
            _webSocketServer = webSocketServer;
            _ErrormsginfoService = errormsginfoService;
        }

        public Task Execute(IJobExecutionContext context)
        {
            //return Task.CompletedTask;
            bool flag = context.JobDetail.JobDataMap.TryGetValue("JobParams", out object? value);
            if (flag && value != null)
            {
                
                try
                {
                    //天车PLC对象
                    OtherDevice TCevice = (OtherDevice)Storage.Devices.Find(v => v.DeviceName == "天车");
                    if (TCevice.Communicator.IsConnected)
                    {
                        #region 读取天车设备数据
                        OHTJob.oHTReadData.R_HeartBeat = TCevice.GetValue<DeviceDBName, bool>(DeviceDBName.R_HeartBeat);
                        OHTJob.oHTReadData.R_RunMode = TCevice.GetValue<DeviceDBName, short>(DeviceDBName.R_RunMode);
                        OHTJob.oHTReadData.R_RunState = TCevice.GetValue<DeviceDBName, short>(DeviceDBName.R_RunState);
                        OHTJob.oHTReadData.R_AlarmCode = TCevice.GetValue<DeviceDBName, short>(DeviceDBName.R_AlarmCode);
                        OHTJob.oHTReadData.R_TaskState = TCevice.GetValue<DeviceDBName, short>(DeviceDBName.R_TaskState);
                        OHTJob.oHTReadData.R_CurrentLine = TCevice.GetValue<DeviceDBName, int>(DeviceDBName.R_CurrentLine);
                        OHTJob.oHTReadData.R_CurrentColumn = TCevice.GetValue<DeviceDBName, int>(DeviceDBName.R_CurrentColumn);
                        OHTJob.oHTReadData.R_RiseUp_Position = TCevice.GetValue<DeviceDBName, int>(DeviceDBName.R_RiseUp_Position);
                        OHTJob.oHTReadData.R_TaskNumber = TCevice.GetValue<DeviceDBName, int>(DeviceDBName.R_TaskNumber);
                        OHTJob.oHTReadData.R_Loaded_1 = TCevice.GetValue<DeviceDBName, short>(DeviceDBName.R_Loaded_1);
                        OHTJob.oHTReadData.R_Loaded_2 = TCevice.GetValue<DeviceDBName, short>(DeviceDBName.R_Loaded_2);
                        OHTJob.oHTReadData.weight = TCevice.GetValue<DeviceDBName, float>(DeviceDBName.weight);
                        #endregion
                        if (W_TC_Heat)
                        {
                            W_TC_Heat = false;
                            TCevice.SetValue(DeviceDBName.W_HeartBeat, W_ZXJ_Heat);
                        }
                        else
                        {
                            W_TC_Heat = true;
                            TCevice.SetValue(DeviceDBName.W_HeartBeat, W_ZXJ_Heat);
                        }
                    }
                    else
                    {
                        throw new Exception($"天车PLC连接失败");
                    }
                    //整形机PLC对象
                    OtherDevice device = (OtherDevice)value;
                    if (device.Communicator.IsConnected)
                    {
                        #region 读取整形机设备数据
                        OHTJob.oHTReadData.R_ZXJ_HeartBeat = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_ZXJ_HeartBeat);
                        OHTJob.oHTReadData.R_ZXJ_isWork = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_ZXJ_isWork);
                        OHTJob.oHTReadData.R_ZXJ_RGVMode = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_ZXJ_RGVMode);
                        OHTJob.oHTReadData.R_ZXJ_TCMode = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_ZXJ_TCMode);
                        OHTJob.oHTReadData.R_ZXJ_TC_isready = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_ZXJ_TC_isready);
                        OHTJob.oHTReadData.R_TCMode_TC = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_TCMode_TC);
                        OHTJob.oHTReadData.R_TCMode_CC = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_TCMode_CC);
                        OHTJob.oHTReadData.R_HC_isReady = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_HC_isReady);
                        OHTJob.oHTReadData.R_HC_isReadyWork = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_HC_isReadyWork);
                        OHTJob.oHTReadData.R_issafe = device.GetValue<ZXJDBName, bool>(ZXJDBName.R_issafe);
                        #endregion
                        if (W_ZXJ_Heat)
                        {
                            W_ZXJ_Heat = false;
                            device.SetValue(ZXJDBName.W_ZXJ_HeartBeat, W_ZXJ_Heat);
                        }
                        else
                        {
                            W_ZXJ_Heat = true;
                            device.SetValue(ZXJDBName.W_ZXJ_HeartBeat, W_ZXJ_Heat);
                        }
                    }
                    else
                    {
                        throw new Exception($"整形机PLC连接失败");
                    }
                    //规整机PLC对象
                    OtherDevice GZJevice = (OtherDevice)Storage.Devices.Find(v => v.DeviceName == "阳极规整机");
                    if (GZJevice.Communicator.IsConnected)
                    {
                        #region 读取规整机设备数据
                        OHTJob.oHTReadData.R_ZXJ_HeartBeat = GZJevice.GetValue<GZJDBName, bool>(GZJDBName.R_GZJ_HeartBeat);
                        OHTJob.oHTReadData.R_GZJ_isWork = GZJevice.GetValue<GZJDBName, bool>(GZJDBName.R_GZJ_isWork);
                        OHTJob.oHTReadData.R_RGVMode = GZJevice.GetValue<GZJDBName, bool>(GZJDBName.R_RGVMode);
                        OHTJob.oHTReadData.R_CCMode = GZJevice.GetValue<GZJDBName, bool>(GZJDBName.R_CCMode);
                        OHTJob.oHTReadData.R_TCMode = GZJevice.GetValue<GZJDBName, bool>(GZJDBName.R_TCMode);
                        OHTJob.oHTReadData.R_DK_isready = GZJevice.GetValue<GZJDBName, bool>(GZJDBName.R_DK_isready);
                        OHTJob.oHTReadData.R_XK_isready = GZJevice.GetValue<GZJDBName, bool>(GZJDBName.R_XK_isready);
                        OHTJob.oHTReadData.R_TC_isready = GZJevice.GetValue<GZJDBName, bool>(GZJDBName.R_TC_isready);
                        #endregion
                    }
                    else
                    {
                        throw new Exception($"规整机PLC连接失败");
                    }
                    //状态数据发送给前端
                    string ohtData = JsonConvert.SerializeObject(OHTJob.oHTReadData);
                    _webSocketServer.PublishAllClientPayload(ohtData);
                }
                catch (Exception ex)
                {
                    //状态数据发送给前端
                    string ohtData = JsonConvert.SerializeObject(OHTJob.oHTReadData);
                    _webSocketServer.PublishAllClientPayload(ohtData);
                    _ErrormsginfoService.UpdateErrorMsg(ex.Message, 1);
                }
            }
            return Task.CompletedTask;
        }


        /// <summary>
        /// 任务实体转换成命令Model
        /// </summary>
        /// <param name="task">任务实体</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public OHTTaskCommand? ConvertToOHTTaskCommand([NotNull] Dt_Task task)
        {
            OHTTaskCommand oHtTaskCommand = new OHTTaskCommand();

            oHtTaskCommand.W_Task_Type = 1;
            oHtTaskCommand.W_Load_Layer = 0;
            oHtTaskCommand.W_Pick_Line = 1;
           
            string[] SourceCodes = task.SourceAddress.Split("-");
            if (SourceCodes.Length == 3)
            {
                oHtTaskCommand.W_Pick_Line = Convert.ToInt16(SourceCodes[1]);
                oHtTaskCommand.W_Put_Column = Convert.ToInt16(SourceCodes[2]);
                oHtTaskCommand.W_Put_Layer = Convert.ToInt16(SourceCodes[3]);
            }
            else
            {
                //数据配置错误
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"任务源地址配置错误！");
                return null;
            }
            string[] targetCodes = task.TargetAddress.Split("-");
            if (targetCodes.Length == 3)
            {
                oHtTaskCommand.W_Put_Line = Convert.ToInt16(targetCodes[1]);
                oHtTaskCommand.W_Put_Column = Convert.ToInt16(targetCodes[2]);
                oHtTaskCommand.W_Put_Layer = Convert.ToInt16(targetCodes[3]);
            }
            else
            {
                //数据配置错误
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"任务目标地址配置错误");
                return null;
            }
            return oHtTaskCommand;
        }


        /// <summary>
        /// 获取任务
        /// </summary>
        /// <returns></returns>
        private Dt_Task? GetTask()
        {
            Dt_Task task;
            task = _taskService.QueryStackerCraneTask("R01");
            return task;
        }


    }


}