#include "core/rendering/screen.hpp"

#include <SDL3/SDL.h>
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#include <emscripten/html5.h>
#endif

#include <algorithm>  // Para max, min, transform
#include <cctype>     // Para toupper
#include <cmath>      // Para round, floor
#include <cstring>    // Para memcpy
#include <fstream>    // Para basic_ostream, operator<<, endl, basic_...
#include <iostream>   // Para cerr
#include <iterator>   // Para istreambuf_iterator, operator==
#include <string>     // Para char_traits, string, operator+, operator==

#include "core/input/mouse.hpp"            // Para updateCursorVisibility
#include "core/rendering/render_info.hpp"  // Para RenderInfo
#ifndef __EMSCRIPTEN__
#include "core/rendering/sdl3gpu/sdl3gpu_shader.hpp"  // Para SDL3GPUShader (no soportado en WebGL2)
#endif
#include "core/rendering/surface.hpp"          // Para Surface, readPalFile
#include "core/rendering/text.hpp"             // Para Text
#include "core/resources/resource_cache.hpp"   // Para Resource
#include "core/resources/resource_helper.hpp"  // Para ResourceHelper
#include "core/resources/resource_list.hpp"    // Para Asset, AssetType
#include "game/options.hpp"                    // Para Options, options, OptionsVideo, Border
#include "game/ui/console.hpp"                 // Para Console
#include "game/ui/notifier.hpp"                // Para Notifier

// [SINGLETON]
Screen* Screen::screen = nullptr;

#ifdef __EMSCRIPTEN__
// ============================================================================
// Restauración del canvas en wasm/Emscripten
// ============================================================================
// SDL3 + Emscripten no notifica de manera fiable los cambios de tamaño del
// canvas HTML (fullscreen exit con Esc, orientationchange). Registramos
// callbacks nativos de Emscripten que re-sincronizan SDL con el estado real
// del navegador delegando en Screen::handleCanvasResized() → setVideoMode().
// Se difiere con emscripten_async_call(0ms) porque cuando el event llega el
// canvas aún no está estable.
// Referencias:
//   - https://github.com/libsdl-org/SDL/issues/13300
//   - https://github.com/libsdl-org/SDL/issues/11389
// ============================================================================
namespace {
    void deferredCanvasResize(void* /*user_data*/) {
        if (Screen::get() != nullptr) { Screen::get()->handleCanvasResized(); }
    }

    auto onEmFullscreenChange(int /*event_type*/, const EmscriptenFullscreenChangeEvent* event, void* /*user_data*/) -> EM_BOOL {
        Options::video.fullscreen = (event != nullptr && event->isFullscreen != 0);
        emscripten_async_call(deferredCanvasResize, nullptr, 0);
        return EM_FALSE;
    }

    auto onEmOrientationChange(int /*event_type*/, const EmscriptenOrientationChangeEvent* /*event*/, void* /*user_data*/) -> EM_BOOL {
        emscripten_async_call(deferredCanvasResize, nullptr, 0);
        return EM_FALSE;
    }
}  // namespace
#endif

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

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

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

// Constructor
Screen::Screen() {
    // Arranca SDL VIDEO, crea la ventana y el renderizador
    initSDLVideo();
    if (Options::video.fullscreen) { SDL_HideCursor(); }

    // Calcular tamaños y hacer .resize() de los buffers de píxeles
    adjustWindowSize();
    adjustRenderLogicalSize();
    updateZoomFactor();

    // Ajusta los tamaños
    game_surface_dstrect_ = {.x = Options::video.border.width, .y = Options::video.border.height, .w = Options::game.width, .h = Options::game.height};

    // Define el color del borde para el modo de pantalla completa
    border_color_ = 0;

    // Crea la textura donde se dibujan los graficos del juego
    game_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, Options::game.width, Options::game.height);
    if (game_texture_ == nullptr) {
        // Registrar el error si está habilitado
        std::cerr << "Error: game_texture_ could not be created!\nSDL Error: " << SDL_GetError() << '\n';
    }
    SDL_SetTextureScaleMode(game_texture_, SDL_SCALEMODE_NEAREST);

    // Crea la textura donde se dibuja el borde que rodea el area de juego
    border_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, Options::game.width + (Options::video.border.width * 2), Options::game.height + (Options::video.border.height * 2));
    if (border_texture_ == nullptr) {
        // Registrar el error si está habilitado
        std::cerr << "Error: border_texture_ could not be created!\nSDL Error: " << SDL_GetError() << '\n';
    }
    SDL_SetTextureScaleMode(border_texture_, SDL_SCALEMODE_NEAREST);

    // Crea las surfaces (PaletteManager aplicará la paleta inicial en su constructor)
    game_surface_ = std::make_shared<Surface>(Options::game.width, Options::game.height);
    game_surface_->clear(0);

    border_surface_ = std::make_shared<Surface>(Options::game.width + (Options::video.border.width * 2), Options::game.height + (Options::video.border.height * 2));
    border_surface_->clear(border_color_);

    // Crea el gestor de paletas; aplica la paleta inicial a ambas surfaces
    palette_manager_ = std::make_unique<PaletteManager>(
        Resource::List::get()->getListByType(Resource::List::Type::PALETTE),
        Options::video.palette,
        sortModeFromString(Options::video.palette_sort),
        game_surface_,
        border_surface_,
        [this]() {
            // Actualizar caché ARGB del borde cuando cambia la paleta
            border_surface_->toARGBBuffer(border_pixel_buffer_.data());
            border_argb_color_ = border_pixel_buffer_[0];
        });

    // Cachear el color ARGB inicial del borde (borde sólido por defecto)
    border_surface_->toARGBBuffer(border_pixel_buffer_.data());
    border_argb_color_ = border_pixel_buffer_[0];

    // Establece la surface que actuará como renderer para recibir las llamadas a render()
    renderer_surface_ = std::make_shared<std::shared_ptr<Surface>>(game_surface_);

    // Crea el objeto de texto para la pantalla de carga
    createText();

    // Renderizar una vez la textura vacía para que tenga contenido válido
    // antes de inicializar los shaders (evita pantalla negra)
    SDL_RenderTexture(renderer_, game_texture_, nullptr, nullptr);
    SDL_RenderTexture(renderer_, border_texture_, nullptr, nullptr);

    // Ahora sí inicializar los shaders
    initShaders();
}

