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

using Autofac.Core;
using AutoMapper;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.DependencyInjection;
using NetTaste;
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Reflection;
using System.Reflection.Metadata;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Comm.Http;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Core.Enums;
using WIDESEAWCS_DTO.Enum;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Service;

namespace WIDESEAWCS_TaskInfoService
{
    public class RgvoperainformService : ServiceBase<Dt_Task_hty, ITask_HtyRepository>, IRgvoperainformService
    {
        private readonly IAgvStationService _gvStationService;
        private readonly IServiceProvider _serviceProvider;
        private static bool _isMonitoring = false;
        //private static CancellationTokenSource _cancellationTokenSource;
        
        // 在类级别添加独立的监控状态
        private bool _isOutboundMonitoring = false;
        private bool _isInboundMonitoring = false;
        private bool _isSafetyDoorMonitoring = false;

        private CancellationTokenSource _outboundCancellationTokenSource;
        private CancellationTokenSource _inboundCancellationTokenSource;
        private CancellationTokenSource _safetyDoorCancellationTokenSource;
        public RgvoperainformService(ITask_HtyRepository BaseDal, IAgvStationService agvStationService, IServiceProvider serviceProvider) : base(BaseDal)
        {
            _gvStationService = agvStationService;
            _serviceProvider = serviceProvider;
        }


        //=================================================读取设备信息==========================================================





        /// <summary>
        /// 获取设备状态（支持出库、入库和安全门独立监控）
        /// </summary>
        /// <param name="off">0:停止 1:启动 2:仅查询</param>
        /// <param name="monitorType">监控类型：outbound-出库 inbound-入库 safetydoor-安全门 all-全部</param>
        /// <returns></returns>
        public WebResponseContent GetDeviceStatusDto(int off, string monitorType = "outbound")
        {
            bool isOutbound = monitorType == "outbound" || monitorType == "all";//出库
            bool isInbound = monitorType == "inbound" || monitorType == "all";//入库
            bool isSafetyDoor = monitorType == "safetydoor" || monitorType == "all";//安全门

            if (off == 1)
            {
                // 启动监控
                if (isOutbound && !_isOutboundMonitoring)
                {
                    _isOutboundMonitoring = true;
                    _outboundCancellationTokenSource = new CancellationTokenSource();
                    _ = Task.Run(async () => await StartDeviceMonitoring(_outboundCancellationTokenSource.Token, "outbound"));
                }

                if (isInbound && !_isInboundMonitoring)
                {
                    _isInboundMonitoring = true;
                    _inboundCancellationTokenSource = new CancellationTokenSource();
                    _ = Task.Run(async () => await StartDeviceMonitoring(_inboundCancellationTokenSource.Token, "inbound"));
                }

                if (isSafetyDoor && !_isSafetyDoorMonitoring)
                {
                    _isSafetyDoorMonitoring = true;
                    _safetyDoorCancellationTokenSource = new CancellationTokenSource();
                    _ = Task.Run(async () => await StartDeviceMonitoring(_safetyDoorCancellationTokenSource.Token, "safetydoor"));
                }

                var immediateData = GetImmediateDeviceData(monitorType);
                string message = GetMonitorStatusMessage(monitorType);
                return WebResponseContent.Instance.OK($"设备状态监控已启动 - {message}", immediateData);
            }
            else if (off == 0)
            {
                // 停止监控
                if (isOutbound && _isOutboundMonitoring)
                {
                    _isOutboundMonitoring = false;
                    _outboundCancellationTokenSource?.Cancel();
                }

                if (isInbound && _isInboundMonitoring)
                {
                    _isInboundMonitoring = false;
                    _inboundCancellationTokenSource?.Cancel();
                }

                if (isSafetyDoor && _isSafetyDoorMonitoring)
                {
                    _isSafetyDoorMonitoring = false;
                    _safetyDoorCancellationTokenSource?.Cancel();
                }

                var finalData = GetImmediateDeviceData(monitorType);
                string message = GetMonitorStatusMessage(monitorType);
                return WebResponseContent.Instance.OK($"设备状态监控已停止 - {message}", finalData);
            }
            else
            {
                // 返回当前数据
                var currentData = GetImmediateDeviceData(monitorType);
                string message = GetMonitorStatusMessage(monitorType);
                return WebResponseContent.Instance.OK($"设备状态监控当前状态 - {message}", currentData);
            }
        }

