mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <filesystem>
#include <fstream>
#include <iostream>
#include <QMessageBox>
#include <QThread>
#include <QScrollBar>
#include <QSizePolicy>
#include <QLabel>
#include <QPushButton>
#include <cerrno>

namespace Ui
{
QString globalStyleSheet =
    "QLabel[type='1']{ "
    "border-radius: 5px;"
    "font-weight: normal;"
    "color: #1e293b;"
    "background: lightgreen;"
    "font-size: 26px;"
    "font-family: 'Source Code Pro';"
    "padding: 10px;"
    " }"
    "QLabel[type='2']{ "
    "border-radius: 5px;"
    "font-weight: normal;"
    "color: #1e293b;"
    "background: lightblue;"
    "font-size: 26px;"
    "font-family: 'Source Code Pro';"
    "padding: 10px;"
    " }"
    "QLabel[type='3']{ "
    "border-radius: 5px;"
    "font-weight: normal;"
    "color: #1e293b;"
    "background: darkbrown;"
    "font-size: 26px;"
    "font-family: 'Source Code Pro';"
    "padding: 10px;"
    " }";
}

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , local_host(nullptr)
    , remote_host(new RemoteHost)
    , chat_window(nullptr)
    , server_thread(nullptr)
{

    memset(&users_mgr, 0, sizeof(users_mgr));

    // Get Users Data
    std::filesystem::create_directory("data");

    std::ifstream users_file("./data/users.dat", std::ios::binary);

    if (users_file.is_open())
    {
        users_file.read(reinterpret_cast<char*>(&users_mgr), sizeof(users_mgr));
    }
    else
    {
        users_mgr.total_users = 0;
    }

    std::cout << "Users Count: " << users_mgr.total_users << std::endl;

    // UI Setup
    ui->setupUi(this);

    ui->stackedWidget->setCurrentIndex(0);

    ui->gridLayout->setColumnStretch(0, 1);
    ui->gridLayout->setColumnStretch(1, 0);
    ui->gridLayout->setColumnStretch(2, 0);

}

MainWindow::~MainWindow()
{
    std::ofstream users_file("./data/users.dat", std::ios::binary);

    if (users_file.is_open())
    {
        users_file.write(reinterpret_cast<char*>(&users_mgr), sizeof(users_mgr));
    }

    logout();

    delete remote_host;
    delete ui;
}

void MainWindow::keyPressEvent(QKeyEvent *e)
{
    QMainWindow::keyPressEvent(e);
//    if (e->key() == Qt::Key_Return)
//        on_btnSend_clicked();
}

void clear_the_layout(QLayout *layout)
{
    while (QLayoutItem *item = layout->takeAt(0))
    {
        if (QWidget *widget = item->widget())
            widget->deleteLater();

        delete item;
    }

}


void MainWindow::on_actionAbout_triggered()
{
    QString description(
        "PacketTalk\n"
        "Version: 0.1\n\n"
        "PacketTalk is a learning project that explores network programming with **Qt Widgets** and **UDP datagram sockets**. Instead of building a complete chat application all at once, the project is developed incrementally, with each feature introduced through small, focused commits."
        "\n\nDeveloped with Qt"
    );
    QMessageBox::information(this, "PacketTalk", description, QMessageBox::Ok);
}


void MainWindow::on_actionExit_triggered()
{
    QApplication::exit(0);
}


void MainWindow::on_msg_recieved(const char *message, const char *peer_path)
{

    int index = users_mgr.find_by_path(peer_path);

    // TODO: What if (!remote_host->is_connected() && index == -1))
    // and you recieve a message?

    if (!remote_host->is_connected() && index != -1)
    {
        remote_host->connect(users_mgr.me.name, users_mgr.users[index].name, users_mgr.users[index].path);
    }

    if (chat_window == nullptr)
        open_chat_window(users_mgr.users[index]);

    chat_window->on_msg_recieved(message);
}

void MainWindow::on_ping_alert(int ms)
{
    // TEMP Testing
    std::cout << "Ping: " << ms << "ms" << std::endl;

}

