using HslCommunication;
using HslCommunication.ModBus;
using Monitor.LogService;
using Monitor.Models;
using System;
using System.Collections.Generic;
using System.Threading;

namespace Module.EMeter.ModbusTcp
{
    /// <summary>
    /// 电表415中使用ModbusTcp协议读取信息
    /// </summary>
    public class EMeterModbus415Tool
    {

        #region 定义锁
        private object lockObj = new object(); //线程同步锁
        #endregion 定义锁

        #region 字段属性
        /// <summary>
        /// 服务端连接IP
        /// </summary>
        private string _ipaddr = "172.0.30.100";
        /// <summary>
        /// 服务端连接IP
        /// </summary>
        public string F_IpAddr
        {
            get
            {
                return _ipaddr;
            }
            set
            {
                lock (lockObj)
                {
                    _ipaddr = value;
                }
            }
        }

        /// <summary>
        /// 服务端连接端口
        /// </summary>
        private int _port = 502;
        /// <summary>
        /// 服务端连接端口
        /// </summary>
        public int F_Port
        {
            get
            {
                return _port;
            }
            set
            {
                lock (lockObj)
                {
                    _port = value;
                }
            }
        }

        /// <summary>
        /// 从站号
        /// </summary>
        private byte _site = 0x01;
        /// <summary>
        /// 从站号
        /// </summary>
        public byte F_Site
        {
            get
            {
                return _site;
            }
            set
            {
                lock (lockObj)
                {
                    _site = value;
                }
            }
        }

        /// <summary>
        /// 通讯是否已连接
        /// </summary>
        private bool _net_connected = false;
        /// <summary>
        /// 通讯是否已连接
        /// </summary>
        public bool F_NetConnected
        {
            get
            {
                return _net_connected;
            }
            set
            {
                lock (lockObj)
                {
                    _net_connected = value;
                }
            }
        }

        /// <summary>
        /// ModbusTcp客户端
        /// </summary>
        private ModbusTcpNet _client;
        /// <summary>
        /// ModbusTcp客户端
        /// </summary>
        public ModbusTcpNet F_ElecClient
        {
            get
            {
                return _client;
            }
            set
            {
                lock (lockObj)
                {
                    _client = value;
                }
            }
        }

        /// <summary>
        /// 设备编号
        /// </summary>
        private string _eqm_code = "001";
        /// <summary>
        /// 设备编号
        /// </summary>
        public string F_EqmCode
        {
            get
            {
                return _eqm_code;
            }
            set
            {
                lock (lockObj)
                {
                    _eqm_code = value;
                }
            }
        }

        /// <summary>
        /// 设备名称
        /// </summary>
        private string _eqm_name = "电表";
        /// <summary>
        /// 设备名称
        /// </summary>
        public string F_EqmName
        {
            get
            {
                return _eqm_name;
            }
            set
            {
                lock (lockObj)
                {
                    _eqm_name = value;
                }
            }
        }

        /// <summary>
        /// 决定去读取参数
        /// </summary>
        private bool _is_read = true;
        /// <summary>
        /// 决定去读取参数
        /// </summary>
        public bool F_IsRead
        {
            get
            {
                return _is_read;
            }
            set
            {
                lock (lockObj)
                {
                    _is_read = value;
                }
            }
        }

        /// <summary>
        /// 故障码
        /// </summary>
        private int _fault_code = 0;
        /// <summary>
        /// 故障码
        /// </summary>
        public int F_FaultCode
        {
            get
            {
                return _fault_code;
            }
            set
            {
                lock (lockObj)
                {
                    _fault_code = value;
                }
            }
        }

        /// <summary>
        /// 故障报警列表
        /// </summary>
        private List<int> _fault_alaram_no_list = new List<int>();
        /// <summary>
        /// 故障报警列表
        /// </summary>
        public List<int> F_FaultAlarmNoList
        {
            get
            {
                return _fault_alaram_no_list;
            }
            set
            {
                lock (lockObj)
                {
                    _fault_alaram_no_list = value;
                }
            }
        }

        /// <summary>
        /// 总有功功率[0x201A]
        /// </summary>
        private float _total_active_power = 0;
        /// <summary>
        /// 总有功功率[0x201A]
        /// </summary>
        public float F_TotalActivePower
        {
            get
            {
                return _total_active_power;
            }
            set
            {
                lock (lockObj)
                {
                    _total_active_power = value;
                }
            }
        }

        /// <summary>
        /// 总有功电能二次侧[0x3000]
        /// </summary>
        private UInt32 _total_active_energy;
        /// <summary>
        /// 总有功电能二次侧[0x3000]
        /// </summary>
        public UInt32 F_TotalActiveEnergy
        {
            get
            {
                return _total_active_energy;
            }
            set
            {
                lock (lockObj)
                {
                    _total_active_energy = value;
                }
            }
        }

        /// <summary>
        /// 电表常用参数结果
        /// </summary>
        private MEMeterParamResult _emeter_param_result = new MEMeterParamResult();
        /// <summary>
        /// 电表常用参数结果
        /// </summary>
        public MEMeterParamResult F_EMeterParamResult
        {
            get
            {
                return _emeter_param_result;
            }
            set
            {
                lock (lockObj)
                {
                    _emeter_param_result = value;
                }
            }
        }

        #endregion 字段属性

        #region 类结构体

