#pragma once

#include <memory>  // Para shared_ptr
#include <string>  // Para string
#include <utility>
#include <vector>  // Para vector

#include "core/rendering/surface.hpp"                  // Para Surface
#include "core/rendering/surface_animated_sprite.hpp"  // Para AnimationsFileBuffer
#include "core/rendering/text.hpp"                     // Para Text, TextFile
#include "game/gameplay/room.hpp"                      // Para room_t
struct JA_Music_t;                                     // lines 11-11
struct JA_Sound_t;                                     // lines 12-12

// Estructura para almacenar ficheros de sonido y su nombre
struct SoundResource {
        std::string name{};       // Nombre del sonido
        JA_Sound_t* sound{nullptr};  // Objeto con el sonido
};

// Estructura para almacenar ficheros musicales y su nombre
struct MusicResource {
        std::string name{};          // Nombre de la musica
        JA_Music_t* music{nullptr};  // Objeto con la música
};

// Estructura para almacenar objetos Surface y su nombre
struct SurfaceResource {
        std::string name{};               // Nombre de la surface
        std::shared_ptr<Surface> surface{};  // Objeto con la surface
};

// Estructura para almacenar objetos Palette y su nombre
struct ResourcePalette {
        std::string name{};  // Nombre de la surface
        Palette palette{};   // Paleta
};

// Estructura para almacenar ficheros TextFile y su nombre
struct TextFileResource {
        std::string name{};                    // Nombre del fichero
        std::shared_ptr<Text::File> text_file{};  // Objeto con los descriptores de la fuente de texto
};

// Estructura para almacenar objetos Text y su nombre
struct TextResource {
        std::string name{};           // Nombre del objeto
        std::shared_ptr<Text> text{};  // Objeto
};

// Estructura para almacenar ficheros animaciones y su nombre
struct AnimationResource {
        std::string name{};             // Nombre del fichero
        std::vector<uint8_t> yaml_data{};  // Bytes del archivo YAML sin parsear
};

// Estructura para almacenar habitaciones y su nombre
struct RoomResource {
        std::string name{};                // Nombre de la habitación
        std::shared_ptr<Room::Data> room{};  // Habitación
};

namespace Resource {

class Cache {
    public:
        static void init();           // Inicialización singleton
        static void destroy();        // Destrucción singleton
        static auto get() -> Cache*;  // Acceso al singleton

        auto getSound(const std::string& name) -> JA_Sound_t*;                  // Getters de recursos
        auto getMusic(const std::string& name) -> JA_Music_t*;
        auto getSurface(const std::string& name) -> std::shared_ptr<Surface>;
        auto getPalette(const std::string& name) -> Palette;
        auto getTextFile(const std::string& name) -> std::shared_ptr<Text::File>;
        auto getText(const std::string& name) -> std::shared_ptr<Text>;
        auto getAnimationData(const std::string& name) -> const AnimationResource&;
        auto getRoom(const std::string& name) -> std::shared_ptr<Room::Data>;
        auto getRooms() -> std::vector<RoomResource>&;

        void reload();  // Recarga todos los recursos

    private:
        // Estructura para llevar la cuenta de los recursos cargados
        struct ResourceCount {
                int total{0};   // Número total de recursos
                int loaded{0};  // Número de recursos cargados

                // Añade una cantidad a los recursos cargados
                void add(int amount) {
                    loaded += amount;
                }

                // Obtiene el porcentaje de recursos cargados
                [[nodiscard]] auto getPercentage() const -> float {
                    return static_cast<float>(loaded) / static_cast<float>(total);
                }
        };

        // Métodos de carga de recursos
        void loadSounds();
        void loadMusics();
        void loadSurfaces();
        void loadPalettes();
        void loadTextFiles();
        void loadAnimations();
        void loadRooms();
        void createText();

        // Métodos de limpieza
        void clear();
        void clearSounds();
        void clearMusics();

        // Métodos de gestión de carga
        void load();
        void calculateTotal();
        void renderProgress();
        static void checkEvents();
        void updateLoadingProgress(int steps = 5);

        // Constructor y destructor
        Cache();
        ~Cache() = default;

        // Singleton instance
        static Cache* cache;

        // Variables miembro
        std::vector<SoundResource> sounds_{};       // Vector con los sonidos
        std::vector<MusicResource> musics_{};       // Vector con las musicas
        std::vector<SurfaceResource> surfaces_{};   // Vector con las surfaces
        std::vector<ResourcePalette> palettes_{};   // Vector con las paletas
        std::vector<TextFileResource> text_files_{}; // Vector con los ficheros de texto
        std::vector<TextResource> texts_{};         // Vector con los objetos de texto
        std::vector<AnimationResource> animations_{}; // Vector con las animaciones
        std::vector<RoomResource> rooms_{};         // Vector con las habitaciones

        ResourceCount count_{};                    // Contador de recursos
        std::shared_ptr<Text> loading_text_{};     // Texto para la pantalla de carga
};

}  // namespace Resource