void MainWindow::on_availability_change(bool is_user_online, const char *peer_path)
{
    if (!ui->gridLayout->count())
        return;

    int index = users_mgr.find_by_path(peer_path);

    if (index == -1)
        return;

    QString objName = users_mgr.users[index].name;

    objName = "status_" + objName;

    for (int i = 0; i < ui->gridLayout->count(); ++i)
    {
        QWidget *widget = ui->gridLayout->itemAt(i)->widget();

        if (widget->objectName() == objName)
        {
            QLabel *label = (QLabel *)widget;

            if (is_user_online)
            {
                widget->setProperty("type", 1);
                widget->setStyleSheet(Ui::globalStyleSheet);
                label->setText("online");
            }
            else
            {
                widget->setProperty("type", 3);
                widget->setStyleSheet(Ui::globalStyleSheet);
                label->setText("offline");
            }
            return;
        }

    }
}

void MainWindow::open_chat_window(User &user)
{
    if (chat_window)
    {
        chat_window->raise();
        chat_window->activateWindow();
        return;
    }

    chat_window = new ChatWindow(user, local_host, remote_host, this);

    chat_window->setAttribute(Qt::WA_DeleteOnClose);

    connect(chat_window, &QObject::destroyed,
            this, [this]()
    {
        chat_window = nullptr;
    });

    chat_window->show();
}

void MainWindow::logout()
{
    if (server_thread)
    {
        for (unsigned int i = 0; i < users_mgr.total_users; ++i)
        {
            if (strcmp(users_mgr.users[i].name, users_mgr.me.name) == 0)
                continue;

            remote_host->broadcast_availability(false, users_mgr.users[i].path);
        }
        local_host->stop_running();
        server_thread->wait();
    }
}

void MainWindow::show_all_users()
{

    int row = 0;
    clear_the_layout(ui->gridLayout);

    for (unsigned int i = 0; i < users_mgr.total_users; ++i)
    {
        if (strcmp(users_mgr.users[i].name, users_mgr.me.name) == 0)
            continue;

        QString objName = users_mgr.users[i].name;

        QLabel *label_name = new QLabel(objName, ui->scrollAreaWidgetContents);

        label_name->setProperty("type", 2);
        label_name->setObjectName("label_" + objName);

        label_name->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
        label_name->setWordWrap(true);
        label_name->setAlignment(Qt::AlignHCenter);

        QString status_str;
        int user_status;

        if (remote_host->check_user_availability(users_mgr.users[i].path))
        {
            remote_host->broadcast_availability(true, users_mgr.users[i].path);
            status_str = "online";
            user_status = 1;
        }
        else
        {
            status_str = "offline";
            user_status = 3;
        }

        QLabel *label_status = new QLabel(status_str, ui->scrollAreaWidgetContents);

        label_status->setProperty("type", user_status);
        label_status->setObjectName("status_" + objName);
        label_status->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        label_status->setAlignment(Qt::AlignHCenter);

        QPushButton *btn = new QPushButton("Message", ui->scrollAreaWidgetContents);
        btn->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        btn->setCursor(Qt::PointingHandCursor);

        btn->setObjectName("btn_" + objName);

        connect(btn, &QPushButton::clicked, this, [this, i]()
        {
            on_btn_connect_clicked(users_mgr.users[i]);
        });


        ui->gridLayout->addWidget(label_name, row, 0, 1, 1);
        ui->gridLayout->addWidget(label_status, row, 1, 1, 1);
        ui->gridLayout->addWidget(btn, row, 2, 1, 1);

        row++;
    }

    ui->gridLayout->setRowStretch(row, 1);

}


void MainWindow::on_btn_connect_clicked(User& user)
{
    if (!local_host->is_connected())
    {
        QMessageBox::critical(this, "Error", "You are not signed in.", QMessageBox::Ok);
        return;
    }

    remote_host->connect(users_mgr.me.name, user.name, user.path);

    open_chat_window(user);

}

