path: root/src/mainwindow.cpp

#include "mainwindow.h"
#include "./ui_mainwindow.h"
#include "src/activitypub/appost.h"
#include "src/archive/base_archive.h"
#include "src/finddialog.h"
#include "src/list_item.h"
#include "src/command_line.h"
#include "src/settingsdialog.h"
#include "src/net/instance.h"

#include <QFileDialog>
#include <QInputDialog>
#include <QMessageBox>
#include <QRandomGenerator>
#include <QClipboard>
#include <QMimeData>
#include <QtConcurrent/QtConcurrent>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    connect(ui->buttonCopy, &QPushButton::clicked, ui->actionCopy_status, &QAction::trigger);
    connect(ui->buttonRandom, &QPushButton::clicked, ui->actionRandom_status, &QAction::trigger);
    connect(ui->buttonSearch, &QPushButton::clicked, ui->actionFind, &QAction::trigger);
    connect(&archive_thread_watcher, &QFutureWatcher<std::variant<QString, Archive::InitError>>::finished, this, &MainWindow::archive_thread_watcher_done);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::act_command_line(CommandLineParsedOptions &options, QCommandLineParser &parser) {
    switch (options.result) {
        case CommandLineError:
            QMessageBox::critical(this, tr("Command line"), tr("The passed command line is incorrect and will be ignored.\nMore information: %1").arg(options.error_message)); exit(EXIT_FAILURE);
            break;
        case CommandLineHelpRequested:
            QMessageBox::information(this, QGuiApplication::applicationDisplayName(), "<pre>" + parser.helpText() + "</pre>"); exit(EXIT_SUCCESS);
            break;
        case CommandLineVersionRequested:
            on_actionAbout_triggered(true); exit(EXIT_SUCCESS);
            break;
        case CommandLineOk:
            if (!options.outbox_filename.isEmpty())
                open_file(options.outbox_filename);
            break;
    }
}

void MainWindow::on_actionOpen_triggered(bool checked) {
    QFileDialog fileDialog;
    fileDialog.setFileMode(QFileDialog::AnyFile);
    fileDialog.setNameFilter(tr("Mastodon data export directory (outbox.json)"));
    if (fileDialog.exec()) {
        QStringList files = fileDialog.selectedFiles();
        open_file(files[0]);
    }
}

void MainWindow::on_actionSettings_triggered(bool checked) {
    if (!settings_dialog) {
        settings_dialog = new SettingsDialog(this);
        connect(settings_dialog, &QDialog::finished, this, &MainWindow::settingsDialog_done);
        if (data_archive)
            settings_dialog->set_instance_address(data_archive->get_instance_address());
    }
    settings_dialog->open();
}

void MainWindow::settingsDialog_done(int result) {
    if (result == QDialog::Accepted) {
        // TODO: reload settings
    }
    delete settings_dialog; settings_dialog = nullptr;
}

void MainWindow::on_actionQuit_triggered(bool checked) {
    QCoreApplication::quit();
}

void MainWindow::on_actionAbout_triggered(bool checked) {
    QMessageBox::information(this, "title", "text");
}

std::variant<QString, Archive::InitError> start_listWidget_itemActivated(StatusListItem* status, int text_zone_width, QLocale* locale) {
    return (QString)status->get_info_html(text_zone_width, locale);
}

void MainWindow::on_listWidget_itemActivated(QListWidgetItem *item) {
    StatusListItem* status = dynamic_cast<StatusListItem*>(item);
    if (status != nullptr) {
        const QFuture<std::variant<QString, Archive::InitError>> status_info = QtConcurrent::run(start_listWidget_itemActivated, status, ui->statusInfoText->width(), &locale_context);
        archive_thread_watcher.setFuture(status_info);
    }
}

void MainWindow::finish_listWidget_itemActivated(const QString& status_info) {
    ui->statusInfoText->setHtml(status_info);
}

void MainWindow::on_actionRandom_status_triggered(bool checked) {
    if (data_archive == nullptr) return; // No archive open, avoids crashing

    int index = QRandomGenerator::global()->bounded(ui->listWidget->count());
    QListWidgetItem* item = ui->listWidget->item(index);
    on_listWidget_itemActivated(item);
    ui->listWidget->setCurrentItem(item);
}

void MainWindow::on_actionCopy_status_triggered(bool checked) {
    if (data_archive == nullptr or ui->listWidget->selectedItems().isEmpty()) return;

    StatusListItem* item = dynamic_cast<StatusListItem*>(ui->listWidget->selectedItems()[0]);
    if (item != nullptr) {
        QString status_text = data_archive->get_html_status_text(item->get_status_index());
        QMimeData* clipboard_data = new QMimeData;
        clipboard_data->setHtml(status_text);
        QGuiApplication::clipboard()->setMimeData(clipboard_data);
    }
}

void MainWindow::on_actionFind_triggered(bool checked) {
    if (!find_dialog) {
        find_dialog = new FindDialog(this);
        find_dialog->set_qlist_widget(ui->listWidget);
        connect(find_dialog, &FindDialog::item_selected, this, &MainWindow::select_list_item);
        connect(this, &MainWindow::search_text_changed, find_dialog, &FindDialog::set_search_text);
        connect(find_dialog, &FindDialog::search_text_changed, this, &MainWindow::set_search_text);

        if (not ui->textInputSearch->text().isEmpty())
            emit search_text_changed(ui->textInputSearch->text(), true);
    }

    find_dialog->show();
    find_dialog->raise();
    find_dialog->activateWindow();
}

void MainWindow::select_list_item(QListWidgetItem* item) {
    on_listWidget_itemActivated(item);
}

