using EasyModbus;
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Text;

namespace GSModbus
{
    /// <summary>
    /// Modbus TCP通信管理器 - 作为MES客户端与PLC服务器通信
    /// </summary>
    public class ModbusManager : IDisposable
    {
        #region 常量定义 - Modbus地址映射
        
        // MES发送给PLC的地址 (MES → PLC)
        /// <summary>
        /// MES发送给PLC的心跳包地址 - 每秒交替发送0/1来维持连接
        /// </summary>
        private const int MES_HEARTBEAT_ADDRESS = 6000;
        
        /// <summary>
        /// MES发送的数据读取确认信号 - 当MES成功读取PLC数据后置1确认
        /// </summary>
        private const int MES_DATA_OK_ADDRESS = 6001;

        // PLC发送给MES的地址 (PLC → MES) - 这些是我们需要读取的地址
        /// <summary>
        /// PLC发送的心跳包地址 - PLC每秒交替发送0/1
        /// </summary>
        private const int PLC_HEARTBEAT_ADDRESS = 6002;
        
        /// <summary>
        /// PLC数据准备就绪信号 - PLC置1表示数据已准备好供MES读取
        /// </summary>
        private const int PLC_DATA_OK_ADDRESS = 6003;
        
        /// <summary>
        /// 产品型号起始地址 - 10个字节存储产品型号(D6004-D6013)
        /// </summary>
        private const int PRODUCT_MODEL_START_ADDRESS = 6004;
        
        /// <summary>
        /// 测试工位地址 - 存储当前测试的工位号
        /// </summary>
        private const int TEST_STATION_ADDRESS = 6014;
        
        /// <summary>
        /// 产品码起始地址 - 10个字节存储产品码(D6015-D6024)
        /// </summary>
        private const int PRODUCT_CODE_START_ADDRESS = 6015;
        
        /// <summary>
        /// 测试结果地址 - 存储测试通过/失败状态
        /// </summary>
        private const int TEST_RESULT_ADDRESS = 6025;
        
        /// <summary>
        /// 记录时间起始地址 - 7个字节存储时间戳(D6026-D6032)
        /// </summary>
        private const int TIMESTAMP_START_ADDRESS = 6026;
        
        /// <summary>
        /// 测量数据起始地址 - 各种传感器测量值(D6033-D6048)
        /// </summary>
        private const int MEASUREMENT_DATA_START_ADDRESS = 6033;

        // PLC服务器连接信息
        private const string PLC_IP_ADDRESS = "192.168.3.250";
        private const int PLC_PORT = 502;
        
        #endregion

        #region 私有字段

        /// <summary>
        /// EasyModbus TCP客户端实例
        /// </summary>
        private ModbusClient _modbusClient;
        
        /// <summary>
        /// 心跳定时器 - 用于定期发送心跳包
        /// </summary>
        private System.Timers.Timer _heartbeatTimer;
        
        /// <summary>
        /// 数据轮询定时器 - 用于定期读取PLC数据
        /// </summary>
        private System.Timers.Timer _dataPollingTimer;
        
        /// <summary>
        /// 心跳包状态 - 在0和1之间交替
        /// </summary>
        private byte _heartbeatState = 0;
        
        /// <summary>
        /// 连接状态标志
        /// </summary>
        private bool _isConnected = false;

        /// <summary>
        /// 取消令牌源 - 用于优雅停止异步操作
        /// </summary>
        private CancellationTokenSource _cancellationTokenSource;

        #endregion

        #region 事件定义

        /// <summary>
        /// 连接状态改变事件
        /// </summary>
        public event EventHandler<bool> ConnectionStatusChanged;
        
        /// <summary>
        /// 接收到PLC数据事件
        /// </summary>
        public event EventHandler<PlcData> DataReceived;
        
        /// <summary>
        /// 错误发生事件
        /// </summary>
        public event EventHandler<string> ErrorOccurred;

        #endregion

        #region 公共属性

        /// <summary>
        /// 获取当前连接状态
        /// </summary>
        public bool IsConnected => _isConnected;

        #endregion

        #region 构造函数

        /// <summary>
        /// 初始化Modbus管理器
        /// </summary>
        public ModbusManager()
        {
            _cancellationTokenSource = new CancellationTokenSource();
            InitializeModbusClient();
            InitializeTimers();
        }

        #endregion

        #region 初始化方法