// Destructor
Screen::~Screen() {
    SDL_DestroyTexture(game_texture_);
    SDL_DestroyTexture(border_texture_);
}

// Limpia el renderer
void Screen::clearRenderer(Rgb color) {
    SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
    SDL_RenderClear(renderer_);
}

// Prepara para empezar a dibujar en la textura de juego
void Screen::start() { setRendererSurface(nullptr); }

// Vuelca el contenido del renderizador en pantalla
void Screen::render() {
    fps_.increment();

    // Renderiza todos los overlays (escribe en game_surface_ CPU-side)
    renderOverlays();

    // En el path SDL3GPU, los píxeles se suben directamente desde la Surface.
    // En el path SDL_Renderer, primero copiamos la surface a la SDL_Texture.
    if (!(shader_backend_ && shader_backend_->isHardwareAccelerated())) {
        surfaceToTexture();
    }

    // Copia la textura al renderizador (o hace el present GPU)
    textureToRenderer();
}

// Establece el modo de video
void Screen::setVideoMode(bool mode) {
    // Actualiza las opciones
    Options::video.fullscreen = mode;

    // Configura el modo de pantalla y ajusta la ventana
    SDL_SetWindowFullscreen(window_, Options::video.fullscreen);
    SDL_SyncWindow(window_);
    adjustWindowSize();
    adjustRenderLogicalSize();
    updateZoomFactor();
}

// Camibia entre pantalla completa y ventana
void Screen::toggleVideoMode() {
    Options::video.fullscreen = !Options::video.fullscreen;
    setVideoMode(Options::video.fullscreen);
}

// Re-sincroniza SDL con el estado real del canvas del navegador. Lo invocan los
// callbacks nativos de Emscripten cuando detectan un fullscreenchange u
// orientationchange. En desktop SDL emite SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED
// correctamente, así que fuera de emscripten es un no-op.
void Screen::handleCanvasResized() {
#ifdef __EMSCRIPTEN__
    setVideoMode(Options::video.fullscreen);
#endif
}

// Reduce el tamaño de la ventana
auto Screen::decWindowZoom() -> bool {
    if (static_cast<int>(Options::video.fullscreen) == 0) {
        const int PREVIOUS_ZOOM = Options::window.zoom;
        --Options::window.zoom;
        Options::window.zoom = std::max(Options::window.zoom, 1);

        if (Options::window.zoom != PREVIOUS_ZOOM) {
            setVideoMode(Options::video.fullscreen);
            return true;
        }
    }

    return false;
}

// Aumenta el tamaño de la ventana
auto Screen::incWindowZoom() -> bool {
    if (static_cast<int>(Options::video.fullscreen) == 0) {
        const int PREVIOUS_ZOOM = Options::window.zoom;
        ++Options::window.zoom;
        Options::window.zoom = std::min(Options::window.zoom, Options::window.max_zoom);

        if (Options::window.zoom != PREVIOUS_ZOOM) {
            setVideoMode(Options::video.fullscreen);
            return true;
        }
    }

    return false;
}

