Merge branch 'develop' of https://github.com/PrismLauncher/PrismLauncher into curse

26 files changed, 729 insertions, 69 deletions

diff --git a/launcher/CMakeLists.txt b/launcher/CMakeLists.txt
index 0dc2b80a..97620401 100644
--- a/launcher/CMakeLists.txt
+++ b/launcher/CMakeLists.txt
@@ -362,6 +362,8 @@ set(MINECRAFT_SOURCES
     minecraft/mod/tasks/LocalWorldSaveParseTask.cpp
     minecraft/mod/tasks/LocalResourceParse.h
     minecraft/mod/tasks/LocalResourceParse.cpp
+    minecraft/mod/tasks/GetModDependenciesTask.h
+    minecraft/mod/tasks/GetModDependenciesTask.cpp
 
     # Assets
     minecraft/AssetsUtils.h
diff --git a/launcher/ResourceDownloadTask.h b/launcher/ResourceDownloadTask.h
index 09147c8c..2baddf8a 100644
--- a/launcher/ResourceDownloadTask.h
+++ b/launcher/ResourceDownloadTask.h
@@ -38,6 +38,8 @@ class ResourceDownloadTask : public SequentialTask {
     const QString& getFilename() const { return m_pack_version.fileName; }
     const QString& getCustomPath() const { return m_custom_target_folder; }
     const QVariant& getVersionID() const { return m_pack_version.fileId; }
+    const ModPlatform::IndexedVersion& getVersion() const { return m_pack_version; }
+    const ModPlatform::ResourceProvider& getProvider() const { return m_pack->provider; }
     const QString& getName() const { return m_pack->name; }
     ModPlatform::IndexedPack::Ptr getPack() { return m_pack; }
 
diff --git a/launcher/minecraft/mod/tasks/GetModDependenciesTask.cpp b/launcher/minecraft/mod/tasks/GetModDependenciesTask.cpp
new file mode 100644
index 00000000..f8ecdb33
--- /dev/null
+++ b/launcher/minecraft/mod/tasks/GetModDependenciesTask.cpp
@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@gmail.com>
+ *
+ *  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/>.
+ */
+
+#include "GetModDependenciesTask.h"
+
+#include <QDebug>
+#include <algorithm>
+#include <memory>
+#include "Json.h"
+#include "QObjectPtr.h"
+#include "minecraft/mod/MetadataHandler.h"
+#include "modplatform/ModIndex.h"
+#include "modplatform/ResourceAPI.h"
+#include "modplatform/flame/FlameAPI.h"
+#include "modplatform/modrinth/ModrinthAPI.h"
+#include "tasks/ConcurrentTask.h"
+#include "tasks/SequentialTask.h"
+#include "ui/pages/modplatform/ModModel.h"
+#include "ui/pages/modplatform/flame/FlameResourceModels.h"
+#include "ui/pages/modplatform/modrinth/ModrinthResourceModels.h"
+
+static Version mcVersion(BaseInstance* inst)
+{
+    return static_cast<MinecraftInstance*>(inst)->getPackProfile()->getComponent("net.minecraft")->getVersion();
+}
+
+static ResourceAPI::ModLoaderTypes mcLoaders(BaseInstance* inst)
+{
+    return static_cast<MinecraftInstance*>(inst)->getPackProfile()->getModLoaders().value();
+}
+
+GetModDependenciesTask::GetModDependenciesTask(QObject* parent,
+                                               BaseInstance* instance,
+                                               ModFolderModel* folder,
+                                               QList<std::shared_ptr<PackDependency>> selected)
+    : SequentialTask(parent, tr("Get dependencies"))
+    , m_selected(selected)
+    , m_flame_provider{ ModPlatform::ResourceProvider::FLAME, std::make_shared<ResourceDownload::FlameModModel>(*instance),
+                        std::make_shared<FlameAPI>() }
+    , m_modrinth_provider{ ModPlatform::ResourceProvider::MODRINTH, std::make_shared<ResourceDownload::ModrinthModModel>(*instance),
+                           std::make_shared<ModrinthAPI>() }
+    , m_version(mcVersion(instance))
+    , m_loaderType(mcLoaders(instance))
+{
+    for (auto mod : folder->allMods())
+        if (auto meta = mod->metadata(); meta)
+            m_mods.append(meta);
+    prepare();
+};
+
+void GetModDependenciesTask::prepare()
+{
+    for (auto sel : m_selected) {
+        for (auto dep : getDependenciesForVersion(sel->version, sel->pack->provider)) {
+            addTask(prepareDependencyTask(dep, sel->pack->provider, 20));
+        }
+    }
+}
+
+ModPlatform::Dependency GetModDependenciesTask::getOverride(const ModPlatform::Dependency& dep,
+                                                            const ModPlatform::ResourceProvider providerName)
+{
+    if (auto isQuilt = m_loaderType & ResourceAPI::Quilt; isQuilt || m_loaderType & ResourceAPI::Fabric) {
+        auto overide = ModPlatform::getOverrideDeps();
+        auto over = std::find_if(overide.cbegin(), overide.cend(), [dep, providerName, isQuilt](auto o) {
+            return o.provider == providerName && dep.addonId == (isQuilt ? o.fabric : o.quilt);
+        });
+        if (over != overide.cend()) {
+            return { isQuilt ? over->quilt : over->fabric, dep.type };
+        }
+    }
+    return dep;
+}
+
+QList<ModPlatform::Dependency> GetModDependenciesTask::getDependenciesForVersion(const ModPlatform::IndexedVersion& version,
+                                                                                 const ModPlatform::ResourceProvider providerName)
+{
+    QList<ModPlatform::Dependency> c_dependencies;
+    for (auto ver_dep : version.dependencies) {
+        if (ver_dep.type != ModPlatform::DependencyType::REQUIRED)
+            continue;
+
+        auto isOnlyVersion = providerName == ModPlatform::ResourceProvider::MODRINTH && ver_dep.addonId.toString().isEmpty();
+        if (auto dep = std::find_if(c_dependencies.begin(), c_dependencies.end(),
+                                    [&ver_dep, isOnlyVersion](const ModPlatform::Dependency& i) {
+                                        return isOnlyVersion ? i.version == ver_dep.version : i.addonId == ver_dep.addonId;
+                                    });
+            dep != c_dependencies.end())
+            continue;  // check the current dependency list
+
+        if (auto dep = std::find_if(m_selected.begin(), m_selected.end(),
+                                    [&ver_dep, providerName, isOnlyVersion](std::shared_ptr<PackDependency> i) {
+                                        return i->pack->provider == providerName && (isOnlyVersion ? i->version.version == ver_dep.version
+                                                                                                   : i->pack->addonId == ver_dep.addonId);
+                                    });
+            dep != m_selected.end())
+            continue;  // check the selected versions
+
+        if (auto dep = std::find_if(m_mods.begin(), m_mods.end(),
+                                    [&ver_dep, providerName, isOnlyVersion](std::shared_ptr<Metadata::ModStruct> i) {
+                                        return i->provider == providerName &&
+                                               (isOnlyVersion ? i->file_id == ver_dep.version : i->project_id == ver_dep.addonId);
+                                    });
+            dep != m_mods.end())
+            continue;  // check the existing mods
+
+        if (auto dep = std::find_if(m_pack_dependencies.begin(), m_pack_dependencies.end(),
+                                    [&ver_dep, providerName, isOnlyVersion](std::shared_ptr<PackDependency> i) {
+                                        return i->pack->provider == providerName && (isOnlyVersion ? i->version.version == ver_dep.addonId
+                                                                                                   : i->pack->addonId == ver_dep.addonId);
+                                    });
+            dep != m_pack_dependencies.end())  // check loaded dependencies
+            continue;
+
+        c_dependencies.append(getOverride(ver_dep, providerName));
+    }
+    return c_dependencies;
+};
+
+Task::Ptr GetModDependenciesTask::getProjectInfoTask(std::shared_ptr<PackDependency> pDep)
+{
+    auto provider = pDep->pack->provider == m_flame_provider.name ? m_flame_provider : m_modrinth_provider;
+    auto responseInfo = std::make_shared<QByteArray>();
+    auto info = provider.api->getProject(pDep->pack->addonId.toString(), responseInfo);
+    QObject::connect(info.get(), &NetJob::succeeded, [responseInfo, provider, pDep] {
+        QJsonParseError parse_error{};
+        QJsonDocument doc = QJsonDocument::fromJson(*responseInfo, &parse_error);
+        if (parse_error.error != QJsonParseError::NoError) {
+            qWarning() << "Error while parsing JSON response for mod info at " << parse_error.offset
+                       << " reason: " << parse_error.errorString();
+            qDebug() << *responseInfo;
+            return;
+        }
+        try {
+            auto obj = provider.name == ModPlatform::ResourceProvider::FLAME ? Json::requireObject(Json::requireObject(doc), "data")
+                                                                             : Json::requireObject(doc);
+            provider.mod->loadIndexedPack(*pDep->pack, obj);
+        } catch (const JSONValidationError& e) {
+            qDebug() << doc;
+            qWarning() << "Error while reading mod info: " << e.cause();
+        }
+    });
+    return info;
+}
+
+Task::Ptr GetModDependenciesTask::prepareDependencyTask(const ModPlatform::Dependency& dep,
+                                                        const ModPlatform::ResourceProvider providerName,
+                                                        int level)
+{
+    auto pDep = std::make_shared<PackDependency>();
+    pDep->dependency = dep;
+    pDep->pack = std::make_shared<ModPlatform::IndexedPack>();
+    pDep->pack->addonId = dep.addonId;
+    pDep->pack->provider = providerName;
+
+    m_pack_dependencies.append(pDep);
+    auto provider = providerName == m_flame_provider.name ? m_flame_provider : m_modrinth_provider;
+
+    auto tasks = makeShared<SequentialTask>(
+        this, QString("DependencyInfo: %1").arg(dep.addonId.toString().isEmpty() ? dep.version : dep.addonId.toString()));
+
+    if (!dep.addonId.toString().isEmpty()) {
+        tasks->addTask(getProjectInfoTask(pDep));
+    }
+
+    ResourceAPI::DependencySearchArgs args = { dep, m_version, m_loaderType };
+    ResourceAPI::DependencySearchCallbacks callbacks;
+
+    callbacks.on_succeed = [dep, provider, pDep, level, this](auto& doc, auto& pack) {
+        try {
+            QJsonArray arr;
+            if (dep.version.length() != 0 && doc.isObject()) {
+                arr.append(doc.object());
+            } else {
+                arr = doc.isObject() ? Json::ensureArray(doc.object(), "data") : doc.array();
+            }
+            pDep->version = provider.mod->loadDependencyVersions(dep, arr);
+            if (!pDep->version.addonId.isValid()) {
+                if (m_loaderType & ResourceAPI::Quilt) {  // falback for quilt
+                    auto overide = ModPlatform::getOverrideDeps();
+                    auto over = std::find_if(overide.cbegin(), overide.cend(),
+                                             [dep, provider](auto o) { return o.provider == provider.name && dep.addonId == o.quilt; });
+                    if (over != overide.cend()) {
+                        removePack(dep.addonId);
+                        addTask(prepareDependencyTask({ over->fabric, dep.type }, provider.name, level));
+                        return;
+                    }
+                }
+                qWarning() << "Error while reading mod version empty ";
+                qDebug() << doc;
+                return;
+            }
+            pDep->version.is_currently_selected = true;
+            pDep->pack->versions = { pDep->version };
+            pDep->pack->versionsLoaded = true;
+
+        } catch (const JSONValidationError& e) {
+            qDebug() << doc;
+            qWarning() << "Error while reading mod version: " << e.cause();
+            return;
+        }
+        if (level == 0) {
+            qWarning() << "Dependency cycle exeeded";
+            return;
+        }
+        if (dep.addonId.toString().isEmpty() && !pDep->version.addonId.toString().isEmpty()) {
+            pDep->pack->addonId = pDep->version.addonId;
+            auto dep = getOverride({ pDep->version.addonId, pDep->dependency.type }, provider.name);
+            if (dep.addonId != pDep->version.addonId) {
+                removePack(pDep->version.addonId);
+                addTask(prepareDependencyTask(dep, provider.name, level));
+            } else
+                addTask(getProjectInfoTask(pDep));
+        }
+        for (auto dep : getDependenciesForVersion(pDep->version, provider.name)) {
+            addTask(prepareDependencyTask(dep, provider.name, level - 1));
+        }
+    };
+
+    auto version = provider.api->getDependencyVersion(std::move(args), std::move(callbacks));
+    tasks->addTask(version);
+    return tasks;
+};
+
+void GetModDependenciesTask::removePack(const QVariant addonId)
+{
+    auto pred = [addonId](const std::shared_ptr<PackDependency>& v) { return v->pack->addonId == addonId; };
+#if QT_VERSION >= QT_VERSION_CHECK(6, 1, 0)
+    m_pack_dependencies.removeIf(pred);
+#else
+    for (auto it = m_pack_dependencies.begin(); it != m_pack_dependencies.end();)
+        if (pred(*it))
+            it = m_pack_dependencies.erase(it);
+        else
+            ++it;
+#endif
+}
diff --git a/launcher/minecraft/mod/tasks/GetModDependenciesTask.h b/launcher/minecraft/mod/tasks/GetModDependenciesTask.h
new file mode 100644
index 00000000..50eba6af
--- /dev/null
+++ b/launcher/minecraft/mod/tasks/GetModDependenciesTask.h
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@gmail.com>
+ *
+ *  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/>.
+ */
+
+#pragma once
+
+#include <QDir>
+#include <QEventLoop>
+#include <QList>
+#include <QVariant>
+#include <functional>
+#include <memory>
+
+#include "minecraft/mod/MetadataHandler.h"
+#include "minecraft/mod/ModFolderModel.h"
+#include "modplatform/ModIndex.h"
+#include "modplatform/ResourceAPI.h"
+#include "tasks/SequentialTask.h"
+#include "tasks/Task.h"
+#include "ui/pages/modplatform/ModModel.h"
+
+class GetModDependenciesTask : public SequentialTask {
+    Q_OBJECT
+   public:
+    using Ptr = shared_qobject_ptr<GetModDependenciesTask>;
+
+    struct PackDependency {
+        ModPlatform::Dependency dependency;
+        ModPlatform::IndexedPack::Ptr pack;
+        ModPlatform::IndexedVersion version;
+        PackDependency() = default;
+        PackDependency(const ModPlatform::IndexedPack::Ptr p, const ModPlatform::IndexedVersion& v)
+        {
+            pack = p;
+            version = v;
+        }
+    };
+
+    struct Provider {
+        ModPlatform::ResourceProvider name;
+        std::shared_ptr<ResourceDownload::ModModel> mod;
+        std::shared_ptr<ResourceAPI> api;
+    };
+
+    explicit GetModDependenciesTask(QObject* parent,
+                                    BaseInstance* instance,
+                                    ModFolderModel* folder,
+                                    QList<std::shared_ptr<PackDependency>> selected);
+
+    auto getDependecies() const -> QList<std::shared_ptr<PackDependency>> { return m_pack_dependencies; }
+
+   protected slots:
+    Task::Ptr prepareDependencyTask(const ModPlatform::Dependency&, const ModPlatform::ResourceProvider, int);
+    QList<ModPlatform::Dependency> getDependenciesForVersion(const ModPlatform::IndexedVersion&,
+                                                             const ModPlatform::ResourceProvider providerName);
+    void prepare();
+    Task::Ptr getProjectInfoTask(std::shared_ptr<PackDependency> pDep);
+    ModPlatform::Dependency getOverride(const ModPlatform::Dependency&, const ModPlatform::ResourceProvider providerName);
+    void removePack(const QVariant addonId);
+
+   private:
+    QList<std::shared_ptr<PackDependency>> m_pack_dependencies;
+    QList<std::shared_ptr<Metadata::ModStruct>> m_mods;
+    QList<std::shared_ptr<PackDependency>> m_selected;
+    Provider m_flame_provider;
+    Provider m_modrinth_provider;
+
+    Version m_version;
+    ResourceAPI::ModLoaderTypes m_loaderType;
+};
diff --git a/launcher/minecraft/mod/tasks/LocalModUpdateTask.cpp b/launcher/minecraft/mod/tasks/LocalModUpdateTask.cpp
index cc4e252c..4352fad9 100644
--- a/launcher/minecraft/mod/tasks/LocalModUpdateTask.cpp
+++ b/launcher/minecraft/mod/tasks/LocalModUpdateTask.cpp
@@ -1,25 +1,24 @@
 // SPDX-License-Identifier: GPL-3.0-only
 /*
-*  PolyMC - Minecraft Launcher
-*  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
-*  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/>.
-*/
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *  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/>.
+ */
 
 #include "LocalModUpdateTask.h"
 
-#include "Application.h"
 #include "FileSystem.h"
 #include "minecraft/mod/MetadataHandler.h"
 
diff --git a/launcher/modplatform/ModIndex.h b/launcher/modplatform/ModIndex.h
index 7d8199b3..83412169 100644
--- a/launcher/modplatform/ModIndex.h
+++ b/launcher/modplatform/ModIndex.h
@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-only
 /*
- *  PolyMC - Minecraft Launcher
+ *  Prism Launcher - Minecraft Launcher
  *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@gmail.com>
  *
  *  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
@@ -33,6 +34,8 @@ enum class ResourceProvider { MODRINTH, FLAME };
 
 enum class ResourceType { MOD, RESOURCE_PACK, SHADER_PACK };
 
+enum class DependencyType { REQUIRED, OPTIONAL, INCOMPATIBLE, EMBEDDED, TOOL, INCLUDE, UNKNOWN };
+
 class ProviderCapabilities {
    public:
     auto name(ResourceProvider) -> const char*;
@@ -52,6 +55,12 @@ struct DonationData {
     QString url;
 };
 
+struct Dependency {
+    QVariant addonId;
+    DependencyType type;
+    QString version;
+};
+
 struct IndexedVersion {
     QVariant addonId;
     QVariant fileId;
@@ -66,6 +75,7 @@ struct IndexedVersion {
     QString hash;
     bool is_preferred = true;
     QString changelog;
+    QList<Dependency> dependencies;
 
     // For internal use, not provided by APIs
     bool is_currently_selected = false;
@@ -120,6 +130,22 @@ struct IndexedPack {
 };
 QString getMetaURL(ResourceProvider provider, QString slug);
 
+struct OverrideDep {
+    QString quilt;
+    QString fabric;
+    QString slug;
+    ModPlatform::ResourceProvider provider;
+};
+
+inline auto getOverrideDeps() -> QList<OverrideDep>
+{
+    return { { "634179", "306612", "API", ModPlatform::ResourceProvider::FLAME },
+             { "720410", "308769", "KotlinLibraries", ModPlatform::ResourceProvider::FLAME },
+
+             { "qvIfYCYJ", "P7dR8mSH", "API", ModPlatform::ResourceProvider::MODRINTH },
+             { "lwVhp9o5", "Ha28R6CL", "KotlinLibraries", ModPlatform::ResourceProvider::MODRINTH } };
+};
+
 }  // namespace ModPlatform
 
 Q_DECLARE_METATYPE(ModPlatform::IndexedPack)
diff --git a/launcher/modplatform/ResourceAPI.h b/launcher/modplatform/ResourceAPI.h
index e24971d5..d3277761 100644
--- a/launcher/modplatform/ResourceAPI.h
+++ b/launcher/modplatform/ResourceAPI.h
@@ -111,6 +111,16 @@ class ResourceAPI {
         std::function<void(QJsonDocument&, ModPlatform::IndexedPack)> on_succeed;
     };
 
+    struct DependencySearchArgs {
+        ModPlatform::Dependency dependency;
+        Version mcVersion;
+        ModLoaderTypes loader;
+    };
+
+    struct DependencySearchCallbacks {
+        std::function<void(QJsonDocument&, const ModPlatform::Dependency&)> on_succeed;
+    };
+
    public:
     /** Gets a list of available sorting methods for this API. */
     [[nodiscard]] virtual auto getSortingMethods() const -> QList<SortingMethod> = 0;
@@ -143,6 +153,12 @@ class ResourceAPI {
         return nullptr;
     }
 
+    [[nodiscard]] virtual Task::Ptr getDependencyVersion(DependencySearchArgs&&, DependencySearchCallbacks&&) const
+    {
+        qWarning() << "TODO";
+        return nullptr;
+    }
+
     static auto getModLoaderString(ModLoaderType type) -> const QString
     {
         switch (type) {
diff --git a/launcher/modplatform/flame/FlameAPI.h b/launcher/modplatform/flame/FlameAPI.h
index 49ba12b0..a0611957 100644
--- a/launcher/modplatform/flame/FlameAPI.h
+++ b/launcher/modplatform/flame/FlameAPI.h
@@ -4,8 +4,10 @@
 
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include "modplatform/ModIndex.h"
+#include "modplatform/ResourceAPI.h"
 #include "modplatform/helpers/NetworkResourceAPI.h"
 
 class FlameAPI : public NetworkResourceAPI {
@@ -75,14 +77,44 @@ class FlameAPI : public NetworkResourceAPI {
 
     [[nodiscard]] std::optional<QString> getVersionsURL(VersionSearchArgs const& args) const override
     {
-        QString url{ QString("https://api.curseforge.com/v1/mods/%1/files?pageSize=10000&").arg(args.pack.addonId.toString()) };
+        auto mappedModLoader = getMappedModLoader(args.loaders.value());
+        auto addonId = args.pack.addonId.toString();
+        if (args.loaders.value() & Quilt) {
+            auto overide = ModPlatform::getOverrideDeps();
+            auto over = std::find_if(overide.cbegin(), overide.cend(), [addonId](auto dep) {
+                return dep.provider == ModPlatform::ResourceProvider::FLAME && addonId == dep.quilt;
+            });
+            if (over != overide.cend()) {
+                mappedModLoader = 5;
+            }
+        }
+        QString url{ QString("https://api.curseforge.com/v1/mods/%1/files?pageSize=10000&").arg(addonId) };
 
         QStringList get_parameters;
         if (args.mcVersions.has_value())
             get_parameters.append(QString("gameVersion=%1").arg(args.mcVersions.value().front().toString()));
         if (args.loaders.has_value())
-            get_parameters.append(QString("modLoaderType=%1").arg(getMappedModLoader(args.loaders.value())));
+            get_parameters.append(QString("modLoaderType=%1").arg(mappedModLoader));
 
         return url + get_parameters.join('&');
     };
+
+    [[nodiscard]] std::optional<QString> getDependencyURL(DependencySearchArgs const& args) const override
+    {
+        auto mappedModLoader = getMappedModLoader(args.loader);
+        auto addonId = args.dependency.addonId.toString();
+        if (args.loader & Quilt) {
+            auto overide = ModPlatform::getOverrideDeps();
+            auto over = std::find_if(overide.cbegin(), overide.cend(), [addonId](auto dep) {
+                return dep.provider == ModPlatform::ResourceProvider::FLAME && addonId == dep.quilt;
+            });
+            if (over != overide.cend()) {
+                mappedModLoader = 5;
+            }
+        }
+        return QString("https://api.curseforge.com/v1/mods/%1/files?pageSize=10000&gameVersion=%2&modLoaderType=%3")
+            .arg(addonId)
+            .arg(args.mcVersion.toString())
+            .arg(mappedModLoader);
+    };
 };
diff --git a/launcher/modplatform/flame/FlameModIndex.cpp b/launcher/modplatform/flame/FlameModIndex.cpp
index 7498e830..227ce489 100644
--- a/launcher/modplatform/flame/FlameModIndex.cpp
+++ b/launcher/modplatform/flame/FlameModIndex.cpp
@@ -39,15 +39,15 @@ void FlameMod::loadURLs(ModPlatform::IndexedPack& pack, QJsonObject& obj)
     auto links_obj = Json::ensureObject(obj, "links");
 
     pack.extraData.issuesUrl = Json::ensureString(links_obj, "issuesUrl");
-    if(pack.extraData.issuesUrl.endsWith('/'))
+    if (pack.extraData.issuesUrl.endsWith('/'))
         pack.extraData.issuesUrl.chop(1);
 
     pack.extraData.sourceUrl = Json::ensureString(links_obj, "sourceUrl");
-    if(pack.extraData.sourceUrl.endsWith('/'))
+    if (pack.extraData.sourceUrl.endsWith('/'))
         pack.extraData.sourceUrl.chop(1);
 
     pack.extraData.wikiUrl = Json::ensureString(links_obj, "wikiUrl");
-    if(pack.extraData.wikiUrl.endsWith('/'))
+    if (pack.extraData.wikiUrl.endsWith('/'))
         pack.extraData.wikiUrl.chop(1);
 
     if (!pack.extraData.body.isEmpty())
@@ -56,7 +56,7 @@ void FlameMod::loadURLs(ModPlatform::IndexedPack& pack, QJsonObject& obj)
 
 void FlameMod::loadBody(ModPlatform::IndexedPack& pack, QJsonObject& obj)
 {
-    pack.extraData.body  = api.getModDescription(pack.addonId.toInt());
+    pack.extraData.body = api.getModDescription(pack.addonId.toInt());
 
     if (!pack.extraData.issuesUrl.isEmpty() || !pack.extraData.sourceUrl.isEmpty() || !pack.extraData.wikiUrl.isEmpty())
         pack.extraDataLoaded = true;
@@ -64,12 +64,12 @@ void FlameMod::loadBody(ModPlatform::IndexedPack& pack, QJsonObject& obj)
 
 static QString enumToString(int hash_algorithm)
 {
-    switch(hash_algorithm){
-    default:
-    case 1:
-        return "sha1";
-    case 2:
-        return "md5";
+    switch (hash_algorithm) {
+        default:
+        case 1:
+            return "sha1";
+        case 2:
+            return "md5";
     }
 }
 
@@ -84,12 +84,12 @@ void FlameMod::loadIndexedPackVersions(ModPlatform::IndexedPack& pack,
 
     for (auto versionIter : arr) {
         auto obj = versionIter.toObject();
-        
+
         auto file = loadIndexedPackVersion(obj);
-        if(!file.addonId.isValid())
+        if (!file.addonId.isValid())
             file.addonId = pack.addonId;
 
-        if(file.fileId.isValid()) // Heuristic to check if the returned value is valid
+        if (file.fileId.isValid())  // Heuristic to check if the returned value is valid
             unsortedVersions.append(file);
     }
 
@@ -136,8 +136,61 @@ auto FlameMod::loadIndexedPackVersion(QJsonObject& obj, bool load_changelog) ->
         }
     }
 
-    if(load_changelog)
+    auto dependencies = Json::ensureArray(obj, "dependencies");
+    for (auto d : dependencies) {
+        auto dep = Json::ensureObject(d);
+        ModPlatform::Dependency dependency;
+        dependency.addonId = Json::requireInteger(dep, "modId");
+        switch (Json::requireInteger(dep, "relationType")) {
+            case 1:  // EmbeddedLibrary
+                dependency.type = ModPlatform::DependencyType::EMBEDDED;
+                break;
+            case 2:  // OptionalDependency
+                dependency.type = ModPlatform::DependencyType::OPTIONAL;
+                break;
+            case 3:  // RequiredDependency
+                dependency.type = ModPlatform::DependencyType::REQUIRED;
+                break;
+            case 4:  // Tool
+                dependency.type = ModPlatform::DependencyType::TOOL;
+                break;
+            case 5:  // Incompatible
+                dependency.type = ModPlatform::DependencyType::INCOMPATIBLE;
+                break;
+            case 6:  // Include
+                dependency.type = ModPlatform::DependencyType::INCLUDE;
+                break;
+            default:
+                dependency.type = ModPlatform::DependencyType::UNKNOWN;
+                break;
+        }
+        file.dependencies.append(dependency);
+    }
+
+    if (load_changelog)
         fi