        /// <summary>
        /// 初始化Modbus TCP客户端
        /// </summary>
        private void InitializeModbusClient()
        {
            try
            {
                // 创建Modbus TCP客户端实例
                _modbusClient = new ModbusClient(PLC_IP_ADDRESS, PLC_PORT);
                
                // 设置连接超时时间(毫秒)
                _modbusClient.ConnectionTimeout = 5000;
                
                LogInfo($"Modbus客户端初始化完成，目标PLC地址: {PLC_IP_ADDRESS}:{PLC_PORT}");
            }
            catch (Exception ex)
            {
                LogError($"初始化Modbus客户端失败: {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 初始化定时器
        /// </summary>
        private void InitializeTimers()
        {
            // 心跳定时器 - 每1秒发送一次心跳
            _heartbeatTimer = new System.Timers.Timer(1000);
            _heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
            _heartbeatTimer.AutoReset = true;

            // 数据轮询定时器 - 每500毫秒读取一次PLC数据
            _dataPollingTimer = new System.Timers.Timer(500);
            _dataPollingTimer.Elapsed += OnDataPollingTimerElapsed;
            _dataPollingTimer.AutoReset = true;

            LogInfo("定时器初始化完成 - 心跳周期:1秒, 数据轮询周期:500毫秒");
        }

        #endregion

        #region 连接管理方法

        /// <summary>
        /// 连接到PLC服务器
        /// </summary>
        /// <returns>连接是否成功</returns>
        public async Task<bool> ConnectAsync()
        {
            try
            {
                LogInfo($"正在连接到PLC服务器 {PLC_IP_ADDRESS}:{PLC_PORT}...");

                // 尝试连接到PLC
                await Task.Run(() => _modbusClient.Connect());

                _isConnected = true;
                LogInfo("成功连接到PLC服务器");

                // 启动定时器
                _heartbeatTimer.Start();
                _dataPollingTimer.Start();

                // 触发连接状态改变事件
                ConnectionStatusChanged?.Invoke(this, true);

                return true;
            }
            catch (Exception ex)
            {
                _isConnected = false;
                LogError($"连接PLC失败: {ex.Message}");
                ConnectionStatusChanged?.Invoke(this, false);
                return false;
            }
        }

        /// <summary>
        /// 断开与PLC的连接
        /// </summary>
        public void Disconnect()
        {
            try
            {
                // 停止定时器
                _heartbeatTimer?.Stop();
                _dataPollingTimer?.Stop();

                // 断开Modbus连接
                if (_modbusClient?.Connected == true)
                {
                    _modbusClient.Disconnect();
                }

                _isConnected = false;
                LogInfo("已断开与PLC的连接");

                // 触发连接状态改变事件
                ConnectionStatusChanged?.Invoke(this, false);
            }
            catch (Exception ex)
            {
                LogError($"断开连接时发生错误: {ex.Message}");
            }
        }

        #endregion

        #region 定时器事件处理

        /// <summary>
        /// 心跳定时器事件 - 每秒向PLC发送心跳包
        /// </summary>
        private async void OnHeartbeatTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (!_isConnected || _cancellationTokenSource.Token.IsCancellationRequested)
                return;

            try
            {
                // 在0和1之间交替心跳状态
                _heartbeatState = (byte)(_heartbeatState == 0 ? 1 : 0);

                // 向PLC发送心跳包
                await Task.Run(() => 
                {
                    _modbusClient.WriteSingleRegister(MES_HEARTBEAT_ADDRESS, _heartbeatState);
                });

                LogDebug($"发送心跳包到PLC: {_heartbeatState}");
            }
            catch (Exception ex)
            {
                LogError($"发送心跳包失败: {ex.Message}");
                // 心跳失败可能表示连接已断开
                await HandleConnectionLoss();
            }
        }

        /// <summary>
        /// 数据轮询定时器事件 - 定期从PLC读取数据
        /// </summary>
        private async void OnDataPollingTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (!_isConnected || _cancellationTokenSource.Token.IsCancellationRequested)
                return;

            try
            {
                // 读取PLC数据
                var plcData = await ReadPlcDataAsync();
                if (plcData != null)
                {
                    // 如果PLC表示数据已准备好，则发送确认信号
                    if (plcData.DataOkSignal == 1)
                    {
                        await SendDataReadConfirmationAsync();
                        
                        // 触发数据接收事件
                        DataReceived?.Invoke(this, plcData);
                        
                        LogInfo("成功读取PLC数据并发送确认信号");
                    }
                }
            }
            catch (Exception ex)
            {
                LogError($"读取PLC数据失败: {ex.Message}");
            }
        }

        #endregion

        #region 数据读取方法

        /// <summary>
        /// 从PLC读取所有数据
        /// </summary>
        /// <returns>PLC数据结构</returns>
        private async Task<PlcData> ReadPlcDataAsync()
        {
            try
            {
                // 读取控制信号
                var controlSignals = await Task.Run(() => 
                    _modbusClient.ReadHoldingRegisters(PLC_HEARTBEAT_ADDRESS, 2));

                // 检查PLC数据是否准备就绪
                if (controlSignals[1] == 0) // DataOK信号为0表示数据未准备好
                {
                    return null;
                }

                // 读取产品型号 (10个寄存器)
                var productModelData = await Task.Run(() => 
                    _modbusClient.ReadHoldingRegisters(PRODUCT_MODEL_START_ADDRESS, 10));

                // 读取测试工位
                var testStationData = await Task.Run(() => 
                    _modbusClient.ReadHoldingRegisters(TEST_STATION_ADDRESS, 1));

                // 读取产品码 (10个寄存器)
                var productCodeData = await Task.Run(() => 
                    _modbusClient.ReadHoldingRegisters(PRODUCT_CODE_START_ADDRESS, 10));

                // 读取测试结果
                var testResultData = await Task.Run(() => 
                    _modbusClient.ReadHoldingRegisters(TEST_RESULT_ADDRESS, 1));

                // 读取时间戳 (7个寄存器)
                var timestampData = await Task.Run(() => 
                    _modbusClient.ReadHoldingRegisters(TIMESTAMP_START_ADDRESS, 7));

                // 读取测量数据 (16个寄存器，从D6033到D6048)
                var measurementData = await Task.Run(() => 
                    _modbusClient.ReadHoldingRegisters(MEASUREMENT_DATA_START_ADDRESS, 16));

                // 解析并返回数据
                return new PlcData
                {
                    // 控制信号
                    PlcHeartbeat = (byte)controlSignals[0],
                    DataOkSignal = (byte)controlSignals[1],
                    
                    // 产品信息
                    ProductModel = ParseStringFromRegisters(productModelData),
                    TestStation = (byte)testStationData[0],
                    ProductCode = ParseStringFromRegisters(productCodeData),
                    TestResult = (byte)testResultData[0],
                    
                    // 时间戳
                    Timestamp = ParseTimestampFromRegisters(timestampData),
                    
                    // 测量数据 (需要除以100来获得实际值，因为PLC以整数*100方式存储小数)
                    MinInstallSize = measurementData[0] / 100.0,
                    MaxInstallSize = measurementData[2] / 100.0,
                    Stroke = measurementData[4] / 100.0,
                    Speed = measurementData[6] / 100.0,
                    WorkingVoltage = measurementData[8] / 100.0,
                    WorkingCurrent = measurementData[10] / 100.0,
                    WorkingPressure = measurementData[12] / 100.0,
                    UpHallSensor = measurementData[14] / 100.0,
                    
                    ReadTime = DateTime.Now
                };
            }
            catch (Exception ex)
            {
                LogError($"读取PLC数据时发生错误: {ex.Message}");
                throw;
            }
        }

        #endregion

        #region 数据解析方法

        /// <summary>
        /// 从寄存器数组解析字符串 - 大端模式，每个寄存器包含2个字符
        /// </summary>
        /// <param name="registers">寄存器数组</param>
        /// <returns>解析出的字符串</returns>
        private string ParseStringFromRegisters(int[] registers)
        {
            var bytes = new List<byte>();
            
            foreach (var register in registers)
            {
                // 大端模式：高字节在前，低字节在后
                bytes.Add((byte)((register >> 8) & 0xFF)); // 高字节
                bytes.Add((byte)(register & 0xFF));        // 低字节
            }
            
            // 移除空字符并转换为字符串
            var validBytes = bytes.TakeWhile(b => b != 0).ToArray();
            return Encoding.ASCII.GetString(validBytes);
        }

        /// <summary>
        /// 从寄存器数组解析时间戳 - 格式: YYYYMMDDHHMMSS
        /// </summary>
        /// <param name="registers">时间戳寄存器数组(7个寄存器)</param>
        /// <returns>解析出的DateTime</returns>
        private DateTime ParseTimestampFromRegisters(int[] registers)
        {
            try
            {
                // 将寄存器数据转换为字符串
                var timestampString = ParseStringFromRegisters(registers);
                
                // 解析时间戳字符串 (格式: YYYYMMDDHHMMSS)
                if (timestampString.Length >= 14)
                {
                    var year = int.Parse(timestampString.Substring(0, 4));
                    var month = int.Parse(timestampString.Substring(4, 2));
                    var day = int.Parse(timestampString.Substring(6, 2));
                    var hour = int.Parse(timestampString.Substring(8, 2));
                    var minute = int.Parse(timestampString.Substring(10, 2));
                    var second = int.Parse(timestampString.Substring(12, 2));
                    
                    return new DateTime(year, month, day, hour, minute, second);
                }
                
                LogWarning($"时间戳格式无效: {timestampString}");
                return DateTime.MinValue;
            }
            catch (Exception ex)
            {
                LogError($"解析时间戳失败: {ex.Message}");
                return DateTime.MinValue;
            }
        }

        #endregion

        #region 数据发送方法

        /// <summary>
        /// 向PLC发送数据读取确认信号
        /// </summary>
        private async Task SendDataReadConfirmationAsync()
        {
            try
            {
                // 向PLC发送确认信号 (置1表示MES已成功读取数据)
                await Task.Run(() => 
                    _modbusClient.WriteSingleRegister(MES_DATA_OK_ADDRESS, 1));
                
                LogDebug("已向PLC发送数据读取确认信号");
            }
            catch (Exception ex)
            {
                LogError($"发送数据确认信号失败: {ex.Message}");
                throw;
            }
        }

        #endregion

        #region 错误处理方法

        /// <summary>
        /// 处理连接丢失
        /// </summary>
        private async Task HandleConnectionLoss()
        {
            if (_isConnected)
            {
                LogWarning("检测到连接丢失，正在尝试重新连接...");
                
                Disconnect();
                
                // 等待3秒后重试连接
                await Task.Delay(3000);
                
                if (!_cancellationTokenSource.Token.IsCancellationRequested)
                {
                    await ConnectAsync();
                }
            }
        }

        #endregion

        #region 日志方法

        private void LogInfo(string message)
        {
            Console.WriteLine($"[INFO] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
        }

        private void LogWarning(string message)
        {
            Console.WriteLine($"[WARN] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
        }

        private void LogError(string message)
        {
            Console.WriteLine($"[ERROR] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
            ErrorOccurred?.Invoke(this, message);
        }

        private void LogDebug(string message)
        {
            Console.WriteLine($"[DEBUG] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
        }

        #endregion

        #region IDisposable实现

        public void Dispose()
        {
            _cancellationTokenSource?.Cancel();
            
            _heartbeatTimer?.Stop();
            _heartbeatTimer?.Dispose();
            
            _dataPollingTimer?.Stop();
            _dataPollingTimer?.Dispose();
            
            Disconnect();
            
            // EasyModbus的ModbusClient没有实现IDisposable接口
            _modbusClient = null;
            _cancellationTokenSource?.Dispose();
        }

        #endregion
    }

    /// <summary>
    /// PLC数据结构 - 包含从PLC读取的所有数据
    /// </summary>
    public class PlcData
    {
        /// <summary>
        /// PLC心跳包状态 (0或1)
        /// </summary>
        public byte PlcHeartbeat { get; set; }
        
        /// <summary>
        /// PLC数据准备就绪信号 (1表示数据已准备好)
        /// </summary>
        public byte DataOkSignal { get; set; }
        
        /// <summary>
        /// 产品型号 (10字节字符串)
        /// </summary>
        public string ProductModel { get; set; } = string.Empty;
        
        /// <summary>
        /// 测试工位号
        /// </summary>
        public byte TestStation { get; set; }
        
        /// <summary>
        /// 产品码 (10字节字符串)
        /// </summary>
        public string ProductCode { get; set; } = string.Empty;
        
        /// <summary>
        /// 测试结果 (1表示通过，0表示失败)
        /// </summary>
        public byte TestResult { get; set; }
        
        /// <summary>
        /// 记录时间戳
        /// </summary>
        public DateTime Timestamp { get; set; }
        
        /// <summary>
        /// 最小安装尺寸 (毫米，保留2位小数)
        /// </summary>
        public double MinInstallSize { get; set; }
        
        /// <summary>
        /// 最大安装尺寸 (毫米，保留2位小数)
        /// </summary>
        public double MaxInstallSize { get; set; }
        
        /// <summary>
        /// 行程 (毫米，保留2位小数)
        /// </summary>
        public double Stroke { get; set; }
        
        /// <summary>
        /// 速度 (单位根据具体需求确定，保留2位小数)
        /// </summary>
        public double Speed { get; set; }
        
        /// <summary>
        /// 工作电压 (伏特，保留2位小数)
        /// </summary>
        public double WorkingVoltage { get; set; }
        
        /// <summary>
        /// 工作电流 (安培，保留2位小数)
        /// </summary>
        public double WorkingCurrent { get; set; }
        
        /// <summary>
        /// 工作压力 (压力单位，保留2位小数)
        /// </summary>
        public double WorkingPressure { get; set; }
        
        /// <summary>
        /// 上升霍尔传感器读数 (保留2位小数)
        /// </summary>
        public double UpHallSensor { get; set; }
        
        /// <summary>
        /// 数据读取时间 (本地时间)
        /// </summary>
        public DateTime ReadTime { get; set; }
    }
}