// SPDX-License-Identifier: GPL-3.0-only
/*
 *  PolyMC - Minecraft Launcher
 *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
 *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, version 3.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * This file incorporates work covered by the following copyright and
 * permission notice:
 *
 *      Copyright 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
 *      Copyright 2020-2021 Petr Mrazek <peterix@gmail.com>
 *
 *      Licensed under the Apache License, Version 2.0 (the "License");
 *      you may not use this file except in compliance with the License.
 *      You may obtain a copy of the License at
 *
 *          http://www.apache.org/licenses/LICENSE-2.0
 *
 *      Unless required by applicable law or agreed to in writing, software
 *      distributed under the License is distributed on an "AS IS" BASIS,
 *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *      See the License for the specific language governing permissions and
 *      limitations under the License.
 */

#include "FTBPackInstallTask.h"

#include "FileSystem.h"
#include "Json.h"
#include "minecraft/MinecraftInstance.h"
#include "minecraft/PackProfile.h"
#include "modplatform/flame/PackManifest.h"
#include "net/ChecksumValidator.h"
#include "settings/INISettingsObject.h"

#include "BuildConfig.h"
#include "Application.h"
#include "ui/dialogs/ScrollMessageBox.h"

namespace ModpacksCH {

PackInstallTask::PackInstallTask(Modpack pack, QString version, QWidget* parent)
    : m_pack(std::move(pack)), m_version_name(std::move(version)), m_parent(parent)
{
}

bool PackInstallTask::abort()
{
    bool aborted = true;

    if (jobPtr)
        aborted &= jobPtr->abort();
    if (modIdResolver)
        aborted &= modIdResolver->abort();

    // FIXME: This should be 'emitAborted()', but InstanceStaging doesn't connect to the abort signal yet...
    if (aborted)
        emitFailed(tr("Aborted"));

    return aborted;
}

void PackInstallTask::executeTask()
{
    setStatus(tr("Getting the manifest..."));

    // Find pack version
    bool found = false;
    VersionInfo version;

    for(auto vInfo : m_pack.versions) {
        if (vInfo.name == m_version_name) {
            found = true;
            version = vInfo;
            break;
        }
    }

    if(!found) {
        emitFailed(tr("Failed to find pack version %1").arg(m_version_name));
        return;
    }

    auto *netJob = new NetJob("ModpacksCH::VersionFetch", APPLICATION->network());

    auto searchUrl = QString(BuildConfig.MODPACKSCH_API_BASE_URL + "public/modpack/%1/%2").arg(m_pack.id).arg(version.id);
    netJob->addNetAction(Net::Download::makeByteArray(QUrl(searchUrl), &response));

    jobPtr = netJob;

    QObject::connect(netJob, &NetJob::succeeded, this, &PackInstallTask::onDownloadSucceeded);
    QObject::connect(netJob, &NetJob::failed, this, &PackInstallTask::onDownloadFailed);
    QObject::connect(netJob, &NetJob::progress, this, &PackInstallTask::setProgress);

    jobPtr->start();
}

void PackInstallTask::onDownloadSucceeded()
{
    jobPtr.reset();

    QJsonParseError parse_error;
    QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
    if(parse_error.error != QJsonParseError::NoError) {
        qWarning() << "Error while parsing JSON response from ModpacksCH at " << parse_error.offset << " reason: " << parse_error.errorString();
        qWarning() << response;
        return;
    }

    auto obj = doc.object();

    ModpacksCH::Version version;
    try {
        ModpacksCH::loadVersion(version, obj);
    } catch (const JSONValidationError &e) {
        emitFailed(tr("Could not understand pack manifest:\n") + e.cause());
        return;
    }

    m_version = version;

    resolveMods();
}

void PackInstallTask::onDownloadFailed(QString reason)
{
    jobPtr.reset();

    emitFailed(reason);
}

void PackInstallTask::resolveMods()
{
    setStatus(tr("Resolving mods..."));
    setProgress(0, 100);

    indexFileIdMap.clear();

    Flame::Manifest manifest;
    int index = 0;

    for(auto const& file : m_version.files) {
        if(!file.serverOnly && file.url.isEmpty()) {
            if(file.curseforge.file <= 0) {
                emitFailed(QString("Invalid manifest: There's no information available to download the file '%1'!").arg(file.name));
                return;
            }

            Flame::File flame_file;
            flame_file.projectId = file.curseforge.project;
            flame_file.fileId = file.curseforge.file;
            flame_file.hash = file.sha1;


            manifest.files.insert(flame_file.fileId, flame_file);
            indexFileIdMap.insert(index, flame_file.fileId);
        }
        index++;
    }

    modIdResolver = new Flame::FileResolvingTask(APPLICATION->network(), manifest);

    connect(modIdResolver.get(), &Flame::FileResolvingTask::succeeded, this, [&]()
    {
        m_abortable = false;

        QString text;
        auto anyBlocked = false;

        Flame::Manifest results = modIdResolver->getResults();
        for (auto index : indexFileIdMap.keys()) {
            int fileId = indexFileIdMap.constFind(index).value();

            Flame::File results_file = results.files[fileId];
            VersionFile& local_file = m_version.files[index];

            // First check for blocked mods
            if (!results_file.resolved || results_file.url.isEmpty()) {
                QString type(local_file.type);

                type[0] = type[0].toUpper();
                text += QString("%1: %2 - <a href='%3'>%3</a><br/>").arg(type, local_file.name, results_file.websiteUrl);
                anyBlocked = true;
            } else {
                local_file.url = results_file.url.toString();
            }
        }

        if (anyBlocked) {
            qDebug() << "Blocked files found, displaying file list";

            auto message_dialog = new ScrollMessageBox(m_parent,
                                                       tr("Blocked files found"),
                                                       tr("The following files are not available for download in third party launchers.<br/>"
                                                          "You will need to manually download them and add them to the instance."),
                                                       text);
            if (message_dialog->exec() == QDialog::Accepted) {
                modIdResolver.reset();
                downloadPack();
            } else {
                modIdResolver.reset();
                abort();
                return;
            }
        } else {
            modIdResolver.reset();
            downloadPack();
        }
    });

    connect(modIdResolver.get(), &Flame::FileResolvingTask::failed, this, &PackInstallTask::onDownloadFailed);
    connect(modIdResolver.get(), &Flame::FileResolvingTask::progress, this, &PackInstallTask::setProgress);

    modIdResolver->start();
}

void PackInstallTask::downloadPack()
{
    setStatus(tr("Downloading mods..."));

    jobPtr = new NetJob(tr("Mod download"), APPLICATION->network());
    for (auto const& file : m_version.files) {
        if (file.serverOnly || file.url.isEmpty())
            continue;

        QFileInfo file_info(file.name);
        auto cacheName = file_info.completeBaseName() + "-" + file.sha1 + "." + file_info.suffix();

        auto entry = APPLICATION->metacache()->resolveEntry("ModpacksCHPacks", cacheName);
        entry->setStale(true);

        auto relpath = FS::PathCombine("minecraft", file.path, file.name);
        auto path = FS::PathCombine(m_stagingPath, relpath);

        if (filesToCopy.contains(path)) {
            qWarning() << "Ignoring" << file.url << "as a file of that path is already downloading.";
            continue;
        }

        qDebug() << "Will download" << file.url << "to" << path;
        filesToCopy[path] = entry->getFullPath();

        auto dl = Net::Download::makeCached(file.url, entry);
        if (!file.sha1.isEmpty()) {
            auto rawSha1 = QByteArray::fromHex(file.sha1.toLatin1());
            dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, rawSha1));
        }

