#include "ComponentUpdateTask.h"
#include <algorithm>

#include "Component.h"
#include "ComponentUpdateTask_p.h"
#include "PackProfile.h"
#include "PackProfile_p.h"
#include "ProblemProvider.h"
#include "Version.h"
#include "cassert"
#include "meta/Index.h"
#include "meta/Version.h"
#include "minecraft/MinecraftInstance.h"
#include "minecraft/OneSixVersionFormat.h"
#include "minecraft/ProfileUtils.h"
#include "net/Mode.h"

#include "Application.h"
#include "tasks/Task.h"

#include "minecraft/Logging.h"

/*
 * This is responsible for loading the components of a component list AND resolving dependency issues between them
 */

/*
 * FIXME: the 'one shot async task' nature of this does not fit the intended usage
 * Really, it should be a reactor/state machine that receives input from the application
 * and dynamically adapts to changing requirements...
 *
 * The reactor should be the only entry into manipulating the PackProfile.
 * See: https://en.wikipedia.org/wiki/Reactor_pattern
 */

/*
 * Or make this operate on a snapshot of the PackProfile state, then merge results in as long as the snapshot and PackProfile didn't change?
 * If the component list changes, start over.
 */

ComponentUpdateTask::ComponentUpdateTask(Mode mode, Net::Mode netmode, PackProfile* list) : Task()
{
    d.reset(new ComponentUpdateTaskData);
    d->m_profile = list;
    d->mode = mode;
    d->netmode = netmode;
}

ComponentUpdateTask::~ComponentUpdateTask() {}

void ComponentUpdateTask::executeTask()
{
    qCDebug(instanceProfileResolveC) << "Loading components";
    loadComponents();
}

namespace {
enum class LoadResult { LoadedLocal, RequiresRemote, Failed };

LoadResult composeLoadResult(LoadResult a, LoadResult b)
{
    if (a < b) {
        return b;
    }
    return a;
}

static LoadResult loadComponent(ComponentPtr component, Task::Ptr& loadTask, Net::Mode netmode)
{
    if (component->m_loaded) {
        qCDebug(instanceProfileResolveC) << component->getName() << "is already loaded";
        return LoadResult::LoadedLocal;
    }

    LoadResult result = LoadResult::Failed;
    auto customPatchFilename = component->getFilename();
    if (QFile::exists(customPatchFilename)) {
        // if local file exists...

        // check for uid problems inside...
        bool fileChanged = false;
        auto file = ProfileUtils::parseJsonFile(QFileInfo(customPatchFilename), false);
        if (file->uid != component->m_uid) {
            file->uid = component->m_uid;
            fileChanged = true;
        }
        if (fileChanged) {
            // FIXME: @QUALITY do not ignore return value
            ProfileUtils::saveJsonFile(OneSixVersionFormat::versionFileToJson(file), customPatchFilename);
        }

        component->m_file = file;
        component->m_loaded = true;
        result = LoadResult::LoadedLocal;
    } else {
        auto metaVersion = APPLICATION->metadataIndex()->get(component->m_uid, component->m_version);
        component->m_metaVersion = metaVersion;
        if (metaVersion->isLoaded()) {
            component->m_loaded = true;
            result = LoadResult::LoadedLocal;
        } else {
            loadTask = APPLICATION->metadataIndex()->loadVersion(component->m_uid, component->m_version, netmode);
            loadTask->start();
            if (netmode == Net::Mode::Online)
                result = LoadResult::RequiresRemote;
            else if (metaVersion->isLoaded())
                result = LoadResult::LoadedLocal;
            else
                result = LoadResult::Failed;
        }
    }
    return result;
}

// FIXME: dead code. determine if this can still be useful?
/*
static LoadResult loadPackProfile(ComponentPtr component, Task::Ptr& loadTask, Net::Mode netmode)
{
    if(component->m_loaded)
    {
        qDebug() << component->getName() << "is already loaded";
        return LoadResult::LoadedLocal;
    }

    LoadResult result = LoadResult::Failed;
    auto metaList = APPLICATION->metadataIndex()->get(component->m_uid);
    if(metaList->isLoaded())
    {
        component->m_loaded = true;
        result = LoadResult::LoadedLocal;
    }
    else
    {
        metaList->load(netmode);
        loadTask = metaList->getCurrentTask();
        result = LoadResult::RequiresRemote;
    }
    return result;
}
*/

}  // namespace