// Establece el zoom directamente; false si fuera del rango [1, max_zoom] o en pantalla completa
auto Screen::setWindowZoom(int zoom) -> bool {
    if (Options::video.fullscreen) { return false; }
    if (zoom < 1 || zoom > Options::window.max_zoom) { return false; }
    if (zoom == Options::window.zoom) { return false; }
    Options::window.zoom = zoom;
    setVideoMode(Options::video.fullscreen);
    return true;
}

// Devuelve el zoom máximo permitido según la pantalla actual
auto Screen::getMaxZoom() -> int {
    return Options::window.max_zoom;
}

// Cambia el color del borde
void Screen::setBorderColor(Uint8 color) {
    border_color_ = color;
    border_surface_->clear(border_color_);

    // Actualizar caché ARGB del borde sólido (ocurre una vez por habitación, no cada frame)
    border_surface_->toARGBBuffer(border_pixel_buffer_.data());
    border_argb_color_ = border_pixel_buffer_[0];
}

// Captura el contenido actual (borde + juego si el borde está activo, solo juego si no)
void Screen::captureComposite(std::vector<Uint32>& buffer, int& out_width, int& out_height) const {
    const int GAME_W = static_cast<int>(game_surface_->getWidth());
    const int GAME_H = static_cast<int>(game_surface_->getHeight());

    if (Options::video.border.enabled) {
        const int BORDER_W = static_cast<int>(border_surface_->getWidth());
        const int BORDER_H = static_cast<int>(border_surface_->getHeight());
        const int OFF_X = Options::video.border.width;
        const int OFF_Y = Options::video.border.height;

        buffer.resize(static_cast<size_t>(BORDER_W) * BORDER_H);
        border_surface_->toARGBBuffer(buffer.data());

        std::vector<Uint32> game_buf(static_cast<size_t>(GAME_W) * GAME_H);
        game_surface_->toARGBBuffer(game_buf.data());

        for (int y = 0; y < GAME_H; ++y) {
            std::memcpy(
                &buffer[(static_cast<size_t>(OFF_Y + y) * BORDER_W) + OFF_X],
                &game_buf[static_cast<size_t>(y) * GAME_W],
                static_cast<size_t>(GAME_W) * sizeof(Uint32));
        }

        out_width = BORDER_W;
        out_height = BORDER_H;
    } else {
        buffer.resize(static_cast<size_t>(GAME_W) * GAME_H);
        game_surface_->toARGBBuffer(buffer.data());
        out_width = GAME_W;
        out_height = GAME_H;
    }
}

// Cambia entre borde visible y no visible
void Screen::toggleBorder() {
    Options::video.border.enabled = !Options::video.border.enabled;
    setVideoMode(Options::video.fullscreen);
    initShaders();
}

// Dibuja las notificaciones
void Screen::renderNotifications() const {
    if (notifications_enabled_) {
        Notifier::get()->render();
    }
}

// Activa/desactiva todos los shaders respetando el shader actualmente seleccionado
void Screen::toggleShaders() {
    Options::video.shader.enabled = !Options::video.shader.enabled;
    if (shader_backend_ && shader_backend_->isHardwareAccelerated()) {
        if (Options::video.shader.enabled) {
            // Activar: usar el shader actualmente seleccionado
            if (Options::video.shader.current_shader == Rendering::ShaderType::CRTPI) {
                shader_backend_->setActiveShader(Rendering::ShaderType::CRTPI);
                applyCurrentCrtPiPreset();
            } else {
                applyCurrentPostFXPreset();
            }
        } else {
            // Desactivar: pass-through con POSTFX (pipeline sin efecto)
            shader_backend_->setActiveShader(Rendering::ShaderType::POSTFX);
            shader_backend_->setPostFXParams(Rendering::PostFXParams{});
        }
    } else {
        // Backend no inicializado aún — inicializarlo ahora
        initShaders();
    }
}

// Recarga el shader del preset actual sin toggle
void Screen::reloadPostFX() {
    if (Options::video.shader.enabled && shader_backend_ && shader_backend_->isHardwareAccelerated()) {
        // El backend ya está activo: solo actualizar uniforms, sin recrear el pipeline
        applyCurrentPostFXPreset();
    } else if (Options::video.shader.enabled) {
        initShaders();
    }
}

// Recarga el shader CrtPi del preset actual sin toggle
void Screen::reloadCrtPi() {
    if (!shader_backend_) { return; }
    applyCurrentCrtPiPreset();
}

// Actualiza la lógica de la clase (versión nueva con delta_time para escenas migradas)
void Screen::update(float delta_time) {
    fps_.calculate(SDL_GetTicks());
    Notifier::get()->update(delta_time);
    if (Console::get() != nullptr) {
        Console::get()->update(delta_time);
    }
    if (RenderInfo::get() != nullptr) { RenderInfo::get()->update(delta_time); }
    Mouse::updateCursorVisibility();
}

