jaildoctors_dilemma/source/screen.cpp

#include "screen.h"

#include <SDL3/SDL.h>
#include <ctype.h>  // Para toupper

#include <algorithm>  // Para max, min, transform
#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 "asset.h"                           // Para Asset, AssetType
#include "mouse.h"                           // Para updateCursorVisibility
#include "options.h"                         // Para Options, options, OptionsVideo, Border
#include "rendering/opengl/opengl_shader.h"  // Para OpenGLShader
#include "resource.h"                        // Para Resource
#include "surface.h"                         // Para Surface, readPalFile
#include "text.h"                            // Para Text
#include "ui/notifier.h"                     // Para Notifier

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

// [SINGLETON] Crearemos el objeto con esta función estática
void Screen::init(SDL_Window* window, SDL_Renderer* renderer) {
    Screen::screen_ = new Screen(window, renderer);
}

// [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
Screen* Screen::get() {
    return Screen::screen_;
}

// Constructor
Screen::Screen(SDL_Window* window, SDL_Renderer* renderer)
    : window_(window),
      renderer_(renderer),
      palettes_(Asset::get()->getListByType(AssetType::PALETTE)) {
    // Inicializa variables
    getDisplayInfo();

    // Ajusta los tamaños
    game_surface_dstrect_ = {options.video.border.width, options.video.border.height, options.game.width, options.game.height};
    adjustWindowSize();
    current_palette_ = findPalette(options.video.palette);

    // Define el color del borde para el modo de pantalla completa
    border_color_ = static_cast<Uint8>(PaletteColor::BLACK);

    // 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_) {
        // Registrar el error si está habilitado
        if (options.console) {
            std::cerr << "Error: game_texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
        }
    }
    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_) {
        // Registrar el error si está habilitado
        if (options.console) {
            std::cerr << "Error: border_texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
        }
    }
    SDL_SetTextureScaleMode(border_texture_, SDL_SCALEMODE_NEAREST);

    // Crea la textura para los shaders
    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;
    shaders_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, options.game.width + EXTRA_WIDTH, options.game.height + EXTRA_HEIGHT);
    if (!shaders_texture_) {
        // Registrar el error si está habilitado
        if (options.console) {
            std::cerr << "Error: shaders_texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
        }
    }
    SDL_SetTextureScaleMode(shaders_texture_, SDL_SCALEMODE_NEAREST);

    // Crea la surface donde se dibujan los graficos del juego
    game_surface_ = std::make_shared<Surface>(options.game.width, options.game.height);
    game_surface_->setPalette(readPalFile(palettes_.at(current_palette_)));
    game_surface_->clear(static_cast<Uint8>(PaletteColor::BLACK));

    // Crea la surface para el borde de colores
    border_surface_ = std::make_shared<Surface>(options.game.width + options.video.border.width * 2, options.game.height + options.video.border.height * 2);
    border_surface_->setPalette(readPalFile(palettes_.at(current_palette_)));
    border_surface_->clear(border_color_);

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

    // Establece el modo de video
    setVideoMode(options.video.fullscreen);

    // Muestra la ventana
    show();

    // Extrae el nombre de las paletas desde su ruta
    processPaletteList();
}

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

// Limpia el renderer
void Screen::clearRenderer(Color 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
    renderOverlays();

    // Copia la surface a la textura
    surfaceToTexture();

    // Copia la textura al renderizador
    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);
    adjustWindowSize();
    adjustRenderLogicalSize();
}

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

