using NLog;
using OrpaonEMS.App.Models;
using OrpaonEMS.Core.Enums;
using OrpaonEMS.Core.EventHandMsg;
using OrpaonEMS.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using HslCommunication.ModBus;
using HslCommunication;
using System.Windows;
using Prism.Mvvm;
using OrpaonEMS.App.Com;
using OrpaonEMS.Model;
using System.Collections.ObjectModel;
using OrpaonEMS.Core.ChannelModel;
using ImTools;
using OrpaonEMS.App.CANDrive;

namespace OrpaonEMS.App.Services
{
    /// <summary>
    /// 液冷空调服务数据
    /// </summary>
    public class ACService : BindableBase
    {
        /// <summary>
        /// ScanDevice扫描Task
        /// </summary>
        static Task ScanDeviceTask { get; set; }

        ///// <summary>
        ///// CAN驱动
        ///// </summary>
        //private CAN CANDrive { get; set; }

        ///// <summary>
        ///// ModbusRtu驱动
        ///// </summary>
        //private ModbusRtu ModbusRtuDrive { get; set; }

        ///// <summary>
        ///// ModbusRtuStation 站号设置
        ///// </summary>
        //private byte ModbusRtuStation { get; set; } = 1;

        /// <summary>
        /// 扫描线程使能
        /// </summary>
        public bool ThreadEnable { get; set; } = true;


        private ObservableCollection<CoolAlarm> _ListRtAlarm = new ObservableCollection<CoolAlarm>();
        /// <summary>
        /// 实时报警
        /// </summary>
        public ObservableCollection<CoolAlarm> ListRtAlarm
        {
            get { return _ListRtAlarm; }
            set { _ListRtAlarm = value; }
        }

        ///// <summary>
        /////  报警状态数据
        ///// </summary>
        //private OperateResult<bool[]> OperateResultBmsAlarm { get; set; }

        ///// <summary>
        ///// BMS只读数据-前125字节
        ///// </summary>
        //private OperateResult<byte[]> OperateResult1 { get; set; }

        /// <summary>
        /// 报警模型
        /// </summary>
        public List<CoolBitAlarmInfo> ListBitAlarmInfo { get; set; }