// Calcula el tamaño de la ventana
void Screen::adjustWindowSize() {
    window_width_ = Options::game.width + (Options::video.border.enabled ? Options::video.border.width * 2 : 0);
    window_height_ = Options::game.height + (Options::video.border.enabled ? Options::video.border.height * 2 : 0);

    // Reservamos memoria una sola vez.
    // Si el buffer es más pequeño que la superficie, crash asegurado.
    border_pixel_buffer_.resize(static_cast<size_t>(window_width_) * static_cast<size_t>(window_height_));
    game_pixel_buffer_.resize(static_cast<size_t>(Options::game.width) * static_cast<size_t>(Options::game.height));

    // border_pixel_buffer_ es el buffer que se sube a la GPU (tamaño total ventana).
    if (Options::video.border.enabled) {
        border_pixel_buffer_.resize(static_cast<size_t>(window_width_) * static_cast<size_t>(window_height_));
    }

    // Lógica de centrado y redimensionado de ventana SDL
    if (static_cast<int>(Options::video.fullscreen) == 0) {
        int old_w;
        int old_h;
        SDL_GetWindowSize(window_, &old_w, &old_h);
        int old_x;
        int old_y;
        SDL_GetWindowPosition(window_, &old_x, &old_y);

        const int NEW_W = window_width_ * Options::window.zoom;
        const int NEW_H = window_height_ * Options::window.zoom;
        const int NEW_X = old_x + ((old_w - NEW_W) / 2);
        const int NEW_Y = old_y + ((old_h - NEW_H) / 2);

        SDL_SetWindowSize(window_, NEW_W, NEW_H);

        // En Wayland, SDL_SetWindowPosition es ignorado por el compositor (limitación de
        // protocolo: el compositor controla la posición de ventanas toplevel). Solo se
        // aplica en X11/Windows/macOS donde el posicionado funciona correctamente.
        // SDL_SyncWindow garantiza que el resize esté completado antes de reposicionar
        // (evita el race condition en X11).
        SDL_SyncWindow(window_);
        const char* driver = SDL_GetCurrentVideoDriver();
        const bool IS_WAYLAND = (driver != nullptr && SDL_strcmp(driver, "wayland") == 0);
        if (!IS_WAYLAND) {
            SDL_SetWindowPosition(window_, std::max(NEW_X, WINDOWS_DECORATIONS), std::max(NEW_Y, 0));
        }
    }
}

// Ajusta el tamaño lógico del renderizador
void Screen::adjustRenderLogicalSize() {
    SDL_SetRenderLogicalPresentation(renderer_, window_width_, window_height_, Options::video.integer_scale ? SDL_LOGICAL_PRESENTATION_INTEGER_SCALE : SDL_LOGICAL_PRESENTATION_LETTERBOX);
}

// Recalcula y almacena el factor de zoom. Llamar solo cuando SDL ya ha estabilizado el estado de la ventana.
// En ventana: Options::window.zoom (siempre entero).
// En fullscreen: mínimo de las escalas en ambos ejes; floor si integer scale está activo.
void Screen::updateZoomFactor() {
    if (!Options::video.fullscreen) {
        zoom_factor_ = static_cast<float>(Options::window.zoom);
        return;
    }
    if (window_width_ == 0 || window_height_ == 0) {
        zoom_factor_ = 1.0F;
        return;
    }
    int pw{0};
    int ph{0};
    SDL_GetRenderOutputSize(renderer_, &pw, &ph);
    const float SCALE = std::min(static_cast<float>(pw) / static_cast<float>(window_width_),
        static_cast<float>(ph) / static_cast<float>(window_height_));
    zoom_factor_ = Options::video.integer_scale ? std::floor(SCALE) : SCALE;
}

// Establece el offset de renderizado (para transiciones de pantalla)
void Screen::setRenderOffset(int x, int y) {
    render_offset_x_ = x;
    render_offset_y_ = y;
}

// Establece el renderizador para las surfaces
void Screen::setRendererSurface(const std::shared_ptr<Surface>& surface) {
    (surface) ? renderer_surface_ = std::make_shared<std::shared_ptr<Surface>>(surface) : renderer_surface_ = std::make_shared<std::shared_ptr<Surface>>(game_surface_);
}

// Cambia la paleta
void Screen::nextPalette() { palette_manager_->next(); }

// Cambia la paleta
void Screen::previousPalette() { palette_manager_->previous(); }

// Copia la surface a la textura
void Screen::surfaceToTexture() {
    if (Options::video.border.enabled) {
        border_surface_->copyToTexture(renderer_, border_texture_);
        game_surface_->copyToTexture(renderer_, border_texture_, nullptr, &game_surface_dstrect_);
    } else {
        game_surface_->copyToTexture(renderer_, game_texture_);
    }
}