        /// <summary>
        /// 启动设备监控
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <param name="monitorType">监控类型</param>
        /// <returns></returns>
        private async Task StartDeviceMonitoring(CancellationToken cancellationToken, string monitorType)
        {
            using (var scope = _serviceProvider.CreateScope())
            {
                var hubContext = scope.ServiceProvider.GetRequiredService<IHubContext<DeviceStatusHub>>();

                while (!cancellationToken.IsCancellationRequested)
                {
                    try
                    {
                        // 获取指定类型的设备数据
                        var deviceData = GetImmediateDeviceData(monitorType);

                        // 推送数据给所有连接的客户端，带上监控类型标识
                        await hubContext.Clients.All.SendAsync("ReceiveDeviceStatusUpdate",
                            new { MonitorType = monitorType, Data = deviceData }, cancellationToken);

                        Console.WriteLine($"✅ {GetMonitorTypeDisplayName(monitorType)}设备数据推送完成，时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");

                        // 等待30秒
                        await Task.Delay(30000, cancellationToken);
                    }
                    catch (OperationCanceledException)
                    {
                        // 监控被取消，正常退出
                        Console.WriteLine($"{GetMonitorTypeDisplayName(monitorType)}设备监控已停止");
                        break;
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"❌ {GetMonitorTypeDisplayName(monitorType)}设备监控异常: {ex.Message}");
                        await Task.Delay(5000, cancellationToken);
                    }
                }
            }

            // 更新监控状态
            switch (monitorType)
            {
                case "outbound":
                    _isOutboundMonitoring = false;
                    break;
                case "inbound":
                    _isInboundMonitoring = false;
                    break;
                case "safetydoor":
                    _isSafetyDoorMonitoring = false;
                    break;
            }
        }

