#include "game/scenes/title_scene.hpp"

#include <SDL3/SDL.h>

#include <algorithm>
#include <cstdint>
#include <iostream>
#include <string>
#include <utility>

#include "core/input/gamepad_bindings.hpp"
#include "core/input/gamepad_manager.hpp"
#include "core/input/global_inputs.hpp"
#include "core/locale/locale.hpp"
#include "core/rendering/notifier.hpp"
#include "core/rendering/render_info.hpp"
#include "core/rendering/screen.hpp"
#include "core/rendering/surface.hpp"
#include "core/rendering/text.hpp"
#include "core/resources/resource_cache.hpp"
#include "core/system/event_buffer.hpp"
#include "core/ui/ui_config.hpp"
#include "game/options.hpp"
#include "utils/defaults.hpp"
#include "utils/defines.hpp"

namespace {

    // TODO: migrar a un logger unificat quan es decideixi (veure INC-03 a
    // docs/audit-core-rendering.md).
    const char* const SCENE_NAME = "TITLE";

    // Textos hardcodejats fins que tinguem artwork. Quan apareguen com
    // a sprites, aquesta secció desapareix sencera.
    const char* const TITLE_LINE_1 = "Aventures en Egipte";
    const char* const TITLE_LINE_2 = "A R C A D E";

    constexpr int TITLE_Y_PERCENT = 25;
    constexpr int PROMPT_Y_PERCENT = 60;
    constexpr int COPYRIGHT_Y_PERCENT = 90;
    constexpr int LOGO_GAP_PX = 2;  // Separació vertical entre el minilogo i el text de copyright.

    // Detecta una pulsació de START dins el frame actual per al jugador
    // indicat. Combina events de teclat (scancode hardcoded a Defaults::
    // KeysGame[P2]) i events de gamepad (botó remapejable via
    // GamepadBindings, lligat al pad assignat al jugador via Options).
    auto pressedStart(int player_id) -> bool {
        const SDL_Scancode KB = (player_id == 0) ? Defaults::KeysGame::START : Defaults::KeysGameP2::START;
        SDL_Gamepad* pad = GamepadManager::get().getForPlayer(player_id);
        const SDL_JoystickID PAD_ID = (pad != nullptr) ? SDL_GetGamepadID(pad) : 0;
        const auto& slot = (player_id == 0) ? Options::controls().gamepad_p1
                                            : Options::controls().gamepad_p2;
        const int START_BTN = GamepadBindings::get().getButton(slot.name, slot.path, GamepadBindings::Action::START);

        return std::ranges::any_of(EventBuffer::events, [&](const SDL_Event& ev) {
            if (ev.type == SDL_EVENT_KEY_DOWN && ev.key.scancode == KB) { return true; }
            if (ev.type == SDL_EVENT_GAMEPAD_BUTTON_DOWN && pad != nullptr && ev.gbutton.which == PAD_ID && static_cast<int>(ev.gbutton.button) == START_BTN) {
                return true;
            }
            return false;
        });
    }

    // Separació vertical entre la primera i segona línia del títol. Una
    // alçada de línia és l'opció més llegible al canvas de 240 px sense
    // entrar a configuració extra; si demà cal afinar-ho, mou-se a
    // ui.yaml.
    [[nodiscard]] auto titleLineGap(const Text& font) -> int {
        return font.getLineHeight();
    }

}  // namespace

TitleScene::TitleScene(std::shared_ptr<Text> display_font, std::shared_ptr<Text> condensed_font, std::shared_ptr<Surface> background, std::shared_ptr<Surface> mini_logo, SceneFactory next_factory)
    : display_font_(std::move(display_font)),
      condensed_font_(std::move(condensed_font)),
      background_(std::move(background)),
      mini_logo_(std::move(mini_logo)),
      next_factory_(std::move(next_factory)),
      timer_ms_(UiConfig::get().titleDurationMs()) {
    std::cout << "[scene] " << SCENE_NAME << " start\n";
    const auto& hh = UiConfig::get().titleHeatHaze();
    if (hh.enabled) {
        heat_haze_.emplace(Effects::HeatHaze::Params{
            .amplitude_px = hh.amplitude_px,
            .wavelength_px = hh.wavelength_px,
            .speed_hz = hh.speed_hz,
        });
    }
    fade_out_.emplace(Transitions::Mosaic::Params{
        .max_block_size = UiConfig::get().titleFadeOutMaxBlock(),
    });
}

