using LogClass;
using NModbus;
using System;
using System.Net.Sockets;

namespace CCDCount.DLL.Tools
{
    public class ModbusTcpClient
    {
        private TcpClient _tcpClient;
        private IModbusMaster _modbusMaster;

        public bool IsTcpClientConnected()
        {
            if (_tcpClient == null || _tcpClient.Client == null)
                return false;
            try
            {
                Socket socket = _tcpClient.Client;
                bool isReadable = socket.Poll(0, SelectMode.SelectRead);
                bool hasNoData = (socket.Available == 0);

                // 可读且无数据 = 连接已断开
                return !(isReadable && hasNoData);
            }
            catch (SocketException) { return false; }
            catch (ObjectDisposedException) { return false; }
        }

        /// <summary>
        /// 连接 Modbus TCP 服务器
        /// </summary>
        /// <param name="ipAddress"></param>
        /// <param name="port"></param>
        /// <returns></returns>
        public bool Connect(string ipAddress, int port = 502)
        {
            try
            {
                _tcpClient = new TcpClient(ipAddress, port)
                {
                    SendTimeout = 2000,
                    ReceiveTimeout = 2000
                };
                // 使用 ModbusFactory 创建 Master（新版本 API）
                var factory = new ModbusFactory();
                _modbusMaster = factory.CreateMaster(_tcpClient);
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"连接失败: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            _modbusMaster?.Dispose();
            _tcpClient?.Close();
        }
        /// <summary>
        /// 读取线圈（功能码01）
        /// </summary>
        /// <param name="slaveId"></param>
        /// <param name="startAddress"></param>
        /// <param name="numRegisters"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public bool[] ReadCoilsRegister(byte slaveId, ushort startAddress, ushort numRegisters)
        {
            if (_modbusMaster == null)
            {
                //FaultLog.RecordErrorMessage($"读取线圈-未连接到服务器");
                return null;
            }
            try
            {
                return _modbusMaster.ReadCoils(slaveId, startAddress, numRegisters);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"读取线圈失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-ReadCoilsRegister-ReadCoilsRegister failed:{ex.Message}");
                return null;
            }
        }