// Copia la textura al renderizador (o hace el present GPU)
void Screen::textureToRenderer() {
    if (shader_backend_ && shader_backend_->isHardwareAccelerated()) {
        const int GAME_W = Options::game.width;
        const int GAME_H = Options::game.height;

        if (Options::video.border.enabled) {
            const int BORDER_W = window_width_;
            const int BORDER_H = window_height_;
            const int OFF_X = static_cast<int>(game_surface_dstrect_.x);
            const int OFF_Y = static_cast<int>(game_surface_dstrect_.y);

            // Rellena solo el marco con el color cacheado — sin lookups de paleta.
            // El área central (juego) se deja sin tocar; el overlay la sobreescribe igualmente.

            const auto BORDER_W_SZ = static_cast<size_t>(BORDER_W);
            const auto GAME_W_SZ = static_cast<size_t>(GAME_W);
            // Franjas superior e inferior (ancho completo)
            std::fill_n(border_pixel_buffer_.data(), static_cast<size_t>(OFF_Y) * BORDER_W_SZ, border_argb_color_);
            std::fill_n(&border_pixel_buffer_[(static_cast<size_t>(OFF_Y) + GAME_H) * BORDER_W_SZ],
                (static_cast<size_t>(BORDER_H - OFF_Y - GAME_H)) * BORDER_W_SZ,
                border_argb_color_);
            // Columnas laterales en las filas del área de juego
            for (int y = OFF_Y; y < OFF_Y + GAME_H; ++y) {
                std::fill_n(&border_pixel_buffer_[static_cast<size_t>(y) * BORDER_W_SZ], OFF_X, border_argb_color_);
                std::fill_n(&border_pixel_buffer_[(static_cast<size_t>(y) * BORDER_W_SZ) + OFF_X + GAME_W],
                    BORDER_W - OFF_X - GAME_W,
                    border_argb_color_);
            }

            // Overlay del juego sobre el centro del buffer (ambos paths)
            game_surface_->toARGBBuffer(game_pixel_buffer_.data());
            for (int y = 0; y < GAME_H; ++y) {
                const Uint32* src = &game_pixel_buffer_[static_cast<size_t>(y) * GAME_W_SZ];
                Uint32* dst = &border_pixel_buffer_[((static_cast<size_t>(OFF_Y) + y) * BORDER_W_SZ) + OFF_X];
                std::memcpy(dst, src, GAME_W_SZ * sizeof(Uint32));
            }

            shader_backend_->uploadPixels(border_pixel_buffer_.data(), BORDER_W, BORDER_H);
        } else {
            // Caso sin borde: subida directa simplificada
            game_surface_->toARGBBuffer(game_pixel_buffer_.data());
            shader_backend_->uploadPixels(game_pixel_buffer_.data(), GAME_W, GAME_H);
        }

        shader_backend_->render();
    } else {
        // Fallback SDL_Renderer (mantiene tu lógica de texturas SDL)
        SDL_Texture* tex = Options::video.border.enabled ? border_texture_ : game_texture_;
        SDL_SetRenderTarget(renderer_, nullptr);
        SDL_RenderClear(renderer_);
        SDL_RenderTexture(renderer_, tex, nullptr, nullptr);
        SDL_RenderPresent(renderer_);
    }
}

// Renderiza todos los overlays (orden: último dibujado queda encima)
void Screen::renderOverlays() {
    if (RenderInfo::get() != nullptr) { RenderInfo::get()->render(); }  // RenderInfo (abajo)
    renderNotifications();                                              // Notifier (medio)
    if (Console::get() != nullptr) { Console::get()->render(); }        // Console (encima)
}

// Cambia a una paleta por nombre (case-insensitive); devuelve false si no existe
auto Screen::setPaletteByName(const std::string& name) -> bool { return palette_manager_->setByName(name); }

// Devuelve los nombres de paletas disponibles (minúsculas, sin extensión .pal)
auto Screen::getPaletteNames() const -> std::vector<std::string> { return palette_manager_->getNames(); }
auto Screen::getPalettePrettyName() const -> std::string { return palette_manager_->getPrettyName(); }
void Screen::nextPaletteSortMode() { palette_manager_->nextSortMode(); }
void Screen::setPaletteSortMode(PaletteSortMode mode) { palette_manager_->setSortMode(mode); }
auto Screen::getPaletteSortModeName() const -> std::string { return palette_manager_->getSortModeName(); }

// Limpia la game_surface_
void Screen::clearSurface(Uint8 index) { game_surface_->clear(index); }

// Establece el tamaño del borde
void Screen::setBorderWidth(int width) { Options::video.border.width = width; }

// Establece el tamaño del borde
void Screen::setBorderHeight(int height) { Options::video.border.height = height; }

// Establece si se ha de ver el borde en el modo ventana
void Screen::setBorderEnabled(bool value) { Options::video.border.enabled = value; }