TitleScene::~TitleScene() = default;

void TitleScene::update(int delta_ms) {
    GlobalInputs::update(delta_ms);
    if (GlobalInputs::wantsQuit()) {
        wants_quit_ = true;
        return;
    }

    if (heat_haze_) { heat_haze_->tick(delta_ms); }

    // Comptador del parpadeig: avança sempre amb `delta_ms` cru. La
    // lectura (cicle/visible) la decideix `render()` segons la fase:
    // IDLE usa visible_ms / hidden_ms del yaml (asimètric, 80/20 per
    // defecte); STARTING usa un cicle simètric 50/50 amb període
    // `starting_blink_period_ms`.
    blink_elapsed_ms_ += delta_ms;

    const bool P1_START = pressedStart(0);
    const bool P2_START = pressedStart(1);

    switch (phase_) {
        case Phase::IDLE: {
            timer_ms_ -= delta_ms;
            if (P1_START) {
                enterStarting(DebugConfig::StartingPlayers::P1);
            } else if (P2_START) {
                enterStarting(DebugConfig::StartingPlayers::P2);
            } else if (timer_ms_ <= 0) {
                // Attract: ningú ha premut. Entrem a STARTING amb BOTH
                // perquè el fade-out de transició també hi compti.
                // Demà, quan tinguem una DemoScene, ací anirà la
                // transició a demo en lloc de a intro.
                enterStarting(DebugConfig::StartingPlayers::BOTH);
            }
            break;
        }
        case Phase::STARTING: {
            starting_timer_ms_ -= delta_ms;
            // Si l'altre jugador prem START dins de la finestra (i el
            // fade encara no ha arrencat), pugem a BOTH i resetegem el
            // comptador. Una vegada el fade ja està actiu, ignorem
            // pulsacions per no saltar visualment la transició.
            const bool OTHER_PRESSED =
                (pending_players_ == DebugConfig::StartingPlayers::P1 && P2_START) ||
                (pending_players_ == DebugConfig::StartingPlayers::P2 && P1_START);
            const bool FADE_LOCKED = fade_out_ && (fade_out_->isActive() || fade_out_->isFinished());
            if (OTHER_PRESSED && !FADE_LOCKED) {
                pending_players_ = DebugConfig::StartingPlayers::BOTH;
                starting_timer_ms_ = UiConfig::get().titleStartingMs();
            }

            // Arrenca el fade quan al comptador li queden <= fade_out_ms,
            // i només una vegada (ni en repeticions ni si l'altre jugador
            // ha resetejat el timer).
            const int FADE_MS = UiConfig::get().titleFadeOutMs();
            if (fade_out_ && !fade_out_->isActive() && !fade_out_->isFinished() && starting_timer_ms_ <= FADE_MS && FADE_MS > 0) {
                fade_out_->begin(FADE_MS);
            }
            if (fade_out_ && fade_out_->isActive()) { fade_out_->tick(delta_ms); }

            if (starting_timer_ms_ <= 0) {
                advanceTo(pending_players_);
            }
            break;
        }
    }

    Notifier::get().update(delta_ms);
    RenderInfo::get().update(delta_ms, Options::buildRenderInfoFrame(UiConfig::get().renderInfoText(), UiConfig::get().renderInfoShadow()));
}

void TitleScene::enterStarting(DebugConfig::StartingPlayers players) {
    phase_ = Phase::STARTING;
    pending_players_ = players;
    starting_timer_ms_ = UiConfig::get().titleStartingMs();
    // Resetem el comptador del parpadeig perquè el primer frame de
    // STARTING comenci visible — sense això, el modulus amb el nou
    // període podria caure mig cicle i donar un primer "off" estrany.
    blink_elapsed_ms_ = 0;
    std::cout << "[scene] " << SCENE_NAME << " STARTING (players=" << DebugConfig::toString(players) << ")\n";
}

void TitleScene::advanceTo(DebugConfig::StartingPlayers players) {
    if (next_factory_) {
        next_scene_ = next_factory_(players);
    }
}