        public EMeterModbus415Tool()
        {
            if (!HslCommunication.Authorization.SetAuthorizationCode("975a841d-7346-489a-80eb-3b68c8b17df1"))
            {
            }
            if (_client == null)
            {
                _client = new ModbusTcpNet(_ipaddr, _port);
            }
        }

        /// <summary>
        /// 电表类结构体
        /// </summary>
        /// <param name="ipaddr">服务端连接IP</param>
        /// <param name="port">服务端连接端口</param>
        public EMeterModbus415Tool(string ipAddr, int port)
        {
            if (!HslCommunication.Authorization.SetAuthorizationCode("975a841d-7346-489a-80eb-3b68c8b17df1"))
            {
            }
            _ipaddr = ipAddr;
            _port = port;
            if (_client == null)
            {
                _client = new ModbusTcpNet(_ipaddr, _port);
            }
        }

        /// <summary>
        /// 电表类结构体
        /// </summary>
        /// <param name="ipaddr">服务端连接IP</param>
        /// <param name="port">服务端连接端口</param>
        /// <param name="site">从站号</param>
        public EMeterModbus415Tool(string ipAddr, int port, byte site)
        {
            if (!HslCommunication.Authorization.SetAuthorizationCode("975a841d-7346-489a-80eb-3b68c8b17df1"))
            {
            }
            _ipaddr = ipAddr;
            _port = port;
            _site = site;
            if (_client == null)
            {
                _client = new ModbusTcpNet(_ipaddr, _port);
            }
        }

        /// <summary>
        /// 电表类结构体
        /// </summary>
        /// <param name="ipaddr">服务端连接IP</param>
        /// <param name="port">服务端连接端口</param>
        /// <param name="site">从站号</param>
        /// <param name="devno">设备编号</param>
        public EMeterModbus415Tool(string ipAddr, int port, byte site, string devNO)
        {
            if (!HslCommunication.Authorization.SetAuthorizationCode("975a841d-7346-489a-80eb-3b68c8b17df1"))
            {
            }
            _ipaddr = ipAddr;
            _port = port;
            _site = site;
            _eqm_code = devNO;
            if (_client == null)
            {
                _client = new ModbusTcpNet(_ipaddr, _port);
            }
        }

        /// <summary>
        /// 电表类结构体
        /// </summary>
        /// <param name="ipaddr">服务端连接IP</param>
        /// <param name="port">服务端连接端口</param>
        /// <param name="site">从站号</param>
        /// <param name="devno">设备编号</param>
        /// <param name="devname">设备名称</param>
        public EMeterModbus415Tool(string ipaddr, int port, byte site, string devno, string devname)
        {
            if (!HslCommunication.Authorization.SetAuthorizationCode("975a841d-7346-489a-80eb-3b68c8b17df1"))
            {
            }
            _ipaddr = ipaddr;
            _port = port;
            _site = site;
            _eqm_code = devno;
            _eqm_name = devname;
            if (_client == null)
            {
                _client = new ModbusTcpNet(_ipaddr, _port);
            }
        }

        #endregion 类结构体

        #region 设备连接

        /// <summary>
        /// ModbusTcp连接
        /// </summary>
        public void Connect()
        {
            try
            {
                if (_client == null)
                {
                    _client = new ModbusTcpNet(_ipaddr, _port, _site);
                }
                if (_client != null)
                {
                    _client = new ModbusTcpNet(_ipaddr, _port, _site);
                    OperateResult OptRet = _client.ConnectServer();

                    if (OptRet.IsSuccess)
                    {
                        _net_connected = true;
                        StartReadParamValueThread();
                    }
                    else
                    {
                        _net_connected = false;
                    }
                }
            }
            catch (Exception ex)
            {
                Log.LogInstance.WriteLog("连接失败" + ex.ToString(), LogType.Run, "电表Log");
            }
        }

        /// <summary>
        /// ModbusTcp连接断开
        /// </summary>
        public void DisConnect()
        {
            try
            {
                OperateResult OptRet = _client.ConnectClose();
                if (OptRet.IsSuccess)
                {
                    _net_connected = false;
                }
            }
            catch (Exception ex)
            {
                Log.LogInstance.WriteLog("断开连接失败" + ex.ToString(), LogType.Run, "电表Log");
            }
        }

        #endregion 设备连接

        #region 参数读写

        /// <summary>
        /// 开始读参数值线程
        /// </summary>
        private void StartReadParamValueThread()
        {
            Thread readParamValueThread = new Thread(ReadParamValueFunc);
            readParamValueThread.IsBackground = true;
            readParamValueThread.Start();
        }



        /// <summary>
        /// 读取参数值方法
        /// </summary>
        private void ReadParamValueFunc()
        {
            while (_is_read)
            {
                if (_net_connected)
                {
                    OperateResult<float> readPowerResult = _client.ReadFloat("x=3;8218");
                    OperateResult <UInt32> readEnergResult = _client.ReadUInt32("x=3;12288");
                    if (readPowerResult.IsSuccess)
                    {              
                        _total_active_power = readPowerResult.Content;    //0x201a=8218
                        _total_active_energy = readEnergResult.Content;   //0x3000=12288

                        MEMeterParamResult paramRlt = new MEMeterParamResult()
                        {
                            F_TotalActivePower = _total_active_power,
                            F_TotalActiveEnergy = _total_active_energy
                        };
                        new ElecMeterValToRedis().StoredMeterParamResult(_eqm_code, paramRlt);

                        _emeter_param_result = paramRlt;
                    }
                }
                Thread.Sleep(2000);
            }
        }

        #endregion 参数读写

    }
}