#include <iostream>
#include "resource.h"
#include "asset.h"
#include "screen.h"

// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
Resource *Resource::resource_ = nullptr;

// [SINGLETON] Crearemos el objeto screen con esta función estática
void Resource::init()
{
    Resource::resource_ = new Resource();
}

// [SINGLETON] Destruiremos el objeto screen con esta función estática
void Resource::destroy()
{
    delete Resource::resource_;
}

// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
Resource *Resource::get()
{
    return Resource::resource_;
}

// Constructor
Resource::Resource()
{
    std::cout << "** LOADING RESOURCES" << std::endl;
    loadSounds();
    loadMusics();
    loadTextures();
    loadTextFiles();
    loadAnimations();
    std::cout << "\n** RESOURCES LOADED" << std::endl;
}

// Destructor
Resource::~Resource()
{
    sounds_.clear();
    musics_.clear();
    textures_.clear();
    text_files_.clear();
    animations_.clear();
}

// Obtiene el sonido a partir de un nombre
JA_Sound_t *Resource::getSound(const std::string &name)
{
    for (const auto &s : sounds_)
    {
        if (s.name == name)
        {
            return s.sound;
        }
    }
    std::cerr << "Error: Sonido no encontrado " << name << std::endl;
    throw std::runtime_error("Sonido no encontrado: " + name);
}

// Obtiene la música a partir de un nombre
JA_Music_t *Resource::getMusic(const std::string &name)
{
    for (const auto &m : musics_)
    {
        if (m.name == name)
        {
            return m.music;
        }
    }
    std::cerr << "Error: Música no encontrada " << name << std::endl;
    throw std::runtime_error("Música no encontrada: " + name);
}

// Obtiene la textura a partir de un nombre
std::shared_ptr<Texture> Resource::getTexture(const std::string &name)
{
    for (const auto &t : textures_)
    {
        if (t.name == name)
        {
            return t.texture;
        }
    }
    std::cerr << "Error: Imagen no encontrada " << name << std::endl;
    throw std::runtime_error("Imagen no encontrada: " + name);
}

// Obtiene el fichero de texto a partir de un nombre
std::shared_ptr<TextFile> Resource::getTextFile(const std::string &name)
{
    for (const auto &t : text_files_)
    {
        if (t.name == name)
        {
            return t.text_file;
        }
    }
    std::cerr << "Error: TextFile no encontrado " << name << std::endl;
    throw std::runtime_error("TextFile no encontrado: " + name);
}

// Obtiene la animación a partir de un nombre
Animations &Resource::getAnimation(const std::string &name)
{
    for (auto &a : animations_)
    {
        if (a.name == name)
        {
            return a.animation;
        }
    }
    std::cerr << "Error: Animación no encontrada " << name << std::endl;
    throw std::runtime_error("Animación no encontrada: " + name);
}

// Carga los sonidos
void Resource::loadSounds()
{
    std::cout << "\n>> SOUND FILES" << std::endl;

    // Obtiene la lista con las rutas a los ficheros de sonidos
    auto list = Asset::get()->getListByType(AssetType::SOUND);
    sounds_.clear();

    for (const auto &l : list)
    {
        // Encuentra el último índice de '/'
        auto last_index = l.find_last_of('/') + 1;

        // Obtiene la subcadena desde el último '/'
        auto name = l.substr(last_index);

        sounds_.emplace_back(ResourceSound(name, JA_LoadSound(l.c_str())));
        printWithDots("Sound : ", name, "[ LOADED ]");
    }
}

// Carga las musicas
void Resource::loadMusics()
{
    std::cout << "\n>> MUSIC FILES" << std::endl;

    // Obtiene la lista con las rutas a los ficheros musicales
    auto list = Asset::get()->getListByType(AssetType::MUSIC);
    musics_.clear();

    for (const auto &l : list)
    {
        // Encuentra el último índice de '/'
        auto last_index = l.find_last_of('/') + 1;

        // Obtiene la subcadena desde el último '/'
        auto name = l.substr(last_index);

        musics_.emplace_back(ResourceMusic(name, JA_LoadMusic(l.c_str())));
        printWithDots("Music : ", name, "[ LOADED ]");
    }
}

// Carga las texturas
void Resource::loadTextures()
{
    std::cout << "\n>> TEXTURES" << std::endl;

    // Obtiene la lista con las rutas a los ficheros png
    auto list = Asset::get()->getListByType(AssetType::BITMAP);
    textures_.clear();

    for (const auto &l : list)
    {
        // Encuentra el último índice de '/'
        auto last_index = l.find_last_of('/') + 1;

        // Obtiene la subcadena desde el último '/'
        auto name = l.substr(last_index);

        textures_.emplace_back(ResourceTexture(name, std::make_shared<Texture>(Screen::get()->getRenderer(), l)));
    }
}

// Carga los ficheros de texto
void Resource::loadTextFiles()
{
    std::cout << "\n>> TEXT FILES" << std::endl;
    // Obtiene la lista con las rutas a los ficheros png
    auto list = Asset::get()->getListByType(AssetType::FONT);
    text_files_.clear();

    for (const auto &l : list)
    {
        // Encuentra el último índice de '/'
        auto last_index = l.find_last_of('/') + 1;

        // Obtiene la subcadena desde el último '/'
        auto name = l.substr(last_index);

        text_files_.emplace_back(ResourceTextFile(name, loadTextFile(l)));
    }
}

// Carga las animaciones
void Resource::loadAnimations()
{
    std::cout << "\n>> ANIMATIONS" << std::endl;
    // Obtiene la lista con las rutas a los ficheros ani
    auto list = Asset::get()->getListByType(AssetType::ANIMATION);
    animations_.clear();

    for (const auto &l : list)
    {
        // Encuentra el último índice de '/'
        auto last_index = l.find_last_of('/') + 1;

        // Obtiene la subcadena desde el último '/'
        auto name = l.substr(last_index);

        animations_.emplace_back(ResourceAnimation(name, loadAnimationsFromFile(l)));
    }
}