pollymc/api/logic/modplatform/ftb/FtbPackInstallTask.cpp

#include "FtbPackInstallTask.h"
#include "Env.h"
#include "MMCZip.h"
#include "QtConcurrent"
#include "BaseInstance.h"
#include "FileSystem.h"
#include "settings/INISettingsObject.h"
#include "minecraft/MinecraftInstance.h"
#include "minecraft/ComponentList.h"
#include "minecraft/GradleSpecifier.h"

#include "net/URLConstants.h"

FtbPackInstallTask::FtbPackInstallTask(FtbModpack pack, QString version)
{
    m_pack = pack;
    m_version = version;
}

void FtbPackInstallTask::executeTask()
{
    downloadPack();
}

void FtbPackInstallTask::downloadPack()
{
    setStatus(tr("Downloading zip for %1").arg(m_pack.name));

    auto packoffset = QString("%1/%2/%3").arg(m_pack.dir, m_version.replace(".", "_"), m_pack.file);
    auto entry = ENV.metacache()->resolveEntry("FTBPacks", packoffset);
    NetJob *job = new NetJob("Download FTB Pack");

    entry->setStale(true);
    QString url;
    if(m_pack.type == FtbPackType::Private)
    {
        url = QString(URLConstants::FTB_CDN_BASE_URL + "privatepacks/%1").arg(packoffset);
    }
    else
    {
        url = QString(URLConstants::FTB_CDN_BASE_URL + "modpacks/%1").arg(packoffset);
    }
    job->addNetAction(Net::Download::makeCached(url, entry));
    archivePath = entry->getFullPath();

    netJobContainer.reset(job);
    connect(job, &NetJob::succeeded, this, &FtbPackInstallTask::onDownloadSucceeded);
    connect(job, &NetJob::failed, this, &FtbPackInstallTask::onDownloadFailed);
    connect(job, &NetJob::progress, this, &FtbPackInstallTask::onDownloadProgress);
    job->start();

    progress(1, 4);
}

void FtbPackInstallTask::onDownloadSucceeded()
{
    abortable = false;
    unzip();
}

void FtbPackInstallTask::onDownloadFailed(QString reason)
{
    abortable = false;
    emitFailed(reason);
}

void FtbPackInstallTask::onDownloadProgress(qint64 current, qint64 total)
{
    abortable = true;
    progress(current, total * 4);
    setStatus(tr("Downloading zip for %1 (%2%)").arg(m_pack.name).arg(current / 10));
}

void FtbPackInstallTask::unzip()
{
    progress(2, 4);
    setStatus(tr("Extracting modpack"));
    QDir extractDir(m_stagingPath);

    m_packZip.reset(new QuaZip(archivePath));
    if(!m_packZip->open(QuaZip::mdUnzip))
    {
        emitFailed(tr("Failed to open modpack file %1!").arg(archivePath));
        return;
    }

    m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractDir, archivePath, extractDir.absolutePath() + "/unzip");
    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &FtbPackInstallTask::onUnzipFinished);
    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &FtbPackInstallTask::onUnzipCanceled);
    m_extractFutureWatcher.setFuture(m_extractFuture);
}

void FtbPackInstallTask::onUnzipFinished()
{
    install();
}

void FtbPackInstallTask::onUnzipCanceled()
{
    emitAborted();
}

void FtbPackInstallTask::install()
{
    progress(3, 4);
    setStatus(tr("Installing modpack"));
    QDir unzipMcDir(m_stagingPath + "/unzip/minecraft");
    if(unzipMcDir.exists())
    {
        //ok, found minecraft dir, move contents to instance dir
        if(!QDir().rename(m_stagingPath + "/unzip/minecraft", m_stagingPath + "/.minecraft"))
        {
            emitFailed(tr("Failed to move unzipped minecraft!"));
            return;
        }
    }

    QString instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg");
    auto instanceSettings = std::make_shared<INISettingsObject>(instanceConfigPath);
    instanceSettings->registerSetting("InstanceType", "Legacy");
    instanceSettings->set("InstanceType", "OneSix");

    MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
    auto components = instance.getComponentList();
    components->buildingFromScratch();
    components->setComponentVersion("net.minecraft", m_pack.mcVersion, true);

    bool fallback = true;

    //handle different versions
    QFile packJson(m_stagingPath + "/.minecraft/pack.json");
    QDir jarmodDir = QDir(m_stagingPath + "/unzip/instMods");
    if(packJson.exists())
    {
        packJson.open(QIODevice::ReadOnly | QIODevice::Text);
        QJsonDocument doc = QJsonDocument::fromJson(packJson.readAll());
        packJson.close();

        //we only care about the libs
        QJsonArray libs = doc.object().value("libraries").toArray();

        foreach (const QJsonValue &value, libs)
        {
            QString nameValue = value.toObject().value("name").toString();
            if(!nameValue.startsWith("net.minecraftforge"))
            {
                continue;
            }

            GradleSpecifier forgeVersion(nameValue);

            components->setComponentVersion("net.minecraftforge", forgeVersion.version().replace(m_pack.mcVersion, "").replace("-", ""));
            packJson.remove();
            fallback = false;
            break;
        }

    }

    if(jarmodDir.exists())
    {
        qDebug() << "Found jarmods, installing...";

        QStringList jarmods;
        for (auto info: jarmodDir.entryInfoList(QDir::NoDotAndDotDot | QDir::Files))
        {
            qDebug() << "Jarmod:" << info.fileName();
            jarmods.push_back(info.absoluteFilePath());
        }

        components->installJarMods(jarmods);
        fallback = false;
    }

    //just nuke unzip directory, it s not needed anymore
    FS::deletePath(m_stagingPath + "/unzip");

    if(fallback)
    {
        //TODO: Some fallback mechanism... or just keep failing!
        emitFailed(tr("No installation method found!"));
        return;
    }

    components->saveNow();

    progress(4, 4);

    instance.setName(m_instName);
    if(m_instIcon == "default")
    {
        m_instIcon = "ftb_logo";
    }
    instance.setIconKey(m_instIcon);
    instanceSettings->resumeSave();

    emitSucceeded();
}

bool FtbPackInstallTask::abort()
{
    if(abortable)
    {
        return netJobContainer->abort();
    }
    return false;
}