void ComponentUpdateTask::loadComponents()
{
    LoadResult result = LoadResult::LoadedLocal;
    size_t taskIndex = 0;
    size_t componentIndex = 0;
    d->remoteLoadSuccessful = true;

    // load all the components OR their lists...
    for (auto component : d->m_profile->d->components) {
        Task::Ptr loadTask;
        LoadResult singleResult;
        RemoteLoadStatus::Type loadType;
        component->resetComponentProblems();
        // FIXME: to do this right, we need to load the lists and decide on which versions to use during dependency resolution. For now,
        // ignore all that...
#if 0
        switch(d->mode)
        {
            case Mode::Launch:
            {
                singleResult = loadComponent(component, loadTask, d->netmode);
                loadType = RemoteLoadStatus::Type::Version;
                break;
            }
            case Mode::Resolution:
            {
                singleResult = loadPackProfile(component, loadTask, d->netmode);
                loadType = RemoteLoadStatus::Type::List;
                break;
            }
        }
#else
        singleResult = loadComponent(component, loadTask, d->netmode);
        loadType = RemoteLoadStatus::Type::Version;
#endif
        if (singleResult == LoadResult::LoadedLocal) {
            component->updateCachedData();
        }
        result = composeLoadResult(result, singleResult);
        if (loadTask) {
            qCDebug(instanceProfileResolveC) << d->m_profile->d->m_instance->name() << "|"
                                             << "Remote loading is being run for" << component->getName();
            connect(loadTask.get(), &Task::succeeded, this, [this, taskIndex]() { remoteLoadSucceeded(taskIndex); });
            connect(loadTask.get(), &Task::failed, this, [this, taskIndex](const QString& error) { remoteLoadFailed(taskIndex, error); });
            connect(loadTask.get(), &Task::aborted, this, [this, taskIndex]() { remoteLoadFailed(taskIndex, tr("Aborted")); });
            RemoteLoadStatus status;
            status.type = loadType;
            status.PackProfileIndex = componentIndex;
            status.task = loadTask;
            d->remoteLoadStatusList.append(status);
            taskIndex++;
        }
        componentIndex++;
    }
    d->remoteTasksInProgress = taskIndex;
    switch (result) {
        case LoadResult::LoadedLocal: {
            // Everything got loaded. Advance to dependency resolution.
            performUpdateActions();
            resolveDependencies(d->mode == Mode::Launch || d->netmode == Net::Mode::Offline);
            break;
        }
        case LoadResult::RequiresRemote: {
            // we wait for signals.
            break;
        }
        case LoadResult::Failed: {
            emitFailed(tr("Some component metadata load tasks failed."));
            break;
        }
    }
}

namespace {
struct RequireEx : public Meta::Require {
    size_t indexOfFirstDependee = 0;
};
struct RequireCompositionResult {
    bool ok;
    RequireEx outcome;
};
using RequireExSet = std::set<RequireEx>;
}  // namespace

static RequireCompositionResult composeRequirement(const RequireEx& a, const RequireEx& b)
{
    assert(a.uid == b.uid);
    RequireEx out;
    out.uid = a.uid;
    out.indexOfFirstDependee = std::min(a.indexOfFirstDependee, b.indexOfFirstDependee);
    if (a.equalsVersion.isEmpty()) {
        out.equalsVersion = b.equalsVersion;
    } else if (b.equalsVersion.isEmpty()) {
        out.equalsVersion = a.equalsVersion;
    } else if (a.equalsVersion == b.equalsVersion) {
        out.equalsVersion = a.equalsVersion;
    } else {
        // FIXME: mark error as explicit version conflict
        return { false, out };
    }

    if (a.suggests.isEmpty()) {
        out.suggests = b.suggests;
    } else if (b.suggests.isEmpty()) {
        out.suggests = a.suggests;
    } else {
        Version aVer(a.suggests);
        Version bVer(b.suggests);
        out.suggests = (aVer < bVer ? b.suggests : a.suggests);
    }
    return { true, out };
}