        /// <summary>
        /// 获取设备数据
        /// </summary>
        /// <param name="monitorType">监控类型</param>
        /// <returns></returns>
        private Dictionary<string, Dictionary<string, int>> GetImmediateDeviceData(string monitorType = "all")
        {
            // 定义设备分组
            var deviceGroups = new Dictionary<string, List<string>>
            {
                // 出库设备
                ["MotherCar"] = new List<string> { "RGV112", "RGV110", "RGV114", "RGV115" },
                ["TransferCar"] = new List<string> { "RGV116", "RGV111" },
                ["MaterialOut"] = new List<string> { "RGV118" },

                // 入库设备
                ["InboundMotherCar"] = new List<string> { "RGV103", "RGV105", "RGV108", "RGV109" },
                ["InboundTransferCar"] = new List<string> { "RGV104", "RGV107" },
                ["MaterialIn"] = new List<string> { "RGV101" },

                // 安全门设备
                ["SafetyDoor"] = new List<string> { "HCJ2000" }, // 安全门
            };

            // 设备类型对应的参数配置
            var paramConfigs = new Dictionary<string, List<(string DeviceProParamName, string DeviceProParamType, string DeviceProRemark)>>
            {
                // 出库设备参数配置
                ["TransferCar"] = new List<(string, string, string)>
        {
            ("RgvCraneAutoStatus", "RgvCraneAutoStatus", "工作模式"),
            ("RGVCurrentlocation", "RGVCurrentlocation", "当前位置"),
            ("RgvEquipmentStatus", "RgvEquipmentStatus", "有货状态"),
            ("RGV_Targetaddress", "ReadDeviceCommand", "目标地址"),
            ("RGV_Rgvtaskstutas", "RGV_Rgvtaskstutas", "任务状态"),
            ("RGV_Rgvtaskid", "ReadDeviceCommand", "RGV任务编号"),
            ("RGV_Faultcode", "ReadDeviceCommand", "故障代码"),
            ("RGV_Risingsignalplace", "ReadDeviceCommand", "上升信号到位"),
            ("RGV_Descentsignal", "ReadDeviceCommand", "下降信号到位"),
            ("RGVInitialize", "RGVInitialize", "初始化未完成标志位")
        },
                ["MotherCar"] = new List<(string, string, string)>
        {
            ("RgvCraneAutoStatus", "RgvCraneAutoStatus", "工作模式"),
            ("RGVCurrentlocation", "RGVCurrentlocation", "当前位置"),
            ("RgvEquipmentStatus", "RgvEquipmentStatus", "有货状态"),
            ("RGV_Targetaddress", "ReadDeviceCommand", "目标地址"),
            ("RGV_Rgvtaskstutas", "RGV_Rgvtaskstutas", "任务状态"),
            ("RGV_Rgvtaskid", "ReadDeviceCommand", "RGV任务编号"),
            ("RGV_Faultcode", "ReadDeviceCommand", "故障代码"),
            ("RGVInitialize", "RGVInitialize", "初始化未完成标志位")
        },
                ["MaterialOut"] = new List<(string, string, string)>
        {
            ("RgvCraneAutoStatus", "RgvCraneAutoStatus", "工作模式"),
            ("RGVCurrentlocation", "RGVCurrentlocation", "当前位置"),
            ("RgvEquipmentStatus", "RgvEquipmentStatus", "有货状态"),
            ("RGV_Targetaddress", "ReadDeviceCommand", "目标地址"),
            ("RGV_Rgvtaskstutas", "RGV_Rgvtaskstutas", "任务状态"),
            ("RGV_Rgvtaskid", "ReadDeviceCommand", "RGV任务编号"),
            ("RGV_Faultcode", "ReadDeviceCommand", "故障代码"),
            ("RGV_Risingsignalplace", "ReadDeviceCommand", "上升信号到位"),
            ("RGV_Descentsignal", "ReadDeviceCommand", "下降信号到位"),
            ("RGV_Telescopicfork", "ReadDeviceCommand", "伸缩叉伸出信号"),
            ("RGV_Retractionsignal", "ReadDeviceCommand", "伸缩叉缩回信号"),
            ("RGV_Telescopicfork", "DeviceCommand", "伸出操作"),
            ("RGVForkCurrentPosition", "RGVForkCurrentPosition", "当前位置（货叉）"),
            ("RGVInitialize", "RGVInitialize", "初始化未完成标志位")
        },

                // 入库设备参数配置
                ["MaterialIn"] = new List<(string, string, string)>
        {
            ("RgvCraneAutoStatus", "RgvCraneAutoStatus", "工作模式"),
            ("RGVCurrentlocation", "RGVCurrentlocation", "当前位置"),
            ("RgvEquipmentStatus", "RgvEquipmentStatus", "有货状态"),
            ("RGV_Targetaddress", "ReadDeviceCommand", "目标地址"),
            ("RGV_Rgvtaskstutas", "RGV_Rgvtaskstutas", "任务状态"),
            ("RGV_Rgvtaskid", "ReadDeviceCommand", "RGV任务编号"),
            ("RGV_Faultcode", "ReadDeviceCommand", "故障代码"),
            ("RGV_Risingsignalplace", "ReadDeviceCommand", "上升信号到位"),
            ("RGV_Descentsignal", "ReadDeviceCommand", "下降信号到位"),
            ("RGV_Telescopicfork", "ReadDeviceCommand", "伸缩叉伸出信号"),
            ("RGV_Retractionsignal", "ReadDeviceCommand", "伸缩叉缩回信号"),
            ("RGV_Telescopicfork", "DeviceCommand", "伸出操作"),
            ("RGVForkCurrentPosition", "RGVForkCurrentPosition", "当前位置（货叉）"),
            ("RGVInitialize", "RGVInitialize", "初始化未完成标志位")
        },
                ["InboundMotherCar"] = new List<(string, string, string)>
        {
            ("RgvCraneAutoStatus", "RgvCraneAutoStatus", "工作模式"),
            ("RGVCurrentlocation", "RGVCurrentlocation", "当前位置"),
            ("RgvEquipmentStatus", "RgvEquipmentStatus", "有货状态"),
            ("RGV_Targetaddress", "ReadDeviceCommand", "目标地址"),
            ("RGV_Rgvtaskstutas", "RGV_Rgvtaskstutas", "任务状态"),
            ("RGV_Rgvtaskid", "ReadDeviceCommand", "RGV任务编号"),
            ("RGV_Faultcode", "ReadDeviceCommand", "故障代码"),
            ("RGVInitialize", "RGVInitialize", "初始化未完成标志位")
        },
                ["InboundTransferCar"] = new List<(string, string, string)>
        {
            ("RgvCraneAutoStatus", "RgvCraneAutoStatus", "工作模式"),
            ("RGVCurrentlocation", "RGVCurrentlocation", "当前位置"),
            ("RgvEquipmentStatus", "RgvEquipmentStatus", "有货状态"),
            ("RGV_Targetaddress", "ReadDeviceCommand", "目标地址"),
            ("RGV_Rgvtaskstutas", "RGV_Rgvtaskstutas", "任务状态"),
            ("RGV_Rgvtaskid", "ReadDeviceCommand", "RGV任务编号"),
            ("RGV_Faultcode", "ReadDeviceCommand", "故障代码"),
            ("RGV_Risingsignalplace", "ReadDeviceCommand", "上升信号到位"),
            ("RGV_Descentsignal", "ReadDeviceCommand", "下降信号到位"),
            ("RGVInitialize", "RGVInitialize", "初始化未完成标志位")
        },

                // 安全门设备参数配置
                ["SafetyDoor"] = new List<(string, string, string)>
        {
            ("IndicatorStatus", "ReadDeviceCommand", "安全门指示灯状态"),
            ("DoorRequest", "ReadDeviceCommand", "安全门请求开门"),
            ("PowerOffStatus", "ReadDeviceCommand", "安全门断电状态"),
            ("EmergencyStopStatus", "ReadDeviceCommand", "安全门急停状态"),
            ("SafetyLockStatus", "ReadDeviceCommand", "安全门锁状态"),
            ("ResetStatus", "ReadDeviceCommand", "安全门复位状态"),
            ("AlarmSummary", "DeviceCommand", "报警信息"),
            ("OpenDoor", "DeviceCommand", "开门信息")
        }
            };

            // 创建最终结果字典
            var finalResult = new Dictionary<string, Dictionary<string, int>>();

            // 根据监控类型筛选设备组
            var filteredDeviceGroups = deviceGroups.Where(group =>
            {
                return monitorType switch
                {
                    "outbound" => group.Key == "MotherCar" || group.Key == "TransferCar" || group.Key == "MaterialOut",
                    "inbound" => group.Key == "MaterialIn" || group.Key == "InboundMotherCar" || group.Key == "InboundTransferCar",
                    "safetydoor" => group.Key == "SafetyDoor", // 安全门监控类型
                    "all" => true,
                    _ => group.Key == "MotherCar" || group.Key == "TransferCar" || group.Key == "MaterialOut"
                };
            }).ToDictionary(x => x.Key, x => x.Value);

            int i = 0;
            // 遍历筛选后的设备组
            foreach (var deviceGroup in filteredDeviceGroups)
            {
                string deviceType = deviceGroup.Key;
                List<string> deviceCodes = deviceGroup.Value;

                // 获取该设备类型的参数配置
                if (!paramConfigs.ContainsKey(deviceType))
                    continue;

                var deviceParams = paramConfigs[deviceType];

                // 遍历该类型下的所有设备
                foreach (string deviceChildCode in deviceCodes)
                {
                    IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == deviceChildCode);

                    // 处理不同类型的设备
                    if (device is SpeStackerCrane commonStacker)
                    {
                        // 为当前设备创建一个字典，用于保存 DeviceProRemark 和对应的值
                        var deviceData = new Dictionary<string, int>();

                        // 遍历该设备的所有参数
                        foreach (var param in deviceParams)
                        {
                            try
                            {
                                DeviceProDTO? rgvResetOperation = RgvOperationService.GetRGVDeviceProDTO(
                                    commonStacker, deviceChildCode, param.DeviceProParamName, param.DeviceProParamType);

                                if (rgvResetOperation != null)
                                {
                                    int res = RgvOperationService.GetLine(commonStacker, rgvResetOperation.DeviceProAddress);

                                    // 确保每个 DeviceProRemark 都对应正确的查询结果
                                    deviceData[param.DeviceProRemark] = res;
                                }
                                else
                                {
                                    deviceData[param.DeviceProRemark] = -1; // 使用 -1 表示查询失败
                                }
                            }
                            catch (Exception)
                            {
                                deviceData[param.DeviceProRemark] = -1; // 使用 -1 表示查询异常
                            }
                        }

                        // 将当前设备的数据添加到最终结果中
                        finalResult[deviceChildCode] = deviceData;
                    }
                    else if (device is CommonConveyorLine conveyorLine)
                    {
                        // 处理安全门设备（CommonConveyorLine 类型）
                        // 创建三个安全门设备的数据
                        List<string> safetyDoorList = new List<string> { "AQM001", "AQM002", "AQM003" };

                        // 为每个安全门创建数据
                        foreach (string safetyDoorCode in safetyDoorList)
                        {
                            var deviceData = new Dictionary<string, int>();

                            // 遍历该设备的所有参数
                            foreach (var param in deviceParams)
                            {
                                try
                                {
                                    // 使用安全门名称查询对应的参数
                                    DeviceProDTO? devicePro = GetSafetyDoorDeviceProDTO(
                                        conveyorLine, safetyDoorCode, param.DeviceProParamName, param.DeviceProParamType);

                                    if (devicePro != null)
                                    {
                                        // 对于 CommonConveyorLine 类型，使用通用的数据读取方法
                                        int res = ReadCommonConveyorLineData(conveyorLine, devicePro.DeviceProAddress);
                                        deviceData[param.DeviceProRemark] = res;
                                    }
                                    else
                                    {
                                        deviceData[param.DeviceProRemark] = -1; // 使用 -1 表示查询失败
                                    }
                                }
                                catch (Exception)
                                {
                                    deviceData[param.DeviceProRemark] = -1; // 使用 -1 表示查询异常
                                }
                            }

                            // 将当前安全门设备的数据添加到最终结果中，使用安全门名称作为key
                            finalResult[safetyDoorCode] = deviceData;
                        }
                    }
                    else
                    {
                        // 即使设备不存在或不是支持的类型，也创建一个空字典
                        finalResult[deviceChildCode] = new Dictionary<string, int>();
                        if (device != null)
                        {
                            Console.WriteLine($"警告：设备 {deviceChildCode} 类型 {device.GetType().Name} 不支持，无法读取数据");
                        }
                        else
                        {
                            Console.WriteLine($"警告：设备 {deviceChildCode} 不存在");
                        }
                    }
                }
            }

