orni-attack/source/core/resources/resource_loader.cpp

// resource_loader.cpp - Implementació del carregador de recursos
// © 2026 JailDesigner

#include "resource_loader.hpp"

#include <algorithm>
#include <filesystem>
#include <fstream>
#include <iostream>

namespace Resource {

    // Singleton
    auto Loader::get() -> Loader& {
        static Loader instance_;
        return instance_;
    }

    // Inicialitzar el sistema de recursos
    auto Loader::initialize(const std::string& pack_file, bool enable_fallback) -> bool {
        fallback_enabled_ = enable_fallback;

        // Intentar load el paquet
        pack_ = std::make_unique<Pack>();

        if (!pack_->loadPack(pack_file)) {
            if (!fallback_enabled_) {
                std::cerr << "[ResourceLoader] ERROR FATAL: No es pot load " << pack_file
                          << " y el fallback está desactivat\n";
                return false;
            }

            std::cout << "[ResourceLoader] Paquet no trobat, usant fallback al sistema de archivos\n";
            pack_.reset();  // No hay paquet
            return true;
        }

        std::cout << "[ResourceLoader] Paquet carregat: " << pack_file << "\n";
        return true;
    }

    // Carregar un recurs
    auto Loader::loadResource(const std::string& filename) -> std::vector<uint8_t> {
        // Intentar load del paquet primer
        if (pack_) {
            if (pack_->hasResource(filename)) {
                auto data = pack_->getResource(filename);
                if (!data.empty()) {
                    return data;
                }
                std::cerr << "[ResourceLoader] Advertència: recurs buit al paquet: " << filename
                          << "\n";
            }

            // Si no está al paquet y no hay fallback, falla
            if (!fallback_enabled_) {
                std::cerr << "[ResourceLoader] ERROR: Recurs no trobat al paquet i fallback desactivat: "
                          << filename << "\n";
                return {};
            }
        }

        // Fallback al sistema de archivos
        if (fallback_enabled_) {
            return loadFromFilesystem(filename);
        }

        return {};
    }

    auto Loader::listResources(const std::string& prefix) -> std::vector<std::string> {
        std::vector<std::string> result;

        if (pack_) {
            for (const auto& path : pack_->getResourceList()) {
                if (path.starts_with(prefix)) {
                    result.push_back(path);
                }
            }
            return result;
        }

        if (!fallback_enabled_) {
            return result;
        }

        std::string root = base_path_.empty() ? "data/" + prefix : base_path_ + "/data/" + prefix;
        if (!std::filesystem::exists(root)) {
            return result;
        }

        for (const auto& entry : std::filesystem::recursive_directory_iterator(root)) {
            if (!entry.is_regular_file()) {
                continue;
            }
            std::string full = entry.path().generic_string();
            if (auto pos = full.find("/data/"); pos != std::string::npos) {
                result.push_back(full.substr(pos + 6));
            } else if (full.starts_with("data/")) {
                result.push_back(full.substr(5));
            }
        }
        std::ranges::sort(result);
        return result;
    }

    // Comprovar si existeix un recurs
    auto Loader::resourceExists(const std::string& filename) -> bool {
        // Comprovar al paquet
        if (pack_ && pack_->hasResource(filename)) {
            return true;
        }

        // Comprovar al sistema de archivos si está activat el fallback
        if (fallback_enabled_) {
            std::string fullpath = base_path_.empty() ? "data/" + filename : base_path_ + "/data/" + filename;
            return std::filesystem::exists(fullpath);
        }

        return false;
    }

    // Validar el paquet
    auto Loader::validatePack() -> bool {
        if (!pack_) {
            std::cerr << "[ResourceLoader] Advertència: no hay paquet carregat per validar\n";
            return false;
        }

        return pack_->validatePack();
    }

    // Comprovar si hay paquet carregat
    auto Loader::isPackLoaded() const -> bool {
        return pack_ != nullptr;
    }

    // Establir la ruta base
    void Loader::setBasePath(const std::string& path) {
        base_path_ = path;
        std::cout << "[ResourceLoader] Ruta base establerta: " << base_path_ << "\n";
    }

    // Obtenir la ruta base
    auto Loader::getBasePath() const -> const std::string& {
        return base_path_;
    }

    // Carregar des del sistema de archivos (fallback)
    auto Loader::loadFromFilesystem(const std::string& filename) -> std::vector<uint8_t> {
        // The filename is already normalized (e.g., "shapes/logo/letra_j.shp")
        // We need to prepend base_path + "data/"
        std::string fullpath;

        if (base_path_.empty()) {
            fullpath = "data/" + filename;
        } else {
            fullpath = base_path_ + "/data/" + filename;
        }

        std::ifstream file(fullpath, std::ios::binary | std::ios::ate);
        if (!file) {
            std::cerr << "[ResourceLoader] Error: no es pot obrir " << fullpath << "\n";
            return {};
        }

        std::streamsize file_size = file.tellg();
        file.seekg(0, std::ios::beg);

        std::vector<uint8_t> data(file_size);
        if (!file.read(reinterpret_cast<char*>(data.data()), file_size)) {
            std::cerr << "[ResourceLoader] Error: no es pot llegir " << fullpath << "\n";
            return {};
        }

        std::cout << "[ResourceLoader] Carregat des del sistema de archivos: " << fullpath << "\n";
        return data;
    }

}  // namespace Resource