// gather the requirements from all components, finding any obvious conflicts
static bool gatherRequirementsFromComponents(const ComponentContainer& input, RequireExSet& output)
{
    bool succeeded = true;
    size_t componentNum = 0;
    for (auto component : input) {
        auto& componentRequires = component->m_cachedRequires;
        for (const auto& componentRequire : componentRequires) {
            auto found = std::find_if(output.cbegin(), output.cend(),
                                      [componentRequire](const Meta::Require& req) { return req.uid == componentRequire.uid; });

            RequireEx componenRequireEx;
            componenRequireEx.uid = componentRequire.uid;
            componenRequireEx.suggests = componentRequire.suggests;
            componenRequireEx.equalsVersion = componentRequire.equalsVersion;
            componenRequireEx.indexOfFirstDependee = componentNum;

            if (found != output.cend()) {
                // found... process it further
                auto result = composeRequirement(componenRequireEx, *found);
                if (result.ok) {
                    output.erase(componenRequireEx);
                    output.insert(result.outcome);
                } else {
                    qCCritical(instanceProfileResolveC) << "Conflicting requirements:" << componentRequire.uid
                                                        << "versions:" << componentRequire.equalsVersion << ";" << (*found).equalsVersion;
                }
                succeeded &= result.ok;
            } else {
                // not found, accumulate
                output.insert(componenRequireEx);
            }
        }
        componentNum++;
    }
    return succeeded;
}

/// Get list of uids that can be trivially removed because nothing is depending on them anymore (and they are installed as deps)
static void getTrivialRemovals(const ComponentContainer& components, const RequireExSet& reqs, QStringList& toRemove)
{
    for (const auto& component : components) {
        if (!component->m_dependencyOnly)
            continue;
        if (!component->m_cachedVolatile)
            continue;
        RequireEx reqNeedle;
        reqNeedle.uid = component->m_uid;
        const auto iter = reqs.find(reqNeedle);
        if (iter == reqs.cend()) {
            toRemove.append(component->m_uid);
        }
    }
}

/**
 * handles:
 * - trivial addition (there is an unmet requirement and it can be trivially met by adding something)
 * - trivial version conflict of dependencies == explicit version required and installed is different
 *
 * toAdd - set of requirements than mean adding a new component
 * toChange - set of requirements that mean changing version of an existing component
 */
static bool getTrivialComponentChanges(const ComponentIndex& index, const RequireExSet& input, RequireExSet& toAdd, RequireExSet& toChange)
{
    enum class Decision { Undetermined, Met, Missing, VersionNotSame, LockedVersionNotSame } decision = Decision::Undetermined;

    QString reqStr;
    bool succeeded = true;
    // list the composed requirements and say if they are met or unmet
    for (auto& req : input) {
        do {
            if (req.equalsVersion.isEmpty()) {
                reqStr = QString("Req: %1").arg(req.uid);
                if (index.contains(req.uid)) {
                    decision = Decision::Met;
                } else {
                    toAdd.insert(req);
                    decision = Decision::Missing;
                }
                break;
            } else {
                reqStr = QString("Req: %1 == %2").arg(req.uid, req.equalsVersion);
                const auto& compIter = index.find(req.uid);
                if (compIter == index.cend()) {
                    toAdd.insert(req);
                    decision = Decision::Missing;
                    break;
                }
                auto& comp = (*compIter);
                if (comp->getVersion() != req.equalsVersion) {
                    if (comp->isCustom()) {
                        decision = Decision::LockedVersionNotSame;
                    } else {
                        if (comp->m_dependencyOnly) {
                            decision = Decision::VersionNotSame;
                        } else {
                            decision = Decision::LockedVersionNotSame;
                        }
                    }
                    break;
                }
                decision = Decision::Met;
            }
        } while (false);
        switch (decision) {
            case Decision::Undetermined:
                qCCritical(instanceProfileResolveC) << "No decision for" << reqStr;
                succeeded = false;
                break;
            case Decision::Met:
                qCDebug(instanceProfileResolveC) << reqStr << "Is met.";
                break;
            case Decision::Missing:
                qCDebug(instanceProfileResolveC) << reqStr << "Is missing and should be added at" << req.indexOfFirstDependee;
                toAdd.insert(req);
                break;
            case Decision::VersionNotSame:
                qCDebug(instanceProfileResolveC) << reqStr << "already has different version that can be changed.";
                toChange.insert(req);
                break;
            case Decision::LockedVersionNotSame:
                qCDebug(instanceProfileResolveC) << reqStr << "already has different version that cannot be changed.";
                succeeded = false;
                break;
        }
    }
    return succeeded;
}