void MainWindow::on_btn_submit_reg_clicked()
{

    if (users_mgr.total_users >= MAX_USERS)
    {
        QMessageBox::critical(this, "PacketTalk", "Max users limit reached.", QMessageBox::Ok);
        return;
    }

    std::string stdstr_name = ui->lineEdit_name_reg->text().toStdString();

    if (users_mgr.find_user(stdstr_name.c_str()) != -1)
    {
        QMessageBox::critical(this, "PacketTalk", "Username taken already!", QMessageBox::Ok);
        return;
    }

    int index = users_mgr.total_users++; // Increase users count

    char *name = users_mgr.users[index].name;
    char *path = users_mgr.users[index].path;
    char *password = users_mgr.users[index].password;

    strncpy(name, stdstr_name.c_str(), MAX_USERNAME - 2);

    std::string stdstr_path = name;
    stdstr_path = "/tmp/PacketTalk_" + stdstr_path;

    std::string stdstr_password = ui->lineEdit_password_reg->text().toStdString();

    strncpy(password, stdstr_password.c_str(), MAX_USERPASSWORD - 2);
    strncpy(path, stdstr_path.c_str(), MAX_USERPATH - 2);

    QMessageBox::information(this, "PacketTalk", "Congratulations! Your account has been registered.");

    ui->lineEdit_name->setText(name);
    ui->lineEdit_password->setText(password);

    ui->stackedWidget->setCurrentIndex(0);

}

void MainWindow::on_btn_signin_clicked()
{
    int index;
    std::string text = ui->lineEdit_name->text().toStdString();

    if ((index = users_mgr.find_user(text.c_str())) == -1)
    {
        QMessageBox::critical(this, "PacketTalk", "Wrong username!", QMessageBox::Ok);
        return;
    }

    char *name = users_mgr.users[index].name;
    char *path = users_mgr.users[index].path;
    char *password = users_mgr.users[index].password;

    memset(&users_mgr.me, 0, sizeof(users_mgr.me));

    strncpy(users_mgr.me.name, name, MAX_USERNAME - 2);
    strncpy(users_mgr.me.path, path, MAX_USERPATH - 2);
    strncpy(users_mgr.me.password, password, MAX_USERPASSWORD - 2);

    local_host = new LocalHost();

    try
    {
        local_host->connect(path);
        remote_host->set_localhost_fd(local_host->get_socket_fd());
    }
    catch (SocketError& err)
    {
        QMessageBox::critical(this, "Error", err.what(), QMessageBox::Ok);
        QApplication::exit(-1);
    }

    server_thread = new QThread(this);

    local_host->moveToThread(server_thread);

    connect(server_thread, &QThread::started, local_host, &LocalHost::run_server);

    connect(server_thread, &QThread::finished, server_thread, &QObject::deleteLater);

    connect(local_host, &LocalHost::finished, server_thread, &QThread::quit, Qt::DirectConnection);

    connect(local_host, &LocalHost::finished, local_host, &QObject::deleteLater);

    connect(local_host, &LocalHost::msg_recieved, this, &MainWindow::on_msg_recieved);

    connect(local_host, &LocalHost::ping, this, &MainWindow::on_ping_alert);

    connect(local_host, &LocalHost::availability_changed, this, &MainWindow::on_availability_change);

    connect(server_thread, &QThread::finished,
            this, [this]()
    {
        server_thread = nullptr;
        local_host = nullptr;
    });

    server_thread->start();

    QString msg = "Welcome " + ui->lineEdit_name->text() + "!";
    QMessageBox::information(this, this->windowTitle(), msg, QMessageBox::Ok);
    ui->label_top->setText(msg);
    ui->stackedWidget->setCurrentIndex(1);

    show_all_users();

}

void MainWindow::on_btn_signup_clicked()
{
    ui->stackedWidget->setCurrentIndex(2);
}

void MainWindow::on_btn_logout_clicked()
{
    logout();

    clear_the_layout(ui->gridLayout);

    ui->stackedWidget->setCurrentIndex(0);
}