using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Infrastructure.Helper
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net.Sockets;
    using System.Threading.Tasks;

    /// <summary>
    /// Modbus TCP 客户端帮助类（支持常用功能码）  客户端 = 主站
    /// </summary>
    public class ModbusTcpClientHelper : IDisposable
    {
        private TcpClient _tcpClient;
        private NetworkStream _networkStream;
        private readonly object _lockObj = new object(); // 线程安全锁

        /// <summary>
        /// 连接Modbus TCP服务器 服务端 = 从站
        /// </summary>
        /// <param name="ip">服务器IP</param>
        /// <param name="port">端口（默认502）</param>
        /// <param name="timeoutMs">超时时间（毫秒，默认3000）</param>
        public void Connect(string ip, int port = 502, int timeoutMs = 3000)
        {
            if (_tcpClient != null && _tcpClient.Connected)
                return;

            lock (_lockObj)
            {
                try
                {
                    Console.WriteLine($"连接Modbus TCP服务器已启动");
                    _tcpClient = new TcpClient();
                    _tcpClient.SendTimeout = timeoutMs;
                    _tcpClient.ReceiveTimeout = timeoutMs;
                    _tcpClient.Connect(ip, port);
                    _networkStream = _tcpClient.GetStream();
                    Console.WriteLine($"连接Modbus TCP服务器已成功");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"连接Modbus TCP服务器失败： {ex.Message}");
                }
            }
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            lock (_lockObj)
            {
                _networkStream?.Close();
                _tcpClient?.Close();
                _networkStream = null;
                _tcpClient = null;
            }
        }

        /// <summary>
        /// 读取保持寄存器（功能码0x03）
        /// </summary>
        /// <param name="unitId">从站地址（单元ID）</param>
        /// <param name="startAddress">起始地址（0-based）</param>
        /// <param name="numberOfRegisters">寄存器数量</param>
        /// <returns>寄存器值列表（每个寄存器2字节，高位在前）</returns>
        public List<ushort> ReadHoldingRegisters(byte unitId, ushort startAddress, ushort numberOfRegisters)
        {
            var request = BuildReadRequest(unitId, 0x03, startAddress, numberOfRegisters);
            var response = SendAndReceive(request);
            return ParseReadRegistersResponse(response, numberOfRegisters);
        }

        /// <summary>
        /// 读取输入寄存器（功能码0x04）
        /// </summary>
        public List<ushort> ReadInputRegisters(byte unitId, ushort startAddress, ushort numberOfRegisters)
        {
            var request = BuildReadRequest(unitId, 0x04, startAddress, numberOfRegisters);
            var response = SendAndReceive(request);
            return ParseReadRegistersResponse(response, numberOfRegisters);
        }

        /// <summary>
        /// 读取离散输入（功能码0x02，对应DI/数字输入端口，如X1-X8）
        /// </summary>
        /// <param name="unitId">从站地址</param>
        /// <param name="startAddress">起始地址（0-based）</param>
        /// <param name="numberOfInputs">离散输入数量</param>
        /// <returns>离散输入状态列表（true=导通/按下，false=断开/未按下）</returns>
        public List<bool> ReadDiscreteInputs(byte unitId, ushort startAddress, ushort numberOfInputs)
        {
            var request = BuildReadRequest(unitId, 0x02, startAddress, numberOfInputs);
            var response = SendAndReceive(request);
            return ParseReadDiscreteInputsResponse(response, numberOfInputs);
        }

        /// <summary>
        /// 解析离散输入响应（功能码02，逻辑和读线圈一致）
        /// </summary>
        private List<bool> ParseReadDiscreteInputsResponse(byte[] response, ushort expectedCount)
        {
            // 功能码校验（02=读离散输入）
            if (response[7] != 0x02)
                throw new Exception($"Modbus异常：功能码={response[7]:X2}，预期02");

            var byteCount = response[8];
            var expectedBytes = (expectedCount + 7) / 8; // 位转字节，向上取整
            if (byteCount != expectedBytes)
                throw new Exception($"响应字节数与预期不符：实际={byteCount}，预期={expectedBytes}");

            var discreteInputs = new List<bool>();
            for (int i = 0; i < expectedCount; i++)
            {
                var byteIndex = 9 + i / 8; // 每个字节存8个位
                var bitIndex = i % 8;      // 字节内的位索引
                var mask = (byte)(1 << bitIndex);
                discreteInputs.Add((response[byteIndex] & mask) != 0);
            }
            return discreteInputs;
        }
        /// <summary>
        /// 写入单个保持寄存器（功能码0x06）
        /// </summary>
        /// <param name="unitId">从站地址</param>
        /// <param name="address">寄存器地址（0-based）</param>
        /// <param name="value">要写入的值（16位）</param>
        public void WriteSingleRegister(byte unitId, ushort address, ushort value)
        {
            var request = BuildWriteSingleRequest(unitId, 0x06, address, value);
            var response = SendAndReceive(request);
            ValidateWriteResponse(response, 0x06, address, value);
        }

        /// <summary>
        /// 写入多个保持寄存器（功能码0x10）
        /// </summary>
        /// <param name="unitId">从站地址</param>
        /// <param name="startAddress">起始地址（0-based）</param>
        /// <param name="values">要写入的值列表（每个值16位）</param>
        public void WriteMultipleRegisters(byte unitId, ushort startAddress, List<ushort> values)
        {
            var request = BuildWriteMultipleRequest(unitId, 0x10, startAddress, values);
            var response = SendAndReceive(request);
            ValidateWriteResponse(response, 0x10, startAddress, (ushort)values.Count);
        }

        /// <summary>
        /// 读取线圈状态（功能码0x01）
        /// </summary>
        /// <param name="unitId">从站地址</param>
        /// <param name="startAddress">起始地址（0-based）</param>
        /// <param name="numberOfCoils">线圈数量（1-2000）</param>
        /// <returns>线圈状态列表（true=ON，false=OFF）</returns>
        public List<bool> ReadCoils(byte unitId, ushort startAddress, ushort numberOfCoils)
        {
            var request = BuildReadRequest(unitId, 0x01, startAddress, numberOfCoils);
            var response = SendAndReceive(request);
            return ParseReadCoilsResponse(response, numberOfCoils);
        }

        /// <summary>
        /// 写入单个线圈（功能码0x05）
        /// </summary>
        public void WriteSingleCoil(byte unitId, ushort address, bool value)
        {
            var request = BuildWriteSingleCoilRequest(unitId, 0x05, address, value);
            var response = SendAndReceive(request);
            ValidateWriteResponse(response, 0x05, address, value ? (ushort)0xFF00 : (ushort)0x0000);
        }


        #region 私有方法（协议构建与解析）

        /// <summary>
        /// 构建读请求报文（功能码0x01、0x02、0x03、0x04通用）
        /// </summary>
        private byte[] BuildReadRequest(byte unitId, byte functionCode, ushort startAddress, ushort quantity)
        {
            var request = new List<byte>
        {
            unitId,                  // 单元ID
            functionCode             // 功能码
        };
            request.AddRange(BitConverter.GetBytes(startAddress).Reverse()); // 起始地址（大端序）
            request.AddRange(BitConverter.GetBytes(quantity).Reverse());   // 数量（大端序）
            AddCrcOrLength(request); // 添加长度（Modbus TCP无CRC，用MBAP长度）
            return request.ToArray();
        }

        /// <summary>
        /// 构建写单个寄存器请求（功能码0x06）
        /// </summary>
        private byte[] BuildWriteSingleRequest(byte unitId, byte functionCode, ushort address, ushort value)
        {
            var request = new List<byte>
        {
            unitId,
            functionCode
        };
            request.AddRange(BitConverter.GetBytes(address).Reverse());
            request.AddRange(BitConverter.GetBytes(value).Reverse());
            AddCrcOrLength(request);
            return request.ToArray();
        }

        /// <summary>
        /// 构建写多个寄存器请求（功能码0x10）
        /// </summary>
        private byte[] BuildWriteMultipleRequest(byte unitId, byte functionCode, ushort startAddress, List<ushort> values)
        {
            var request = new List<byte>
        {
            unitId,
            functionCode,
            (byte)(startAddress >> 8),  // 起始地址高字节
            (byte)(startAddress & 0xFF),// 起始地址低字节
            (byte)(values.Count >> 8),  // 数量高字节
            (byte)(values.Count & 0xFF),// 数量低字节
            (byte)(values.Count * 2)   // 字节数（每个寄存器2字节）
        };
            foreach (var value in values)
            {
                request.AddRange(BitConverter.GetBytes(value).Reverse()); // 寄存器值（大端序）
            }
            AddCrcOrLength(request);
            return request.ToArray();
        }

        /// <summary>
        /// 构建写单个线圈请求（功能码0x05）
        /// </summary>
        private byte[] BuildWriteSingleCoilRequest(byte unitId, byte functionCode, ushort address, bool value)
        {
            var request = new List<byte>
        {
            unitId,
            functionCode
        };
            request.AddRange(BitConverter.GetBytes(address).Reverse());
            request.AddRange(value ? new byte[] { 0xFF, 0x00 } : new byte[] { 0x00, 0x00 }); // ON=0xFF00，OFF=0x0000
            AddCrcOrLength(request);
            return request.ToArray();
        }

        /// <summary>
        /// 添加MBAP头的长度字段（Modbus TCP无CRC，用长度标识后续字节数）
        /// </summary>
        private void AddCrcOrLength(List<byte> data)
        {
            // Modbus TCP格式：[事务ID(2)][协议ID(2)][长度(2)][单元ID(1)][PDU...]
            // 此处简化：假设事务ID=0，协议ID=0，长度=单元ID+PDU长度（即data.Length）
            var mbapHeader = new List<byte>
        {
            0x00, 0x00, // 事务ID=0
            0x00, 0x00, // 协议ID=0（Modbus）
            0x00, (byte)(data.Count) // 长度=单元ID+PDU长度（data已包含单元ID+PDU）
        };
            mbapHeader.AddRange(data);
            data.Clear();
            data.AddRange(mbapHeader);
        }


        private byte[] SendAndReceive(byte[] request)
        {
            if (_networkStream == null || !_tcpClient.Connected)
                throw new InvalidOperationException("未连接到Modbus TCP服务器");

            lock (_lockObj)
            {
                try
                {
                    // 1. 清空流缓存（仅用DataAvailable+循环读取，不依赖Length）
                    if (_networkStream.DataAvailable)
                    {
                        byte[] discardBuffer = new byte[1024];
                        while (_networkStream.DataAvailable)
                        {
                            _networkStream.Read(discardBuffer, 0, discardBuffer.Length);
                        }
                    }

                    // 2. 发送请求
                    _networkStream.Write(request, 0, request.Length);
                    _networkStream.Flush();

                    // 3. 读取MBAP头（6字节）：循环读取直到获取完整6字节
                    byte[] headerBuffer = new byte[6];
                    int totalRead = 0;
                    DateTime startTime = DateTime.Now;
                    int timeoutMs = _tcpClient.ReceiveTimeout;

                    while (totalRead < 6)
                    {
                        // 检查超时
                        if (DateTime.Now.Subtract(startTime).TotalMilliseconds > timeoutMs)
                            throw new TimeoutException();

                        int bytesRead = _networkStream.Read(headerBuffer, totalRead, 6 - totalRead);
                        if (bytesRead == 0)
                            break; // 连接关闭
                        totalRead += bytesRead;
                    }

                    if (totalRead != 6)
                        throw new Exception($"接收MBAP头失败：预期6字节，实际读取{totalRead}字节");

                    // 4. 解析长度字段
                    int length = (headerBuffer[4] << 8) | headerBuffer[5];
                    if (length <= 0 || length > 1024)
                        throw new Exception($"MBAP头长度字段无效：{length}");

                    // 5. 读取PDU数据
                    byte[] pduBuffer = new byte[length];
                    totalRead = 0;
                    startTime = DateTime.Now;
                    while (totalRead < length)
                    {
                        if (DateTime.Now.Subtract(startTime).TotalMilliseconds > timeoutMs)
                            throw new TimeoutException();

                        int bytesRead = _networkStream.Read(pduBuffer, totalRead, length - totalRead);
                        if (bytesRead == 0)
                            break;
                        totalRead += bytesRead;
                    }

                    if (totalRead != length)
                        throw new Exception($"接收响应数据不完整：预期{length}字节，实际读取{totalRead}字节");

                    // 6. 拼接响应
                    byte[] responseBuffer = new byte[6 + length];
                    Array.Copy(headerBuffer, 0, responseBuffer, 0, 6);
                    Array.Copy(pduBuffer, 0, responseBuffer, 6, length);

                    return responseBuffer;
                }
                catch (TimeoutException)
                {
                    throw new Exception("接收响应超时");
                }
                catch (Exception ex)
                {
                    throw new Exception($"通信失败：{ex.Message}", ex);
                }
            }
        }

        /// <summary>
        /// 确保读取指定长度的字节（纯流式读取，无seek/长度操作）
        /// </summary>
        /// <param name="stream">网络流</param>
        /// <param name="buffer">接收缓冲区</param>
        /// <param name="offset">偏移量</param>
        /// <param name="count">需要读取的字节数</param>
        /// <param name="timeoutMs">超时时间（毫秒）</param>
        /// <returns>实际读取的字节数</returns>
        private int ReadExactly(NetworkStream stream, byte[] buffer, int offset, int count, int timeoutMs)
        {
            int totalRead = 0;
            DateTime startTime = DateTime.Now;

            while (totalRead < count)
            {
                // 检查是否超时
                if (DateTime.Now.Subtract(startTime).TotalMilliseconds > timeoutMs)
                    throw new TimeoutException();

                // 读取剩余字节（NetworkStream.Read是非阻塞，可能只返回部分字节）
                int bytesRead = stream.Read(buffer, offset + totalRead, count - totalRead);
                if (bytesRead == 0)
                    break; // 流已关闭，无法继续读取

                totalRead += bytesRead;
            }

            return totalRead;
        }
        /// <summary>
        /// 解析读寄存器响应（功能码0x03、0x04）
        /// </summary>
        private List<ushort> ParseReadRegistersResponse(byte[] response, ushort expectedCount)
        {
            // 响应格式：[MBAP头(7)][单元ID(1)][功能码(1)][字节数(1)][数据(n)]
            var dataStartIndex = 7; // MBAP头7字节（事务ID2+协议ID2+长度2+单元ID1）+ 功能码1？不，重新算：
                                    // 实际响应结构：MBAP头(7字节) = [事务ID(2),协议ID(2),长度(2),单元ID(1)]？不，标准MBAP头是7字节：
                                    // 正确的MBAP头：事务ID(2)、协议ID(2)、长度(2)、单元ID(1) → 共7字节。然后PDU是功能码(1)+数据。
                                    // 所以response的结构：
                                    // 0-1: 事务ID
                                    // 2-3: 协议ID
                                    // 4-5: 长度（=单元ID+PDU长度）
                                    // 6: 单元ID
                                    // 7: 功能码
                                    // 8: 字节数（=n*2，n为寄存器数量）
                                    // 9~: 数据（每个寄存器2字节，大端序）

            if (response[7] != 0x03 && response[7] != 0x04) // 检查功能码（成功时无异常码）
                throw new Exception($"Modbus异常：功能码={response[7]:X2}");

            var byteCount = response[8];
            if (byteCount != expectedCount * 2)
                throw new Exception($"响应字节数与预期不符：实际={byteCount}，预期={expectedCount * 2}");

            var registers = new List<ushort>();
            for (int i = 0; i < expectedCount; i++)
            {
                var index = 9 + i * 2;
                var highByte = response[index];
                var lowByte = response[index + 1];
                registers.Add((ushort)((highByte << 8) | lowByte));
            }
            return registers;
        }

        /// <summary>
        /// 解析读线圈响应（功能码0x01）
        /// </summary>
        private List<bool> ParseReadCoilsResponse(byte[] response, ushort expectedCount)
        {
            if (response[7] != 0x01)
                throw new Exception($"Modbus异常：功能码={response[7]:X2}");

            var byteCount = response[8];
            var expectedBytes = (expectedCount + 7) / 8; // 向上取整
            if (byteCount != expectedBytes)
                throw new Exception($"响应字节数与预期不符：实际={byteCount}，预期={expectedBytes}");

            var coils = new List<bool>();
            for (int i = 0; i < expectedCount; i++)
            {
                var byteIndex = 9 + i / 8;
                var bitIndex = i % 8;
                var mask = (byte)(1 << bitIndex);
                coils.Add((response[byteIndex] & mask) != 0);
            }
            return coils;
        }

        /// <summary>
        /// 验证写操作响应（确保从站正确接收）
        /// </summary>
        private void ValidateWriteResponse(byte[] response, byte functionCode, ushort address, ushort value)
        {
            if (response[7] != functionCode) // 功能码应与原请求一致（无异常）
                throw new Exception($"写操作失败：响应功能码={response[7]:X2}");

            // 解析响应中的地址和值（应与请求一致）
            var respAddress = (ushort)((response[8] << 8) | response[9]);
            var respValue = (ushort)((response[10] << 8) | response[11]);
            if (respAddress != address || respValue != value)
                throw new Exception($"写操作响应不匹配：地址={respAddress:X4}（预期={address:X4}），值={respValue:X4}（预期={value:X4}）");
        }

        #endregion


        #region IDisposable实现
        private bool _disposed = false;
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    Disconnect();
                }
                _disposed = true;
            }
        }

        ~ModbusTcpClientHelper()
        {
            Dispose(false);
        }
        #endregion
    }

    // ===== 新增这两行 =====
    public class ThreeColorLightModbus : ModbusTcpClientHelper { }
    public class AlarmLightModbus : ModbusTcpClientHelper { }
}