mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "registerdialog.h"
#include "triggerdialog.h"
#include <QFileDialog>
#include <QMessageBox>
#include <QSerialPortInfo>
#include <QSerialPort>
#include <QDateTime>
#include <QInputDialog>
#include <QtEndian>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    m_modbusClient(nullptr),
    m_pollTimer(new QTimer(this)),
    m_isConnected(false)
{
    ui->setupUi(this);
    setupUi();
    
    connect(m_pollTimer, &QTimer::timeout, this, &MainWindow::onPollTimerTimeout);
    
    newProject();
    updateConnectionControls();
}

MainWindow::~MainWindow()
{
    if (m_modbusClient) {
        m_modbusClient->disconnectDevice();
        delete m_modbusClient;
    }
    delete ui;
}

void MainWindow::setupUi()
{
    // Connect menu actions
    connect(ui->actionNew, &QAction::triggered, this, &MainWindow::onNewProject);
    connect(ui->actionOpen, &QAction::triggered, this, &MainWindow::onOpenProject);
    connect(ui->actionSave, &QAction::triggered, this, &MainWindow::onSaveProject);
    connect(ui->actionSaveAs, &QAction::triggered, this, &MainWindow::onSaveProjectAs);
    connect(ui->actionExit, &QAction::triggered, this, &QWidget::close);
    
    // Connect connection controls
    connect(ui->connectButton, &QPushButton::clicked, this, &MainWindow::onConnect);
    connect(ui->disconnectButton, &QPushButton::clicked, this, &MainWindow::onDisconnect);
    connect(ui->connectionTypeCombo, SIGNAL(currentIndexChanged(int)), 
            this, SLOT(onConnectionTypeChanged(int)));
    
    // Connect register controls
    connect(ui->addRegisterButton, &QPushButton::clicked, this, &MainWindow::onAddRegister);
    connect(ui->editRegisterButton, &QPushButton::clicked, this, &MainWindow::onEditRegister);
    connect(ui->removeRegisterButton, &QPushButton::clicked, this, &MainWindow::onRemoveRegister);
    connect(ui->registerTable, &QTableWidget::itemSelectionChanged, 
            this, &MainWindow::onRegisterTableSelectionChanged);
    connect(ui->registerTable, &QTableWidget::cellDoubleClicked,
            this, &MainWindow::onRegisterTableDoubleClicked);
    
    // Connect read/write controls
    connect(ui->readAllButton, &QPushButton::clicked, this, &MainWindow::onReadAll);
    connect(ui->readSelectedButton, &QPushButton::clicked, this, &MainWindow::onReadSelected);
    connect(ui->writeSelectedButton, &QPushButton::clicked, this, &MainWindow::onWriteSelected);
    
    // Connect trigger controls
    connect(ui->addTriggerButton, &QPushButton::clicked, this, &MainWindow::onAddTrigger);
    connect(ui->editTriggerButton, &QPushButton::clicked, this, &MainWindow::onEditTrigger);
    connect(ui->removeTriggerButton, &QPushButton::clicked, this, &MainWindow::onRemoveTrigger);
    connect(ui->triggerTable, &QTableWidget::itemSelectionChanged,
            this, &MainWindow::onTriggerTableSelectionChanged);
    
    // Connect polling controls
    connect(ui->startPollingButton, &QPushButton::clicked, this, &MainWindow::onStartPolling);
    connect(ui->stopPollingButton, &QPushButton::clicked, this, &MainWindow::onStopPolling);
    
    // Setup register table
    ui->registerTable->setColumnCount(6);
    ui->registerTable->setHorizontalHeaderLabels(
        QStringList() << "Name" << "Type" << "Address" << "Data Type" << "Value" << "Status");
    ui->registerTable->horizontalHeader()->setStretchLastSection(true);
    ui->registerTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    
    // Setup trigger table
    ui->triggerTable->setColumnCount(4);
    ui->triggerTable->setHorizontalHeaderLabels(
        QStringList() << "Register" << "Condition" << "Value" << "Action");
    ui->triggerTable->horizontalHeader()->setStretchLastSection(true);
    ui->triggerTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    
    // Populate serial ports
    const auto ports = QSerialPortInfo::availablePorts();
    for (const QSerialPortInfo &port : ports) {
        ui->serialPortCombo->addItem(port.portName());
    }
    
    // Populate baud rates
    ui->baudRateCombo->addItems({"9600", "19200", "38400", "57600", "115200"});
    ui->baudRateCombo->setCurrentText("9600");
    
    // Populate parity
    ui->parityCombo->addItems({"None", "Even", "Odd"});
}

