#include "game/scenes/game_over.hpp"

#include <SDL3/SDL.h>

#include <algorithm>  // Para min, max
#include <string>     // Para basic_string, operator+, to_string

#include "core/input/global_inputs.hpp"                // Para check
#include "core/rendering/screen.hpp"                   // Para Screen
#include "core/rendering/surface_animated_sprite.hpp"  // Para SAnimatedSprite
#include "core/rendering/text.hpp"                     // Para TEXT_CENTER, TEXT_COLOR, Text
#include "core/resources/resource.hpp"                 // Para Resource
#include "external/jail_audio.h"                       // Para JA_PlayMusic
#include "game/options.hpp"                            // Para Options, options, OptionsStats, Secti...
#include "game/scene_manager.hpp"                      // Para SceneManager
#include "utils/defines.hpp"                           // Para GAMECANVAS_CENTER_X, GAME_SPEED
#include "core/system/global_events.hpp"               // Para check
#include "utils/utils.hpp"                             // Para PaletteColor, stringToColor

// Constructor
GameOver::GameOver()
    : player_sprite_(std::make_shared<SurfaceAnimatedSprite>(Resource::get()->getSurface("player_game_over.gif"), Resource::get()->getAnimations("player_game_over.ani"))),
      tv_sprite_(std::make_shared<SurfaceAnimatedSprite>(Resource::get()->getSurface("tv.gif"), Resource::get()->getAnimations("tv.ani"))) {
    SceneManager::current = SceneManager::Scene::GAME_OVER;
    SceneManager::options = SceneManager::Options::NONE;

    player_sprite_->setPosX(GAMECANVAS_CENTER_X + 10);
    player_sprite_->setPosY(30);
    tv_sprite_->setPosX(GAMECANVAS_CENTER_X - tv_sprite_->getWidth() - 10);
    tv_sprite_->setPosY(30);

    Screen::get()->setBorderColor(static_cast<Uint8>(PaletteColor::BLACK));

    // Inicializa el vector de colores
    const std::vector<std::string> COLORS = {"white", "yellow", "cyan", "green", "magenta", "red", "blue", "black"};
    for (const auto& color : COLORS) {
        colors_.push_back(stringToColor(color));
    }
    color_ = colors_.back();
}

// Actualiza el objeto
void GameOver::update() {
    // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
    if (SDL_GetTicks() - ticks_ > GAME_SPEED) {
        // Actualiza el contador de ticks
        ticks_ = SDL_GetTicks();

        // Comprueba las entradas
        checkInput();

        // Actualiza el color usado para renderizar los textos e imagenes
        updateColor();

        // Actualiza los contadores
        updateCounters();

        // Actualiza los dos sprites
        player_sprite_->update();
        tv_sprite_->update();

        // Actualiza el objeto Screen
        Screen::get()->update();
    }
}

// Dibuja el final en pantalla
void GameOver::render() {
    constexpr int Y = 32;

    Screen::get()->start();
    Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));

    auto text = Resource::get()->getText("smb2");

    // Escribe el texto de GAME OVER
    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y, "G A M E   O V E R", 1, color_);

    // Dibuja los sprites
    player_sprite_->setPosY(Y + 30);
    tv_sprite_->setPosY(Y + 30);
    renderSprites();

    // Escribe el texto con las habitaciones y los items
    const std::string ITEMS_TEXT = std::to_string(Options::stats.items / 100) + std::to_string((Options::stats.items % 100) / 10) + std::to_string(Options::stats.items % 10);
    const std::string ROOMS_TEXT = std::to_string(Options::stats.rooms / 100) + std::to_string((Options::stats.rooms % 100) / 10) + std::to_string(Options::stats.rooms % 10);
    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 80, "ITEMS: " + ITEMS_TEXT, 1, color_);
    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 90, "ROOMS: " + ROOMS_TEXT, 1, color_);

    // Escribe el texto con "Tu peor pesadilla"
    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 110, "YOUR WORST NIGHTMARE IS", 1, color_);
    text->writeDX(TEXT_CENTER | TEXT_COLOR, GAMECANVAS_CENTER_X, Y + 120, Options::stats.worst_nightmare, 1, color_);

    // Vuelca el contenido del renderizador en pantalla
    Screen::get()->render();
}

// Comprueba el manejador de eventos
void GameOver::checkEvents() {
    SDL_Event event;
    while (SDL_PollEvent(&event)) {
        GlobalEvents::check(event);
    }
}

// Comprueba las entradas
void GameOver::checkInput() {
    GlobalInputs::check();
}

// Bucle principal
void GameOver::run() {
    while (SceneManager::current == SceneManager::Scene::GAME_OVER) {
        update();
        checkEvents();
        render();
    }
}

// Actualiza el color usado para renderizar los textos e imagenes
void GameOver::updateColor() {
    const int HALF = COUNTER_SECTION_END / 2;

    if (counter_ < HALF) {
        const float STEP = std::min(counter_, COUNTER_FADE_LENGHT) / (float)COUNTER_FADE_LENGHT;
        const int INDEX = (colors_.size() - 1) - int((colors_.size() - 1) * STEP);
        color_ = colors_[INDEX];
    } else {
        const float STEP = std::min(std::max(counter_, COUNTER_INIT_FADE) - COUNTER_INIT_FADE, COUNTER_FADE_LENGHT) / (float)COUNTER_FADE_LENGHT;
        const int INDEX = (colors_.size() - 1) * STEP;
        color_ = colors_[INDEX];
    }
}

// Dibuja los sprites
void GameOver::renderSprites() {
    player_sprite_->render(1, color_);
    tv_sprite_->render(1, color_);
}

// Actualiza los contadores
void GameOver::updateCounters() {
    // Actualiza el contador
    if (pre_counter_ < 50) {
        pre_counter_++;
    } else {
        counter_++;
    }

    // Hace sonar la música
    if (counter_ == 1) {
        JA_PlayMusic(Resource::get()->getMusic("game_over.ogg"), 0);
    }

    // Comprueba si ha terminado la sección
    else if (counter_ == COUNTER_SECTION_END) {
        SceneManager::current = SceneManager::Scene::LOGO;
        SceneManager::options = SceneManager::Options::LOGO_TO_TITLE;
    }
}