mainwindow.cpp

#include "mainwindow.h"
#include <QVBoxLayout>
#include <QWidget>
#include <signal.h>
#include <QMouseEvent>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) {
    qRegisterMetaType<SystemStats>("SystemStats"); // Register custom struct

    setupUI();

    // --- Threading Architecture ---
    worker = new SystemWorker();
    worker->moveToThread(&workerThread);

    // When thread starts, tell worker to start polling
    connect(&workerThread, &QThread::started, worker, &SystemWorker::startPolling);

    // Connect worker's signal to UI update slot
    connect(worker, &SystemWorker::statsUpdated, this, &MainWindow::updateUI);

    // Clean up memory when thread quits
    connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);

    workerThread.start();
}

MainWindow::~MainWindow() {
    workerThread.quit();
    workerThread.wait();
}

// Multi-tabbed UI
void MainWindow::setupUI() {
    this->setWindowTitle("System Core Monitor");
    this->resize(450, 150);
    this->setStyleSheet("QMainWindow { background-color: #1e1e2e; }"); // Dark theme

    // Initialize tab widget
    tabWidget = new QTabWidget(this);
    tabWidget->setStyleSheet(
        "QTabBar::tab { background: #313244; color: #cdd6f4; padding: 8px 20px; border: 1px solid #45475a; }"
        "QTabBar::tab:selected { background: #45475a; font-weight: bold; border-bottom-color: #45475a; }"
        "QTabWidget::pane { border: 1px solid #45475a; top: -1px; }"
        "QWidget { background-color: #1e1e2e; }"
        );

    // =======================================
    // TAB: CPU
    // =======================================
    QWidget* cpuTab = new QWidget();
    QVBoxLayout* cpuLayout = new QVBoxLayout(cpuTab);

    cpuLabel = new QLabel("CPU Load: Calculating...", this);
    cpuLabel->setStyleSheet("color: #cdd6f4; font-size: 14px; font-weight: bold;");

    cpuProgressBar = new QProgressBar(this);
    cpuProgressBar->setRange(0, 100);
    cpuProgressBar->setStyleSheet(
        "QProgressBar { border: 1px solid #45475a; border-radius: 5px; background: #313244; color: white; text-align: center; }"
        "QProgressBar::chunk { background-color: #89b4fa; border-radius: 4px; }" // Blue for CPU
        );

    // --- Process Table ---
    cpuProcessTable = new QTableWidget(0, 3, this); // 3 Columns: PID, Name, CPU %
    cpuProcessTable->setHorizontalHeaderLabels({"PID", "Process Name", "CPU (%)"});
    cpuProcessTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    cpuProcessTable->setSelectionMode(QAbstractItemView::SingleSelection);
    cpuProcessTable->horizontalHeader()->setStretchLastSection(true);
    cpuProcessTable->verticalHeader()->setVisible(false);
    cpuProcessTable->viewport()->installEventFilter(this);
    cpuProcessTable->installEventFilter(this);

    cpuProcessTable->setStyleSheet(
        "QTableWidget { background-color: #1e1e2e; color: #cdd6f4; gridline-color: #45475a; border: 1px solid #45475a; }"
        "QHeaderView::section { background-color: #313244; color: white; padding: 4px; border: 1px solid #45475a; font-weight: bold; }"
        "QTableWidget::item:selected { background-color: #89b4fa; color: black; }"
        );

    // --- Kill Button ---
    killCpuProcessButton = new QPushButton("Kill Process (CPU)", this);
    killCpuProcessButton->setEnabled(false);
    killCpuProcessButton->setStyleSheet(
        "QPushButton { background-color: #f38ba8; color: #1e1e2e; font-weight: bold; padding: 8px; border-radius: 4px; }"
        "QPushButton:hover { background-color: #ffb4c8; }"
        "QPushButton:disabled { background-color: #45475a; color: #7f849c; }"
        );

    // Connect the kill process button to the kill process function through lambda bridging
    connect(killCpuProcessButton, &QPushButton::clicked, this, [this]() {
        killProcessFromTable(cpuProcessTable);
    });

    // Table row selection listener; if a row is selected, kill process button is enabled and vice versa
    connect(cpuProcessTable, &QTableWidget::itemSelectionChanged, this, [this]() {
        // check whether any row is highlighted
        bool hasSelection = !cpuProcessTable->selectedItems().isEmpty();

        killCpuProcessButton->setEnabled(hasSelection);
    });

    cpuLayout->addWidget(cpuLabel);
    cpuLayout->addWidget(cpuProgressBar);
    cpuLayout->addWidget(cpuProcessTable);
    cpuLayout->addWidget(killCpuProcessButton);
    cpuLayout->addStretch(); // Pushes UI to the top

    // =======================================
    // TAB: Memory
    // =======================================
    QWidget* ramTab = new QWidget();
    QVBoxLayout* ramLayout = new QVBoxLayout(ramTab);

    ramLabel = new QLabel("RAM Usage: Calculating...", this);
    ramLabel->setStyleSheet("color: #cdd6f4; font-size: 14px; font-weight: bold;");

    ramProgressBar = new QProgressBar(this);
    ramProgressBar->setRange(0, 100);

    ramProgressBar->setStyleSheet(
        "QProgressBar { border: 1px solid #45475a; border-radius: 5px; background: #313244; color: white; text-align: center; }"
        "QProgressBar::chunk { background-color: #a6e3a1; border-radius: 4px; }"
        );

    // --- Process Table ---
    ramProcessTable = new QTableWidget(0, 3, this); // 0 rows, 3 columns
    ramProcessTable->setHorizontalHeaderLabels({"PID", "Process Name", "Memory (MB)"});
    ramProcessTable->setSelectionBehavior(QAbstractItemView::SelectRows); // Select entire row, not individual cells
    ramProcessTable->setSelectionMode(QAbstractItemView::SingleSelection);
    ramProcessTable->horizontalHeader()->setStretchLastSection(true); // Fills the remaining space
    ramProcessTable->verticalHeader()->setVisible(false); // Hide the row numbers on the left
    ramProcessTable->viewport()->installEventFilter(this);
    ramProcessTable->installEventFilter(this);

    ramProcessTable->setStyleSheet(
        "QTableWidget { background-color: #1e1e2e; color: #cdd6f4; gridline-color: #45475a; border: 1px solid #45475a; }"
        "QHeaderView::section { background-color: #313244; color: white; padding: 4px; border: 1px solid #45475a; font-weight: bold; }"
        "QTableWidget::item:selected { background-color: #89b4fa; color: black; }"
        );

    // --- Kill Button ---
    killRamProcessButton = new QPushButton("Kill Selected Process", this);
    killRamProcessButton->setEnabled(false);
    killRamProcessButton->setStyleSheet(
        "QPushButton { background-color: #f38ba8; color: #1e1e2e; font-weight: bold; padding: 8px; border-radius: 4px; }"
        "QPushButton:hover { background-color: #ffb4c8; }"
        "QPushButton:disabled { background-color: #45475a; color: #7f849c; }"
        );

    connect(killRamProcessButton, &QPushButton::clicked, this, [this]() {
        killProcessFromTable(ramProcessTable);
    });

    // Table row selection listener; if a row is selected, kill process button is enabled and vice versa
    connect(ramProcessTable, &QTableWidget::itemSelectionChanged, this, [this]() {
        bool hasSelection = !ramProcessTable->selectedItems().isEmpty();

        killRamProcessButton->setEnabled(hasSelection);
    });

    ramLayout->addWidget(ramLabel);
    ramLayout->addWidget(ramProgressBar);
    ramLayout->addWidget(ramProcessTable);
    ramLayout->addWidget(killRamProcessButton);
    ramLayout->addStretch(); // Pushes UI to the top

    // =======================================
    // TAB: Network
    // =======================================
    QWidget* networkTab = new QWidget();
    QVBoxLayout* networkLayout = new QVBoxLayout(networkTab);

    networkLabel = new QLabel("Network: Calculating...", this);
    networkLabel->setStyleSheet("color: #cdd6f4; font-size: 14px; font-weight: bold; margin-top: 10px;");

    // --- Process Table ---
    networkProcessTable = new QTableWidget(0, 4, this);
    networkProcessTable->setHorizontalHeaderLabels({"PID", "Process Name", "Down (KB/s)", "Up (KB/s)"});
    networkProcessTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    networkProcessTable->setSelectionMode(QAbstractItemView::SingleSelection);
    networkProcessTable->horizontalHeader()->setStretchLastSection(true);
    networkProcessTable->verticalHeader()->setVisible(false);
    networkProcessTable->viewport()->installEventFilter(this);
    networkProcessTable->installEventFilter(this);

    networkProcessTable->setStyleSheet(
        "QTableWidget { background-color: #1e1e2e; color: #cdd6f4; border: 1px solid #45475a; }"
        "QHeaderView::section { background-color: #313244; color: white; padding: 4px; border: 1px solid #45475a; font-weight: bold; }"
        "QTableWidget::item:selected { background-color: #89b4fa; color: black; }"
        );

    // --- Kill Button ---
    killNetworkProcessButton = new QPushButton("Kill Process (Network)", this);
    killNetworkProcessButton->setEnabled(false);
    killNetworkProcessButton->setStyleSheet(
        "QPushButton { background-color: #f38ba8; color: #1e1e2e; font-weight: bold; padding: 8px; border-radius: 4px; }"
        "QPushButton:hover { background-color: #ffb4c8; }"
        "QPushButton:disabled { background-color: #45475a; color: #7f849c; }"
        );

    connect(killNetworkProcessButton, &QPushButton::clicked, this, [this]() {
        killProcessFromTable(networkProcessTable);
    });

    connect(networkProcessTable, &QTableWidget::itemSelectionChanged, this, [this]() {
        bool hasSelection = !networkProcessTable->selectedItems().isEmpty();

        killNetworkProcessButton->setEnabled(hasSelection);
    });

    networkLayout->addWidget(networkLabel);
    networkLayout->addWidget(networkProcessTable);
    networkLayout->addWidget(killNetworkProcessButton);
    networkLayout->addStretch(); // Pushes UI to the top

    // Adding all the created tabs to the TabWidget
    tabWidget->addTab(cpuTab, "CPU");
    tabWidget->addTab(ramTab, "Memory");
    tabWidget->addTab(networkTab, "Network");

    // Setting the TabWidget as the main view
    this->setCentralWidget(tabWidget);
}