// Muestra la ventana
void Screen::show() { SDL_ShowWindow(window_); }

// Oculta la ventana
void Screen::hide() { SDL_HideWindow(window_); }

// Establece la visibilidad de las notificaciones
void Screen::setNotificationsEnabled(bool value) { notifications_enabled_ = value; }

// Alterna entre activar y desactivar el escalado entero
void Screen::toggleIntegerScale() {
    Options::video.integer_scale = !Options::video.integer_scale;
    SDL_SetRenderLogicalPresentation(renderer_, Options::game.width, Options::game.height, Options::video.integer_scale ? SDL_LOGICAL_PRESENTATION_INTEGER_SCALE : SDL_LOGICAL_PRESENTATION_LETTERBOX);
    if (shader_backend_) {
        shader_backend_->setScaleMode(Options::video.integer_scale);
    }
    updateZoomFactor();
}

// Alterna entre activar y desactivar el V-Sync
void Screen::toggleVSync() {
    Options::video.vertical_sync = !Options::video.vertical_sync;
    SDL_SetRenderVSync(renderer_, Options::video.vertical_sync ? 1 : SDL_RENDERER_VSYNC_DISABLED);
    if (shader_backend_) {
        shader_backend_->setVSync(Options::video.vertical_sync);
    }
}

// Getters
auto Screen::getRenderer() -> SDL_Renderer* { return renderer_; }
auto Screen::getRendererSurface() -> std::shared_ptr<Surface> { return (*renderer_surface_); }
auto Screen::getGameSurface() -> std::shared_ptr<Surface> { return game_surface_; }
auto Screen::getBorderSurface() -> std::shared_ptr<Surface> {
    return border_surface_;
}

auto loadData(const std::string& filepath) -> std::vector<uint8_t> {
    // Load using ResourceHelper (supports both filesystem and pack)
    return Resource::Helper::loadFile(filepath);
}

void Screen::setLinearUpscale(bool linear) {
    Options::video.supersampling.linear_upscale = linear;
    if (shader_backend_ && shader_backend_->isHardwareAccelerated()) {
        shader_backend_->setLinearUpscale(linear);
    }
}

void Screen::setDownscaleAlgo(int algo) {
    Options::video.supersampling.downscale_algo = algo;
    if (shader_backend_ && shader_backend_->isHardwareAccelerated()) {
        shader_backend_->setDownscaleAlgo(algo);
    }
}

auto Screen::getSsTextureSize() const -> std::pair<int, int> {
    if (!shader_backend_) { return {0, 0}; }
    return shader_backend_->getSsTextureSize();
}

// Activa/desactiva el supersampling global (Ctrl+F4)
void Screen::toggleSupersampling() {
    Options::video.supersampling.enabled = !Options::video.supersampling.enabled;
    if (Options::video.shader.enabled && shader_backend_ && shader_backend_->isHardwareAccelerated()) {
        applyCurrentPostFXPreset();
    }
}

// Aplica los parámetros del preset actual al backend de shaders
void Screen::applyCurrentPostFXPreset() {
    if (shader_backend_ && !Options::postfx_presets.empty()) {
        const auto& p = Options::postfx_presets[static_cast<size_t>(Options::video.shader.current_postfx_preset)];
        // Supersampling es un toggle global (Options::video.supersampling.enabled), no por preset.
        // setOversample primero: puede recrear texturas antes de que setPostFXParams
        // decida si hornear scanlines en CPU o aplicarlas en GPU.
        shader_backend_->setOversample(Options::video.supersampling.enabled ? 3 : 1);
        Rendering::PostFXParams params{.vignette = p.vignette, .scanlines = p.scanlines, .chroma = p.chroma, .mask = p.mask, .gamma = p.gamma, .curvature = p.curvature, .bleeding = p.bleeding, .flicker = p.flicker};
        shader_backend_->setPostFXParams(params);
    }
}

// Aplica los parámetros del preset CrtPi actual al backend de shaders
void Screen::applyCurrentCrtPiPreset() {
    if (shader_backend_ && !Options::crtpi_presets.empty()) {
        const auto& p = Options::crtpi_presets[static_cast<size_t>(Options::video.shader.current_crtpi_preset)];
        Rendering::CrtPiParams params{
            .scanline_weight = p.scanline_weight,
            .scanline_gap_brightness = p.scanline_gap_brightness,
            .bloom_factor = p.bloom_factor,
            .input_gamma = p.input_gamma,
            .output_gamma = p.output_gamma,
            .mask_brightness = p.mask_brightness,
            .curvature_x = p.curvature_x,
            .curvature_y = p.curvature_y,
            .mask_type = p.mask_type,
            .enable_scanlines = p.enable_scanlines,
            .enable_multisample = p.enable_multisample,
            .enable_gamma = p.enable_gamma,
            .enable_curvature = p.enable_curvature,
            .enable_sharper = p.enable_sharper,
        };
        shader_backend_->setCrtPiParams(params);
    }
}

