using HslCommunication.ModBus;
using HslCommunication;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using NLog;
using System.Windows;
using Prism.Mvvm;
using OrpaonEMS.App.Com;
using OrpaonEMS.Core.EventHandMsg;

namespace OrpaonEMS.App.Services
{
    /// <summary>
    /// 消防的数据服务
    /// </summary>
    public class FFService : BindableBase
    {
        public FFService(ILogService logger, ConfigDataService configDataService)
        {
            Logger = logger;
            ConfigDataService = configDataService;

            if (ConfigDataService.IsDemo)
            {
                ModbusRtuDrive?.Close();
                ModbusRtuDrive = new ModbusRtu();
                ModbusRtuDrive.AddressStartWithZero = true;
                ModbusRtuDrive.IsStringReverse = false;
                ModbusRtuDrive.DataFormat = HslCommunication.Core.DataFormat.ABCD;
                try
                {
                    ModbusRtuDrive.SerialPortInni(sp =>
                    {
                        sp.PortName = "COM2";
                        //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);
                }

                ScanDeviceStart();
            }

        }


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

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

        /// <summary>
        /// ScanDevice扫描Task
        /// </summary>
        static Task ScanDeviceTask { get; set; }

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

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

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

        /// <summary>
        ///扫描
        /// </summary>
        private void ScanDeviceStart()
        {
            Thread.Sleep(1000);
            ScanDeviceTask = Task.Run(async () =>
            {
                await Task.Delay(5000);
                while (ThreadEnable)
                {
                    Thread.Sleep(800);
                    OperateResult1 = ModbusRtuDrive.Read("1", 20);//初始地址固定验证
                    if (OperateResult1.IsSuccess)
                    {
                        //喷射延时数据
                        FireInjectionDely = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 4);
                        FireWorkModelVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 5);
                        FireGasPress = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 6);
                        FireSmokeTrigVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 7);
                        FireTempTrigVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 8);
                        FireFlammableTrigMsgVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 9);
                        FireStateMsgVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 10);

