/*
 * This file is part of smolbote. It's copyrighted by the contributors recorded
 * in the version control history of the file, available from its original
 * location: https://neueland.iserlohn-fortress.net/gitea/aqua/smolbote
 *
 * SPDX-License-Identifier: GPL-3.0
 */

#include "browser.h"
#include "plugin.h"
#include "session.h"
#include "util.h"
#include "version.h"
#include <QFile>
#include <QLibraryInfo>
#include <QTranslator>
#include <configuration/configuration.h>
#include <iostream>
#include <memory>
#ifdef _WIN32
#include <cstdio>
#include <windows.h>
#endif

#ifdef BreakpadEnabled
#ifdef Q_OS_LINUX
#include <client/linux/handler/exception_handler.h>

// bool filter_callback (void*)
// --> true: continue processing and write a minidump

static bool dumpCallback(const google_breakpad::MinidumpDescriptor &descriptor, void *context, bool succeeded)
{
    printf("Dump path: %s\n", descriptor.path());

    if(auto *app = static_cast<Browser *>(context); app != nullptr) {
        auto session = app->session();
        QJsonDocument doc(session);
        QFile sessionFile(QString("%1.json").arg(QString::fromStdString(descriptor.path())));
        if(sessionFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
            sessionFile.write(qUtf8Printable(doc.toJson()));
            sessionFile.flush();
            sessionFile.close();
        }
    }

    return succeeded;
}
#endif // Q_OS_LINUX
#endif

int main(int argc, char **argv)
{
    // a beautiful hack to be able to write to stdout on Windows
#ifdef _WIN32
    if(AttachConsole(ATTACH_PARENT_PROCESS)) {
        freopen("CONOUT$", "w", stdout);
        freopen("CONOUT$", "w", stderr);
    }
#endif

    // create and load configuration
    std::unique_ptr<Configuration> config = std::make_unique<Configuration>(nullptr);
#ifdef QT_DEBUG
    QObject::connect(config.get(), &Configuration::settingChanged, [](const std::string &path, const QString &value) {
        qDebug("!!! setting changed %s=[%s]", path.c_str(), qUtf8Printable(value));
    });
#endif

    if(!config->parse(argc, argv)) {
        qWarning("Error parsing command line, check --help for usage.");
        return -1;
    }
    if(!config->parse(config->value<std::string>("config").value())) {
        qWarning("Error parsing config file.");
    }

    // --version
    if(config->exists("version")) {
        std::cout << "smolbote " << SMOLBOTE_VERSION << std::endl;
        return 0;
    }

    // --build
    if(config->exists("build")) {
        std::cout << SMOLBOTE_BUILD;
        return 0;
    }

    QVector<Plugin> plugins;
    for(const QString &path : Util::files(config->value<QString>("plugins.path").value())) {
        plugins.append(loadPluginFromPath(path));
    }
    QMap<QString, std::function<int()>> pluginCommands;
    for(const auto &plugin : plugins) {
        auto *pluginInterface = qobject_cast<PluginInterface *>(plugin.instance);
        Q_CHECK_PTR(pluginInterface);

        QHashIterator<QString, std::function<int()>> i(pluginInterface->commands());
        while(i.hasNext()) {
            i.next();
            pluginCommands.insert(i.key(), i.value());
        }
    }

    if(config->exists("help")) {
        std::cout << "smolbote " << SMOLBOTE_VERSION << ": yet another no-frills browser" << std::endl;
        std::cout << "Usage: " << argv[0] << " [options] [command/URL(s)]" << std::endl
                  << std::endl;

        std::cout << "Command-line Options: " << std::endl
                  << config->commandlineOptions() << std::endl;

        std::cout << "Commands: " << std::endl;
        for(auto it = pluginCommands.constBegin(); it != pluginCommands.constEnd(); ++it) {
            std::cout << it.key().toStdString() << std::endl;
        }
        std::cout << std::endl;

        std::cout << "Configuration Options: " << std::endl
                  << config->configurationOptions() << std::endl;

#ifdef Q_OS_LINUX
        std::cout << std::endl
                  << "For more information refer to the manual page smolbote.7" << std::endl;
#endif
        return 0;
    }

    // argc, argv, allowSecondary
    Browser app(argc, argv);
    // set this, otherwise the webview becomes black when using a stylesheet
    app.setAttribute(Qt::AA_DontCreateNativeWidgetSiblings, true);

#ifdef BreakpadEnabled
    google_breakpad::MinidumpDescriptor descriptor("/tmp");

    // minidump descriptor, filter callback, minidump callback, callback_context, install handler, server_fd
    google_breakpad::ExceptionHandler eh(descriptor, nullptr, dumpCallback, &app, true, -1);
#endif

    // translator
    if(config->exists("browser.locale")) {
        auto *translator = new QTranslator(&app);
        if(translator->load("qt_" + config->value<QString>("browser.locale").value(), QLibraryInfo::location(QLibraryInfo::TranslationsPath)))
            app.installTranslator(translator);
        else
            delete translator;
    }

    if(config->exists("browser.translation")) {
        auto *translator = new QTranslator(&app);
        if(translator->load(config->value<QString>("browser.translation").value()))
            app.installTranslator(translator);
        else
            delete translator;
    }

    // command line arguments
    bool isStandalone = config->exists("no-remote");
    auto arguments = config->value<std::vector<std::string>>("args");
    auto session = config->value<QString>("browser.session");
    auto profile = config->value<QString>("profile.default");

    app.setConfiguration(config);
    app.setup();

    for(const Plugin &plugin : plugins) {
        app.registerPlugin(plugin);
    }

    QStringList urls;
    if(arguments) {
        for(const auto &u : arguments.value()) {
            if(pluginCommands.contains(QString::fromStdString(u))) {
                return pluginCommands.value(QString::fromStdString(u))();
            } else {
                urls.append(QString::fromStdString(u));
            }
        }
    }

    // if app is primary, create new sessions from received messages
    if(app.isPrimary() && !isStandalone) {
        QObject::connect(&app, &Browser::receivedMessage, &app, [&app](quint32 instanceId, QByteArray message) {
            Q_UNUSED(instanceId);
            auto doc = QJsonDocument::fromJson(message);
            app.createSession(doc.object());
        });
    }

    {
        QJsonObject sessionData;
        if(session) {
            QFile sessionJson(session.value());
            if(sessionJson.open(QIODevice::ReadOnly | QIODevice::Text)) {
                sessionData = QJsonDocument::fromJson(sessionJson.readAll()).object();
                sessionJson.close();
            }
        } else {
            sessionData = Session::window(profile.value(), urls);
        }

        if(app.isPrimary() || isStandalone) {
            app.createSession(sessionData);
        } else {
            // app is secondary and not standalone
            return app.sendMessage(QJsonDocument(sessionData).toJson());
        }
    }

    return app.exec();
}