feat(RD): add texture pack downloader

This extends the resource pack downloader, with the custom behavior of
filtering the versions that shows up, to those <= 1.6. As always, Flame
is funky and requires a bit more workarounds than average.

This will also get a nice improvement when the Version parsing and
comparison PR gets merged! :D

Signed-off-by: flow <flowlnlnln@gmail.com>

launcher/ui/pages/modplatform/flame/FlameResourceModels.cpp

@@ -57,5 +57,63 @@ auto FlameResourcePackModel::documentToArray(QJsonDocument& obj) const -> QJsonA
     return Json::ensureArray(obj.object(), "data");
 }
 
+FlameTexturePackModel::FlameTexturePackModel(const BaseInstance& base) : TexturePackResourceModel(base, new FlameAPI) {}
+
+void FlameTexturePackModel::loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj)
+{
+    FlameMod::loadIndexedPack(m, obj);
+}
+
+// We already deal with the URLs when initializing the pack, due to the API response's structure
+void FlameTexturePackModel::loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj)
+{
+    FlameMod::loadBody(m, obj);
+}
+
+void FlameTexturePackModel::loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr)
+{
+    FlameMod::loadIndexedPackVersions(m, arr, APPLICATION->network(), &m_base_instance);
+
+    QVector<ModPlatform::IndexedVersion> filtered_versions(m.versions.size());
+
+    // FIXME: Client-side version filtering. This won't take into account any user-selected filtering.
+    for (auto const& version : m.versions) {
+        auto const& mc_versions = version.mcVersion;
+
+        if (std::any_of(mc_versions.constBegin(), mc_versions.constEnd(),
+                        [this](auto const& mc_version){ return Version(mc_version) <= maximumTexturePackVersion(); }))
+            filtered_versions.push_back(version);
+    }
+
+    m.versions = filtered_versions;
+}
+
+ResourceAPI::SearchArgs FlameTexturePackModel::createSearchArguments()
+{
+    auto args = TexturePackResourceModel::createSearchArguments();
+
+    auto profile = static_cast<const MinecraftInstance&>(m_base_instance).getPackProfile();
+    QString instance_minecraft_version = profile->getComponentVersion("net.minecraft");
+
+    // Bypass the texture pack logic, because we can't do multiple versions in the API query
+    args.versions = { instance_minecraft_version };
+
+    return args;
+}
+
+ResourceAPI::VersionSearchArgs FlameTexturePackModel::createVersionsArguments(QModelIndex& entry)
+{
+    auto args = TexturePackResourceModel::createVersionsArguments(entry);
+
+    // Bypass the texture pack logic, because we can't do multiple versions in the API query
+    args.mcVersions = {};
+
+    return args;
+}
+
+auto FlameTexturePackModel::documentToArray(QJsonDocument& obj) const -> QJsonArray
+{
+    return Json::ensureArray(obj.object(), "data");
+}
 
 }  // namespace ResourceDownload

launcher/ui/pages/modplatform/flame/FlameResourceModels.h

@@ -46,4 +46,25 @@ class FlameResourcePackModel : public ResourcePackResourceModel {
     auto documentToArray(QJsonDocument& obj) const -> QJsonArray override;
 };
 
+class FlameTexturePackModel : public TexturePackResourceModel {
+    Q_OBJECT
+
+   public:
+    FlameTexturePackModel(const BaseInstance&);
+    ~FlameTexturePackModel() override = default;
+
+   private:
+    [[nodiscard]] QString debugName() const override { return Flame::debugName() + " (Model)"; }
+    [[nodiscard]] QString metaEntryBase() const override { return Flame::metaEntryBase(); }
+
+    void loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
+    void loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
+    void loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr) override;
+
+    ResourceAPI::SearchArgs createSearchArguments() override;
+    ResourceAPI::VersionSearchArgs createVersionsArguments(QModelIndex&) override;
+
+    auto documentToArray(QJsonDocument& obj) const -> QJsonArray override;
+};
+
 }  // namespace ResourceDownload

launcher/ui/pages/modplatform/flame/FlameResourcePages.cpp

@@ -133,10 +133,50 @@ void FlameResourcePackPage::openUrl(const QUrl& url)
     ResourcePackResourcePage::openUrl(url);
 }
 
