#ifndef MODBUS_TCP_CLIENT_H
#define MODBUS_TCP_CLIENT_H

#include "IYModbusTCPClient.h"
#include <memory>
#include <mutex>
#include <atomic>

extern "C" {
#include "modbus.h"
}

/**
 * @brief Modbus TCP 客户端实现类，基于 libmodbus 库
 *
 * 提供完整的 Modbus TCP 客户端功能，包括：
 * - 连接管理
 * - 所有标准 Modbus 功能码支持
 * - 错误处理和重连机制
 * - 数据类型转换
 */
class ModbusTCPClient : public IYModbusTCPClient {
public:
    /**
     * @brief 构造函数
     * @param serverIP 服务器 IP 地址
     * @param serverPort 服务器端口，默认 502
     */
    ModbusTCPClient(const std::string& serverIP, int serverPort = 502);

    /**
     * @brief 析构函数
     */
    virtual ~ModbusTCPClient() override;

    // 禁用拷贝构造和赋值
    ModbusTCPClient(const ModbusTCPClient&) = delete;
    ModbusTCPClient& operator=(const ModbusTCPClient&) = delete;

    // === 实现 IYModbusTCPClient 接口 ===

    virtual bool SetConnectionParams(const std::string& serverIP, int serverPort) override;
    virtual bool SetSlaveId(int slaveId) override;
    virtual bool SetTimeout(int timeoutMs) override;
    virtual void SetConnectionStateCallback(ConnectionStateCallback callback) override;

    virtual Result Connect() override;
    virtual void Disconnect() override;

    virtual ConnectionState GetConnectionState() const override;
    virtual bool IsConnected() const override;

    // === 读操作 ===

    virtual Result ReadCoils(int startAddress, int quantity, std::vector<bool>& values) override;
    virtual Result ReadDiscreteInputs(int startAddress, int quantity, std::vector<bool>& values) override;
    virtual Result ReadHoldingRegisters(int startAddress, int quantity, std::vector<uint16_t>& values) override;
    virtual Result ReadInputRegisters(int startAddress, int quantity, std::vector<uint16_t>& values) override;

    // === 写操作 ===

    virtual Result WriteSingleCoil(int address, bool value) override;
    virtual Result WriteSingleRegister(int address, uint16_t value) override;
    virtual Result WriteMultipleCoils(int startAddress, const std::vector<bool>& values) override;
    virtual Result WriteMultipleRegisters(int startAddress, const std::vector<uint16_t>& values) override;

    // === 组合操作 ===

    virtual Result ReadWriteMultipleRegisters(int readStartAddress, int readQuantity,
                                              int writeStartAddress, const std::vector<uint16_t>& writeValues,
                                              std::vector<uint16_t>& readValues) override;

    // === 错误处理 ===

    virtual std::string GetLastError() const override;

private:
    /**
     * @brief 设置连接状态
     * @param newState 新状态
     * @param message 状态变化消息
     */
    void SetConnectionState(ConnectionState newState, const std::string& message = "");

    /**
     * @brief 检查 modbus 上下文是否有效
     * @return 是否有效
     */
    bool IsModbusContextValid() const;

    /**
     * @brief 将 libmodbus 错误转换为 Result
     * @return 转换后的结果
     */
    Result ConvertLibmodbusError() const;

    /**
     * @brief 设置最后错误信息
     * @param error 错误信息
     */
    void SetLastError(const std::string& error);

private:
    modbus_t* m_modbusContext;                      ///< libmodbus 上下文
    std::string m_serverIP;                         ///< 服务器 IP 地址
    int m_serverPort;                               ///< 服务器端口
    int m_slaveId;                                  ///< 从站 ID
    int m_timeoutMs;                                ///< 超时时间（毫秒）

    std::atomic<ConnectionState> m_connectionState; ///< 连接状态
    ConnectionStateCallback m_stateCallback;        ///< 状态变化回调

    mutable std::mutex m_mutex;                     ///< 互斥锁
    std::string m_lastError;                        ///< 最后错误信息
};

#endif // MODBUS_TCP_CLIENT_H