ComponentContainer ComponentUpdateTask::collectTreeLinked(const QString& uid)
{
    ComponentContainer linked;

    auto& components = d->m_profile->d->components;
    auto& componentIndex = d->m_profile->d->componentIndex;
    auto& instance = d->m_profile->d->m_instance;
    for (auto comp : components) {
        qCDebug(instanceProfileResolveC) << instance->name() << "|"
                                         << "scanning" << comp->getID() << ":" << comp->getVersion() << "for tree link";
        auto dep = std::find_if(comp->m_cachedRequires.cbegin(), comp->m_cachedRequires.cend(),
                                [uid](const Meta::Require& req) -> bool { return req.uid == uid; });
        if (dep != comp->m_cachedRequires.cend()) {
            qCDebug(instanceProfileResolveC) << instance->name() << "|" << comp->getID() << ":" << comp->getVersion() << "depends on"
                                             << uid;
            linked.append(comp);
        }
    }
    auto iter = componentIndex.find(uid);
    if (iter != componentIndex.end()) {
        ComponentPtr comp = *iter;
        comp->updateCachedData();
        qCDebug(instanceProfileResolveC) << instance->name() << "|" << comp->getID() << ":" << comp->getVersion() << "has"
                                         << comp->m_cachedRequires.size() << "dependencies";
        for (auto dep : comp->m_cachedRequires) {
            qCDebug(instanceProfileC) << instance->name() << "|" << uid << "depends on" << dep.uid;
            auto found = componentIndex.find(dep.uid);
            if (found != componentIndex.end()) {
                qCDebug(instanceProfileC) << instance->name() << "|" << (*found)->getID() << "is present";
                linked.append(*found);
            }
        }
    }
    return linked;
}

