#pragma once

#include <SDL3/SDL.h>

#include <cstdint>

namespace Defaults {

    // Mode de presentació lògica (escala finestra). Mapeja als valors de
    // SDL_RendererLogicalPresentation des de Screen via una funció helper,
    // perquè aquest header no depengui de detalls de SDL3 més enllà del scancode.
    enum class ScalingMode : std::uint8_t {
        DISABLED = 0,
        STRETCH = 1,
        LETTERBOX = 2,
        OVERSCAN = 3,
        INTEGER = 4,
    };

    // Filtre de textura per a l'upscale final.
    enum class TextureFilter : std::uint8_t {
        NEAREST = 0,
        LINEAR = 1,
    };

    // Posició de l'overlay RenderInfo: apagat, a dalt o a baix del canvas.
    // Cicle OFF → TOP → BOTTOM → OFF amb la hotkey corresponent.
    enum class RenderInfoPosition : std::uint8_t {
        OFF = 0,
        TOP = 1,
        BOTTOM = 2,
    };
    constexpr int RENDER_INFO_POSITION_COUNT = 3;

    namespace Window {
        constexpr int ZOOM = 3;
        constexpr bool FULLSCREEN = false;
    }  // namespace Window

    namespace I18n {
        constexpr const char* LOCALE = "ca";                // Idioma per defecte (codi ISO 639-1).
        constexpr const char* LOCALE_DIR = "data/locale/";  // Carpeta amb els YAML per idioma.
    }  // namespace I18n

    namespace Video {
        constexpr bool VSYNC = true;
        constexpr ScalingMode SCALING_MODE = ScalingMode::LETTERBOX;
        constexpr TextureFilter TEXTURE_FILTER = TextureFilter::NEAREST;
        constexpr bool GPU_ACCELERATION = true;                                       // Path SDL3 GPU per defecte; fallback a SDL_Renderer si falla.
        constexpr const char* GPU_PREFERRED_DRIVER = "";                              // Buit = auto. Aplica a l'arrencada.
        constexpr bool SHADER_ENABLED = true;                                         // Aplica PostFX; si false, sempre passthrough.
        constexpr const char* CURRENT_SHADER = "postfx";                              // Shader actiu: "postfx" o "crtpi".
        constexpr const char* POSTFX_DEFAULT_PRESET = "CRT";                          // Preset inicial PostFX.
        constexpr const char* CRTPI_DEFAULT_PRESET = "Default";                       // Preset inicial CrtPi.
        constexpr const char* POSTFX_FILE = "shaders/postfx.yaml";                    // Relatiu a la carpeta de sistema.
        constexpr const char* CRTPI_FILE = "shaders/crtpi.yaml";                      // Relatiu a la carpeta de sistema.
        constexpr RenderInfoPosition RENDER_INFO_POSITION = RenderInfoPosition::OFF;  // Overlay de debug amagat per defecte.
        constexpr bool RENDER_INFO_SHOW_TIME = true;                                  // Si l'overlay és visible, mostra el temps de joc.
    }  // namespace Video

    namespace Audio {
        constexpr bool ENABLED = true;
        constexpr float VOLUME = 1.0F;
        constexpr bool MUSIC_ENABLED = true;
        constexpr float MUSIC_VOLUME = 0.8F;
        constexpr bool SOUND_ENABLED = true;
        constexpr float SOUND_VOLUME = 1.0F;
        constexpr float VOLUME_STEP = 0.05F;               // Pas estàndard per a la UI (5%).
        constexpr int FREQUENCY = 48000;                   // Freqüència de mostreig del dispositiu (Hz).
        constexpr int CROSSFADE_MS = 1500;                 // Durada per defecte del crossfade entre pistes (ms).
        constexpr SDL_AudioFormat FORMAT = SDL_AUDIO_S16;  // Format PCM 16-bit signat natiu.
        constexpr int CHANNELS = 2;                        // Nombre de canals de sortida (estèreo).
    }  // namespace Audio

    namespace KeysGame {
        constexpr SDL_Scancode UP = SDL_SCANCODE_UP;
        constexpr SDL_Scancode DOWN = SDL_SCANCODE_DOWN;
        constexpr SDL_Scancode LEFT = SDL_SCANCODE_LEFT;
        constexpr SDL_Scancode RIGHT = SDL_SCANCODE_RIGHT;
        constexpr SDL_Scancode JUMP = SDL_SCANCODE_M;
        constexpr SDL_Scancode EXIT = SDL_SCANCODE_ESCAPE;
    }  // namespace KeysGame