        jobPtr->addNetAction(dl);
    }

    connect(jobPtr.get(), &NetJob::succeeded, this, [&]()
    {
        jobPtr.reset();
        install();
    });
    connect(jobPtr.get(), &NetJob::failed, [&](QString reason)
    {
        jobPtr.reset();
        emitFailed(reason);
    });
    connect(jobPtr.get(), &NetJob::progress, this, &PackInstallTask::setProgress);

    jobPtr->start();

    m_abortable = true;
}

void PackInstallTask::install()
{
    m_abortable = false;

    setStatus(tr("Copying modpack files"));

    for (auto iter = filesToCopy.cbegin(); iter != filesToCopy.cend(); iter++) {
        auto& to = iter.key();
        auto& from = iter.value();
        FS::copy fileCopyOperation(from, to);
        if(!fileCopyOperation()) {
            qWarning() << "Failed to copy" << from << "to" << to;
            emitFailed(tr("Failed to copy files"));
            return;
        }
    }

    setStatus(tr("Installing modpack"));

    auto instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg");
    auto instanceSettings = std::make_shared<INISettingsObject>(instanceConfigPath);
    instanceSettings->suspendSave();

    MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
    auto components = instance.getPackProfile();
    components->buildingFromScratch();

    for(auto target : m_version.targets) {
        if(target.type == "game" && target.name == "minecraft") {
            components->setComponentVersion("net.minecraft", target.version, true);
            break;
        }
    }

    for(auto target : m_version.targets) {
        if(target.type != "modloader") continue;

        if(target.name == "forge") {
            components->setComponentVersion("net.minecraftforge", target.version);
        }
        else if(target.name == "fabric") {
            components->setComponentVersion("net.fabricmc.fabric-loader", target.version);
        }
    }

    // install any jar mods
    QDir jarModsDir(FS::PathCombine(m_stagingPath, "minecraft", "jarmods"));
    if (jarModsDir.exists()) {
        QStringList jarMods;

        for (const auto& info : jarModsDir.entryInfoList(QDir::NoDotAndDotDot | QDir::Files)) {
            jarMods.push_back(info.absoluteFilePath());
        }

        components->installJarMods(jarMods);
    }

    components->saveNow();

    instance.setName(m_instName);
    instance.setIconKey(m_instIcon);
    instance.setManagedPack("modpacksch", QString::number(m_pack.id), m_pack.name, QString::number(m_version.id), m_version.name);
    instanceSettings->resumeSave();

    emitSucceeded();
}

}