// FIXME, TODO: decouple dependency resolution from loading
// FIXME: This works directly with the PackProfile internals. It shouldn't! It needs richer data types than PackProfile uses.
// FIXME: throw all this away and use a graph
void ComponentUpdateTask::resolveDependencies(bool checkOnly)
{
    qCDebug(instanceProfileResolveC) << "Resolving dependencies";
    /*
     * this is a naive dependency resolving algorithm. all it does is check for following conditions and react in simple ways:
     * 1. There are conflicting dependencies on the same uid with different exact version numbers
     *    -> hard error
     * 2. A dependency has non-matching exact version number
     *    -> hard error
     * 3. A dependency is entirely missing and needs to be injected before the dependee(s)
     *    -> requirements are injected
     *
     * NOTE: this is a placeholder and should eventually be replaced with something 'serious'
     */
    auto& components = d->m_profile->d->components;
    auto& componentIndex = d->m_profile->d->componentIndex;

    RequireExSet allRequires;
    QStringList toRemove;
    do {
        allRequires.clear();
        toRemove.clear();
        if (!gatherRequirementsFromComponents(components, allRequires)) {
            finalizeComponents();
            emitFailed(tr("Conflicting requirements detected during dependency checking!"));
            return;
        }
        getTrivialRemovals(components, allRequires, toRemove);
        if (!toRemove.isEmpty()) {
            qCDebug(instanceProfileResolveC) << "Removing obsolete components...";
            for (auto& remove : toRemove) {
                qCDebug(instanceProfileResolveC) << "Removing" << remove;
                d->m_profile->remove(remove);
            }
        }
    } while (!toRemove.isEmpty());
    RequireExSet toAdd;
    RequireExSet toChange;
    bool succeeded = getTrivialComponentChanges(componentIndex, allRequires, toAdd, toChange);
    if (!succeeded) {
        finalizeComponents();
        emitFailed(tr("Instance has conflicting dependencies."));
        return;
    }
    if (checkOnly) {
        finalizeComponents();
        if (toAdd.size() || toChange.size()) {
            emitFailed(tr("Instance has unresolved dependencies while loading/checking for launch."));
        } else {
            emitSucceeded();
        }
        return;
    }

    bool recursionNeeded = false;
    if (toAdd.size()) {
        // add stuff...
        for (auto& add : toAdd) {
            auto component = makeShared<Component>(d->m_profile, add.uid);
            if (!add.equalsVersion.isEmpty()) {
                // exact version
                qCDebug(instanceProfileResolveC)
                    << "Adding" << add.uid << "version" << add.equalsVersion << "at position" << add.indexOfFirstDependee;
                component->m_version = add.equalsVersion;
            } else {
                // version needs to be decided
                qCDebug(instanceProfileResolveC) << "Adding" << add.uid << "at position" << add.indexOfFirstDependee;
                // ############################################################################################################
                // HACK HACK HACK HACK FIXME: this is a placeholder for deciding what version to use. For now, it is hardcoded.
                if (!add.suggests.isEmpty()) {
                    component->m_version = add.suggests;
                } else {
                    if (add.uid == "org.lwjgl") {
                        component->m_version = "2.9.1";
                    } else if (add.uid == "org.lwjgl3") {
                        component->m_version = "3.1.2";
                    } else if (add.uid == "net.fabricmc.intermediary" || add.uid == "org.quiltmc.hashed") {
                        auto minecraft = std::find_if(components.begin(), components.end(),
                                                      [](ComponentPtr& cmp) { return cmp->getID() == "net.minecraft"; });
                        if (minecraft != components.end()) {
                            component->m_version = (*minecraft)->getVersion();
                        }
                    }
                }
                // HACK HACK HACK HACK FIXME: this is a placeholder for deciding what version to use. For now, it is hardcoded.
                // ############################################################################################################
            }
            component->m_dependencyOnly = true;
            // FIXME: this should not work directly with the component list
            d->m_profile->insertComponent(add.indexOfFirstDependee, component);
            componentIndex[add.uid] = component;
        }
        recursionNeeded = true;
    }
    if (toChange.size()) {
        // change a version of something that exists
        for (auto& change : toChange) {
            // FIXME: this should not work directly with the component list
            qCDebug(instanceProfileResolveC) << "Setting version of " << change.uid << "to" << change.equalsVersion;
            auto component = componentIndex[change.uid];
            component->setVersion(change.equalsVersion);
        }
        recursionNeeded = true;
    }

    if (recursionNeeded) {
        loadComponents();
    } else {
        finalizeComponents();
        emitSucceeded();
    }
}

// Variant visitation via lambda
template <class... Ts>
struct overload : Ts... {
    using Ts::operator()...;
};
template <class... Ts>
overload(Ts...) -> overload<Ts...>;