            return finalResult;
        }

        /// <summary>
        /// 获取监控状态消息
        /// </summary>
        /// <param name="monitorType"></param>
        /// <returns></returns>
        private string GetMonitorStatusMessage(string monitorType)
        {
            return monitorType switch
            {
                "outbound" => $"出库监控: {(_isOutboundMonitoring ? "运行中" : "已停止")}",
                "inbound" => $"入库监控: {(_isInboundMonitoring ? "运行中" : "已停止")}",
                "safetydoor" => $"安全门监控: {(_isSafetyDoorMonitoring ? "运行中" : "已停止")}",
                "all" => $"出库监控: {(_isOutboundMonitoring ? "运行中" : "已停止")}, 入库监控: {(_isInboundMonitoring ? "运行中" : "已停止")}, 安全门监控: {(_isSafetyDoorMonitoring ? "运行中" : "已停止")}",
                _ => $"出库监控: {(_isOutboundMonitoring ? "运行中" : "已停止")}"
            };
        }

        /// <summary>
        /// 获取监控类型显示名称
        /// </summary>
        /// <param name="monitorType"></param>
        /// <returns></returns>
        private string GetMonitorTypeDisplayName(string monitorType)
        {
            return monitorType switch
            {
                "outbound" => "出库",
                "inbound" => "入库",
                "safetydoor" => "安全门",
                "all" => "全部",
                _ => "出库"
            };
        }


        /// <summary>
        /// 读取设备信息
        /// </summary>
        /// <param name="conveyorLine"></param>
        /// <param name="DeviceProDataBlock"></param>
        /// <returns></returns>
        public static int ReadCommonConveyorLineData(CommonConveyorLine Commonstacker, string DeviceProDataBlock)
        {
            return Commonstacker.Communicator.Read<short>(DeviceProDataBlock);
        }


        /// <summary>
        /// 查询安全门设备
        /// </summary>
        /// <param name="Commonstacker"></param>
        /// <param name="SCAddress"></param>
        /// <param name="Interactivet"></param>
        /// <returns></returns>
        public static DeviceProDTO? GetSafetyDoorDeviceProDTO(CommonConveyorLine Commonstacker, string SCAddress, string DeviceProParamName, string DeviceProParamType)
        {
            return Commonstacker.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == SCAddress && x.DeviceProParamName == DeviceProParamName && x.DeviceProParamType == DeviceProParamType);
        }

        //=================================================读取设备信息==========================================================


        #region 设备信息
        /***
        /// <summary>
        /// 查询RGV设备
        /// </summary>
        /// <param name="Commonstacker"></param>
        /// <param name="SCAddress"></param>
        /// <param name="Interactivet"></param>
        /// <returns></returns>
        public static DeviceProDTO? GetRGVDeviceProDTO(SpeStackerCrane Commonstacker, string SCAddress, string DeviceProParamName, string DeviceProParamType)
        {
            return Commonstacker.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == SCAddress && x.DeviceProParamName == DeviceProParamName && x.DeviceProParamType == DeviceProParamType);
        }
        /// <summary>
        /// 读取设备信息
        /// </summary>
        /// <param name="conveyorLine"></param>
        /// <param name="DeviceProDataBlock"></param>
        /// <returns></returns>
        public static int GetLine(SpeStackerCrane Commonstacker, string DeviceProDataBlock)
        {
            return Commonstacker.Communicator.Read<short>(DeviceProDataBlock);
        }

        /// <summary>
        /// 写入设备信息
        /// </summary>
        /// <param name="conveyorLine"></param>
        /// <param name="DeviceProDataBlock"></param>
        /// <returns></returns>
        public static bool RgvSetLine(SpeStackerCrane Commonstacker, string DeviceProDataBlock, short rgvvalues)
        {
            return Commonstacker.Communicator.Write<short>(DeviceProDataBlock, rgvvalues);
        }
        */
        #endregion


        /// <summary>
        /// 设备操作
        /// </summary>
        /// <param name="deviceName"></param>
        /// <param name="operationType"></param>
        /// <param name="parameter"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent DeviceOperation(string deviceName, string operationType, int parameter)
        {
            WebResponseContent webResponse = new WebResponseContent();
            IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == deviceName);
            if (device == null) return webResponse.Error("未找到此设备");
            SpeStackerCrane Commonstacker = (SpeStackerCrane)device;
            string DeviceProParamName = null;
            string DeviceProParamType = null;
            int zhi = 1002011;
            try
            {

            switch (operationType)
            {
                case "cs":          //初始化
                                    //获取实例
                    DeviceProDTO? RGV_RGVtasktypetcs = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, deviceName, "RGV_RGVtasktypet", "DeviceCommand");        //任务类型                                                                                                                                                   //第一步写入任务
                    RgvOperationService.RgvSetLine(Commonstacker, RGV_RGVtasktypetcs.DeviceProAddress, (short)3);
                        //写入自动
                    DeviceProDTO? RGV_DWorkingmodecs = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, deviceName, "RGV_DWorkingmode", "DeviceCommand");        //任务id
                    RgvOperationService.RgvSetLine(Commonstacker, RGV_DWorkingmodecs.DeviceProAddress, (short)1);
                        //写入清除任务
                    RgvOperationService.RgvSetLine(Commonstacker, RGV_RGVtasktypetcs.DeviceProAddress, (short)4);

                        //反馈确认任务
                    DeviceProDTO? RGV_taskcompletecs = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, deviceName, "RGV_taskcomplete", "RGV_taskcomplete");        //任务id
                    RgvOperationService.RgvSetLine(Commonstacker, RGV_taskcompletecs.DeviceProAddress, (short)1);
                    DeviceProParamName = "RGV_Resetoperation";
                    DeviceProParamType = "DeviceCommand";
                    zhi = 1;
                        break;
                case "sd":             //手动
                    DeviceProParamName = "RGV_DWorkingmode";
                    DeviceProParamType = "DeviceCommand";
                    zhi = 0;
                    break;
                case "zd":              //自动
                    DeviceProParamName = "RGV_DWorkingmode";
                    DeviceProParamType = "DeviceCommand";
                    zhi = 1;
                    break;
                case "ss":              //上升
                    DeviceProParamName = "RGV_Risingsignalplace";
                    DeviceProParamType = "DeviceCommand";
                    zhi = parameter;
                    break;
                case "xj":          //下降
                    DeviceProParamName = "RGV_Descentsignal";
                    DeviceProParamType = "DeviceCommand";
                    zhi = parameter;
                    break;
                case "dz":          //地址
                    DeviceProParamName = "RGV_RGVTasklocationt";
                    DeviceProParamType = "DeviceCommand";
                    zhi = parameter;
                        //获取实例
                        DeviceProDTO? RGV_RGVtasktypet = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, deviceName, "RGV_RGVtasktypet", "DeviceCommand");        //任务类型
                                                                                                                                                                        //第一步写入任务
                        RgvOperationService.RgvSetLine(Commonstacker, RGV_RGVtasktypet.DeviceProAddress, (short)3);

                        //写入自动
                        DeviceProDTO? RGV_DWorkingmode = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, deviceName, "RGV_Rgvtaskidt", "DeviceCommand");        //任务id
                                                                                                                                                                      //任务id
                        RgvOperationService.RgvSetLine(Commonstacker, RGV_DWorkingmode.DeviceProAddress, (short)30001);

                        //任务id
                        DeviceProDTO? RGV_taskcomplete = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, deviceName, "RGV_Lanjiantaskidt", "DeviceCommand");        //任务id
                        RgvOperationService.RgvSetLine(Commonstacker, RGV_taskcomplete.DeviceProAddress, (short)30001);
                        break;
                case "sc":      //伸出
                        //DeviceProParamName = "RGV_DWorkingmode";
                        //DeviceProParamType = "DeviceCommand";
                        //zhi = 1;
                        break;
                case "sh":      //缩回
                    //DeviceProParamName = "RGV_Retractionsignal";
                    //DeviceProParamType = "DeviceCommand";
                    //zhi = 1;
                    break;
                case "kld":      //开雷达
                    DeviceProParamName = "RGV_Shieldradar";
                    DeviceProParamType = "DeviceCommand";
                    zhi = 1;
                    break;
                case "gld":      //关雷达
                    DeviceProParamName = "RGV_Shieldradar";
                    DeviceProParamType = "DeviceCommand";
                    zhi = 0;
                    break;
                case "fw":
                        DeviceProParamName = "RGV_Resetoperation";
                        DeviceProParamType = "DeviceCommand";
                        zhi = 1;
                        break;
                }

                //获取需要复位的设备
                DeviceProDTO? RGV_Resetoperation = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, deviceName, DeviceProParamName, DeviceProParamType);        //复位报警信息
            RgvOperationService.RgvSetLine(Commonstacker, RGV_Resetoperation.DeviceProAddress,(short)zhi);
            return webResponse.OK("设备操作成功");
            }catch(Exception)
            {
                return webResponse.Error("设备操作失败");
            }

        }


        /// <summary>
        /// 一键操作
        /// </summary>
        /// <param name="monitorType"></param>
        /// <param name="operationType"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent OneClickOperation(string monitorType, string operationType)
        {
            WebResponseContent webResponse = new WebResponseContent();
            List<string> Devices = new List<string>();
            if (monitorType == "Inbound")
            {
                //入库设备
                Devices = new List<string> { "RGV103", "RGV105", "RGV108", "RGV109", "RGV104", "RGV107", "RGV101" };
            }
            else if (monitorType == "Outbound")
            {
                //出库设备
                Devices = new List<string> { "RGV112", "RGV110", "RGV114", "RGV115", "RGV116", "RGV111", "RGV118" };
            }
            try
            {
            List<IDevice?> devices = Storage.Devices.Where(x => Devices.Contains(x.DeviceCode)).Cast<IDevice?>().ToList();
            if (devices == null || !devices.Any())
            {
                return webResponse.Error("未找到相关设备");
            }
            string DeviceProParamName = null;
            string DeviceProParamType = null;
            int zhi = 1002011;
            switch (operationType)
            {
                case "init":    //初始化
                        DeviceProParamName = "RGV_Resetoperation";
                        DeviceProParamType = "DeviceCommand";
                        zhi = 1;
                        break;
                case "reset":
                        DeviceProParamName = "RGV_Resetoperation";
                        DeviceProParamType = "DeviceCommand";
                        zhi = 1;
                        break;
                case "start":
                        DeviceProParamName = "RGV_DWorkingmode";
                        DeviceProParamType = "DeviceCommand";
                        zhi = 1;
                        break;
                case "stop":
                        DeviceProParamName = "RGV_DWorkingmode";
                        DeviceProParamType = "DeviceCommand";
                        zhi = 0;
                        break;
            }
            foreach(var device in devices)
            {
                    SpeStackerCrane Commonstacker = (SpeStackerCrane)device;

                    if (operationType == "init")
                    {
                        //获取实例
                        DeviceProDTO? RGV_RGVtasktypetcs = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, device.DeviceCode, "RGV_RGVtasktypet", "DeviceCommand");        //任务类型                                                                                                                                                   //第一步写入任务
                        RgvOperationService.RgvSetLine(Commonstacker, RGV_RGVtasktypetcs.DeviceProAddress, (short)3);
                        //写入自动
                        DeviceProDTO? RGV_DWorkingmodecs = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, device.DeviceCode, "RGV_DWorkingmode", "DeviceCommand");        //任务id
                        RgvOperationService.RgvSetLine(Commonstacker, RGV_DWorkingmodecs.DeviceProAddress, (short)1);
                        //写入清除任务
                        RgvOperationService.RgvSetLine(Commonstacker, RGV_RGVtasktypetcs.DeviceProAddress, (short)4);

                        //反馈确认任务
                        DeviceProDTO? RGV_taskcompletecs = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, device.DeviceCode, "RGV_taskcomplete", "RGV_taskcomplete");        //任务id
                        RgvOperationService.RgvSetLine(Commonstacker, RGV_taskcompletecs.DeviceProAddress, (short)1);
                    }
                DeviceProDTO? RGV_Resetoperation = RgvOperationService.GetRGVDeviceProDTO(Commonstacker, device.DeviceCode, DeviceProParamName, DeviceProParamType);        //复位报警信息
                RgvOperationService.RgvSetLine(Commonstacker, RGV_Resetoperation.DeviceProAddress, (short)zhi);
            }
            return webResponse.OK("设备操作成功");
        }catch(Exception)
            {
                return webResponse.Error("设备操作失败");
            }
}
    }
}