        public ACService(ILogService logger, ConfigDataService configDataService)
        {
            Logger = logger;
            ConfigDataService = configDataService;

            if (!ConfigDataService.IsDemo)
            {
                CAN.ConnectionCan(BaudRate.EMUC_BAUDRATE_500K);
                CAN.Start();
            }


            //ModbusRtuDrive = new ModbusTcpNet("192.168.10.253", 502);
            //ModbusRtuDrive?.Close();
            //ModbusRtuDrive = new ModbusRtu(ModbusRtuStation);
            //ModbusRtuDrive.AddressStartWithZero = true;
            //ModbusRtuDrive.IsStringReverse = false;
            //ModbusRtuDrive.DataFormat = HslCommunication.Core.DataFormat.ABCD;
            //try
            //{
            //    ModbusRtuDrive.SerialPortInni(sp =>
            //    {
            //        sp.PortName = "COM7";
            //        //sp.PortName = "COM10";
            //        sp.BaudRate = 9600;
            //        sp.DataBits = 8;
            //        sp.StopBits = System.IO.Ports.StopBits.One;
            //        sp.Parity = System.IO.Ports.Parity.None;
            //    });

            //    var result = ModbusRtuDrive.Open();
            //    if (!result.IsSuccess)
            //    {
            //        Logger.Info("液冷连接失败");
            //    }
            //}
            //catch (Exception ex)
            //{
            //    MessageBox.Show(ex.Message);
            //}

            ListBitAlarmInfo = new List<CoolBitAlarmInfo>()
            {
                new CoolBitAlarmInfo(){Category=1,BitIndex = 0,Content="供水泵故障"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 1,Content="泵空转保护"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 2,Content="泵堵转保护"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 3,Content="泵过流故障"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 4,Content="泵欠压故障"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 5,Content="泵过压故障"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 6,Content="泵缺相/电流采样偏移/失步/预充故障"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 7,Content="泵驱动过热保护故障"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 8,Content="供水压力传感器故障"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 9,Content="主板 IIC 故障 "},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 10,Content="回水压力低故障"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 11,Content="供水压力过高"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 12,Content="电压过高"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 13,Content="电压过低"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 14,Content="备用"},
                new CoolBitAlarmInfo(){Category=1,BitIndex = 15,Content="备用"},

                new CoolBitAlarmInfo(){Category=2,BitIndex = 0,Content="系统低压"},
                new CoolBitAlarmInfo(){Category=2,BitIndex = 1,Content="电加热保护 "},
                new CoolBitAlarmInfo(){Category=2,BitIndex = 2,Content="风机过载"},
                new CoolBitAlarmInfo(){Category=2,BitIndex = 3,Content="系统高压故障"},
                new CoolBitAlarmInfo(){Category=2,BitIndex = 4,Content="蒸发进口探头故障 "},
                new CoolBitAlarmInfo(){Category=2,BitIndex = 5,Content="蒸发出口探头故障"},
                new CoolBitAlarmInfo(){Category=2,BitIndex = 6,Content="系统高压报警锁定"},
                new CoolBitAlarmInfo(){Category=2,BitIndex = 7,Content="排气压力传感器故障"},
                new CoolBitAlarmInfo(){Category=2,BitIndex = 8,Content="压缩机变频器通讯故障"},

                new CoolBitAlarmInfo(){Category=3,BitIndex = 0,Content="液温探头故障"},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 1,Content="回液探头故障"},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 2,Content="环境探头故障 "},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 3,Content="液温过高"},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 4,Content="回水压力传感器故障"},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 5,Content="屏幕与主板通讯超时"},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 6,Content="液温过低"},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 7,Content="供水压力过高预警"},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 8,Content="掉电报警"},
                new CoolBitAlarmInfo(){Category=3,BitIndex = 9,Content="从板通讯故障"},

                new CoolBitAlarmInfo(){Category=4,BitIndex = 0,Content="压机起动瞬间过流"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 1,Content="压机加速运行过流"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 2,Content="压机减速运行过流"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 3,Content="压机恒速运行过流\r"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 4,Content="压机加速运行过压\r"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 5,Content="压机减速运行过压"},
                new CoolBitAlarmInfo(){Category=4,BitIndex =6,Content="压机恒速运行过压\r"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 7,Content="压机待机时过压"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 8,Content="压机运行中欠"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 9,Content="压机输出缺相"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 10,Content="压机功率器件保护"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 11,Content="压机过热"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 12,Content="压机过载"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 13,Content="压机检测压机过载"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 14,Content="压机负载过重\r"},
                new CoolBitAlarmInfo(){Category=4,BitIndex = 15,Content="压机速度过大"},

                new CoolBitAlarmInfo(){Category=5,BitIndex = 0,Content="压机 D 轴电流过大"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 1,Content="压机 Q 轴电流过大"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 2,Content="压机参数存储失败"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 3,Content="压机通讯异常"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 4,Content="压机电流检测故障"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 5,Content="压机启动中电机堵转"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 6,Content="压机运行中电机堵转"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 7,Content="压机失速故障"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 8,Content="压机中断溢出 1"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 9,Content="压机中断溢出 2"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 10,Content="压机启动中转子抖动过大"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 11,Content="压机运行中转子抖动过大"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 12,Content="PFC 过流"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 13,Content="PFC 峰值电流过大"},
                new CoolBitAlarmInfo(){Category=5,BitIndex = 14,Content="PFC 有效值电流过大"},

            };
            foreach (var item in ListBitAlarmInfo)
            {
                item.PubCoolAlarmEventHandler += Item_PubCoolAlarmEventHandler;
            }

            ScanDeviceStart();

            //CoolAutoControls = new CoolAutoControl();
            //CoolAutoControls.CoolCmdHandler += CoolAutoControls_CoolCmdHandler;
            //液冷的监控
            //Task.Run(() => ListenCoolCycle());

        }

        private int _AlarmCount;
        /// <summary>
        /// 报警个数
        /// </summary>
        public int AlarmCount
        {
            get { return _AlarmCount; }
            set { _AlarmCount = value; RaisePropertyChanged(); }
        }

        /// <summary>
        ///报警发布
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Item_PubCoolAlarmEventHandler(object? sender, Event.CoolAlarmCellEventHandMsg AlarmData)
        {
            //统计个数
            AlarmCount = ListBitAlarmInfo.Where(a => a.State == true).Count();

            if (AlarmData.State)//报警发生
            {
                var FindData = ListRtAlarm.Where(a => a.Content == AlarmData.Content);
                if (FindData.Count() > 0)
                {
                    ListRtAlarm.Add(FindData.First());
                }
                Console.WriteLine($"时间：{DateTime.Now.ToString()}：PCS报警激活：{AlarmData.Content} ");
            }
            else//报警消失
            {
                Console.WriteLine($"时间：{DateTime.Now.ToString()}：PCS报警消失：{AlarmData.Content} ");
                var FindData = ListRtAlarm.Where(a => a.Content == AlarmData.Content);
                if (FindData.Count() > 0)
                {
                    ListRtAlarm.Remove(FindData.First());
                }

                ////报警结束，可以采集数据
                //AlarmChannel.Writer.WriteAsync(new AlarmChannelData()
                //{
                //    MsgTime = DateTime.Now,
                //    alarmChannel = new AlarmChannel()
                //    {
                //        Content = AlarmData.Content,
                //        StartTime = AlarmData.CurTimeInfo.StartTime,
                //        EndTime = AlarmData.CurTimeInfo.EndTime,
                //        AlarmDur = (decimal)AlarmData.CurTimeInfo.AlarmDur,
                //        Level = AlarmData.Level,
                //    }
                //});
            }

            //报警个数为0，那么就清空报警数据了
            if (AlarmCount == 0)
            {
                ListRtAlarm.Clear();
                return;
            }

        }

        /// <summary>
        ///扫描
        /// </summary>
        private void ScanDeviceStart()
        {
            Thread.Sleep(1000);

            ScanDeviceTask = Task.Run(async () =>
            {
                //延后5秒
                await Task.Delay(5000);

                //默认的指令状态
                if (ConfigDataService.SetCtrModel <= 3)
                {
                    //控制模式
                    SendCanMsg.ValueToMotorolaSignal(ConfigDataService.SetCtrModel, 0, 2, 1, 0);
                    //自动模式
                    SendCanMsg.ValueToMotorolaSignal(0, 4, 1, 1, 0);
                }
                else
                {
                    //控制模式
                    SendCanMsg.ValueToMotorolaSignal(0, 0, 2, 1, 0);
                    //自动模式
                    SendCanMsg.ValueToMotorolaSignal(1, 4, 1, 1, 0);
                }
                //制冷温度目标
                SendCanMsg.ValueToMotorolaSignal(1, 16, 8, 1, 0);

                //制热设定温度
                SendCanMsg.ValueToMotorolaSignal(ConfigDataService.SetHeadTargetTemp, 24, 8, 1, -40);
                //制冷设定温度
                SendCanMsg.ValueToMotorolaSignal(ConfigDataService.SetCoolTargetTemp, 32, 8, 1, -40);
                //运行泵转速
                SendCanMsg.ValueToMotorolaSignal(100, 40, 8, 1, 0);
                //运行泵转速
                SendCanMsg.ValueToMotorolaSignal(50, 48, 8, 1, 0);

                while (ThreadEnable)
                {
                    await Task.Delay(800);

                    ////控制模式
                    //SendCanMsg.ValueToMotorolaSignal(0, 0, 2, 1, 0);
                    ////自动模式
                    //SendCanMsg.ValueToMotorolaSignal(0, 4, 1, 1, 0);
                    ////制冷温度目标
                    //SendCanMsg.ValueToMotorolaSignal(1, 16, 8, 1, 0);
                    ////制热设定温度
                    //SendCanMsg.ValueToMotorolaSignal(10, 24, 8, 1, -40);
                    ////制冷设定温度
                    //SendCanMsg.ValueToMotorolaSignal(10, 32, 8, 1, -40);
                    ////运行泵转速
                    //SendCanMsg.ValueToMotorolaSignal(100, 40, 8, 1, 0);
                    ////运行泵转速
                    //SendCanMsg.ValueToMotorolaSignal(100, 48, 8, 1, 0);
                    //var data = SendCanMsg.GetCanMsg();

                    //ID(0x04904000) 下发指令
                    LinkStateValue = CAN.SendData(0x04904000, SendCanMsg.GetCanMsg());

                    //读取数据
                    CoolWorkModelValue = ACCANParsData.msg_0X18008040.WorkState;
                    OutTemp = ACCANParsData.msg_0X18008040.OutTemp;
                    InTemp = ACCANParsData.msg_0X18008040.InTemp;
                    SysEnvTemp = ACCANParsData.msg_0X18008040.SysEnvTemp;
                    InPress = ACCANParsData.msg_0X18008040.InPress;
                    OutPress = ACCANParsData.msg_0X18008040.OutPress;
                    InverterErrCode = ACCANParsData.msg_0X18008040.InverterErrCode.ToString();
                    CoolFaultCode = ACCANParsData.msg_0X18008040.ErrCode.ToString();
                    CoolFaultLevel = ACCANParsData.msg_0X18008040.ErrLevel.ToString();

                    CapState = ACCANParsData.msg_0X18018040.CompressorState == 1 ? "开启" : "关闭";
                    CapHeatStripState = ACCANParsData.msg_0X18018040.CompressorHeatStripState == 1 ? "开启" : "关闭";
                    EleHeatState = ACCANParsData.msg_0X18018040.EleHeatState == 1 ? "开启" : "关闭";
                    WaterPumpState = ACCANParsData.msg_0X18018040.WaterPumpState == 1 ? "开启" : "关闭";
                    Fan1State = ACCANParsData.msg_0X18018040.FanState1 == 1 ? "开启" : "关闭";
                    Fan2State = ACCANParsData.msg_0X18018040.FanState2 == 1 ? "开启" : "关闭";
                    Fan3State = ACCANParsData.msg_0X18018040.FanState3 == 1 ? "开启" : "关闭";
                    CapSpeed = ACCANParsData.msg_0X18018040.CompressorSpeed;
                    PumpSpeed = ACCANParsData.msg_0X18018040.PumpSpeed;

                    #region ModbusRTU 地址

                    ////读数据
                    //OperateResult1 = ModbusRtuDrive.Read("0", 100);
                    //if (OperateResult1.IsSuccess)
                    //{
                    //    //机组运行状态
                    //    CoolStateVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 0);

                    //    OutTemp.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 6);
                    //    InTemp.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 8);
                    //    SysSteamInTemp.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 10);
                    //    SysSteamOutTemp.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 12);
                    //    SysEnvTemp.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 14);
                    //    SysCondSC.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 16);
                    //    OpenDeg.SrRtValue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 18);
                    //    PumpSpeed.SrRtValue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 20);
                    //    CapSpeed.SrRtValue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 22);
                    //    FanSpeed.SrRtValue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 24);
                    //    OutPress.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 26);
                    //    InPress.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 28);
                    //    ExPress.SrRtValue = ModbusRtuDrive.ByteTransform.TransInt16(OperateResult1.Content, 30);

                    //    CoolFaultValue1 = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 50);
                    //    CoolFaultValue2 = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 52);
                    //    CoolFaultValue3 = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 54);
                    //    CoolFaultValue4 = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 56);
                    //    CoolFaultValue5 = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 58);


                    //}

                    #endregion
                }
            });
        }

        #region 液冷自动控制

        /// <summary>
        /// 液冷自动控制模型
        /// </summary>
        public CoolAutoControl CoolAutoControls { get; set; }

        private void CoolAutoControls_CoolCmdHandler(object sender, CoolValue cmdData)
        {
            SetCoolTargetTemp((ushort)cmdData.TargetTemp);
            SetCoolCtrModel(cmdData.CmdType);

        }

        /// <summary>
        /// 监控液冷并控制
        /// </summary>
        /// <returns></returns>
        private async Task ListenCoolCycle()
        {
            while (ThreadEnable)
            {
                try
                {
                    Thread.Sleep(60000);
                    //CoolAutoControls.UpdateValue(OutPress.RtValue);
                    CoolAutoControls.UpdateCoolState(CoolAlarmState);
                }
                catch (Exception ex)
                {
                    Logger.Info($"时间:{DateTime.Now.ToString()}-【ListenPeakValleyTimeCycle】-{ex.Message}");
                }

            }
        }


        #endregion


        #region 液冷数据

        private bool _LinkStateValue = false;
        /// <summary>
        /// 液冷连接状态
        /// </summary>
        public bool LinkStateValue
        {
            get { return _LinkStateValue; }
            set
            {
                if (_LinkStateValue != value)
                {
                    if (value)
                    {
                        LinkStateMsg = "正常";
                    }
                    else
                    {
                        LinkStateMsg = "失败";
                    }

                    _LinkStateValue = value;
                }

            }
        }

        private string _LinkStateMsg = "失败";
        /// <summary>
        /// 液冷连接状态
        /// </summary>
        public string LinkStateMsg
        {
            get { return _LinkStateMsg; }
            set { _LinkStateMsg = value; RaisePropertyChanged(); }
        }



        /// <summary>
        /// 液冷的报警状态信息
        /// True:报警发生
        /// False:没有报警
        /// </summary>
        public bool CoolAlarmState { get; set; } = false;

        /// <summary>
        /// 设置液冷的数据
        /// </summary>
        /// <returns></returns>
        public bool SetCoolTargetTemp(ushort value)
        {
            //  ulong data = Convert.ToUInt64((values - offset) / factor);

            var SetValue = (ushort)((value - (-40)));
            //var result = ModbusRtuDrive.Write("223", SetValue);
            //if (result.IsSuccess)
            //{
            //    return true;
            //}
            return false;
        }

        /// <summary>
        /// 设置液冷的控制模式
        /// </summary>
        /// <returns></returns>
        public bool SetCoolCtrModel(CoolState coolState)
        {
            //0:关机模式；1：制冷模式；2：制热模式；3：自循环模式
            switch (coolState)
            {
                case CoolState.Stop:
                    ////自动模式
                    SendCanMsg.ValueToMotorolaSignal(0, 4, 1, 1, 0);
                    //控制模式
                    SendCanMsg.ValueToMotorolaSignal(0, 0, 2, 1, 0);
                    return false;
                case CoolState.Cool:
                    ////自动模式
                    SendCanMsg.ValueToMotorolaSignal(0, 4, 1, 1, 0);
                    //控制模式
                    SendCanMsg.ValueToMotorolaSignal(1, 0, 2, 1, 0);
                    return false;
                case CoolState.Heat:
                    ////自动模式
                    SendCanMsg.ValueToMotorolaSignal(0, 4, 1, 1, 0);
                    //控制模式
                    SendCanMsg.ValueToMotorolaSignal(2, 0, 2, 1, 0);
                    return false;
                case CoolState.AutoCycle:
                    ////自动模式
                    SendCanMsg.ValueToMotorolaSignal(0, 4, 1, 1, 0);
                    //控制模式
                    SendCanMsg.ValueToMotorolaSignal(3, 0, 2, 1, 0);
                    return false;
                case CoolState.Auto:
                    //自动模式
                    SendCanMsg.ValueToMotorolaSignal(1, 4, 1, 1, 0);
                    return false;
                default:
                    return false;
            }
        }

        ///// <summary>
        ///// 设置液冷的控制模式
        ///// </summary>
        ///// <returns></returns>
        //public bool SetCoolCtrModel(CoolState coolState)
        //{
        //    switch (coolState)
        //    {
        //        case CoolState.Stop:
        //            var result1 = ModbusRtuDrive.Write("222", (ushort)0);
        //            if (result1.IsSuccess)
        //            {
        //                return true;
        //            }
        //            return false;
        //        case CoolState.Cool:
        //            var result2 = ModbusRtuDrive.Write("222", (ushort)1);
        //            if (result2.IsSuccess)
        //            {
        //                return true;
        //            }
        //            return false;
        //        case CoolState.Heat:
        //            var result3 = ModbusRtuDrive.Write("222", (ushort)2);
        //            if (result3.IsSuccess)
        //            {
        //                return true;
        //            }
        //            return false;
        //        case CoolState.AutoCycle:
        //            var result4 = ModbusRtuDrive.Write("222", (ushort)3);
        //            if (result4.IsSuccess)
        //            {
        //                return true;
        //            }
        //            return false;
        //        default:
        //            return false;
        //    }
        //}

        private double _InPress;
        /// <summary>
        /// 进水压力
        /// 只读
        /// </summary>
        public double InPress
        {
            get { return _InPress; }
            set { _InPress = value; RaisePropertyChanged(); }
        }

        private double _OutPress;
        /// <summary>
        /// 出水压力
        /// </summary>
        public double OutPress
        {
            get { return _OutPress; }
            set { _OutPress = value; RaisePropertyChanged(); }
        }

        private double _OutTemp;
        /// <summary>
        /// 出水温度
        /// </summary>
        public double OutTemp
        {
            get { return _OutTemp; }
            set { _OutTemp = value; RaisePropertyChanged(); }
        }

        private double _InTemp;
        /// <summary>
        /// 回水温度
        /// </summary>
        public double InTemp
        {
            get { return _InTemp; }
            set { _InTemp = value; RaisePropertyChanged(); }
        }

        private double _SysEnvTemp;
        /// <summary>
        /// 环境温度
        /// </summary>
        public double SysEnvTemp
        {
            get { return _SysEnvTemp; }
            set { _SysEnvTemp = value; RaisePropertyChanged(); }
        }

        private double _PumpSpeed;
        /// <summary>
        /// 泵转速
        /// </summary>
        public double PumpSpeed
        {
            get { return _PumpSpeed; }
            set { _PumpSpeed = value; RaisePropertyChanged(); }
        }

        private double _CapSpeed;
        /// <summary>
        /// 压机转速
        /// </summary>
        public double CapSpeed
        {
            get { return _CapSpeed; }
            set { _CapSpeed = value; RaisePropertyChanged(); }
        }

        private string _CoolWorkModelMsg;
        /// <summary>
        /// 液冷机组工作模式
        /// 运行在自动模式时，在
        /// 1~3 之间切换
        /// </summary>
        public string CoolWorkModelMsg
        {
            get { return _CoolWorkModelMsg; }
            set { _CoolWorkModelMsg = value; RaisePropertyChanged(); }
        }

        private int _CoolWorkModelValue;
        /// <summary>
        /// 工作模式状态字
        /// </summary>
        public int CoolWorkModelValue
        {
            get { return _CoolWorkModelValue; }
            set
            {
                //if (_CoolWorkModelValue != value)
                //{
                switch (value)
                {
                    case 0:
                        CoolWorkModelMsg = "关机模式";
                        break;
                    case 1:
                        CoolWorkModelMsg = "制冷模式";
                        break;
                    case 2:
                        CoolWorkModelMsg = "制热模式";
                        break;
                    case 3:
                        CoolWorkModelMsg = "自循环模式";
                        break;
                    case 4:
                        CoolWorkModelMsg = "自动模式";
                        break;
                    default:
                        break;
                }
                //}
                _CoolWorkModelValue = value;
            }
        }



        private string _InverterErrCode;
        /// <summary>
        /// 变频器故障码
        /// </summary>
        public string InverterErrCode
        {
            get { return _InverterErrCode; }
            set { _InverterErrCode = value; RaisePropertyChanged(); }
        }

        private string coolFaultCode;
        /// <summary>
        /// 液冷故障码
        /// </summary>
        public string CoolFaultCode
        {
            get { return coolFaultCode; }
            set { coolFaultCode = value; RaisePropertyChanged(); }
        }

        private string coolFaultLevel;
        /// <summary>
        /// 液冷等级
        /// </summary>
        public string CoolFaultLevel
        {
            get { return coolFaultLevel; }
            set { coolFaultLevel = value; RaisePropertyChanged(); }
        }

        private string _CapState;
        /// <summary>
        /// 压缩机 运行状态
        /// 开启和关闭
        /// </summary>
        public string CapState
        {
            get { return _CapState; }
            set { _CapState = value; RaisePropertyChanged(); }
        }

        private string _CapHeatStripState;
        /// <summary>
        /// 压缩机加热带 运行状态
        /// 开启和关闭
        /// </summary>
        public string CapHeatStripState
        {
            get { return _CapHeatStripState; }
            set { _CapHeatStripState = value; RaisePropertyChanged(); }
        }

        private string _EleHeatState;
        /// <summary>
        /// 电加热 运行状态
        /// 开启和关闭
        /// </summary>
        public string EleHeatState
        {
            get { return _EleHeatState; }
            set { _EleHeatState = value; RaisePropertyChanged(); }
        }

        private string _WaterPumpState;
        /// <summary>
        /// 供水泵 运行状态
        /// 开启和关闭
        /// </summary>
        public string WaterPumpState
        {
            get { return _WaterPumpState; }
            set { _WaterPumpState = value; RaisePropertyChanged(); }
        }

        private string _Fan1State;
        /// <summary>
        /// 风机1 运行状态
        /// 开启和关闭
        /// </summary>
        public string Fan1State
        {
            get { return _Fan1State; }
            set { _Fan1State = value; RaisePropertyChanged(); }
        }

        private string _Fan2State;
        /// <summary>
        /// 风机2 运行状态
        /// 开启和关闭
        /// </summary>
        public string Fan2State
        {
            get { return _Fan2State; }
            set { _Fan2State = value; RaisePropertyChanged(); }
        }

        private string _Fan3State;
        /// <summary>
        /// 风机3 运行状态
        /// 开启和关闭
        /// </summary>
        public string Fan3State
        {
            get { return _Fan3State; }
            set { _Fan3State = value; RaisePropertyChanged(); }
        }

        public ILogService Logger { get; }
        public ConfigDataService ConfigDataService { get; }

        //private ushort _CoolStateVaue = 0;
        ///// <summary>
        ///// 液冷状态字
        ///// 机组运行状态
        ///// </summary>
        //public ushort CoolStateVaue
        //{
        //    get { return _CoolStateVaue; }
        //    set
        //    {
        //        //if (value != _CoolStateVaue)
        //        //{
        //        switch (BitHelper.GetLByteUint16(value))
        //        {
        //            case 0:
        //                CoolStatesMsg = "空闲";
        //                break;
        //            case 1:
        //                CoolStatesMsg = "准备启动";
        //                break;
        //            case 2:
        //                CoolStatesMsg = "运行";
        //                break;
        //            case 3:
        //                CoolStatesMsg = "延时停机";
        //                break;
        //            case 4:
        //                CoolStatesMsg = "故障";
        //                break;
        //            default:
        //                break;
        //        }

        //        switch (BitHelper.GetHByteUint16(value))
        //        {
        //            case 0:
        //                CoolWorkModelMsg = "待机";
        //                break;
        //            case 1:
        //                CoolWorkModelMsg = "制冷";
        //                break;
        //            case 2:
        //                CoolWorkModelMsg = "制热";
        //                break;
        //            case 3:
        //                CoolWorkModelMsg = "自循环";
        //                break;
        //            default:
        //                break;
        //        }
        //        _CoolStateVaue = value;
        //        //}

        //    }
        //}




        #region Old ModbusTcp

        ///// <summary>
        ///// 回水压力
        ///// 只读
        ///// </summary>
        //public BMSRoShortCell InPress { get; set; } = new BMSRoShortCell(
        //    "回水压力",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "227",//地址
        //    true,//是否关注
        //    "bar"//单位
        //    );

        ///// <summary>
        ///// 供水压力
        ///// </summary>
        //public BMSRoShortCell OutPress { get; set; } = new BMSRoShortCell(
        //    "供水压力",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "228",//地址
        //    true,//是否关注
        //    "bar"//单位
        //    );

        ///// <summary>
        ///// 排气压力
        ///// </summary>
        //public BMSRoShortCell ExPress { get; set; } = new BMSRoShortCell(
        //    "排气压力",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "228",//地址
        //    true,//是否关注
        //    "bar"//单位
        //    );

        ///// <summary>
        ///// 供液温度
        ///// </summary>
        //public BMSRoShortCell OutTemp { get; set; } = new BMSRoShortCell(
        //    "供液温度",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "225",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );


        ///// <summary>
        ///// 回液温度
        ///// </summary>
        //public BMSRoShortCell InTemp { get; set; } = new BMSRoShortCell(
        //    "回液温度",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );

        ///// <summary>
        ///// 系统蒸进
        ///// </summary>
        //public BMSRoShortCell SysSteamInTemp { get; set; } = new BMSRoShortCell(
        //    "系统蒸进",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );

        ///// <summary>
        ///// 蒸出温度
        ///// </summary>
        //public BMSRoShortCell SysSteamOutTemp { get; set; } = new BMSRoShortCell(
        //    "蒸出温度",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );


        ///// <summary>
        ///// 环境温度
        ///// </summary>
        //public BMSRoShortCell SysEnvTemp { get; set; } = new BMSRoShortCell(
        //    "环境温度",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );


        ///// <summary>
        ///// 系统冷凝
        ///// </summary>
        //public BMSRoShortCell SysCondSC { get; set; } = new BMSRoShortCell(
        //    "系统冷凝",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );

        ///// <summary>
        ///// 节流电膨当前开度
        ///// </summary>
        //public BMSRoUShortCell OpenDeg { get; set; } = new BMSRoUShortCell(
        //    "节流电膨当前开度",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );


        ///// <summary>
        ///// 水泵当前转速
        ///// </summary>
        //public BMSRoUShortCell PumpSpeed { get; set; } = new BMSRoUShortCell(
        //    "水泵当前转速",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );


        ///// <summary>
        ///// 压缩机当前转速
        ///// </summary>
        //public BMSRoUShortCell CapSpeed { get; set; } = new BMSRoUShortCell(
        //    "压缩机当前转速",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );

        ///// <summary>
        ///// 风机转速
        ///// </summary>
        //public BMSRoUShortCell FanSpeed { get; set; } = new BMSRoUShortCell(
        //    "风机转速",//名称
        //    0,//偏移量
        //    0.1,//分辨率
        //    1,//Index
        //    1,//长度
        //    "226",//地址
        //    true,//是否关注
        //    "℃"//单位
        //    );





        //private ushort _CoolFaultValue1;
        ///// <summary>
        ///// 液冷状态字
        ///// 液冷故障码及等级
        ///// （0：无故障 1：
        /////  有故障）
        ///// </summary>
        //public ushort CoolFaultValue1
        //{
        //    get { return _CoolFaultValue1; }
        //    set
        //    {
        //        if (value != _CoolFaultValue1)
        //        {
        //            if (value == 0)//报警位0，则清除报警数据
        //            {
        //                ListRtAlarm.Clear();
        //            }
        //            else
        //            {
        //                var Data = ListBitAlarmInfo.Where(a => a.Category == 1).ToList();
        //                foreach (var itemAlarm in Data)
        //                {
        //                    itemAlarm.State = ComHelper.GetBitValue(value, itemAlarm.BitIndex);
        //                }
        //            }
        //            _CoolFaultValue1 = value;
        //        }

        //    }
        //}


        //private ushort _CoolFaultValue2;
        ///// <summary>
        ///// 液冷状态字
        ///// 液冷故障码及等级
        ///// （0：无故障 2：
        /////  有故障）
        ///// </summary>
        //public ushort CoolFaultValue2
        //{
        //    get { return _CoolFaultValue2; }
        //    set
        //    {
        //        if (value != _CoolFaultValue2)
        //        {
        //            if (value == 0)//报警位0，则清除报警数据
        //            {
        //                ListRtAlarm.Clear();
        //            }
        //            else
        //            {
        //                var Data = ListBitAlarmInfo.Where(a => a.Category == 2).ToList();
        //                foreach (var itemAlarm in Data)
        //                {
        //                    itemAlarm.State = ComHelper.GetBitValue(value, itemAlarm.BitIndex);
        //                }
        //            }
        //            _CoolFaultValue2 = value;
        //        }

        //    }
        //}



        //private ushort _CoolFaultValue3;
        ///// <summary>
        ///// 液冷状态字
        ///// 液冷故障码及等级
        ///// （0：无故障 3：
        /////  有故障）
        ///// </summary>
        //public ushort CoolFaultValue3
        //{
        //    get { return _CoolFaultValue3; }
        //    set
        //    {
        //        if (value != _CoolFaultValue3)
        //        {
        //            if (value == 0)//报警位0，则清除报警数据
        //            {
        //                ListRtAlarm.Clear();
        //            }
        //            else
        //            {
        //                var Data = ListBitAlarmInfo.Where(a => a.Category == 3).ToList();
        //                foreach (var itemAlarm in Data)
        //                {
        //                    itemAlarm.State = ComHelper.GetBitValue(value, itemAlarm.BitIndex);
        //                }
        //            }
        //            _CoolFaultValue3 = value;
        //        }

        //    }
        //}


        //private ushort _CoolFaultValue4;
        ///// <summary>
        ///// 液冷状态字
        ///// 液冷故障码及等级
        ///// （0：无故障 4：
        /////  有故障）
        ///// </summary>
        //public ushort CoolFaultValue4
        //{
        //    get { return _CoolFaultValue4; }
        //    set
        //    {
        //        if (value != _CoolFaultValue4)
        //        {
        //            if (value == 0)//报警位0，则清除报警数据
        //            {
        //                ListRtAlarm.Clear();
        //            }
        //            else
        //            {
        //                var Data = ListBitAlarmInfo.Where(a => a.Category == 4).ToList();
        //                foreach (var itemAlarm in Data)
        //                {
        //                    itemAlarm.State = ComHelper.GetBitValue(value, itemAlarm.BitIndex);
        //                }
        //            }
        //            _CoolFaultValue4 = value;
        //        }

        //    }
        //}


        //private ushort _CoolFaultValue5;
        ///// <summary>
        ///// 液冷状态字
        ///// 液冷故障码及等级
        ///// （0：无故障 5：
        /////  有故障）
        ///// </summary>
        //public ushort CoolFaultValue5
        //{
        //    get { return _CoolFaultValue5; }
        //    set
        //    {
        //        if (value != _CoolFaultValue5)
        //        {
        //            if (value == 0)//报警位0，则清除报警数据
        //            {
        //                ListRtAlarm.Clear();
        //            }
        //            else
        //            {
        //                var Data = ListBitAlarmInfo.Where(a => a.Category == 5).ToList();
        //                foreach (var itemAlarm in Data)
        //                {
        //                    itemAlarm.State = ComHelper.GetBitValue(value, itemAlarm.BitIndex);
        //                }
        //            }
        //            _CoolFaultValue5 = value;
        //        }

        //    }
        //}

        //private string _CoolStatesMsg;
        ///// <summary>
        ///// 液冷机组运行状态消息
        ///// </summary>
        //public string CoolStatesMsg
        //{
        //    get { return _CoolStatesMsg; }
        //    set { _CoolStatesMsg = value; RaisePropertyChanged(); }
        //}


        #endregion


        #endregion
    }
}