void ComponentUpdateTask::performUpdateActions()
{
    auto& instance = d->m_profile->d->m_instance;
    bool addedActions;
    QStringList toRemove;
    do {
        addedActions = false;
        toRemove.clear();
        auto& components = d->m_profile->d->components;
        auto& componentIndex = d->m_profile->d->componentIndex;
        for (auto component : components) {
            if (!component) {
                continue;
            }
            auto action = component->getUpdateAction();
            auto visitor =
                overload{ [](const UpdateActionNone&) {
                             // noop
                         },
                          [&component, &instance](const UpdateActionChangeVersion& cv) {
                              qCDebug(instanceProfileResolveC) << instance->name() << "|"
                                                               << "UpdateActionChangeVersion" << component->getID() << ":"
                                                               << component->getVersion() << "change to" << cv.targetVersion;
                              component->setVersion(cv.targetVersion);
                              component->waitLoadMeta();
                          },
                          [&component, &instance](const UpdateActionLatestRecommendedCompatible lrc) {
                              qCDebug(instanceProfileResolveC)
                                  << instance->name() << "|"
                                  << "UpdateActionLatestRecommendedCompatible" << component->getID() << ":" << component->getVersion()
                                  << "updating to latest recommend or compatible with" << lrc.parentUid << lrc.version;
                              auto versionList = APPLICATION->metadataIndex()->get(component->getID());
                              if (versionList) {
                                  versionList->waitToLoad();
                                  auto recommended = versionList->getRecommendedForParent(lrc.parentUid, lrc.version);
                                  if (!recommended) {
                                      recommended = versionList->getLatestForParent(lrc.parentUid, lrc.version);
                                  }
                                  if (recommended) {
                                      component->setVersion(recommended->version());
                                      component->waitLoadMeta();
                                      return;
                                  } else {
                                      component->addComponentProblem(ProblemSeverity::Error,
                                                                     QObject::tr("No compatible version of %1 found for %2 %3")
                                                                         .arg(component->getName(), lrc.parentName, lrc.version));
                                  }
                              } else {
                                  component->addComponentProblem(
                                      ProblemSeverity::Error,
                                      QObject::tr("No version list in metadata index for %1").arg(component->getID()));
                              }
                          },
                          [&component, &instance, &toRemove](const UpdateActionRemove&) {
                              qCDebug(instanceProfileResolveC)
                                  << instance->name() << "|"
                                  << "UpdateActionRemove" << component->getID() << ":" << component->getVersion() << "removing";
                              toRemove.append(component->getID());
                          },
                          [this, &component, &instance, &addedActions, &componentIndex](const UpdateActionImportantChanged& ic) {
                              qCDebug(instanceProfileResolveC)
                                  << instance->name() << "|"
                                  << "UpdateImportantChanged" << component->getID() << ":" << component->getVersion() << "was changed from"
                                  << ic.oldVersion << "updating linked components";
                              auto oldVersion = APPLICATION->metadataIndex()->getLoadedVersion(component->getID(), ic.oldVersion);
                              for (auto oldReq : oldVersion->requiredSet()) {
                                  auto currentlyRequired = component->m_cachedRequires.find(oldReq);
                                  if (currentlyRequired == component->m_cachedRequires.cend()) {
                                      auto oldReqComp = componentIndex.find(oldReq.uid);
                                      if (oldReqComp != componentIndex.cend()) {
                                          (*oldReqComp)->setUpdateAction(UpdateAction{ UpdateActionRemove{} });
                                          addedActions = true;
                                      }
                                  }
                              }
                              auto linked = collectTreeLinked(component->getID());
                              for (auto comp : linked) {
                                  if (comp->isCustom()) {
                                      continue;
                                  }
                                  auto compUid = comp->getID();
                                  auto parentReq = std::find_if(component->m_cachedRequires.begin(), component->m_cachedRequires.end(),
                                                                [compUid](const Meta::Require& req) { return req.uid == compUid; });
                                  if (parentReq != component->m_cachedRequires.end()) {
                                      auto newVersion = parentReq->equalsVersion.isEmpty() ? parentReq->suggests : parentReq->equalsVersion;
                                      if (!newVersion.isEmpty()) {
                                          comp->setUpdateAction(UpdateAction{ UpdateActionChangeVersion{ newVersion } });
                                      } else {
                                          comp->setUpdateAction(UpdateAction{ UpdateActionLatestRecommendedCompatible{
                                              component->getID(),
                                              component->getName(),
                                              component->getVersion(),
                                          } });
                                      }
                                  } else {
                                      comp->setUpdateAction(UpdateAction{ UpdateActionLatestRecommendedCompatible{
                                          component->getID(),
                                          component->getName(),
                                          component->getVersion(),
                                      } });
                                  }
                                  addedActions = true;
                              }
                          } };
            std::visit(visitor, action);
            component->clearUpdateAction();
            for (auto uid : toRemove) {
                d->m_profile->remove(uid);
            }
        }
    } while (addedActions);
}