    // Tecles del segon jugador local (WASD). Simètriques a KeysGame però
    // mapejades a la mà esquerra del teclat. Cada Player instancia amb els
    // seus propis Controls, així que aquests són un recull de fàbrica:
    // canviar-los ací canvia el mapatge per a qualsevol escena que els use.
    namespace KeysGameP2 {
        constexpr SDL_Scancode UP = SDL_SCANCODE_W;
        constexpr SDL_Scancode DOWN = SDL_SCANCODE_S;
        constexpr SDL_Scancode LEFT = SDL_SCANCODE_A;
        constexpr SDL_Scancode RIGHT = SDL_SCANCODE_D;
        constexpr SDL_Scancode JUMP = SDL_SCANCODE_V;
    }  // namespace KeysGameP2

    namespace Player {
        constexpr float SPEED_PX_PER_S = 60.0F;  // Velocitat base del jugador (sense sprint / slow-zones).
        // Factor multiplicatiu aplicat a la velocitat quan un jugador empenta
        // l'altre (0.30 = el pusher es ralentitza al 30% i el pushed és
        // arrossegat a la mateixa velocitat). Sobrescrivible des del YAML
        // del mapa amb la clau `push_factor`.
        constexpr float PUSH_FACTOR = 0.30F;
    }  // namespace Player

    // Fallbacks del tema d'UI: índexs de paleta, timings (ms) i fonts.
    // El tema en viu és a data/ui.yaml, carregat per UiConfig a
    // l'arrencada; aquests valors només s'apliquen si el fitxer falta o
    // li manca alguna clau. Ací només cal tocar-los si es vol canviar el
    // fallback "de fàbrica".
    namespace UI {
        // Fonts d'UI centralitzades: un únic lloc per conèixer la carpeta
        // (data/fonts/), el nom-clau al Resource::Cache i els fitxers .gif /
        // .fnt de cada font. Afegir-ne una nova és una constant ací i ja.
        namespace Font {
            constexpr const char* DIR = "data/fonts/";

            // HUD/Notifier/RenderInfo: font principal de UI del joc.
            // El kerning és la separació extra entre glifs (sumat a l'amplada
            // natural). 1 és el valor clàssic; valors negatius ajunten glifs
            // per a fonts de display amb sidebearings amples.
            constexpr const char* HUD_NAME = "8bithud";
            constexpr const char* HUD_GIF = "data/fonts/8bithud.gif";
            constexpr const char* HUD_FNT = "data/fonts/8bithud.fnt";
            constexpr int HUD_KERNING = 1;

            // Placeholders (LOGO / TITLE / INTRO): font temporal fins que els
            // placeholders es substitueixin per les seues escenes finals.
            constexpr const char* PLACEHOLDER_NAME = "ari-w9500-condensed-display";
            constexpr const char* PLACEHOLDER_GIF = "data/fonts/ari-w9500-condensed-display.gif";
            constexpr const char* PLACEHOLDER_FNT = "data/fonts/ari-w9500-condensed-display.fnt";
            constexpr int PLACEHOLDER_KERNING = 1;

            // Menú de servei (F9): títol en display normal, items en la
            // variant condensed-display (més compacta, perquè caben més
            // files sense encongir la caixa). Kerning 0 a totes dues perquè
            // els glifs de display ja porten sidebearings generosos.
            constexpr const char* MENU_TITLE_NAME = "ari-w9500-display";
            constexpr const char* MENU_TITLE_GIF = "data/fonts/ari-w9500-display.gif";
            constexpr const char* MENU_TITLE_FNT = "data/fonts/ari-w9500-display.fnt";
            constexpr int MENU_TITLE_KERNING = 0;

            constexpr const char* MENU_ITEMS_NAME = "ari-w9500-condensed-display";
            constexpr const char* MENU_ITEMS_GIF = "data/fonts/ari-w9500-condensed-display.gif";
            constexpr const char* MENU_ITEMS_FNT = "data/fonts/ari-w9500-condensed-display.fnt";
            constexpr int MENU_ITEMS_KERNING = 0;
        }  // namespace Font

        // Overlay de RenderInfo (F12).
        constexpr Uint8 RENDER_INFO_TEXT = 58;
        constexpr Uint8 RENDER_INFO_SHADOW = 16;

        // Fons del canvas (zona fora del tilemap en letterbox/integer).
        constexpr Uint8 CANVAS_BG = 72;

        // Preset per defecte del Notifier.
        constexpr Uint8 NOTIFICATION_TEXT = 232;
        constexpr Uint8 NOTIFICATION_BG = 64;
        constexpr int NOTIFICATION_TIME_MS = 4000;

        // Preset per a la confirmació d'eixida (ESC doble). La durada ha
        // de coincidir amb la del Notifier perquè el missatge i la finestra
        // de confirmació expiren alhora (veure GlobalInputs::onExit).
        constexpr Uint8 EXIT_TEXT = 71;
        constexpr Uint8 EXIT_BG = 2;
        constexpr int EXIT_TIME_MS = 4000;