+FlameTexturePackPage::FlameTexturePackPage(TexturePackDownloadDialog* dialog, BaseInstance& instance)
+    : TexturePackResourcePage(dialog, instance)
+{
+    m_model = new FlameTexturePackModel(instance);
+    m_ui->packView->setModel(m_model);
+
+    addSortings();
+
+    // sometimes Qt just ignores virtual slots and doesn't work as intended it seems,
+    // so it's best not to connect them in the parent's contructor...
+    connect(m_ui->sortByBox, SIGNAL(currentIndexChanged(int)), this, SLOT(triggerSearch()));
+    connect(m_ui->packView->selectionModel(), &QItemSelectionModel::currentChanged, this, &FlameTexturePackPage::onSelectionChanged);
+    connect(m_ui->versionSelectionBox, &QComboBox::currentTextChanged, this, &FlameTexturePackPage::onVersionSelectionChanged);
+    connect(m_ui->resourceSelectionButton, &QPushButton::clicked, this, &FlameTexturePackPage::onResourceSelected);
+
+    m_ui->packDescription->setMetaEntry(metaEntryBase());
+}
+
+bool FlameTexturePackPage::optedOut(ModPlatform::IndexedVersion& ver) const
+{
+    return isOptedOut(ver);
+}
+
+void FlameTexturePackPage::openUrl(const QUrl& url)
+{
+    if (url.scheme().isEmpty()) {
+        QString query = url.query(QUrl::FullyDecoded);
+
+        if (query.startsWith("remoteUrl=")) {
+            // attempt to resolve url from warning page
+            query.remove(0, 10);
+            ResourcePackResourcePage::openUrl({QUrl::fromPercentEncoding(query.toUtf8())}); // double decoding is necessary
+            return;
+        }
+    }
+
+    TexturePackResourcePage::openUrl(url);
+}
+
 // I don't know why, but doing this on the parent class makes it so that
 // other mod providers start loading before being selected, at least with
 // my Qt, so we need to implement this in every derived class...
 auto FlameModPage::shouldDisplay() const -> bool { return true; }
 auto FlameResourcePackPage::shouldDisplay() const -> bool { return true; }
+auto FlameTexturePackPage::shouldDisplay() const -> bool { return true; }
 
 }  // namespace ResourceDownload

launcher/ui/pages/modplatform/flame/FlameResourcePages.h

@@ -44,7 +44,7 @@
 
 #include "ui/pages/modplatform/ModPage.h"
 #include "ui/pages/modplatform/ResourcePackPage.h"
-#include "ui/pages/modplatform/ShaderPackPage.h"
+#include "ui/pages/modplatform/TexturePackPage.h"
 
 namespace ResourceDownload {
 
@@ -111,4 +111,31 @@ class FlameResourcePackPage : public ResourcePackResourcePage {
     void openUrl(const QUrl& url) override;
 };
 
+class FlameTexturePackPage : public TexturePackResourcePage {
+    Q_OBJECT
+
+   public:
+    static FlameTexturePackPage* create(TexturePackDownloadDialog* dialog, BaseInstance& instance)
+    {
+        return TexturePackResourcePage::create<FlameTexturePackPage>(dialog, instance);
+    }
+
+    FlameTexturePackPage(TexturePackDownloadDialog* dialog, BaseInstance& instance);
+    ~FlameTexturePackPage() override = default;
+
+    [[nodiscard]] bool shouldDisplay() const override;
+
+    [[nodiscard]] inline auto displayName() const -> QString override { return Flame::displayName(); }
+    [[nodiscard]] inline auto icon() const -> QIcon override { return Flame::icon(); }
+    [[nodiscard]] inline auto id() const -> QString override { return Flame::id(); }
+    [[nodiscard]] inline auto debugName() const -> QString override { return Flame::debugName(); }
+    [[nodiscard]] inline auto metaEntryBase() const -> QString override { return Flame::metaEntryBase(); }
+
+    [[nodiscard]] inline auto helpPage() const -> QString override { return ""; }
+
+    bool optedOut(ModPlatform::IndexedVersion& ver) const override;
+
+    void openUrl(const QUrl& url) override;
+};
+
 }  // namespace ResourceDownload