void ComponentUpdateTask::finalizeComponents()
{
    auto& components = d->m_profile->d->components;
    auto& componentIndex = d->m_profile->d->componentIndex;
    for (auto component : components) {
        for (auto req : component->m_cachedRequires) {
            auto found = componentIndex.find(req.uid);
            if (found == componentIndex.cend()) {
                component->addComponentProblem(
                    ProblemSeverity::Error,
                    QObject::tr("%1 is missing requirement %2 %3")
                        .arg(component->getName(), req.uid, req.equalsVersion.isEmpty() ? req.suggests : req.equalsVersion));
            } else {
                auto reqComp = *found;
                if (!reqComp->getProblems().isEmpty()) {
                    component->addComponentProblem(
                        reqComp->getProblemSeverity(),
                        QObject::tr("%1, a dependency of this component, has reported issues").arg(reqComp->getName()));
                }
                if (!req.equalsVersion.isEmpty() && req.equalsVersion != reqComp->getVersion()) {
                    component->addComponentProblem(ProblemSeverity::Error,
                                                   QObject::tr("%1, a dependency of this component, is not the required version %2")
                                                       .arg(reqComp->getName(), req.equalsVersion));
                } else if (!req.suggests.isEmpty() && req.suggests != reqComp->getVersion()) {
                    component->addComponentProblem(ProblemSeverity::Warning,
                                                   QObject::tr("%1, a dependency of this component, is not the suggested version %2")
                                                       .arg(reqComp->getName(), req.suggests));
                }
            }
        }
        for (auto conflict : component->knownConflictingComponents()) {
            auto found = componentIndex.find(conflict);
            if (found != componentIndex.cend()) {
                auto foundComp = *found;
                if (foundComp->isCustom()) {
                    continue;
                }
                component->addComponentProblem(
                    ProblemSeverity::Warning,
                    QObject::tr("%1 and %2 are known to not work together. It is recommended to remove one of them.")
                        .arg(component->getName(), foundComp->getName()));
            }
        }
    }
}

void ComponentUpdateTask::remoteLoadSucceeded(size_t taskIndex)
{
    if (static_cast<size_t>(d->remoteLoadStatusList.size()) < taskIndex) {
        qCWarning(instanceProfileResolveC) << "Got task index outside of results" << taskIndex;
        return;
    }
    auto& taskSlot = d->remoteLoadStatusList[taskIndex];
    disconnect(taskSlot.task.get(), &Task::succeeded, this, nullptr);
    disconnect(taskSlot.task.get(), &Task::failed, this, nullptr);
    disconnect(taskSlot.task.get(), &Task::aborted, this, nullptr);
    if (taskSlot.finished) {
        qCWarning(instanceProfileResolveC) << "Got multiple results from remote load task" << taskIndex;
        return;
    }
    qCDebug(instanceProfileResolveC) << "Remote task" << taskIndex << "succeeded";
    taskSlot.succeeded = false;
    taskSlot.finished = true;
    d->remoteTasksInProgress--;
    // update the cached data of the component from the downloaded version file.
    if (taskSlot.type == RemoteLoadStatus::Type::Version) {
        auto component = d->m_profile->getComponent(taskSlot.PackProfileIndex);
        component->m_loaded = true;
        component->updateCachedData();
    }
    checkIfAllFinished();
}

void ComponentUpdateTask::remoteLoadFailed(size_t taskIndex, const QString& msg)
{
    if (static_cast<size_t>(d->remoteLoadStatusList.size()) < taskIndex) {
        qCWarning(instanceProfileResolveC) << "Got task index outside of results" << taskIndex;
        return;
    }
    auto& taskSlot = d->remoteLoadStatusList[taskIndex];
    disconnect(taskSlot.task.get(), &Task::succeeded, this, nullptr);
    disconnect(taskSlot.task.get(), &Task::failed, this, nullptr);
    disconnect(taskSlot.task.get(), &Task::aborted, this, nullptr);
    if (taskSlot.finished) {
        qCWarning(instanceProfileResolveC) << "Got multiple results from remote load task" << taskIndex;
        return;
    }
    qCDebug(instanceProfileResolveC) << "Remote task" << taskIndex << "failed: " << msg;
    d->remoteLoadSuccessful = false;
    taskSlot.succeeded = false;
    taskSlot.finished = true;
    taskSlot.error = msg;
    d->remoteTasksInProgress--;
    checkIfAllFinished();
}

void ComponentUpdateTask::checkIfAllFinished()
{
    if (d->remoteTasksInProgress) {
        // not yet...
        return;
    }
    if (d->remoteLoadSuccessful) {
        // nothing bad happened... clear the temp load status and proceed with looking at dependencies
        d->remoteLoadStatusList.clear();
        performUpdateActions();
        resolveDependencies(d->mode == Mode::Launch);
    } else {
        // remote load failed... report error and bail
        QStringList allErrorsList;
        for (auto& item : d->remoteLoadStatusList) {
            if (!item.succeeded) {
                allErrorsList.append(item.error);
            }
        }
        auto allErrors = allErrorsList.join("\n");
        emitFailed(tr("Component metadata update task failed while downloading from remote server:\n%1").arg(allErrors));
        d->remoteLoadStatusList.clear();
    }
}