// Reduce el tamaño de la ventana
bool Screen::decWindowZoom() {
    if (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
bool Screen::incWindowZoom() {
    if (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;
}

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

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

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

// Cambia el estado de los shaders
void Screen::toggleShaders() {
    options.video.shaders = !options.video.shaders;
    setVideoMode(options.video.fullscreen);
}

// Actualiza la lógica de la clase
void Screen::update() {
    fps_.calculate(SDL_GetTicks());
    Notifier::get()->update();
    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);


    // Establece el nuevo tamaño
    if (options.video.fullscreen == 0) {
        int old_width, old_height;
        SDL_GetWindowSize(window_, &old_width, &old_height);

        int old_pos_x, old_pos_y;
        SDL_GetWindowPosition(window_, &old_pos_x, &old_pos_y);

        const int NEW_POS_X = old_pos_x + (old_width - (window_width_ * options.window.zoom)) / 2;
        const int NEW_POS_Y = old_pos_y + (old_height - (window_height_ * options.window.zoom)) / 2;

        SDL_SetWindowSize(window_, window_width_ * options.window.zoom, window_height_ * options.window.zoom);
        SDL_SetWindowPosition(window_, std::max(NEW_POS_X, WINDOWS_DECORATIONS), std::max(NEW_POS_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);
}

// Establece el renderizador para las surfaces
void Screen::setRendererSurface(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() {
    ++current_palette_;
    if (current_palette_ == static_cast<int>(palettes_.size())) {
        current_palette_ = 0;
    }

    setPalete();
}

// Cambia la paleta
void Screen::previousPalette() {
    if (current_palette_ > 0) {
        --current_palette_;
    } else {
        current_palette_ = static_cast<Uint8>(palettes_.size() - 1);
    }

    setPalete();
}

// Establece la paleta
void Screen::setPalete() {
    game_surface_->loadPalette(Resource::get()->getPalette(palettes_.at(current_palette_)));
    border_surface_->loadPalette(Resource::get()->getPalette(palettes_.at(current_palette_)));

    options.video.palette = palettes_.at(current_palette_);

    // Eliminar ".gif"
    size_t pos = options.video.palette.find(".pal");
    if (pos != std::string::npos) {
        options.video.palette.erase(pos, 4);
    }

    // Convertir a mayúsculas
    std::transform(options.video.palette.begin(), options.video.palette.end(), options.video.palette.begin(), ::toupper);
}

// Extrae los nombres de las paletas
void Screen::processPaletteList() {
    for (auto& palette : palettes_) {
        palette = getFileName(palette);
    }
}

// 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
void Screen::textureToRenderer() {
    SDL_Texture* texture_to_render = options.video.border.enabled ? border_texture_ : game_texture_;

    if (options.video.shaders && shader_backend_) {
        SDL_SetRenderTarget(renderer_, shaders_texture_);
        SDL_RenderTexture(renderer_, texture_to_render, nullptr, nullptr);
        SDL_SetRenderTarget(renderer_, nullptr);
        shader_backend_->render();
    } else {
        SDL_SetRenderTarget(renderer_, nullptr);
        SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
        SDL_RenderClear(renderer_);
        SDL_RenderTexture(renderer_, texture_to_render, nullptr, nullptr);
        SDL_RenderPresent(renderer_);
    }
}

// Renderiza todos los overlays
void Screen::renderOverlays() {
    renderNotifications();
    renderInfo();
}

// Localiza la paleta dentro del vector de paletas
size_t Screen::findPalette(const std::string& name) {
    std::string upper_name = toUpper(name + ".pal");

    for (size_t i = 0; i < palettes_.size(); ++i) {
        if (toUpper(getFileName(palettes_[i])) == upper_name) {
            return i;
        }
    }
    return static_cast<size_t>(0);
}

// Recrea la textura para los shaders
void Screen::createShadersTexture() {
    if (shaders_texture_) {
        SDL_DestroyTexture(shaders_texture_);
    }

    // Crea la textura donde se dibuja el borde que rodea el area de juego
    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;
    shaders_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, options.game.width + EXTRA_WIDTH, options.game.height + EXTRA_HEIGHT);
    if (!shaders_texture_) {
        // Registrar el error si está habilitado
        if (options.console) {
            std::cerr << "Error: shaders_texture_ could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
        }
    }
}

// Muestra información por pantalla
void Screen::renderInfo() {
    if (show_debug_info_ && Resource::get()) {
        auto text = Resource::get()->getText("smb2");
        auto color = static_cast<Uint8>(PaletteColor::YELLOW);

        // FPS
        const std::string FPS_TEXT = std::to_string(fps_.lastValue) + " FPS";
        text->writeColored(options.game.width - text->lenght(FPS_TEXT), 0, FPS_TEXT, color);

        // Resolution
        text->writeColored(0, 0, info_resolution_, color);
    }
}

// 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; }

// Activa / desactiva la información de debug
void Screen::toggleDebugInfo() { show_debug_info_ = !show_debug_info_; }

// 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);
}

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

std::vector<uint8_t> loadData(const std::string& filepath) {
    // Fallback a filesystem
    std::ifstream file(filepath, std::ios::binary | std::ios::ate);
    if (!file) {
        return {};
    }

    std::streamsize fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    std::vector<uint8_t> data(fileSize);
    if (!file.read(reinterpret_cast<char*>(data.data()), fileSize)) {
        return {};
    }

    return data;
}

// Carga el contenido de los archivos GLSL
void Screen::loadShaders() {
    if (vertex_shader_source_.empty()) {
        // Detectar si necesitamos OpenGL ES (Raspberry Pi)
        // Intentar cargar versión ES primero si existe
        std::string VERTEX_FILE = "crtpi_vertex_es.glsl";
        auto data = loadData(Asset::get()->get(VERTEX_FILE));

        if (data.empty()) {
            // Si no existe versión ES, usar versión Desktop
            VERTEX_FILE = "crtpi_vertex.glsl";
            data = loadData(Asset::get()->get(VERTEX_FILE));
            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                "Usando shaders OpenGL Desktop 3.3");
        } else {
            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                "Usando shaders OpenGL ES 3.0 (Raspberry Pi)");
        }

        if (!data.empty()) {
            vertex_shader_source_ = std::string(data.begin(), data.end());
        }
    }
    if (fragment_shader_source_.empty()) {
        // Intentar cargar versión ES primero si existe
        std::string FRAGMENT_FILE = "crtpi_fragment_es.glsl";
        auto data = loadData(Asset::get()->get(FRAGMENT_FILE));

        if (data.empty()) {
            // Si no existe versión ES, usar versión Desktop
            FRAGMENT_FILE = "crtpi_fragment.glsl";
            data = loadData(Asset::get()->get(FRAGMENT_FILE));
        }

        if (!data.empty()) {
            fragment_shader_source_ = std::string(data.begin(), data.end());
        }
    }
}

// Inicializa los shaders
void Screen::initShaders() {
#ifndef __APPLE__
    if (options.video.shaders) {
        loadShaders();
        if (!shader_backend_) {
            shader_backend_ = std::make_unique<Rendering::OpenGLShader>();
        }
        shader_backend_->init(window_, game_texture_, vertex_shader_source_, fragment_shader_source_);
    }
#else
    // En macOS, OpenGL está deprecated y rinde mal
    // TODO: Implementar backend de Metal para shaders en macOS
    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
        "Shaders no disponibles en macOS (OpenGL deprecated). Usa Metal backend.");
#endif
}

// Obtiene información sobre la pantalla
void Screen::getDisplayInfo() {
    int i;
    int num_displays = 0;
    SDL_DisplayID *displays = SDL_GetDisplays(&num_displays);
    if (displays != nullptr) {
        for (i = 0; i < num_displays; ++i) {
            SDL_DisplayID instance_id = displays[i];
            const char *name = SDL_GetDisplayName(instance_id);

            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Display %" SDL_PRIu32 ": %s", instance_id, (name != nullptr) ? name : "Unknown");
        }

        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
        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Current display mode: %dx%d @ %dHz", static_cast<int>(dm->w), static_cast<int>(dm->h), static_cast<int>(dm->refresh_rate));

        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Window resolution: %dx%d x%d", static_cast<int>(options.game.width), static_cast<int>(options.game.height), options.window.zoom);

        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);
    }
}