                        //FireMainPowerStateVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 466);
                        //FireSubPowerStateVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 468);
                        //FireSolenoidValveStateVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 470);
                        //FireInjectionCountdown = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 472);
                        //FirePressSensorStateVaue = ModbusRtuDrive.ByteTransform.TransUInt16(OperateResult1.Content, 474);
                        //xxx = ModbusTcpNetDrive.ByteTransform.TransUInt16(OperateResultConfigData.Content, 460);
                        LinkStateValue = true;
                    }
                    else
                    {
                        LinkStateValue = false;
                    }
                }
            });
        }

        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(); }
        }

        #region 消防数据


        //private ushort firePress;
        ///// <summary>
        ///// 消防压力d
        ///// </summary>
        //public ushort FirePress
        //{
        //    get { return firePress; }
        //    set { firePress = value; RaisePropertyChanged(); }
        //}


        private string _FireStateMsg="正常";
        /// <summary>
        /// 火警状态
        /// </summary>
        public string FireStateMsg
        {
            get { return _FireStateMsg; }
            set { _FireStateMsg = value; RaisePropertyChanged(); }
        }
        private ushort _FireStateMsgVaue = 100;
        /// <summary>
        /// 火警状态状态字
        /// </summary>
        public ushort FireStateMsgVaue
        {
            get { return _FireStateMsgVaue; }
            set
            {
                if (value != _FireStateMsgVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireStateMsg = "工作正常";
                            break;
                        case 1:
                            FireStateMsg = "一级预警";
                            break;
                        case 2:
                            FireStateMsg = "二级报警";
                            break;
                        case 3:
                            FireStateMsg = "三级火警";
                            break;
                        case 4:
                            FireStateMsg = "紧急启动";
                            break;
                        case 5:
                            FireStateMsg = "紧急停止";
                            break;
                        default:
                            break;
                    }
                    _FireStateMsgVaue = value;
                }
            }
        }



        private string fireSmokeTrigMsg= "正常";
        /// <summary>
        /// 消防烟感触发
        /// </summary>
        public string FireSmokeTrigMsg
        {
            get { return fireSmokeTrigMsg; }
            set { fireSmokeTrigMsg = value; RaisePropertyChanged(); }
        }


        private ushort _FireSmokeTrigVaue = 100;
        /// <summary>
        /// 消防烟感触发状态字
        /// </summary>
        public ushort FireSmokeTrigVaue
        {
            get { return _FireSmokeTrigVaue; }
            set
            {
                if (value != _FireSmokeTrigVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireSmokeTrigMsg = "未触发";
                            break;
                        case 1:
                            FireSmokeTrigMsg = "已触发";
                            break;
                        default:
                            break;
                    }
                    _FireSmokeTrigVaue = value;
                }
            }
        }

        private string fireTempTrigMsg = "已触发";
        /// <summary>
        /// 消防温感触发
        /// </summary>
        public string FireTempTrigMsg
        {
            get { return fireTempTrigMsg; }
            set { fireTempTrigMsg = value; RaisePropertyChanged(); }
        }

        private ushort _FireTempTrigVaue = 100;
        /// <summary>
        /// 消防温感触发状态字
        /// </summary>
        public ushort FireTempTrigVaue
        {
            get { return _FireTempTrigVaue; }
            set
            {
                if (value != _FireTempTrigVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireTempTrigMsg = "未触发";
                            break;
                        case 1:
                            FireTempTrigMsg = "已触发";
                            break;
                        default:
                            break;
                    }
                    _FireTempTrigVaue = value;
                }
            }
        }

        private string _FireFlammableTrigMsg = "未触发";
        /// <summary>
        /// 可燃状态触发
        /// </summary>
        public string FireFlammableTrigMsg
        {
            get { return _FireFlammableTrigMsg; }
            set { _FireFlammableTrigMsg = value; RaisePropertyChanged(); }
        }


        private ushort _FireFlammableTrigMsgVaue = 100;
        /// <summary>
        /// 可燃状态状态字
        /// </summary>
        public ushort FireFlammableTrigMsgVaue
        {
            get { return _FireFlammableTrigMsgVaue; }
            set
            {
                if (value != _FireFlammableTrigMsgVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireFlammableTrigMsg = "未触发";
                            break;
                        case 1:
                            FireFlammableTrigMsg = "已触发";
                            break;
                        default:
                            break;
                    }
                    _FireFlammableTrigMsgVaue = value;
                }
            }
        }





        private string fireWorkModelMsg = "自动";
        /// <summary>
        /// 消防设备工作模式内容
        /// </summary>
        public string FireWorkModelMsg
        {
            get { return fireWorkModelMsg; }
            set { fireWorkModelMsg = value; RaisePropertyChanged(); }
        }


        private ushort _FireWorkModelVaue = 100;
        /// <summary>
        /// 消防设备工作模式状态字
        /// </summary>
        public ushort FireWorkModelVaue
        {
            get { return _FireWorkModelVaue; }
            set
            {
                if (value != _FireWorkModelVaue)
                {
                    if (BitHelper.GetBitValue(value, 15))
                    {
                        FireWorkModelMsg = "自动";
                    }
                    else
                    {
                        FireWorkModelMsg = "手动";
                    }

                    FireMainPowerStateVaue = BitHelper.GetBitValue(value, 14) ? (ushort)1 : (ushort)0;
                    FireSubPowerStateVaue = BitHelper.GetBitValue(value, 13) ? (ushort)1 : (ushort)0;
                    FireChargStateVaue = BitHelper.GetBitValue(value, 12) ? (ushort)1 : (ushort)0;
                    FireDriveEleStateVaue = BitHelper.GetBitValue(value, 11) ? (ushort)1 : (ushort)0;
                    FirePressSensorStateVaue = BitHelper.GetBitValue(value, 10) ? (ushort)1 : (ushort)0;
                    FireSolenoidStateVaue = BitHelper.GetBitValue(value, 9) ? (ushort)1 : (ushort)0;
                    FireSprayStateVaue = BitHelper.GetBitValue(value, 8) ? (ushort)1 : (ushort)0;

                    _FireWorkModelVaue = value;
                }
            }
        }

        private string _FireSprayStateMsg = "未喷";
        /// <summary>
        /// 喷洒标记状态
        /// </summary>
        public string FireSprayStateMsg
        {
            get { return _FireSprayStateMsg; }
            set { _FireSprayStateMsg = value; RaisePropertyChanged(); }
        }


        private ushort _FireSprayStateVaue = 100;
        /// <summary>
        /// 喷洒标记状态字
        /// </summary>
        public ushort FireSprayStateVaue
        {
            get { return _FireSprayStateVaue; }
            set
            {
                if (value != _FireSprayStateVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireSprayStateMsg = "未喷";
                            break;
                        case 1:
                            FireSprayStateMsg = "已喷";
                            break;
                        default:
                            break;
                    }
                    _FireSprayStateVaue = value;
                }
            }
        }


        private string fireMainPowerStateMsg = "正常";
        /// <summary>
        /// 消防主电源状态
        /// </summary>
        public string FireMainPowerStateMsg
        {
            get { return fireMainPowerStateMsg; }
            set { fireMainPowerStateMsg = value; RaisePropertyChanged(); }
        }


        private ushort _FireMainPowerStateVaue = 100;
        /// <summary>
        /// 消防主电源状态状态字
        /// </summary>
        public ushort FireMainPowerStateVaue
        {
            get { return _FireMainPowerStateVaue; }
            set
            {
                if (value != _FireMainPowerStateVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireMainPowerStateMsg = "正常";
                            break;
                        case 1:
                            FireMainPowerStateMsg = "异常";
                            break;
                        default:
                            break;
                    }
                    _FireMainPowerStateVaue = value;
                }
            }
        }

        private string _FireSubPowerStateMsg = "正常";
        /// <summary>
        /// 消防副电源状态
        /// </summary>
        public string FireSubPowerStateMsg
        {
            get { return _FireSubPowerStateMsg; }
            set { _FireSubPowerStateMsg = value; RaisePropertyChanged(); }
        }


        private ushort _FireSubPowerStateVaue = 100;
        /// <summary>
        /// 消防副电源状态状态字
        /// </summary>
        public ushort FireSubPowerStateVaue
        {
            get { return _FireSubPowerStateVaue; }
            set
            {
                if (value != _FireSubPowerStateVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireSubPowerStateMsg = "正常";
                            break;
                        case 1:
                            FireSubPowerStateMsg = "异常";
                            break;
                        default:
                            break;
                    }
                    _FireSubPowerStateVaue = value;
                }
            }
        }

        private string _FireChargStateMsg = "正常";
        /// <summary>
        /// 充电状态
        /// </summary>
        public string FireChargStateMsg
        {
            get { return _FireChargStateMsg; }
            set { _FireChargStateMsg = value; RaisePropertyChanged(); }
        }
        private ushort _FireChargStateVaue = 100;
        /// <summary>
        /// 充电状态状态字
        /// </summary>
        public ushort FireChargStateVaue
        {
            get { return _FireChargStateVaue; }
            set
            {
                if (value != _FireChargStateVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireChargStateMsg = "不充";
                            break;
                        case 1:
                            FireChargStateMsg = "充电";
                            break;
                        default:
                            break;
                    }
                    _FireChargStateVaue = value;
                }
            }
        }

        private string _FireDriveEleStateMsg = "正常";
        /// <summary>
        /// 驱动电路状态
        /// </summary>
        public string FireDriveEleStateMsg
        {
            get { return _FireDriveEleStateMsg; }
            set { _FireDriveEleStateMsg = value; RaisePropertyChanged(); }
        }
        private ushort _FireDriveEleStateVaue = 100;
        /// <summary>
        /// 驱动电路状态状态字
        /// </summary>
        public ushort FireDriveEleStateVaue
        {
            get { return _FireDriveEleStateVaue; }
            set
            {
                if (value != _FireDriveEleStateVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireDriveEleStateMsg = "正常";
                            break;
                        case 1:
                            FireDriveEleStateMsg = "故障";
                            break;
                        default:
                            break;
                    }
                    _FireDriveEleStateVaue = value;
                }
            }
        }


        private string _FireSolenoidStateMsg = "正常";
        /// <summary>
        /// 消防电磁阀状态
        /// </summary>
        public string FireSolenoidStateMsg
        {
            get { return _FireSolenoidStateMsg; }
            set { _FireSolenoidStateMsg = value; RaisePropertyChanged(); }
        }


        private ushort _FireSolenoidStateVaue = 100;
        /// <summary>
        ///消防电磁阀状态状态字
        /// </summary>
        public ushort FireSolenoidStateVaue
        {
            get { return _FireSolenoidStateVaue; }
            set
            {
                if (value != _FireSolenoidStateVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FireSolenoidStateMsg = "关闭";
                            break;
                        case 1:
                            FireSolenoidStateMsg = "开启";
                            break;
                        default:
                            break;
                    }
                    _FireSolenoidStateVaue = value;
                }
            }
        }


        private ushort fireInjectionCountdown;
        /// <summary>
        /// 消防喷射倒计时
        /// </summary>
        public ushort FireInjectionCountdown
        {
            get { return fireInjectionCountdown; }
            set { fireInjectionCountdown = value; RaisePropertyChanged(); }
        }

        private ushort _FireInjectionDely;
        /// <summary>
        /// 喷洒延时
        /// </summary>
        public ushort FireInjectionDely
        {
            get { return _FireInjectionDely; }
            set { _FireInjectionDely = value; RaisePropertyChanged(); }
        }

        private ushort _FireGasPress;
        /// <summary>
        /// 钢瓶气压 单位KPa
        /// </summary>
        public ushort FireGasPress
        {
            get { return _FireGasPress; }
            set { _FireGasPress = value; RaisePropertyChanged(); }
        }

        private string firePressSensorStateMsg = "无异常";
        /// <summary>
        /// 消防压力传感器状态检测
        /// </summary>
        public string FirePressSensorStateMsg
        {
            get { return firePressSensorStateMsg; }
            set { firePressSensorStateMsg = value; RaisePropertyChanged(); }
        }


        private ushort _FirePressSensorStateVaue = 100;
        /// <summary>
        /// 消防压力传感器状态检测状态字
        /// </summary>
        public ushort FirePressSensorStateVaue
        {
            get { return _FirePressSensorStateVaue; }
            set
            {
                if (value != _FirePressSensorStateVaue)
                {
                    switch (value)
                    {
                        case 0:
                            FirePressSensorStateMsg = "无异常";
                            break;
                        case 1:
                            FirePressSensorStateMsg = "有异常";
                            break;
                        default:
                            break;
                    }
                    _FirePressSensorStateVaue = value;
                }
            }
        }

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

        #endregion


    }
}