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>
    /// 电表527中使用ModbusTcp协议读取信息
    /// </summary>
    public class EMeterModbus527Tool
    {

        #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>
        /// 总有功功率[0031H]
        /// </summary>
        private UInt16 _total_active_power = 0;
        /// <summary>
        /// 总有功功率[0031H]
        /// </summary>
        public UInt16 F_TotalActivePower
        {
            get
            {
                return _total_active_power;
            }
            set
            {
                lock (lockObj)
                {
                    _total_active_power = value;
                }
            }
        }

        /// <summary>
        /// 吸收有功电能二次侧
        /// </summary>
        private float _show_energy;
        /// <summary>
        /// 吸收有功电能二次侧 003FH～0040H(吸收有功电能)
        /// </summary>
        public float F_ShowEnergy
        {
            get
            {
                return _show_energy;
            }
            set
            {
                lock (lockObj)
                {
                    _show_energy = value;
                }
            }
        }
        
        /// <summary>
        /// 总有功电能二次侧[0052H～0053H]
        /// </summary>
        private float _total_active_energy;
        /// <summary>
        /// 总有功电能二次侧[0052H～0053H]
        /// </summary>
        public float 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 EMeterModbus527Tool()
        {
            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 EMeterModbus527Tool(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 EMeterModbus527Tool(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 EMeterModbus527Tool(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, _site);
            }
        }

        /// <summary>
        /// 电表类结构体
        /// </summary>
        /// <param name="ipaddr">服务端连接IP</param>
        /// <param name="port">服务端连接端口</param>
        /// <param name="site">从站号</param>
        /// <param name="devno">设备编号</param>
        /// <param name="devname">设备名称</param>
        public EMeterModbus527Tool(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)
            {
                // var operateResult = _client.Read("x=3;0", 65);
                // if (_net_connected && operateResult.IsSuccess)
                // {
                //     var PT = _client.ByteTransform.TransInt16(operateResult.Content, 6);
                //     var CT = _client.ByteTransform.TransInt16(operateResult.Content, 8);
                //     //_total_active_power = _client.ByteTransform.TransUInt16(_client.Read("x=3;45", 150).Content, 4);
                //     //_total_active_energy = _client.ByteTransform.TransSingle(_client.Read("x=3;45", 150).Content, 56) / 1000f;
                //     var transInt16 = (new decimal(_client.ByteTransform.TransUInt16(operateResult.Content, 126))*65536+_client.ByteTransform.TransUInt16(operateResult.Content, 128)/ new decimal(1000f))*new decimal(PT) *new decimal(CT);
                //     _show_energy = (float)transInt16;
                //     MEMeterParamResult paramRlt = new MEMeterParamResult()
                //     {
                //         F_EqmCode = _eqm_code,
                //         F_ShowEnergy=_show_energy,
                //         F_TotalActivePower = _total_active_power,
                //         F_TotalActiveEnergy = Convert.ToUInt32(_total_active_energy)
                //     };
                //     _emeter_param_result = paramRlt;
                //     new ElecMeterValToRedis().StoredMeterParamResult(_eqm_code, paramRlt);
                // }
                
                var operateResult1 = _client.Read("x=3;0", 10);
                var operateResult2 = _client.Read("x=3;63", 10);
                if (_net_connected && operateResult1.IsSuccess && operateResult2.IsSuccess)
                {
                    var PT = _client.ByteTransform.TransInt16(operateResult1.Content, 6);
                    var CT = _client.ByteTransform.TransInt16(operateResult1.Content, 8);
                    //_total_active_power = _client.ByteTransform.TransUInt16(_client.Read("x=3;45", 150).Content, 4);
                    //_total_active_energy = _client.ByteTransform.TransSingle(_client.Read("x=3;45", 150).Content, 56) / 1000f;
                    var transInt16 = (new decimal(_client.ByteTransform.TransUInt16(operateResult2.Content, 0))*65536+_client.ByteTransform.TransUInt16(operateResult2.Content, 2)/ new decimal(1000f))*new decimal(PT) *new decimal(CT);
                    _show_energy = (float)transInt16;
                    MEMeterParamResult paramRlt = new MEMeterParamResult()
                    {
                        F_EqmCode = _eqm_code,
                        F_ShowEnergy=_show_energy,
                        F_TotalActivePower = _total_active_power,
                        F_TotalActiveEnergy = Convert.ToUInt32(_total_active_energy)
                    };
                    _emeter_param_result = paramRlt;
                    new ElecMeterValToRedis().StoredMeterParamResult(_eqm_code, paramRlt);
                }
               
                
                Thread.Sleep(2000);
            }
        }

        #endregion 参数读写

    }
}