coffee_crisis_arcade_edition/source/resource.h

#pragma once

#include <memory>
#include <string>
#include <vector>
#include "animated_sprite.h"
#include "text.h"
#include "texture.h"
#include "utils.h"
#include "jail_audio.h"

// --- Clase Resource: gestiona todos los recursos del juego (singleton) ---
class Resource
{
public:
    // --- Métodos de singleton ---
    static void init();     // Inicializa el objeto Resource
    static void destroy();  // Libera el objeto Resource
    static Resource *get(); // Obtiene el puntero al objeto Resource

    // --- Métodos de acceso a recursos ---
    JA_Sound_t *getSound(const std::string &name);                  // Obtiene el sonido por nombre
    JA_Music_t *getMusic(const std::string &name);                  // Obtiene la música por nombre
    std::shared_ptr<Texture> getTexture(const std::string &name);   // Obtiene la textura por nombre
    std::shared_ptr<TextFile> getTextFile(const std::string &name); // Obtiene el fichero de texto por nombre
    std::shared_ptr<Text> getText(const std::string &name);         // Obtiene el objeto de texto por nombre
    AnimationsFileBuffer &getAnimation(const std::string &name);    // Obtiene la animación por nombre
    DemoData &getDemoData(int index);                               // Obtiene los datos de demo por índice

    // --- Métodos de recarga de recursos ---
    void reload();         // Recarga todos los recursos
    void reloadTextures(); // Recarga solo las texturas

private:
    // --- Estructuras para recursos individuales ---
    struct ResourceSound
    {
        std::string name;  // Nombre del sonido
        JA_Sound_t *sound; // Objeto con el sonido

        ResourceSound(const std::string &name, JA_Sound_t *sound)
            : name(name), sound(sound) {}
    };

    struct ResourceMusic
    {
        std::string name;  // Nombre de la música
        JA_Music_t *music; // Objeto con la música

        ResourceMusic(const std::string &name, JA_Music_t *music)
            : name(name), music(music) {}
    };

    struct ResourceTexture
    {
        std::string name;                 // Nombre de la textura
        std::shared_ptr<Texture> texture; // Objeto con la textura

        ResourceTexture(const std::string &name, std::shared_ptr<Texture> texture)
            : name(name), texture(texture) {}
    };

    struct ResourceTextFile
    {
        std::string name;                    // Nombre del fichero
        std::shared_ptr<TextFile> text_file; // Objeto con los descriptores de la fuente de texto

        ResourceTextFile(const std::string &name, std::shared_ptr<TextFile> text_file)
            : name(name), text_file(text_file) {}
    };

    struct ResourceText
    {
        std::string name;           // Nombre del objeto
        std::shared_ptr<Text> text; // Objeto de texto

        ResourceText(const std::string &name, std::shared_ptr<Text> text)
            : name(name), text(text) {}
    };

    struct ResourceAnimation
    {
        std::string name;               // Nombre de la animación
        AnimationsFileBuffer animation; // Objeto con las animaciones

        ResourceAnimation(const std::string &name, const AnimationsFileBuffer &animation)
            : name(name), animation(animation) {}
    };

    // --- Estructura para el progreso de carga ---
    struct ResourceCount
    {
        int total;  // Número total de recursos
        int loaded; // Número de recursos cargados

        ResourceCount() : total(0), loaded(0) {}
        ResourceCount(int total, int loaded) : total(total), loaded(loaded) {}

        void add(int amount) { loaded += amount; }
        float getPercentage() const
        {
            return total > 0 ? static_cast<float>(loaded) / static_cast<float>(total) : 0.0f;
        }
    };

    // --- Instancia singleton ---
    static Resource *instance_; // Instancia única de Resource

    // --- Vectores de recursos ---
    std::vector<ResourceSound> sounds_;         // Vector con los sonidos
    std::vector<ResourceMusic> musics_;         // Vector con las músicas
    std::vector<ResourceTexture> textures_;     // Vector con las texturas
    std::vector<ResourceTextFile> text_files_;  // Vector con los ficheros de texto
    std::vector<ResourceText> texts_;           // Vector con los objetos de texto
    std::vector<ResourceAnimation> animations_; // Vector con las animaciones
    std::vector<DemoData> demos_;               // Vector con los ficheros de datos para el modo demostración

    // --- Progreso de carga ---
    ResourceCount count_; // Contador de recursos cargados

    // --- Métodos internos de carga y gestión ---
    void loadSounds();     // Carga los sonidos
    void loadMusics();     // Carga las músicas
    void loadTextures();   // Carga las texturas
    void loadTextFiles();  // Carga los ficheros de texto
    void loadAnimations(); // Carga las animaciones
    void loadDemoData();   // Carga los datos para el modo demostración
    void addPalettes();    // Añade paletas a las texturas
    void createTextures(); // Crea las texturas a partir de los datos cargados
    void createText();     // Crea los objetos de texto
    void clear();          // Vacía todos los vectores de recursos
    void load();           // Carga todos los recursos
    void clearSounds();    // Vacía el vector de sonidos
    void clearMusics();    // Vacía el vector de músicas

    // --- Métodos internos para gestionar el progreso ---
    void calculateTotal();                     // Calcula el número de recursos para cargar
    void renderProgress();                     // Muestra el progreso de carga
    void checkEvents();                        // Comprueba los eventos durante la carga
    void updateLoadingProgress(int steps = 1); // Actualiza el progreso de carga

    // --- Constructores y destructor privados (singleton) ---
    Resource();            // Constructor privado
    ~Resource() = default; // Destructor privado
};