void TitleScene::render() {
    const auto& ui_config = UiConfig::get();
    const auto& palette = Resource::Cache::get().getPalette("ui");

    // Fons: la imatge si està disponible (cobreix tot el canvas amb la
    // seua paleta nadiua), opcionalment amb heat-haze; en cas contrari,
    // color pla de la paleta UI com a fallback defensiu.
    if (background_) {
        if (heat_haze_) {
            heat_haze_->render(*background_, 0, 0);
        } else {
            background_->render(0, 0);
        }
    } else {
        Screen::get().fillRect(0, 0, GameCanvas::WIDTH, GameCanvas::HEIGHT, palette[ui_config.titleBgColor()]);
    }

    const Uint8 TEXT_COLOR = ui_config.titleTextColor();
    const Uint8 OUTLINE_COLOR = ui_config.titleCopyrightColor();
    constexpr Uint8 OUTLINE_DIST = 1;
    constexpr Uint8 STROKE4 = Text::CENTER_FLAG | Text::COLOR_FLAG | Text::STROKE4_FLAG;

    if (display_font_) {
        const int TITLE_Y = (GameCanvas::HEIGHT * TITLE_Y_PERCENT) / 100;
        display_font_->writeDX(STROKE4,
            GameCanvas::CENTER_X,
            TITLE_Y,
            TITLE_LINE_1,
            display_font_->getDefaultKerning(),
            TEXT_COLOR,
            OUTLINE_DIST,
            OUTLINE_COLOR);
        display_font_->writeDX(STROKE4,
            GameCanvas::CENTER_X,
            TITLE_Y + titleLineGap(*display_font_),
            TITLE_LINE_2,
            display_font_->getDefaultKerning(),
            TEXT_COLOR,
            OUTLINE_DIST,
            OUTLINE_COLOR);
    }

    if (condensed_font_) {
        // Cicle de parpadeig: a IDLE pren visible_ms+hidden_ms del yaml
        // (asimètric, 80/20 per defecte); a STARTING commuta a 50/50 amb
        // `starting_blink_period_ms` per donar feedback de "polsat".
        // Si el cicle val 0 (configuració degenerada), cau a "sempre visible".
        int cycle_ms = 0;
        int visible_ms = 0;
        if (phase_ == Phase::STARTING) {
            cycle_ms = std::max(0, ui_config.titleStartingBlinkPeriodMs());
            visible_ms = cycle_ms / 2;
        } else {
            visible_ms = std::max(0, ui_config.titleBlinkVisibleMs());
            cycle_ms = visible_ms + std::max(0, ui_config.titleBlinkHiddenMs());
        }
        const bool VISIBLE = (cycle_ms == 0) || ((blink_elapsed_ms_ % cycle_ms) < visible_ms);

        if (VISIBLE) {
            const int PROMPT_Y = (GameCanvas::HEIGHT * PROMPT_Y_PERCENT) / 100;
            condensed_font_->writeDX(STROKE4,
                GameCanvas::CENTER_X,
                PROMPT_Y,
                Locale::get().text("title.press_start"),
                condensed_font_->getDefaultKerning() - 1,
                TEXT_COLOR,
                OUTLINE_DIST,
                OUTLINE_COLOR);
        }
    }

    // Footer: minilogo centrat horitzontalment damunt del © de
    // copyright. El text va al 90% Y, el logo just damunt amb un petit
    // gap (LOGO_GAP_PX). Tots dos blocs són hardcodejats fins que
    // tinguem artwork final.
    if (condensed_font_) {
        const int COPY_Y = (GameCanvas::HEIGHT * COPYRIGHT_Y_PERCENT) / 100;
        if (mini_logo_) {
            const int LOGO_X = GameCanvas::CENTER_X - (mini_logo_->getWidth() / 2);
            const int LOGO_Y = COPY_Y - mini_logo_->getHeight() - LOGO_GAP_PX;
            mini_logo_->render(LOGO_X, LOGO_Y);
        }
        condensed_font_->writeDX(Text::CENTER_FLAG | Text::COLOR_FLAG,
            GameCanvas::CENTER_X,
            COPY_Y,
            "© 2026 JailDesigner",
            condensed_font_->getDefaultKerning() - 1,
            ui_config.titleCopyrightColor());
    }

    Notifier::get().render();

    // El fade-out cobreix l'escena i el Notifier (forma part de la
    // transició), però NO el RenderInfo (overlay de debug, sempre
    // visible).
    if (fade_out_ && (fade_out_->isActive() || fade_out_->isFinished())) {
        fade_out_->render();
    }

    RenderInfo::get().render();
    Screen::get().present();
}