#include "modbusmanager.h"
#include <QThread>

ModbusManager::ModbusManager(RegisterManager* regManager, QObject *parent)
    : QObject(parent)
{
    modbusThread = new QThread(this);
    worker = new ModbusWorker(regManager);
    pollTimer = new QTimer(this);
    worker->moveToThread(modbusThread);

    // 连接工作线程信号
    connect(worker, &ModbusWorker::connectionStatusChanged,
            this, &ModbusManager::connectionStatusChanged);
    connect(worker, &ModbusWorker::errorOccurred,
            this, &ModbusManager::errorOccurred);
    connect(worker, &ModbusWorker::registerValueUpdated,
            this, &ModbusManager::registerValueUpdated);

    connect(pollTimer, &QTimer::timeout, this, &ModbusManager::readRegisters);
    connect(modbusThread, &QThread::started, worker, &ModbusWorker::initModbusDevice);

    modbusThread->start();
}

ModbusManager::~ModbusManager()
{
    modbusThread->quit();
    modbusThread->wait();
    delete worker;
    pollTimer->stop();
}

void ModbusManager::connectToDevice(const QString& portName,
                         QSerialPort::BaudRate baudRate,
                         QSerialPort::DataBits dataBits,
                         QSerialPort::Parity parity,
                         QSerialPort::StopBits stopBits)
{
    QMetaObject::invokeMethod(worker, "connectToDevice", Qt::QueuedConnection,
                              Q_ARG(QString, portName),
                              Q_ARG(QSerialPort::BaudRate, baudRate),
                              Q_ARG(QSerialPort::DataBits, dataBits),
                              Q_ARG(QSerialPort::Parity, parity),
                              Q_ARG(QSerialPort::StopBits, stopBits));
}

void ModbusManager::disconnectDevice()
{
    QMetaObject::invokeMethod(worker, "disconnectDevice", Qt::QueuedConnection);
}

void ModbusManager::startSimulation(int interval)
{
    pollTimer->start(interval);
}

void ModbusManager::stopSimulation()
{
    pollTimer->stop();
}

void ModbusManager::writeRegister(const QString& registerId, quint16 value)
{
    QMetaObject::invokeMethod(worker, "writeRegister", Qt::QueuedConnection,
                              Q_ARG(QString, registerId),
                              Q_ARG(quint16, value));
}

void ModbusManager::readRegisters()
{
    QMetaObject::invokeMethod(worker, "readRegisters", Qt::QueuedConnection);
}