#include "Updates.hpp"

#include "common/NetworkRequest.hpp"
#include "common/Outcome.hpp"
#include "common/Version.hpp"
#include "singletons/Paths.hpp"
#include "util/CombinePath.hpp"
#include "util/PostToThread.hpp"

#include <QDebug>
#include <QDesktopServices>
#include <QMessageBox>
#include <QProcess>

namespace chatterino {

Updates::Updates()
    : currentVersion_(CHATTERINO_VERSION)
    , updateGuideLink_("https://chatterino.com")
{
    qDebug() << "init UpdateManager";
}

Updates &Updates::getInstance()
{
    // fourtf: don't add this class to the application class
    static Updates instance;

    return instance;
}

const QString &Updates::getCurrentVersion() const
{
    return currentVersion_;
}

const QString &Updates::getOnlineVersion() const
{
    return onlineVersion_;
}

void Updates::installUpdates()
{
    if (this->status_ != UpdateAvailable)
    {
        assert(false);
        return;
    }

#ifdef Q_OS_MACOS
    QMessageBox *box = new QMessageBox(
        QMessageBox::Information, "Chatterino Update",
        "A link will open in your browser. Download and install to update.");
    box->setAttribute(Qt::WA_DeleteOnClose);
    box->exec();
    QDesktopServices::openUrl(this->updateExe_);
#elif defined Q_OS_LINUX
    QMessageBox *box =
        new QMessageBox(QMessageBox::Information, "Chatterino Update",
                        "Automatic updates are currently not available on "
                        "linux. Please redownload the app to update.");
    box->setAttribute(Qt::WA_DeleteOnClose);
    box->exec();
    QDesktopServices::openUrl(this->updateGuideLink_);
#elif defined Q_OS_WIN
    QMessageBox *box =
        new QMessageBox(QMessageBox::Information, "Chatterino Update",
                        "Chatterino is downloading the update "
                        "in the background and will run the "
                        "updater once it is finished.");
    box->setAttribute(Qt::WA_DeleteOnClose);
    box->show();

    NetworkRequest req(this->updateExe_);
    req.setTimeout(600000);
    req.onError([this](int) -> bool {
        this->setStatus_(DownloadFailed);

        QMessageBox *box =
            new QMessageBox(QMessageBox::Information, "Chatterino Update",
                            "Failed to download the update. \n\nTry manually "
                            "downloading the update.");
        box->setAttribute(Qt::WA_DeleteOnClose);
        box->exec();
        return true;
    });

    req.onSuccess([this](auto result) -> Outcome {
        QByteArray object = result.getData();
        auto filename = combinePath(getPaths()->miscDirectory, "Update.exe");

        QFile file(filename);
        file.open(QIODevice::Truncate | QIODevice::WriteOnly);

        if (file.write(object) == -1)
        {
            this->setStatus_(WriteFileFailed);
            QMessageBox *box = new QMessageBox(
                QMessageBox::Information, "Chatterino Update",
                "Failed to save the update file. This could be due to "
                "window settings or antivirus software.\n\nTry manually "
                "downloading the update.");
            box->setAttribute(Qt::WA_DeleteOnClose);
            box->exec();

            QDesktopServices::openUrl(this->updateExe_);
            return Failure;
        }
        file.close();

        if (QProcess::startDetached(filename))
        {
            QApplication::exit(0);
        }
        else
        {
            QMessageBox *box = new QMessageBox(
                QMessageBox::Information, "Chatterino Update",
                "Failed to execute update binary. This could be due to window "
                "settings or antivirus software.\n\nTry manually downloading "
                "the update.");
            box->setAttribute(Qt::WA_DeleteOnClose);
            box->exec();

            QDesktopServices::openUrl(this->updateExe_);
        }

        return Success;
    });
    this->setStatus_(Downloading);
    req.execute();
#endif
}

void Updates::checkForUpdates()
{
    QString url =
        "https://notitia.chatterino.com/version/chatterino/" CHATTERINO_OS
        "/stable";

    NetworkRequest req(url);
    req.setTimeout(60000);
    req.onSuccess([this](auto result) -> Outcome {
        auto object = result.parseJson();
        /// Version available on every platform
        QJsonValue version_val = object.value("version");

        if (!version_val.isString())
        {
            this->setStatus_(SearchFailed);
            qDebug() << "error updating";
            return Failure;
        }

#if defined Q_OS_WIN || defined Q_OS_MACOS
        /// Windows downloads an installer for the new version
        QJsonValue updateExe_val = object.value("updateexe");
        if (!updateExe_val.isString())
        {
            this->setStatus_(SearchFailed);
            qDebug() << "error updating";
            return Failure;
        }
        this->updateExe_ = updateExe_val.toString();

#elif defined Q_OS_LINUX
        QJsonValue updateGuide_val = object.value("updateguide");
        if (updateGuide_val.isString())
        {
            this->updateGuideLink_ = updateGuide_val.toString();
        }
#else
        return Failure;
#endif

        /// Current version
        this->onlineVersion_ = version_val.toString();

        /// Update available :)
        if (this->currentVersion_ != this->onlineVersion_)
        {
            this->setStatus_(UpdateAvailable);
        }
        else
        {
            this->setStatus_(NoUpdateAvailable);
        }
        return Failure;
    });
    this->setStatus_(Searching);
    req.execute();
}

Updates::Status Updates::getStatus() const
{
    return this->status_;
}

bool Updates::shouldShowUpdateButton() const
{
    switch (this->getStatus())
    {
        case UpdateAvailable:
        case SearchFailed:
        case Downloading:
        case DownloadFailed:
        case WriteFileFailed:
            return true;

        default:
            return false;
    }
}

bool Updates::isError() const
{
    switch (this->getStatus())
    {
        case SearchFailed:
        case DownloadFailed:
        case WriteFileFailed:
            return true;

        default:
            return false;
    }
}

void Updates::setStatus_(Status status)
{
    if (this->status_ != status)
    {
        this->status_ = status;
        postToThread([this, status] { this->statusUpdated.invoke(status); });
    }
}

}  // namespace chatterino