// game_scene.hpp - Lógica principal del juego
// © 2026 JailDesigner

#pragma once

#include <array>
#include <cstdint>
#include <memory>
#include <string>

#include "core/graphics/border.hpp"
#include "core/graphics/playfield.hpp"
#include "core/graphics/starfield_parallax.hpp"
#include "core/graphics/vector_text.hpp"
#include "core/physics/physics_world.hpp"
#include "core/rendering/sdl_manager.hpp"
#include "core/system/game_config.hpp"
#include "core/system/scene.hpp"
#include "core/system/scene_context.hpp"
#include "core/types.hpp"
#include "game/constants.hpp"
#include "game/effects/debris_manager.hpp"
#include "game/effects/firework_manager.hpp"
#include "game/effects/floating_score_manager.hpp"
#include "game/effects/trail_manager.hpp"
#include "game/entities/bullet.hpp"
#include "game/entities/enemy.hpp"
#include "game/entities/ship.hpp"
#include "game/stage_system/stage_config.hpp"
#include "game/stage_system/stage_manager.hpp"

// Game over state machine
enum class GameOverState : uint8_t {
    NONE,      // Normal gameplay
    CONTINUE,  // Continue countdown screen (9→0)
    GAME_OVER  // Final game over (returning to title)
};

// Clase principal del juego (escena)
class GameScene final : public Scene {
   public:
    explicit GameScene(SDLManager& sdl, SceneManager::SceneContext& context);
    ~GameScene() override = default;

    // Scene interface
    void handleEvent(const SDL_Event& event) override;
    void update(float delta_time) override;
    void draw() override;
    [[nodiscard]] auto isFinished() const -> bool override;

   private:
    SDLManager& sdl_;
    SceneManager::SceneContext& context_;
    GameConfig::MatchConfig match_config_;  // Configuración de jugadors active

    // Mundo físico (Fase 5) — integración cinemática + colisiones
    Physics::PhysicsWorld physics_world_;

    // Efectes visuals
    Effects::DebrisManager debris_manager_;
    Effects::FireworkManager firework_manager_;
    Effects::FloatingScoreManager floating_score_manager_;
    Effects::TrailManager trail_manager_;

    // Estat del juego
    std::array<Ship, 2> ships_;  // [0]=P1, [1]=P2
    std::array<Enemy, Constants::MAX_ORNIS> enemies_;
    // 6 balas: P1=[0,1,2], P2=[3,4,5]. El cast a size_t evita la
    // widening conversion implícita que detecta clang-tidy.
    std::array<Bullet, static_cast<std::size_t>(Constants::MAX_BALES) * 2> bullets_;
    std::array<float, 2> hit_timer_per_player_;  // Death timers per player (seconds)

    // Lives and game over system
    std::array<int, 2> lives_per_player_;  // [0]=P1, [1]=P2
    GameOverState game_over_state_;        // Game over state machine (NONE, CONTINUE, GAME_OVER)
    int continue_counter_;                 // Continue countdown (9→0)
    float continue_tick_timer_;            // Timer for countdown tick (1.0s)
    int continues_used_;                   // Continues used this game (0-3 max)
    float game_over_timer_;                // Final GAME OVER timer before title screen
    Vec2 death_position_;                  // Death position (for respawn)
    std::array<int, 2> score_per_player_;  // [0]=P1, [1]=P2

    // Text vectorial
    Graphics::VectorText text_;

    // Capa més profunda del fons: estrelles 2D amb parallax (estàtiques de moment).
    Graphics::StarfieldParallax starfield_parallax_;

    // Fons del playfield (graella + futures capes)
    Graphics::Playfield playfield_;

    // Border del playfield (4 línies amb desplaçaments i flash per impactes)
    Graphics::Border border_;

    // [NEW] Stage system
    std::unique_ptr<StageSystem::StageSystemConfig> stage_config_;
    std::unique_ptr<StageSystem::StageManager> stage_manager_;

    // Control de sons de animación INIT_HUD
    bool init_hud_rect_sound_played_{false};  // Flag para evitar repetir sonido del rectángulo

    // Funciones privades
    void tocado(uint8_t player_id);
    void drawScoreboard();                                              // Dibuixar marcador de puntuación
    void fireBullet(uint8_t player_id);                                 // Shoot bullet from player
    [[nodiscard]] auto getSpawnPoint(uint8_t player_id) const -> Vec2;  // Get spawn position for player

    // [NEW] Continue & Join system
    void joinPlayer(uint8_t player_id);  // Join inactive player mid-game
    void drawContinue();                 // Draw continue screen

    // [NEW] Stage system helpers
    void drawStageMessage(const std::string& message);

    // Helpers de renderitzat (extracció de draw() per reduir complexitat).
    // Cadascun gestiona un bloc concret; draw() només despatxa segons l'estat.
    void drawEnemies() const;
    void drawBullets() const;
    void drawActiveShipsAlive() const;
    void drawContinueState();
    void drawGameOverState();
    void drawInitHudState();
    void drawLevelStartState();
    void drawPlayingState();
    void drawLevelCompletedState();

    // [NEW] Función helper del marcador
    [[nodiscard]] auto buildScoreboard() const -> std::string;

    // Sub-pasos de update() (descompuestos en Fase 9d para reducir
    // complejidad cognitiva; cada uno es responsable de una sección).
    void stepPhysics(float delta_time);
    void stepShootingInput();
    void stepMidGameJoin();
    // Devuelven true si el frame debe salir tras esta sección.
    [[nodiscard]] auto stepContinueScreen(float delta_time) -> bool;
    [[nodiscard]] auto stepGameOver(float delta_time) -> bool;
    // Avanza el death timer / respawn / transición a CONTINUE. Si algún
    // jugador está en secuencia de muerte, también actualiza efectos
    // (enemigos, balas, debris) que siguen vivos en el escenario.
    void stepDeathSequence(float delta_time);
    void stepStageStateMachine(float delta_time);
    void runStageInitHud(float delta_time);
    void runStageLevelStart(float delta_time);
    void runStagePlaying(float delta_time);
    void runStageLevelCompleted(float delta_time);
    // Helper: ejecuta colisiones de gameplay con el Context preparado.
    void runCollisionDetections();
};