        // Índexs de paleta per al menú de servei (F9).
        constexpr Uint8 MENU_BG = 2;         // Fons de la caixa.
        constexpr Uint8 MENU_BORDER = 232;   // Vora.
        constexpr Uint8 MENU_TITLE = 237;    // Títol i subtítol.
        constexpr Uint8 MENU_LABEL = 58;     // Etiquetes dels items.
        constexpr Uint8 MENU_VALUE = 232;    // Valor actual.
        constexpr Uint8 MENU_CURSOR = 71;    // Item seleccionat.
        constexpr Uint8 MENU_DISABLED = 16;  // Label en gris quan no aplica.

        // Índexs de paleta per al marcador de joc (HUD de la GameScene).
        // Arranca reciclant els colors del menú per coherència visual;
        // separant els noms a constants pròpies, tocar-los a posteriori
        // no afecta el menú.
        constexpr Uint8 HUD_BG = 0;       // Fons de cada bloc.
        constexpr Uint8 HUD_LABEL = 58;   // Etiquetes ("P1", "V", "T").
        constexpr Uint8 HUD_VALUE = 187;  // Valors (score, vides, tresors).
        constexpr Uint8 HUD_FLASH = 237;  // Color temporal del valor en flash.

        // Timings d'animació del HUD. L'entrada són els tres blocs lliscant
        // a la seua posició; flash i shake acompanyen un `player_hit`.
        constexpr int HUD_ENTRY_MS = 400;
        constexpr int HUD_FLASH_MS = 250;
        constexpr int HUD_SHAKE_MS = 300;

        // Pausa graduada de la GameScene: el món no para d'un colp, es
        // frena amb una corba i torna a arrancar amb una altra. Els noms
        // de corba han de coincidir amb els registrats a
        // UiConfig::curveByName (linear / outQuad / inQuad / inOutQuad /
        // outCubic / inCubic). Si un nom no es reconeix, es cau a
        // Easing::linear.
        constexpr int PAUSE_ENTER_MS = 400;
        constexpr int PAUSE_EXIT_MS = 250;
        constexpr const char* PAUSE_ENTER_CURVE = "outCubic";
        constexpr const char* PAUSE_EXIT_CURVE = "inCubic";
    }  // namespace UI

#ifdef _DEBUG
    // Constants de l'editor de tilemap. Només presents en Debug — en
    // Release l'editor no existeix, així que ni les constants tenen sentit.
    namespace Editor {
        // Color del rectangle 1 px que envolta el canvas durant l'edició.
        constexpr std::uint32_t BORDER_ARGB = 0xFF2244FFU;
        // Ruta de persistència: writer surgical sobre la font del repo.
        constexpr const char* SAVE_PATH = "data/maps/pyramid.yaml";
        // Píxels entre el canvas i el rectangle del TilePicker per totes
        // les vores. Prou perquè el border blau de l'editor no es
        // superpose amb la graella del picker.
        constexpr int PICKER_MARGIN = 8;
        // Fons del TilePicker (blau fosc, prou contrastat amb els tiles
        // de color clar i clarament diferent del canvas).
        constexpr std::uint32_t PICKER_BG_ARGB = 0xFF101824U;
        // Vora 1 px del tile sota el cursor al picker.
        constexpr std::uint32_t PICKER_HOVER_ARGB = 0xFFFFFFFFU;
    }  // namespace Editor
#endif

    // Configuració de l'escena de joc (timings i corbes de la FSM de sala).
    // Independent de la piràmide concreta — quan un dia hi haja diferents
    // ritmes per piràmide, aquest YAML pot adoptar variants per nivell.
    namespace GameScene {
        constexpr const char* CONFIG_YAML = "data/scenes/game.yaml";
    }  // namespace GameScene

    // Rutes d'assets per piràmide. Centralitzats ací perquè `GameScene` no
    // en contingui cap literal; afegir una piràmide nova serà un altre
    // conjunt de constants + un Config distint passat al ctor.
    namespace Pyramid {
        // Índex ordenat de les 30 sales (5 piràmides × 6 sales). El consumeix
        // `Levels::LevelManager` a la primera invocació; cada entrada apunta
        // a un `data/maps/p<N>/r<M>.yaml`. Substituirà `MAP_YAML` quan el
        // wiring del LevelManager estigui complet.
        constexpr const char* LEVELS_YAML = "data/maps/levels.yaml";
        constexpr const char* MAP_YAML = "data/maps/pyramid.yaml";
        constexpr const char* PLAYER_SPRITE = "data/player/sam.gif";
        constexpr const char* PLAYER_YAML = "data/player/sam.yaml";
        // Personatge del segon jugador. Clonat de sam amb repaletat (roig→blau);
        // la geometria del sprite i les animacions coincideixen amb les de P1,
        // així que Player::loadFrom només cal cridar-la amb un dels dos YAMLs.
        constexpr const char* PLAYER_SPRITE_P2 = "data/player/morcus.gif";
        constexpr const char* PLAYER_YAML_P2 = "data/player/morcus.yaml";
        constexpr const char* MUSIC_TRACK = "pyramid_1.ogg";
    }  // namespace Pyramid

}  // namespace Defaults