void MainWindow::onNewProject()
{
    if (!m_currentProjectFile.isEmpty()) {
        auto reply = QMessageBox::question(this, "New Project",
            "Current project will be closed. Save changes?",
            QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
            
        if (reply == QMessageBox::Cancel) {
            return;
        } else if (reply == QMessageBox::Yes) {
            if (!saveCurrentProject()) {
                return;
            }
        }
    }
    
    newProject();
}

void MainWindow::onOpenProject()
{
    QString filename = QFileDialog::getOpenFileName(this, "Open Project",
        QString(), "Modbus Project Files (*.mbproj)");
        
    if (!filename.isEmpty()) {
        loadProject(filename);
    }
}

void MainWindow::onSaveProject()
{
    saveCurrentProject();
}

void MainWindow::onSaveProjectAs()
{
    QString filename = QFileDialog::getSaveFileName(this, "Save Project As",
        QString(), "Modbus Project Files (*.mbproj)");
        
    if (!filename.isEmpty()) {
        if (!filename.endsWith(".mbproj")) {
            filename += ".mbproj";
        }
        m_currentProjectFile = filename;
        saveCurrentProject();
    }
}

void MainWindow::onConnect()
{
    createModbusClient();
    
    if (connectDevice()) {
        m_isConnected = true;
        updateConnectionControls();
        log("Connected to Modbus device", "success");
    } else {
        log("Failed to connect to Modbus device", "error");
    }
}

void MainWindow::onDisconnect()
{
    if (m_modbusClient) {
        m_modbusClient->disconnectDevice();
        m_isConnected = false;
        updateConnectionControls();
        log("Disconnected from Modbus device", "info");
    }
    
    onStopPolling();
}

void MainWindow::onConnectionTypeChanged(int index)
{
    ui->tcpSettingsWidget->setVisible(index == 0);
    ui->rtuSettingsWidget->setVisible(index == 1);
}

void MainWindow::onAddRegister()
{
    RegisterDialog dialog(this);
    if (dialog.exec() == QDialog::Accepted) {
        ModbusRegister reg = dialog.getRegister();
        m_project.addRegister(reg);
        updateRegisterTable();
        log("Register added: " + reg.name(), "info");
    }
}

void MainWindow::onEditRegister()
{
    int row = ui->registerTable->currentRow();
    if (row < 0) return;
    
    int regIndex = m_rowToRegisterIndex[row];
    ModbusRegister reg = m_project.registers()[regIndex];
    
    RegisterDialog dialog(this);
    dialog.setRegister(reg);
    
    if (dialog.exec() == QDialog::Accepted) {
        ModbusRegister updatedReg = dialog.getRegister();
        m_project.updateRegister(regIndex, updatedReg);
        updateRegisterTable();
        log("Register updated: " + updatedReg.name(), "info");
    }
}

void MainWindow::onRemoveRegister()
{
    int row = ui->registerTable->currentRow();
    if (row < 0) return;
    
    int regIndex = m_rowToRegisterIndex[row];
    QString name = m_project.registers()[regIndex].name();
    
    auto reply = QMessageBox::question(this, "Remove Register",
        QString("Remove register '%1'?").arg(name),
        QMessageBox::Yes | QMessageBox::No);
        
    if (reply == QMessageBox::Yes) {
        m_project.removeRegister(regIndex);
        updateRegisterTable();
        log("Register removed: " + name, "info");
    }
}

void MainWindow::onRegisterTableSelectionChanged()
{
    bool hasSelection = ui->registerTable->currentRow() >= 0;
    ui->editRegisterButton->setEnabled(hasSelection);
    ui->removeRegisterButton->setEnabled(hasSelection);
    ui->readSelectedButton->setEnabled(hasSelection && m_isConnected);
    ui->writeSelectedButton->setEnabled(hasSelection && m_isConnected);
}

void MainWindow::onRegisterTableDoubleClicked(int row, int column)
{
    if (column == 4) { // Value column
        int regIndex = m_rowToRegisterIndex[row];
        const ModbusRegister &reg = m_project.registers()[regIndex];
        
        if (!reg.isReadOnly() && m_isConnected) {
            bool ok;
            QString newValue = QInputDialog::getText(this, "Write Value",
                QString("Enter new value for '%1':").arg(reg.name()),
                QLineEdit::Normal, reg.value().toString(), &ok);
                
            if (ok) {
                QVariant value;
                switch (reg.dataType()) {
                case DataType::Bool:
                    value = (newValue.toLower() == "true" || newValue == "1");
                    break;
                case DataType::Int16:
                case DataType::Int32:
                    value = newValue.toInt();
                    break;
                case DataType::Uint16:
                case DataType::Uint32:
                    value = newValue.toUInt();
                    break;
                case DataType::Float32:
                    value = newValue.toFloat();
                    break;
                }
                
                writeRegister(reg, value);
            }
        }
    }
}

void MainWindow::onReadAll()
{
    if (!m_isConnected) return;
    
    log("Reading all registers...", "info");
    
    for (int i = 0; i < m_project.registers().size(); ++i) {
        readRegister(m_project.registers()[i], i);
    }
}

void MainWindow::onReadSelected()
{
    if (!m_isConnected) return;
    
    int row = ui->registerTable->currentRow();
    if (row < 0) return;
    
    int regIndex = m_rowToRegisterIndex[row];
    const ModbusRegister &reg = m_project.registers()[regIndex];
    
    log("Reading register: " + reg.name(), "info");
    readRegister(reg, row);
}

void MainWindow::onWriteSelected()
{
    if (!m_isConnected) return;
    
    int row = ui->registerTable->currentRow();
    if (row < 0) return;
    
    int regIndex = m_rowToRegisterIndex[row];
    const ModbusRegister &reg = m_project.registers()[regIndex];
    
    if (reg.isReadOnly()) {
        QMessageBox::warning(this, "Write Error", "Register is read-only");
        return;
    }
    
    onRegisterTableDoubleClicked(row, 4);
}

void MainWindow::onAddTrigger()
{
    if (m_project.registers().isEmpty()) {
        QMessageBox::information(this, "Add Trigger",
            "Please add some registers first before creating triggers.");
        return;
    }
    
    TriggerDialog dialog(m_project.registers(), this);
    if (dialog.exec() == QDialog::Accepted) {
        TriggerCondition trigger = dialog.getTrigger();
        m_project.addTrigger(trigger);
        updateTriggerTable();
        log("Trigger added for: " + trigger.registerName, "info");
    }
}

void MainWindow::onEditTrigger()
{
    int row = ui->triggerTable->currentRow();
    if (row < 0 || row >= m_project.triggers().size()) return;
    
    TriggerDialog dialog(m_project.registers(), this);
    dialog.setTrigger(m_project.triggers()[row]);
    
    if (dialog.exec() == QDialog::Accepted) {
        m_project.triggers()[row] = dialog.getTrigger();
        updateTriggerTable();
        log("Trigger updated", "info");
    }
}

void MainWindow::onRemoveTrigger()
{
    int row = ui->triggerTable->currentRow();
    if (row < 0) return;
    
    m_project.removeTrigger(row);
    updateTriggerTable();
    log("Trigger removed", "info");
}

void MainWindow::onTriggerTableSelectionChanged()
{
    bool hasSelection = ui->triggerTable->currentRow() >= 0;
    ui->editTriggerButton->setEnabled(hasSelection);
    ui->removeTriggerButton->setEnabled(hasSelection);
}

void MainWindow::onStartPolling()
{
    if (!m_isConnected) {
        QMessageBox::warning(this, "Polling", "Not connected to Modbus device");
        return;
    }
    
    int interval = ui->pollIntervalSpin->value();
    if (interval < 100) interval = 100;
    
    m_pollTimer->start(interval);
    ui->startPollingButton->setEnabled(false);
    ui->stopPollingButton->setEnabled(true);
    ui->pollIntervalSpin->setEnabled(false);
    
    log(QString("Polling started (interval: %1 ms)").arg(interval), "success");
}

void MainWindow::onStopPolling()
{
    m_pollTimer->stop();
    ui->startPollingButton->setEnabled(true);
    ui->stopPollingButton->setEnabled(false);
    ui->pollIntervalSpin->setEnabled(true);
    
    log("Polling stopped", "info");
}

void MainWindow::onPollTimerTimeout()
{
    // Read registers that have polling enabled
    for (int i = 0; i < m_project.registers().size(); ++i) {
        const ModbusRegister &reg = m_project.registers()[i];
        if (reg.pollInterval() > 0) {
            readRegister(reg, i);
        }
    }
    
    evaluateTriggers();
}

void MainWindow::onReadFinished()
{
    auto reply = qobject_cast<QModbusReply *>(sender());
    if (!reply) return;
    
    int row = m_pendingReads.value(reply, -1);
    
    if (reply->error() == QModbusDevice::NoError) {
        const QModbusDataUnit unit = reply->result();
        
        if (row >= 0 && row < ui->registerTable->rowCount()) {
            int regIndex = m_rowToRegisterIndex[row];
            const ModbusRegister &reg = m_project.registers()[regIndex];
            
            QVector<quint16> values;
            for (uint i = 0; i < unit.valueCount(); ++i) {
                values.append(unit.value(i));
            }
            
            QVariant value = registersToVariant(values, reg.dataType());
            
            // Update the register in the project
            ModbusRegister updatedReg = reg;
            updatedReg.setValue(value);
            m_project.updateRegister(regIndex, updatedReg);
            
            updateRegisterValue(row, value);
            
            ui->registerTable->item(row, 5)->setText("OK");
            ui->registerTable->item(row, 5)->setForeground(Qt::darkGreen);
        }
    } else {
        if (row >= 0) {
            ui->registerTable->item(row, 5)->setText("Error: " + reply->errorString());
            ui->registerTable->item(row, 5)->setForeground(Qt::red);
            log("Read error: " + reply->errorString(), "error");
        }
    }
    
    m_pendingReads.remove(reply);
    reply->deleteLater();
}

void MainWindow::onWriteFinished()
{
    auto reply = qobject_cast<QModbusReply *>(sender());
    if (!reply) return;
    
    int row = m_pendingWrites.value(reply, -1);
    
    if (reply->error() == QModbusDevice::NoError) {
        if (row >= 0) {
            ui->registerTable->item(row, 5)->setText("Written");
            ui->registerTable->item(row, 5)->setForeground(Qt::darkGreen);
            
            int regIndex = m_rowToRegisterIndex[row];
            log("Write successful: " + m_project.registers()[regIndex].name(), "success");
        }
    } else {
        if (row >= 0) {
            ui->registerTable->item(row, 5)->setText("Write Error");
            ui->registerTable->item(row, 5)->setForeground(Qt::red);
        }
        log("Write error: " + reply->errorString(), "error");
    }
    
    m_pendingWrites.remove(reply);
    reply->deleteLater();
}

void MainWindow::onModbusError(QModbusDevice::Error error)
{
    if (error != QModbusDevice::NoError) {
        log("Modbus error: " + m_modbusClient->errorString(), "error");
    }
}

void MainWindow::onModbusStateChanged(QModbusDevice::State state)
{
    QString stateStr;
    switch (state) {
    case QModbusDevice::UnconnectedState:
        stateStr = "Disconnected";
        m_isConnected = false;
        break;
    case QModbusDevice::ConnectingState:
        stateStr = "Connecting...";
        break;
    case QModbusDevice::ConnectedState:
        stateStr = "Connected";
        m_isConnected = true;
        break;
    case QModbusDevice::ClosingState:
        stateStr = "Closing...";
        break;
    }
    
    ui->statusBar->showMessage(stateStr);
    updateConnectionControls();
}

void MainWindow::updateConnectionControls()
{
    ui->connectButton->setEnabled(!m_isConnected);
    ui->disconnectButton->setEnabled(m_isConnected);
    ui->readAllButton->setEnabled(m_isConnected && !m_project.registers().isEmpty());
    ui->readSelectedButton->setEnabled(m_isConnected && ui->registerTable->currentRow() >= 0);
    ui->writeSelectedButton->setEnabled(m_isConnected && ui->registerTable->currentRow() >= 0);
    ui->startPollingButton->setEnabled(m_isConnected && !m_pollTimer->isActive());
    ui->stopPollingButton->setEnabled(m_pollTimer->isActive());
}

void MainWindow::updateRegisterTable()
{
    ui->registerTable->clearContents();
    ui->registerTable->setRowCount(m_project.registers().size());
    m_rowToRegisterIndex.clear();
    
    for (int i = 0; i < m_project.registers().size(); ++i) {
        const ModbusRegister &reg = m_project.registers()[i];
        m_rowToRegisterIndex[i] = i;
        
        ui->registerTable->setItem(i, 0, new QTableWidgetItem(reg.name()));
        ui->registerTable->setItem(i, 1, new QTableWidgetItem(reg.registerTypeString()));
        ui->registerTable->setItem(i, 2, new QTableWidgetItem(QString::number(reg.address())));
        ui->registerTable->setItem(i, 3, new QTableWidgetItem(reg.dataTypeString()));
        ui->registerTable->setItem(i, 4, new QTableWidgetItem(reg.value().toString()));
        ui->registerTable->setItem(i, 5, new QTableWidgetItem("Not Read"));
    }
}

void MainWindow::updateTriggerTable()
{
    ui->triggerTable->clearContents();
    ui->triggerTable->setRowCount(m_project.triggers().size());
    
    for (int i = 0; i < m_project.triggers().size(); ++i) {
        const TriggerCondition &trigger = m_project.triggers()[i];
        
        ui->triggerTable->setItem(i, 0, new QTableWidgetItem(trigger.registerName));
        ui->triggerTable->setItem(i, 1, new QTableWidgetItem(trigger.condition));
        ui->triggerTable->setItem(i, 2, new QTableWidgetItem(trigger.value.toString()));
        ui->triggerTable->setItem(i, 3, new QTableWidgetItem(trigger.action));
    }
}

void MainWindow::updateRegisterValue(int row, const QVariant &value)
{
    if (row >= 0 && row < ui->registerTable->rowCount()) {
        QString valueStr;
        if (value.type() == QVariant::Bool) {
            valueStr = value.toBool() ? "true" : "false";
        } else {
            valueStr = value.toString();
        }
        ui->registerTable->item(row, 4)->setText(valueStr);
    }
}

void MainWindow::log(const QString &message, const QString &type)
{
    QString timestamp = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
    QString color = "black";
    
    if (type == "error") color = "red";
    else if (type == "success") color = "green";
    else if (type == "warning") color = "orange";
    
    QString html = QString("<font color='%1'>[%2] %3</font>")
                   .arg(color, timestamp, message);
    
    ui->logText->append(html);
}

void MainWindow::createModbusClient()
{
    destroyModbusClient();
    
    if (ui->connectionTypeCombo->currentIndex() == 0) {
        // TCP
        m_modbusClient = new QModbusTcpClient(this);
    } else {
        // RTU
        m_modbusClient = new QModbusRtuSerialMaster(this);
    }
    
    connect(m_modbusClient, &QModbusClient::errorOccurred,
            this, &MainWindow::onModbusError);
    connect(m_modbusClient, &QModbusClient::stateChanged,
            this, &MainWindow::onModbusStateChanged);
    
    m_modbusClient->setTimeout(ui->timeoutSpin->value());
    m_modbusClient->setNumberOfRetries(ui->retriesSpin->value());
}

void MainWindow::destroyModbusClient()
{
    if (m_modbusClient) {
        m_modbusClient->disconnectDevice();
        delete m_modbusClient;
        m_modbusClient = nullptr;
    }
}

bool MainWindow::connectDevice()
{
    if (!m_modbusClient) return false;
    
    if (ui->connectionTypeCombo->currentIndex() == 0) {
        // TCP
        m_modbusClient->setConnectionParameter(QModbusDevice::NetworkPortParameter,
                                               ui->portSpin->value());
        m_modbusClient->setConnectionParameter(QModbusDevice::NetworkAddressParameter,
                                               ui->hostEdit->text());
    } else {
        // RTU
        m_modbusClient->setConnectionParameter(QModbusDevice::SerialPortNameParameter,
                                               ui->serialPortCombo->currentText());
        m_modbusClient->setConnectionParameter(QModbusDevice::SerialBaudRateParameter,
                                               ui->baudRateCombo->currentText().toInt());
        m_modbusClient->setConnectionParameter(QModbusDevice::SerialDataBitsParameter,
                                               ui->dataBitsSpin->value());
        m_modbusClient->setConnectionParameter(QModbusDevice::SerialStopBitsParameter,
                                               ui->stopBitsSpin->value());
        
        QSerialPort::Parity parity = QSerialPort::NoParity;
        if (ui->parityCombo->currentText() == "Even") parity = QSerialPort::EvenParity;
        else if (ui->parityCombo->currentText() == "Odd") parity = QSerialPort::OddParity;
        m_modbusClient->setConnectionParameter(QModbusDevice::SerialParityParameter, parity);
    }
    
    return m_modbusClient->connectDevice();
}

void MainWindow::readRegister(const ModbusRegister &reg, int tableRow)
{
    if (!m_modbusClient || m_modbusClient->state() != QModbusDevice::ConnectedState) {
        return;
    }
    
    QModbusDataUnit::RegisterType regType = reg.toModbusRegisterType();
    int count = reg.registerCount();
    
    QModbusDataUnit readUnit(regType, reg.address(), count);
    
    if (auto *reply = m_modbusClient->sendReadRequest(readUnit, ui->slaveIdSpin->value())) {
        if (!reply->isFinished()) {
            connect(reply, &QModbusReply::finished, this, &MainWindow::onReadFinished);
            m_pendingReads[reply] = tableRow;
        } else {
            delete reply;
        }
    }
}

void MainWindow::writeRegister(const ModbusRegister &reg, const QVariant &value)
{
    if (!m_modbusClient || m_modbusClient->state() != QModbusDevice::ConnectedState) {
        return;
    }
    
    QModbusDataUnit::RegisterType regType = reg.toModbusRegisterType();
    QVector<quint16> values = variantToRegisters(value, reg.dataType());
    
    QModbusDataUnit writeUnit(regType, reg.address(), values);
    
    // Find the table row for this register
    int tableRow = -1;
    for (auto it = m_rowToRegisterIndex.begin(); it != m_rowToRegisterIndex.end(); ++it) {
        if (m_project.registers()[it.value()].address() == reg.address() &&
            m_project.registers()[it.value()].registerType() == reg.registerType()) {
            tableRow = it.key();
            break;
        }
    }
    
    if (auto *reply = m_modbusClient->sendWriteRequest(writeUnit, ui->slaveIdSpin->value())) {
        if (!reply->isFinished()) {
            connect(reply, &QModbusReply::finished, this, &MainWindow::onWriteFinished);
            m_pendingWrites[reply] = tableRow;
        } else {
            delete reply;
        }
    }
}

QVector<quint16> MainWindow::variantToRegisters(const QVariant &value, DataType dataType)
{
    QVector<quint16> regs;
    
    switch (dataType) {
    case DataType::Bool:
        regs.append(value.toBool() ? 1 : 0);
        break;
    case DataType::Uint16:
        regs.append(value.toUInt());
        break;
    case DataType::Int16:
        regs.append(static_cast<quint16>(value.toInt()));
        break;
    case DataType::Uint32: {
        quint32 val = value.toUInt();
        regs.append(static_cast<quint16>(val >> 16));
        regs.append(static_cast<quint16>(val & 0xFFFF));
        break;
    }
    case DataType::Int32: {
        qint32 val = value.toInt();
        quint32 uval = *reinterpret_cast<quint32*>(&val);
        regs.append(static_cast<quint16>(uval >> 16));
        regs.append(static_cast<quint16>(uval & 0xFFFF));
        break;
    }
    case DataType::Float32: {
        float val = value.toFloat();
        quint32 uval = *reinterpret_cast<quint32*>(&val);
        regs.append(static_cast<quint16>(uval >> 16));
        regs.append(static_cast<quint16>(uval & 0xFFFF));
        break;
    }
    }
    
    return regs;
}

QVariant MainWindow::registersToVariant(const QVector<quint16> &regs, DataType dataType)
{
    if (regs.isEmpty()) return QVariant();
    
    switch (dataType) {
    case DataType::Bool:
        return regs[0] != 0;
    case DataType::Uint16:
        return regs[0];
    case DataType::Int16:
        return static_cast<qint16>(regs[0]);
    case DataType::Uint32:
        if (regs.size() >= 2) {
            return (static_cast<quint32>(regs[0]) << 16) | regs[1];
        }
        break;
    case DataType::Int32:
        if (regs.size() >= 2) {
            quint32 uval = (static_cast<quint32>(regs[0]) << 16) | regs[1];
            return *reinterpret_cast<qint32*>(&uval);
        }
        break;
    case DataType::Float32:
        if (regs.size() >= 2) {
            quint32 uval = (static_cast<quint32>(regs[0]) << 16) | regs[1];
            return *reinterpret_cast<float*>(&uval);
        }
        break;
    }
    
    return QVariant();
}

void MainWindow::evaluateTriggers()
{
    for (const TriggerCondition &trigger : m_project.triggers()) {
        // Find the register
        for (int i = 0; i < m_project.registers().size(); ++i) {
            const ModbusRegister &reg = m_project.registers()[i];
            if (reg.name() == trigger.registerName) {
                if (evaluateCondition(reg.value(), trigger.condition, trigger.value)) {
                    log(QString("TRIGGER: %1 %2 %3 -> %4")
                        .arg(trigger.registerName)
                        .arg(trigger.condition)
                        .arg(trigger.value.toString())
                        .arg(trigger.action), "warning");
                }
                break;
            }
        }
    }
}

bool MainWindow::evaluateCondition(const QVariant &regValue, const QString &condition, const QVariant &triggerValue)
{
    double regVal = regValue.toDouble();
    double trigVal = triggerValue.toDouble();
    
    if (condition == "==") return qFuzzyCompare(regVal, trigVal);
    if (condition == "!=") return !qFuzzyCompare(regVal, trigVal);
    if (condition == ">") return regVal > trigVal;
    if (condition == "<") return regVal < trigVal;
    if (condition == ">=") return regVal >= trigVal;
    if (condition == "<=") return regVal <= trigVal;
    
    return false;
}

void MainWindow::newProject()
{
    m_project = ModbusProject();
    m_project.setName("Untitled");
    m_currentProjectFile.clear();
    
    applyProjectToUi();
    updateRegisterTable();
    updateTriggerTable();
    
    setWindowTitle("QModbusUniversal - New Project");
}

void MainWindow::loadProject(const QString &filename)
{
    ModbusProject project;
    if (project.loadFromFile(filename)) {
        m_project = project;
        m_currentProjectFile = filename;
        applyProjectToUi();
        updateRegisterTable();
        updateTriggerTable();
        setWindowTitle("QModbusUniversal - " + QFileInfo(filename).fileName());
        log("Project loaded: " + filename, "success");
    } else {
        QMessageBox::critical(this, "Load Error", "Failed to load project file");
    }
}

bool MainWindow::saveCurrentProject()
{
    if (m_currentProjectFile.isEmpty()) {
        QString filename = QFileDialog::getSaveFileName(this, "Save Project",
            QString(), "Modbus Project Files (*.mbproj)");
            
        if (filename.isEmpty()) return false;
        
        if (!filename.endsWith(".mbproj")) {
            filename += ".mbproj";
        }
        m_currentProjectFile = filename;
    }
    
    // Update project from UI
    m_project.setConnectionType(ui->connectionTypeCombo->currentIndex() == 0 ? 
                                ConnectionType::TCP : ConnectionType::RTU);
    m_project.setTcpHost(ui->hostEdit->text());
    m_project.setTcpPort(ui->portSpin->value());
    m_project.setRtuPort(ui->serialPortCombo->currentText());
    m_project.setRtuBaudRate(ui->baudRateCombo->currentText().toInt());
    m_project.setSlaveId(ui->slaveIdSpin->value());
    m_project.setTimeout(ui->timeoutSpin->value());
    m_project.setRetries(ui->retriesSpin->value());
    
    if (m_project.saveToFile(m_currentProjectFile)) {
        setWindowTitle("QModbusUniversal - " + QFileInfo(m_currentProjectFile).fileName());
        log("Project saved: " + m_currentProjectFile, "success");
        return true;
    } else {
        QMessageBox::critical(this, "Save Error", "Failed to save project file");
        return false;
    }
}

void MainWindow::applyProjectToUi()
{
    ui->connectionTypeCombo->setCurrentIndex(
        m_project.connectionType() == ConnectionType::TCP ? 0 : 1);
    ui->hostEdit->setText(m_project.tcpHost());
    ui->portSpin->setValue(m_project.tcpPort());
    
    int portIdx = ui->serialPortCombo->findText(m_project.rtuPort());
    if (portIdx >= 0) ui->serialPortCombo->setCurrentIndex(portIdx);
    
    ui->baudRateCombo->setCurrentText(QString::number(m_project.rtuBaudRate()));
    ui->slaveIdSpin->setValue(m_project.slaveId());
    ui->timeoutSpin->setValue(m_project.timeout());
    ui->retriesSpin->setValue(m_project.retries());
    
    onConnectionTypeChanged(ui->connectionTypeCombo->currentIndex());
}