        /// <summary>
        /// 读取保持寄存器（功能码03）
        /// </summary>
        /// <param name="slaveId"></param>
        /// <param name="startAddress"></param>
        /// <param name="numRegisters"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public ushort[] ReadHoldingRegisters(byte slaveId, ushort startAddress, ushort numRegisters)
        {
            if (_modbusMaster == null)
            {
                //FaultLog.RecordErrorMessage($"读取保持寄存器-未连接到服务器");
                return null;
            }
            try
            {
                return _modbusMaster.ReadHoldingRegisters(slaveId, startAddress, numRegisters);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"读取保持寄存器失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-ReadHoldingRegisters-ReadHoldingRegisters failed:{ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// 读取保持寄存器中的REAL值（功能码03）
        /// </summary>
        /// <param name="slaveId">从站ID</param>
        /// <param name="startAddress">起始地址</param>
        /// <param name="count">REAL值的数量</param>
        /// <returns>REAL值数组</returns>
        public float[] ReadHoldingRegistersAsReal(byte slaveId, ushort startAddress, ushort count)
        {
            if (_modbusMaster == null) throw new InvalidOperationException("未连接到服务器");

            try
            {
                // 每个REAL值占用2个寄存器
                ushort[] registers = _modbusMaster.ReadHoldingRegisters(slaveId, startAddress, (ushort)(count * 2));
                float[] realValues = new float[count];

                for (int i = 0; i < count; i++)
                {
                    // 获取两个连续的寄存器值
                    ushort lowRegister = registers[i * 2];
                    ushort highRegister = registers[i * 2 + 1];

                    // 根据字节序组合成32位值
                    byte[] bytes = new byte[4];
                    bytes[0] = (byte)(lowRegister & 0xFF);
                    bytes[1] = (byte)((lowRegister >> 8) & 0xFF);
                    bytes[2] = (byte)(highRegister & 0xFF);
                    bytes[3] = (byte)((highRegister >> 8) & 0xFF);

                    // 转换为float
                    realValues[i] = BitConverter.ToSingle(bytes, 0);
                }

                return realValues;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"读取REAL值失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-ReadHoldingRegistersAsReal failed:{ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// 读取保持寄存器中的REAL值（支持不同字节序）（功能码03）
        /// </summary>
        /// <param name="slaveId">从站ID</param>
        /// <param name="startAddress">起始地址</param>
        /// <param name="count">REAL值的数量</param>
        /// <param name="byteOrder">字节序 (ABCD, CDAB, BADC, DCBA)</param>
        /// <returns>REAL值数组</returns>
        public float[] ReadHoldingRegistersAsReal(byte slaveId, ushort startAddress, ushort count, string byteOrder = "ABCD")
        {
            if (_modbusMaster == null) throw new InvalidOperationException("未连接到服务器");

            try
            {
                // 每个REAL值占用2个寄存器
                ushort[] registers = _modbusMaster.ReadHoldingRegisters(slaveId, startAddress, (ushort)(count * 2));
                float[] realValues = new float[count];

                for (int i = 0; i < count; i++)
                {
                    ushort highRegister  = registers[i * 2];
                    ushort lowRegister = registers[i * 2 + 1];

                    byte[] bytes = ConvertToByteArray(lowRegister, highRegister, byteOrder);
                    realValues[i] = BitConverter.ToSingle(bytes, 0);
                }

                return realValues;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"读取REAL值失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-ReadHoldingRegistersAsReal failed:{ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// 读取保持寄存器中的Int32值（功能码03）
        /// </summary>
        /// <param name="slaveId">从站ID</param>
        /// <param name="startAddress">起始地址</param>
        /// <param name="count">REAL值的数量</param>
        /// <returns>REAL值数组</returns>
        public UInt32[] ReadHoldingRegistersAsInt32(byte slaveId, ushort startAddress, ushort count)
        {
            if (_modbusMaster == null) throw new InvalidOperationException("未连接到服务器");

            try
            {
                // 每个REAL值占用2个寄存器
                ushort[] registers = _modbusMaster.ReadHoldingRegisters(slaveId, startAddress, (ushort)(count * 2));
                UInt32[] realValues = new UInt32[count];

                for (int i = 0; i < count; i++)
                {
                    // 获取两个连续的寄存器值
                    ushort highRegister = registers[i * 2];
                    ushort lowRegister = registers[i * 2 + 1];

                    // 根据字节序组合成32位值
                    byte[] bytes = new byte[4];
                    if (BitConverter.IsLittleEndian)
                    {
                        bytes[3] = (byte)((highRegister >> 8) & 0xFF);
                        bytes[2] = (byte)(highRegister & 0xFF);
                        bytes[1] = (byte)((lowRegister >> 8) & 0xFF);
                        bytes[0] = (byte)(lowRegister & 0xFF);
                    }
                    else
                    {
                        bytes[0] = (byte)((highRegister >> 8) & 0xFF);
                        bytes[1] = (byte)(highRegister & 0xFF);
                        bytes[2] = (byte)((lowRegister >> 8) & 0xFF);
                        bytes[3] = (byte)(lowRegister & 0xFF);
                    }

                    // 转换为float
                    realValues[i] = (UInt32)BitConverter.ToInt32(bytes, 0);
                }

                return realValues;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"读取Int32值失败: {ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// 写入线圈（功能码05）
        /// </summary>
        /// <param name="slaveId">Slave编号</param>
        /// <param name="CoilsAddress">写入地址</param>
        /// <param name="values">写入值</param>
        /// <exception cref="InvalidOperationException"></exception>
        public void WriteCoilsRegister(byte slaveId, ushort CoilsAddress, bool values)
        {
            if (_modbusMaster == null) throw new InvalidOperationException("未连接到服务器");
            try
            {
                _modbusMaster.WriteSingleCoil(slaveId, CoilsAddress, values);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"写入线圈失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-WriteCoilsRegister-WriteCoilsRegister failed:{ex.Message}");
            }
        }

        /// <summary>
        /// 写入单个寄存器（功能码06）
        /// </summary>
        /// <param name="slaveId"></param>
        /// <param name="registerAddress"></param>
        /// <param name="value"></param>
        /// <exception cref="InvalidOperationException"></exception>
        public void WriteSingleRegister(byte slaveId, ushort registerAddress, ushort value)
        {

            if (_modbusMaster == null) throw new InvalidOperationException("未连接到服务器");
            try
            {
                _modbusMaster.WriteSingleRegister(slaveId, registerAddress, value);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"写入单个寄存器失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-WriteSingleRegister-WriteSingleRegister failed:{ex.Message}");
            }
        }

        /// <summary>
        /// 写入单个REAL值到保持寄存器（功能码16）
        /// </summary>
        /// <param name="slaveId">从站ID</param>
        /// <param name="startAddress">起始地址</param>
        /// <param name="value">REAL值</param>
        /// <param name="byteOrder">字节序 (ABCD, CDAB, BADC, DCBA)</param>
        public void WriteSingleReal(byte slaveId, ushort startAddress, float value, string byteOrder = "ABCD")
        {
            if (_modbusMaster == null) throw new InvalidOperationException("未连接到服务器");

            try
            {
                // 将float转换为字节数组
                byte[] bytes = BitConverter.GetBytes(value);

                // 根据字节序重新排列字节
                ushort[] registers = ConvertBytesToRegisters(bytes, byteOrder);

                // 写入两个连续的寄存器
                _modbusMaster.WriteMultipleRegisters(slaveId, startAddress, registers);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"写入REAL值失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-WriteSingleReal failed:{ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 写入多个寄存器（功能码16）
        /// </summary>
        /// <param name="slaveId"></param>
        /// <param name="startAddress"></param>
        /// <param name="values"></param>
        /// <exception cref="InvalidOperationException"></exception>
        public void WriteMultipleRegisters(byte slaveId, ushort startAddress, ushort[] values)
        {
            if (_modbusMaster == null) throw new InvalidOperationException("未连接到服务器");
            try
            {
                _modbusMaster.WriteMultipleRegisters(slaveId, startAddress, values);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"写入多个寄存器失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-WriteMultipleRegisters-WriteMultipleRegisters failed:{ex.Message}");
            }
        }

        /// <summary>
        /// 写入多个REAL值到保持寄存器（功能码16）
        /// </summary>
        /// <param name="slaveId">从站ID</param>
        /// <param name="startAddress">起始地址</param>
        /// <param name="values">REAL值数组</param>
        /// <param name="byteOrder">字节序 (ABCD, CDAB, BADC, DCBA)</param>
        public void WriteMultipleReals(byte slaveId, ushort startAddress, float[] values, string byteOrder = "ABCD")
        {
            if (_modbusMaster == null)
            {
                //FaultLog.RecordErrorMessage($"写入多个REAL值到保持寄存器-未连接到服务器");
                return;
            }
            if (values == null || values.Length == 0)
            {
                FaultLog.RecordLogMessage("写入多个REAL值到保持寄存器-值数组不能为空",0);
                return;
            }

            try
            {
                // 每个REAL值需要2个寄存器，所以总寄存器数是REAL值数量的2倍
                ushort[] registers = new ushort[values.Length * 2];

                for (int i = 0; i < values.Length; i++)
                {
                    // 将每个float转换为字节数组
                    byte[] bytes = BitConverter.GetBytes(values[i]);

                    // 根据字节序转换为寄存器值
                    ushort[] regPair = ConvertBytesToRegisters(bytes, byteOrder);

                    // 将寄存器值放入数组
                    registers[i * 2] = regPair[0];
                    registers[i * 2 + 1] = regPair[1];
                }

                // 写入所有寄存器
                _modbusMaster.WriteMultipleRegisters(slaveId, startAddress, registers);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"写入多个REAL值失败: {ex.Message}");
                FaultLog.RecordErrorMessage($"MainThreadClass-WriteMultipleReals failed:{ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 写入单个Int32值到保持寄存器（功能码16）
        /// </summary>
        /// <param name="slaveId">从站ID</param>
        /// <param name="startAddress">起始地址</param>
        /// <param name="value">REAL值</param>
        /// <param name="byteOrder">字节序 (ABCD, CDAB, BADC, DCBA)</param>
        public void WriteSingleInt32(byte slaveId, ushort startAddress, UInt32 value)
        {
            // 将32位整数拆分为两个16位寄存器值
            byte[] bytes = BitConverter.GetBytes(value);
            ushort[] registers = new ushort[2];

            // 处理字节序
            if (BitConverter.IsLittleEndian)
            {
                registers[0] = (ushort)((bytes[3] << 8) | bytes[2]); // 高16位
                registers[1] = (ushort)((bytes[1] << 8) | bytes[0]); // 低16位
            }
            else
            {
                registers[0] = (ushort)((bytes[0] << 8) | bytes[1]); // 高16位
                registers[1] = (ushort)((bytes[2] << 8) | bytes[3]); // 低16位
            }

            WriteMultipleRegisters(slaveId, startAddress, registers);
        }

        /// <summary>
        /// 将寄存器数组换为字节数组转（根据指定字节序）
        /// </summary>
        /// <param name="lowRegister">低位寄存器</param>
        /// <param name="highRegister">高位寄存器</param>
        /// <param name="byteOrder">字节序</param>
        /// <returns>字节数组</returns>
        private byte[] ConvertToByteArray(ushort lowRegister, ushort highRegister, string byteOrder)
        {
            byte[] bytes = new byte[4];

            switch (byteOrder.ToUpper())
            {
                case "ABCD": // 大端序
                    bytes[0] = (byte)(highRegister >> 8);
                    bytes[1] = (byte)(highRegister & 0xFF);
                    bytes[2] = (byte)(lowRegister >> 8);
                    bytes[3] = (byte)(lowRegister & 0xFF);
                    break;
                case "CDAB": // 小端序
                    bytes[0] = (byte)(lowRegister >> 8);
                    bytes[1] = (byte)(lowRegister & 0xFF);
                    bytes[2] = (byte)(highRegister >> 8);
                    bytes[3] = (byte)(highRegister & 0xFF);
                    break;
                case "BADC":
                    bytes[0] = (byte)(highRegister & 0xFF);
                    bytes[1] = (byte)(highRegister >> 8);
                    bytes[2] = (byte)(lowRegister & 0xFF);
                    bytes[3] = (byte)(lowRegister >> 8);
                    break;
                case "DCBA":
                    bytes[0] = (byte)(lowRegister & 0xFF);
                    bytes[1] = (byte)(lowRegister >> 8);
                    bytes[2] = (byte)(highRegister & 0xFF);
                    bytes[3] = (byte)(highRegister >> 8);
                    break;
                default:
                    // 默认使用ABCD顺序
                    bytes[0] = (byte)(highRegister >> 8);
                    bytes[1] = (byte)(highRegister & 0xFF);
                    bytes[2] = (byte)(lowRegister >> 8);
                    bytes[3] = (byte)(lowRegister & 0xFF);
                    break;
            }
            return bytes;
        }

        /// <summary>
        /// 将字节数组转换为寄存器数组（根据指定字节序）
        /// </summary>
        /// <param name="bytes">字节数组（4字节）</param>
        /// <param name="byteOrder">字节序</param>
        /// <returns>寄存器数组（2个ushort）</returns>
        private ushort[] ConvertBytesToRegisters(byte[] bytes, string byteOrder)
        {
            if (bytes.Length != 4)
                throw new ArgumentException("字节数组必须包含4个字节用于REAL值转换");

            ushort[] registers = new ushort[2];

            switch (byteOrder.ToUpper())
            {
                case "ABCD": // 大端序
                    registers[0] = (ushort)((bytes[0] << 8) | bytes[1]); // 高位寄存器
                    registers[1] = (ushort)((bytes[2] << 8) | bytes[3]); // 低位寄存器
                    break;
                case "CDAB": // 小端序
                    registers[0] = (ushort)((bytes[2] << 8) | bytes[3]); // 高位寄存器
                    registers[1] = (ushort)((bytes[0] << 8) | bytes[1]); // 低位寄存器
                    break;
                case "BADC":
                    registers[0] = (ushort)((bytes[1] << 8) | bytes[0]); // 高位寄存器
                    registers[1] = (ushort)((bytes[3] << 8) | bytes[2]); // 低位寄存器
                    break;
                case "DCBA":
                    registers[0] = (ushort)((bytes[3] << 8) | bytes[2]); // 高位寄存器
                    registers[1] = (ushort)((bytes[1] << 8) | bytes[0]); // 低位寄存器
                    break;
                default:
                    // 默认使用ABCD顺序
                    registers[0] = (ushort)((bytes[0] << 8) | bytes[1]);
                    registers[1] = (ushort)((bytes[2] << 8) | bytes[3]);
                    break;
            }
            return registers;
        }
    }
}