// Cambia el shader de post-procesado activo y aplica el preset correspondiente
void Screen::setActiveShader(Rendering::ShaderType type) {
    Options::video.shader.current_shader = type;
    if (!shader_backend_) { return; }
    if (!Options::video.shader.enabled) {
        // Shaders desactivados: guardar preferencia pero mantener pass-through
        shader_backend_->setActiveShader(Rendering::ShaderType::POSTFX);
        shader_backend_->setPostFXParams(Rendering::PostFXParams{});
        return;
    }
    shader_backend_->setActiveShader(type);
    if (type == Rendering::ShaderType::CRTPI) {
        applyCurrentCrtPiPreset();
    } else {
        applyCurrentPostFXPreset();
    }
}

// Cicla al siguiente shader disponible (preparado para futura UI)
void Screen::nextShader() {
    const Rendering::ShaderType NEXT = (Options::video.shader.current_shader == Rendering::ShaderType::POSTFX)
        ? Rendering::ShaderType::CRTPI
        : Rendering::ShaderType::POSTFX;
    setActiveShader(NEXT);
}

// Inicializa los shaders
// El device GPU se crea siempre (independientemente de postfx) para evitar
// conflictos SDL_Renderer/SDL_GPU al hacer toggle F4 en Windows/Vulkan.
void Screen::initShaders() {
#ifdef __EMSCRIPTEN__
    // En WebGL2 no hay SDL3 GPU; el render va por SDL_Renderer sin shaders.
    shader_backend_.reset();
#else
    SDL_Texture* tex = Options::video.border.enabled ? border_texture_ : game_texture_;

    if (!shader_backend_) {
        shader_backend_ = std::make_unique<Rendering::SDL3GPUShader>();
        const std::string FALLBACK_DRIVER = "none";
        shader_backend_->setPreferredDriver(Options::video.gpu.acceleration ? Options::video.gpu.preferred_driver : FALLBACK_DRIVER);
    }
    shader_backend_->init(window_, tex, "", "");
    gpu_driver_ = shader_backend_->getDriverName();

    // Propagar flags de vsync, integer scale, upscale y downscale al backend GPU
    shader_backend_->setVSync(Options::video.vertical_sync);
    shader_backend_->setScaleMode(Options::video.integer_scale);
    shader_backend_->setLinearUpscale(Options::video.supersampling.linear_upscale);
    shader_backend_->setDownscaleAlgo(Options::video.supersampling.downscale_algo);

    if (Options::video.shader.enabled) {
        applyCurrentPostFXPreset();
    } else {
        // Pass-through: todos los efectos a 0, el shader solo copia la textura
        shader_backend_->setPostFXParams(Rendering::PostFXParams{});
    }

    // Restaurar el shader activo guardado en config (y sus parámetros CrtPi si aplica)
    shader_backend_->setActiveShader(Options::video.shader.current_shader);
    if (Options::video.shader.current_shader == Rendering::ShaderType::CRTPI) {
        applyCurrentCrtPiPreset();
    }
#endif
}

// Obtiene información sobre la pantalla
void Screen::getDisplayInfo() {
    std::cout << "\n** VIDEO SYSTEM **\n";

    int num_displays = 0;
    SDL_DisplayID* displays = SDL_GetDisplays(&num_displays);
    if (displays != nullptr) {
        for (int i = 0; i < num_displays; ++i) {
            SDL_DisplayID instance_id = displays[i];
            const char* name = SDL_GetDisplayName(instance_id);

            std::cout << "Display " << instance_id << ": " << ((name != nullptr) ? name : "Unknown") << '\n';
        }

        const auto* dm = SDL_GetCurrentDisplayMode(displays[0]);

        // Guarda información del monitor en display_monitor_
        const char* first_display_name = SDL_GetDisplayName(displays[0]);
        display_monitor_.name = (first_display_name != nullptr) ? first_display_name : "Unknown";
        display_monitor_.width = static_cast<int>(dm->w);
        display_monitor_.height = static_cast<int>(dm->h);
        display_monitor_.refresh_rate = static_cast<int>(dm->refresh_rate);

        // Calcula el máximo factor de zoom que se puede aplicar a la pantalla
        Options::window.max_zoom = std::min(dm->w / Options::game.width, dm->h / Options::game.height);
        Options::window.zoom = std::min(Options::window.zoom, Options::window.max_zoom);

        // Muestra información sobre el tamaño de la pantalla y de la ventana de juego
        std::cout << "Current display mode: " << static_cast<int>(dm->w) << "x" << static_cast<int>(dm->h) << " @ " << static_cast<int>(dm->refresh_rate) << "Hz\n";

        std::cout << "Window resolution: " << static_cast<int>(Options::game.width) << "x" << static_cast<int>(Options::game.height) << " x" << Options::window.zoom << '\n';

        Options::video.info = std::to_string(static_cast<int>(dm->w)) + "x" +
            std::to_string(static_cast<int>(dm->h)) + " @ " +
            std::to_string(static_cast<int>(dm->refresh_rate)) + " Hz";

        // Calcula el máximo factor de zoom que se puede aplicar a la pantalla
        const int MAX_ZOOM = std::min(dm->w / Options::game.width, (dm->h - WINDOWS_DECORATIONS) / Options::game.height);

        // Normaliza los valores de zoom
        Options::window.zoom = std::min(Options::window.zoom, MAX_ZOOM);

        SDL_free(displays);
    }
}

