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

#include "resource_loader.hpp"

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

namespace Resource {

// Singleton
Loader& Loader::get() {
    static Loader instance;
    return instance;
}

// Inicialitzar el sistema de recursos
bool Loader::initialize(const std::string& pack_file, bool enable_fallback) {
    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
std::vector<uint8_t> Loader::loadResource(const std::string& filename) {
    // 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 {};
}

// Comprovar si existeix un recurs
bool Loader::resourceExists(const std::string& filename) {
    // 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
bool Loader::validatePack() {
    if (!pack_) {
        std::cerr << "[ResourceLoader] Advertència: no hay paquet carregat per validar\n";
        return false;
    }

    return pack_->validatePack();
}

// Comprovar si hay paquet carregat
bool Loader::isPackLoaded() const {
    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)
std::vector<uint8_t> Loader::loadFromFilesystem(const std::string& filename) {
    // 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