void MainWindow::updateUI(SystemStats stats) {
// Updating RAM Info
    ramProgressBar->setValue(static_cast<int>(stats.ramUsagePercent));
    ramLabel->setText(stats.ramLabelText);

    // Dynamically change color based on usage
    if (stats.ramUsagePercent > 85) {
        ramProgressBar->setStyleSheet("QProgressBar::chunk { background-color: #f38ba8; }"); // Red
    }
    else if (stats.ramUsagePercent > 60) {
        ramProgressBar->setStyleSheet("QProgressBar::chunk { background-color: #f9e2af; }"); // Yellow
    }
    else {
        ramProgressBar->setStyleSheet("QProgressBar::chunk { background-color: #a6e3a1; }"); // Green
    }

// Updating CPU Info
    cpuProgressBar->setValue(static_cast<int>(stats.cpuUsagePercent));
    cpuLabel->setText(stats.cpuLabelText);

    if(stats.cpuUsagePercent > 85){
        cpuProgressBar->setStyleSheet("QProgressBar::chunk { background-color: #f38ba8; }"); // Red
    }
    else if(stats.cpuUsagePercent > 60){
        cpuProgressBar->setStyleSheet("QProgressbar::chunk { background-color: #f9e2af; }"); // Yellow
    }
    else{
        cpuProgressBar->setStyleSheet("QProgressbar::chunk { background-color: #a6e3a1; }"); // Green
    }

// Updating Network Info
    networkLabel->setText(stats.networkLabelText);


// Updating RAM Process Table without flickering
    ramProcessTable->setRowCount(stats.processList.size());

    for (int i = 0; i < stats.processList.size(); ++i) {
        const ProcessInfo &pInfo = stats.processList[i];

        // Check if the cell already exists to avoid memory reallocation
        QTableWidgetItem *pidItem = ramProcessTable->item(i, 0);

        if (!pidItem) {
            // First time drawing this row: create the items
            ramProcessTable->setItem(i, 0, new QTableWidgetItem(QString::number(pInfo.pid)));
            ramProcessTable->setItem(i, 1, new QTableWidgetItem(pInfo.name));
            ramProcessTable->setItem(i, 2, new QTableWidgetItem(QString::number(pInfo.memoryMB)));
        } else {
            // Row exists: just update the text (much faster!)
            pidItem->setText(QString::number(pInfo.pid));
            ramProcessTable->item(i, 1)->setText(pInfo.name);
            ramProcessTable->item(i, 2)->setText(QString::number(pInfo.memoryMB));
        }
    }

// Updating CPU Process Table
    cpuProcessTable->setRowCount(stats.processList.size());

    for (int i = 0; i < stats.processList.size(); ++i) {
        const ProcessInfo &pInfo = stats.processList[i];

        QTableWidgetItem *pidItem = cpuProcessTable->item(i, 0);

        if (!pidItem) {
            cpuProcessTable->setItem(i, 0, new QTableWidgetItem(QString::number(pInfo.pid)));
            cpuProcessTable->setItem(i, 1, new QTableWidgetItem(pInfo.name));
            cpuProcessTable->setItem(i, 2, new QTableWidgetItem(QString::number(pInfo.cpuUsage, 'f', 1)));
        } else {
            pidItem->setText(QString::number(pInfo.pid));
            cpuProcessTable->item(i, 1)->setText(pInfo.name);
            cpuProcessTable->item(i, 2)->setText(QString::number(pInfo.cpuUsage, 'f', 1));
        }
    }


// Updating Network Process Table
    // --- Sort the list by Network Download internally ---
    std::sort(stats.processList.begin(), stats.processList.end(),
              [](const ProcessInfo& a, const ProcessInfo& b) {
                  return a.netDownKBs > b.netDownKBs;
              });

    // --- Update Network Process Table without index scrambling ---
    networkProcessTable->setSortingEnabled(false);
    networkProcessTable->setRowCount(stats.processList.size());

    for (int i = 0; i < stats.processList.size(); ++i) {
        const ProcessInfo &pInfo = stats.processList[i];

        QTableWidgetItem *pidItem = networkProcessTable->item(i, 0);

        if (!pidItem) {
            networkProcessTable->setItem(i, 0, new QTableWidgetItem(QString::number(pInfo.pid)));
            networkProcessTable->setItem(i, 1, new QTableWidgetItem(pInfo.name));

            QTableWidgetItem *dlItem = new QTableWidgetItem();
            dlItem->setData(Qt::EditRole, pInfo.netDownKBs);
            networkProcessTable->setItem(i, 2, dlItem);

            QTableWidgetItem *ulItem = new QTableWidgetItem();
            ulItem->setData(Qt::EditRole, pInfo.netUpKBs);
            networkProcessTable->setItem(i, 3, ulItem);
        } else {
            pidItem->setText(QString::number(pInfo.pid));
            networkProcessTable->item(i, 1)->setText(pInfo.name);
            networkProcessTable->item(i, 2)->setData(Qt::EditRole, pInfo.netDownKBs);
            networkProcessTable->item(i, 3)->setData(Qt::EditRole, pInfo.netUpKBs);
        }
    }
}

