// init_hud_animator.hpp - Animación inicial del HUD del juego
// © 2026 JailDesigner
//
// Cubre la animación INIT_HUD del comienzo de cada partida/stage:
//   1. Crecimiento de los marcos del PLAYAREA con efecto pincel en 3 fases.
//   2. Marcador subiendo desde abajo.
//   3. Naves entrando desde la zone inferior hacia su spawn.
//
// Todas las funciones son puras (sin estado interno propio). GameScene aporta
// el contexto que necesitan: posiciones finales, texto del scoreboard y el
// renderer/VectorText. El timing global (progress 0..1) lo gestiona
// StageManager.

#pragma once

#include <memory>
#include <string>

#include "core/graphics/shape.hpp"
#include "core/graphics/vector_text.hpp"
#include "core/rendering/render_context.hpp"
#include "core/types.hpp"

namespace Systems::InitHud {

    // Dades del marcador. El render reparteix tres blocs ancorats: bloc P1 a
    // l'esquerra i bloc P2 a la dreta (mateix ordre intern "punts vides", no
    // mirrored), i el nivell centrat. Cada bloc de jugador es pinta amb el seu
    // color (vegeu Defaults::Hud::Colors); el nivell, en verd de sistema.
    struct ScoreboardData {
        std::string score_p1;   // 6 dígits, zeros a l'esquerra
        std::string score_p2;   // 6 dígits, zeros a l'esquerra
        int lives_p1{0};        // vides P1 (icones de nau al render)
        int lives_p2{0};        // vides P2
        bool p1_active{false};  // jugador actiu? (inactiu → bloc apagat, sense dibuixar)
        bool p2_active{false};
        std::string level_label;  // ex: "NIVELL "
        std::string level_value;  // ex: "01"
        // Shapes de les naus per dibuixar les vides com a icones en miniatura.
        std::shared_ptr<Graphics::Shape> shape_p1;
        std::shared_ptr<Graphics::Shape> shape_p2;
    };

    // Convierte un progreso global 0..1 al sub-progreso de un elemento que solo
    // se anima en la ventana [ratio_init, ratio_end].
    //   < ratio_init      → 0.0 (no empezó)
    //   > ratio_end       → 1.0 (terminó)
    //   en rango          → interpolación lineal 0..1
    [[nodiscard]] auto computeRangeProgress(float global_progress,
        float ratio_init,
        float ratio_end) -> float;

    // Calcula posición Y animada de una nave durante INIT_HUD. La nave sube
    // desde 50 px bajo el PLAYAREA hasta `final_position` con easing.
    [[nodiscard]] auto computeShipPosition(float progress, const Vec2& final_position) -> Vec2;

    // Dibuja los 4 lados del PLAYAREA con efecto pincel en 3 fases:
    //   0..33%  → línea superior crece desde el centro hacia los lados.
    //   33..66% → líneas verticales bajan por los laterales.
    //   66..100% → línea inferior crece desde los lados hacia el centro.
    void drawBordersAnimated(Rendering::Renderer* renderer, float progress);

    // Dibuixa el marcador en tres blocs ancorats a la fila d'alçada `center_y`:
    // bloc P1 a l'esquerra, bloc P2 a la dreta i nivell centrat. Cada bloc amb
    // el seu color (Defaults::Hud::Colors). El renderer cal per dibuixar les
    // icones de vides (shapes de nau).
    void drawScoreboardAt(Rendering::Renderer* renderer,
        const Graphics::VectorText& text,
        const ScoreboardData& data,
        float center_y,
        float scale,
        float spacing);

    // Dibuixa el marcador pujant des de fora de la pantalla fins a la seva
    // posició final amb easing. Delega a drawScoreboardAt.
    void drawScoreboardAnimated(Rendering::Renderer* renderer,
        const Graphics::VectorText& text,
        const ScoreboardData& data,
        float progress);

}  // namespace Systems::InitHud