// Arranca SDL VIDEO y crea la ventana
auto Screen::initSDLVideo() -> bool {
    // Inicializar SDL
    if (!SDL_Init(SDL_INIT_VIDEO)) {
        std::cerr << "FATAL: Failed to initialize SDL_VIDEO! SDL Error: " << SDL_GetError() << '\n';
        return false;
    }

    // Obtener información de la pantalla
    getDisplayInfo();

    // Configurar hint para renderizado
#ifdef __APPLE__
    if (!SDL_SetHint(SDL_HINT_RENDER_DRIVER, "metal")) {
        std::cout << "WARNING: Failed to set Metal hint!\n";
    }
#endif

    // Crear ventana
    const auto WINDOW_WIDTH = Options::video.border.enabled ? Options::game.width + (Options::video.border.width * 2) : Options::game.width;
    const auto WINDOW_HEIGHT = Options::video.border.enabled ? Options::game.height + (Options::video.border.height * 2) : Options::game.height;
    SDL_WindowFlags window_flags = 0;
    if (Options::video.fullscreen) {
        window_flags |= SDL_WINDOW_FULLSCREEN;
    }
    window_ = SDL_CreateWindow(Options::window.caption.c_str(), WINDOW_WIDTH * Options::window.zoom, WINDOW_HEIGHT * Options::window.zoom, window_flags);

    if (window_ == nullptr) {
        std::cerr << "FATAL: Failed to create window! SDL Error: " << SDL_GetError() << '\n';
        SDL_Quit();
        return false;
    }

    // Crear renderer
    renderer_ = SDL_CreateRenderer(window_, nullptr);
    if (renderer_ == nullptr) {
        std::cerr << "FATAL: Failed to create renderer! SDL Error: " << SDL_GetError() << '\n';
        SDL_DestroyWindow(window_);
        window_ = nullptr;
        SDL_Quit();
        return false;
    }

    // Configurar renderer
    const int EXTRA_WIDTH = Options::video.border.enabled ? Options::video.border.width * 2 : 0;
    const int EXTRA_HEIGHT = Options::video.border.enabled ? Options::video.border.height * 2 : 0;
    SDL_SetRenderLogicalPresentation(
        renderer_,
        Options::game.width + EXTRA_WIDTH,
        Options::game.height + EXTRA_HEIGHT,
        Options::video.integer_scale ? SDL_LOGICAL_PRESENTATION_INTEGER_SCALE : SDL_LOGICAL_PRESENTATION_LETTERBOX);
    SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
    SDL_SetRenderVSync(renderer_, Options::video.vertical_sync ? 1 : SDL_RENDERER_VSYNC_DISABLED);

    registerEmscriptenEventCallbacks();

    std::cout << "Video system initialized successfully\n";
    return true;
}

// Registra los callbacks nativos de Emscripten que restauran el canvas cuando
// SDL3 no emite los events equivalentes. Fuera de Emscripten es un no-op.
void Screen::registerEmscriptenEventCallbacks() {  // NOLINT(readability-convert-member-functions-to-static)
#ifdef __EMSCRIPTEN__
    // NO registramos resize callback. En móvil, el scroll hace que el navegador
    // oculte/muestre la barra de URL, disparando un resize del DOM por cada scroll,
    // lo que nos llevaría a llamar setVideoMode innecesariamente.
    emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, nullptr, EM_TRUE, onEmFullscreenChange);
    emscripten_set_orientationchange_callback(nullptr, EM_TRUE, onEmOrientationChange);
#endif
}

// Crea el objeto de texto
void Screen::createText() {
    // Carga la surface de la fuente directamente del archivo
    auto surface = std::make_shared<Surface>(Resource::List::get()->get("aseprite.gif"));

    // Crea el objeto de texto (el constructor de Text carga el archivo text_file internamente)
    text_ = std::make_shared<Text>(surface, Resource::List::get()->get("aseprite.fnt"));
}