void MainWindow::on_textInputSearch_textEdited(const QString &text) {
    emit search_text_changed(text);
}

void MainWindow::set_search_text(const QString &text) {
    ui->textInputSearch->setText(text);
}

void MainWindow::on_actionOpen_URL_triggered(bool checked) {
    bool ok;
    QString url = QInputDialog::getText(this, tr("Open status from URL"), tr("Status URL:"), QLineEdit::Normal, "https://…", &ok);

    // TODO: Move all of this to another thread
    // TODO: Reuse the Instance object
    // Really hacky code but works as a PoC and allows testing
    if (ok and not url.isEmpty()) {
        Instance* instance = Instance::create_instance();
        APPost* post = instance->get_post_from_url(url);
        QString html = post->get_html_render({ui->statusInfoText->width(), &locale_context});
        ui->statusInfoText->setHtml(html);
        delete instance; instance = nullptr;
    } else return;
}

void MainWindow::relist_statuses() {
    if (data_archive) {
        ui->listWidget->clear();
        data_archive->update_status_list(view_filters, ui->listWidget);
        view_filters_changed = false;
    }
}

// Function used to reset filters when we have detected that the "All toots" toggle has been toggled on or shouldn't be toggled anymore
void MainWindow::reset_view_filters() {
    if (ui->actionAll_toots->isChecked())
        view_filters = {true, true, true, true, view_filters.includeReblogs, view_filters.onlyWithAttachment};
    else
        view_filters = {false, false, false, false, view_filters.includeReblogs, view_filters.onlyWithAttachment};
}

void MainWindow::on_actionAll_toots_triggered(bool checked) {
    ui->actionAll_toots->setChecked(true);
    ui->actionPublic_toots->setChecked(false);
    ui->actionUnlisted_toots->setChecked(false);
    ui->actionPrivate_toots->setChecked(false);
    ui->actionDirect_messages->setChecked(false);
    ui->actionOnly_with_attachment->setChecked(false);

    reset_view_filters();
    relist_statuses();
}

void MainWindow::on_actionPublic_toots_triggered(bool checked) {
    if (ui->actionAll_toots->isChecked()) {
        ui->actionAll_toots->setChecked(false);
        reset_view_filters();
    }
    view_filters.includePublic = checked;
    view_filters_changed = true;
}

void MainWindow::on_actionUnlisted_toots_triggered(bool checked) {
    if (ui->actionAll_toots->isChecked()) {
        ui->actionAll_toots->setChecked(false);
        reset_view_filters();
    }
    view_filters.includeUnlisted = checked;
    view_filters_changed = true;
}

void MainWindow::on_actionPrivate_toots_triggered(bool checked) {
    if (ui->actionAll_toots->isChecked()) {
        ui->actionAll_toots->setChecked(false);
        reset_view_filters();
    }
    view_filters.includePrivate = checked;
    view_filters_changed = true;
}

void MainWindow::on_actionDirect_messages_triggered(bool checked) {
    if (ui->actionAll_toots->isChecked()) {
        ui->actionAll_toots->setChecked(false);
        reset_view_filters();
    }
    view_filters.includeDirect = checked;
    view_filters_changed = true;
}

void MainWindow::on_actionOnly_with_attachment_triggered(bool checked) {
    view_filters.onlyWithAttachment = checked;
    view_filters_changed = true;
}

void MainWindow::on_actionReblogs_triggered(bool checked) {
    view_filters.includeReblogs = checked;
    view_filters_changed = true;
}

void MainWindow::on_menuView_aboutToHide() {
    if (view_filters_changed)
        relist_statuses();
}

void MainWindow::open_file(const QString &filename) {
    if (data_archive) {
        delete data_archive;
        data_archive = nullptr;
    }

    open_file_filename = filename;

    QApplication::setOverrideCursor(Qt::WaitCursor);

    data_archive = Archive::create_archive(ArchiveType::MASTODON, filename);
    if (not data_archive) return;

    QFuture<std::variant<QString, Archive::InitError>> parse_error = QtConcurrent::run(data_archive, &Archive::init);
    archive_thread_watcher.setFuture(parse_error);
}

void MainWindow::finish_open_file(const Archive::InitError& parse_error) {
    switch (parse_error) {
        case Archive::FailedOpeningFile:
            QMessageBox::warning(this, tr("Archive Parser"), tr("Failed opening file %1").arg(open_file_filename)); break;
        case Archive::JsonParseError:
            QMessageBox::warning(this, tr("Archive Parser"), tr("Failed parsing outbox JSON.")); break;
        case Archive::JsonEmpty:
        case Archive::JsonNull:
        case Archive::JsonNotObject:
        case Archive::JsonNotActivityStream:
            QMessageBox::warning(this, tr("Archive Parser"), tr("The outbox JSON is empty or invalid in another way. Not an outbox.json?")); break;
        case Archive::NoError:
            break;
    }

    ui->listWidget->clear();

    if (parse_error == Archive::NoError) {
        data_archive->update_status_list(view_filters, ui->listWidget);
    }

    QApplication::restoreOverrideCursor();
}

void MainWindow::archive_thread_watcher_done() {
    std::variant<QString, Archive::InitError> result = archive_thread_watcher.result();

    // For MainWindow::on_listWidget_itemActivated
    if (const QString* status_info = std::get_if<QString>(&result)) {
        finish_listWidget_itemActivated(*status_info);
    } else
    // For MainWindow::open_file
    if (const Archive::InitError* parse_error = std::get_if<Archive::InitError>(&result)) {
        finish_open_file(*parse_error);
    } else
        qDebug() << "What, the variant is weird";
}