// collision_system.hpp - Detección de colisiones de gameplay
// © 2026 JailDesigner
//
// Detecta colisiones bullet↔enemy, ship↔enemy y bullet↔player y aplica los
// efectos directos sobre las entidades (destruir enemy, desactivar bullet,
// crear debris/floating-score, ajustar score y lives). Las consecuencias de
// gameplay que requieren transición de estado (muerte del jugador, game over)
// se delegan a un callback `on_player_hit`.
//
// Esto es física de gameplay, NO física rígida — el PhysicsWorld ya resolvió
// los impulsos físicos antes. Aquí solo decidimos quién muere/destruye a quién.

#pragma once

#include <array>
#include <cstdint>
#include <functional>

#include "core/defaults.hpp"
#include "core/system/game_config.hpp"
#include "game/effects/debris_manager.hpp"
#include "game/effects/firework_manager.hpp"
#include "game/effects/floating_score_manager.hpp"
#include "game/entities/bullet.hpp"
#include "game/entities/enemy.hpp"
#include "game/entities/ship.hpp"

namespace Systems::Collision {

    // Todo lo que las detecciones necesitan leer/modificar. Vive en GameScene;
    // se le pasa por referencia (no copia, no ownership).
    struct Context {
        std::array<Ship, 2>& ships;
        std::array<Enemy, Defaults::Entities::MAX_ORNIS>& enemies;
        std::array<Bullet, static_cast<std::size_t>(Defaults::Entities::MAX_BALES) * 2>& bullets;
        std::array<float, 2>& hit_timer_per_player;
        std::array<int, 2>& score_per_player;
        std::array<int, 2>& lives_per_player;
        Effects::DebrisManager& debris_manager;
        Effects::FireworkManager& firework_manager;
        Effects::FloatingScoreManager& floating_score_manager;
        const GameConfig::MatchConfig& match_config;
        // Trigger de muerte del jugador (GameScene::tocado).
        std::function<void(uint8_t /*player_id*/)> on_player_hit;
    };

    // Detecta colisiones bullet → enemy. Si hit:
    //   - Primer impacto: aplica impulse, marca al enemy como "herido", desactiva bullet.
    //   - Segundo impacto (enemy ya herido): explosión inmediata + puntos al shooter.
    void detectBulletEnemy(Context& ctx);

    // Procesa enemigos cuyo wound timer ha expirado este frame: explosión + puntos
    // al `last_hit_by_` del enemy (si está set).
    void processWoundedDeaths(Context& ctx);

    // Si un enemy herido colisiona con uno sano (ni herido ni invulnerable),
    // el sano también queda herido (efecto cadena). Propaga `last_hit_by_` para
    // que el shooter original siga acreditándose la muerte en cascada. El rebote
    // físico ya lo resuelve PhysicsWorld; aquí solo propagamos el estado.
    void detectWoundedChain(Context& ctx);

    // Detecta colisiones ship → enemy. Si hit, llama on_player_hit(player_id).
    void detectShipEnemy(Context& ctx);

    // Detecta colisiones bullet → player (friendly fire / self-hit).
    // Self-hit: el shooter pierde 1 vida. Teammate-hit: la víctima pierde 1, el
    // atacante gana 1. En ambos casos, llama on_player_hit y desactiva bullet.
    void detectBulletPlayer(Context& ctx);

    // Las tres en orden lógico del frame.
    void detectAll(Context& ctx);

}  // namespace Systems::Collision