void MainWindow::killProcessFromTable(QTableWidget* table)
{
    // Finding out the highlighted row
    int currentRow = table->currentRow();

    if (currentRow >= 0) {
        // Extract the text from the PID column (Column 0)
        QTableWidgetItem *pidItem = table->item(currentRow, 0);

        if (pidItem) {
            // Convert the string to an integer
            pid_t pid = pidItem->text().toInt();

            // Fire the UNIX signal to terminate the app forcefully
            kill(pid, SIGKILL);
        }
    }
}

// Capturing the mouse click outside the QTableWidget; on the main window and deselect the table row
void MainWindow::mousePressEvent(QMouseEvent *event) {
    // qDebug() << "[UI] Main Window background clicked! Forcing global deselect.";

    // 1. Clear visuals
    cpuProcessTable->clearSelection();
    ramProcessTable->clearSelection();
    networkProcessTable->clearSelection();

    // 2. Clear internal focus
    cpuProcessTable->setCurrentItem(nullptr);
    ramProcessTable->setCurrentItem(nullptr);
    networkProcessTable->setCurrentItem(nullptr);

    // Pass to base class
    QMainWindow::mousePressEvent(event);
}

// Capturing and stealing away the mouse click on the table viewport's empty space and deselect the table row
bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
    if (event->type() == QEvent::MouseButtonPress) {
        QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);

        // // DEBUG: Tell us exactly what is being clicked!
        // qDebug() << "[CLICK TRACE] Mouse hit object:" << obj->metaObject()->className();

        QTableWidget *clickedTable = nullptr;

        // Checking if user clicked the viewport OR the outer table frame
        if (obj == cpuProcessTable || obj == cpuProcessTable->viewport()) {
            clickedTable = cpuProcessTable;
        } else if (obj == ramProcessTable || obj == ramProcessTable->viewport()) {
            clickedTable = ramProcessTable;
        } else if (obj == networkProcessTable || obj == networkProcessTable->viewport()) {
            clickedTable = networkProcessTable;
        }

        if (clickedTable) {
            // Mapping the coordinates to the viewport just in case they clicked the outer frame
            QPoint clickPos = clickedTable->viewport()->mapFromGlobal(mouseEvent->globalPosition().toPoint());
            QTableWidgetItem *item = clickedTable->itemAt(clickPos);

            if (!item) {
                // qDebug() << "[UI] Empty table space clicked! Forcing deselect.";
                clickedTable->clearSelection();
                clickedTable->setCurrentItem(nullptr);
                return true;
            }
            // else {
            //     qDebug() << "[UI] Valid process clicked at row" << item->row();
            // }
        }
    }

    return QMainWindow::eventFilter(obj, event);
}