#pragma once

#include <SDL3/SDL_rect.h>      // Para SDL_FRect
#include <memory>               // Para shared_ptr, unique_ptr
#include <string>               // Para string
#include <vector>               // Para vector
#include "balloon.h"            // Para BALLOON_SPEED, Balloon
#include "balloon_formations.h" // Para BalloonFormations
#include "explosions.h"         // Para Explosions
#include "param.h"              // Para Param, ParamGame, param
#include "utils.h"              // Para Zone
class Texture;

using Balloons = std::vector<std::shared_ptr<Balloon>>;

// Clase BalloonManager
class BalloonManager
{
public:
    // Constructor y Destructor
    BalloonManager();
    ~BalloonManager() = default;

    // Actualización y Renderizado
    void update(); // Actualiza el estado de los globos
    void render(); // Renderiza los globos en pantalla

    // Gestión de globos
    void freeBalloons(); // Libera globos que ya no sirven

    // Creación de formaciones enemigas
    void deployBalloonFormation(int stage); // Crea una formación de enemigos aleatoria
    void deploySet(int set);                // Crea una formación específica
    void deploySet(int set, int y);         // Crea una formación específica con coordenadas

    // Creación de globos
    std::shared_ptr<Balloon> createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer); // Crea un nuevo globo
    void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction);                                          // Crea un globo a partir de otro
    void createPowerBall();                                                                                                                  // Crea una PowerBall
    void createTwoBigBalloons();                                                                                                             // Crea dos globos grandes
    void createRandomBalloons();                                                                                                             // Crea una disposición aleatoria de globos

    // Control de velocidad y despliegue
    void setBalloonSpeed(float speed);                                            // Ajusta la velocidad de los globos
    void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; }; // Establece la velocidad base
    void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); };        // Restablece la velocidad de los globos
    void updateBalloonDeployCounter();                                            // Actualiza el contador de despliegue
    bool canPowerBallBeCreated();                                                 // Indica si se puede crear una PowerBall
    int calculateScreenPower();                                                   // Calcula el poder de los globos en pantalla

    // Manipulación de globos existentes
    int popBalloon(std::shared_ptr<Balloon> balloon);      // Explosiona un globo, creando otros si aplica
    int destroyBalloon(std::shared_ptr<Balloon> &balloon); // Explosiona un globo sin crear otros
    int destroyAllBalloons();                              // Destruye todos los globos
    void stopAllBalloons();                                // Detiene el movimiento de los globos
    void startAllBalloons();                               // Reactiva el movimiento de los globos

    // Cambios de apariencia
    void reverseColorsToAllBalloons(); // Invierte los colores de los globos
    void normalColorsToAllBalloons();  // Restaura los colores originales

    // Configuración de sonido
    void setSounds(bool value); // Activa o desactiva los sonidos de los globos

    // Configuración de juego
    void setPlayArea(SDL_FRect play_area) { play_area_ = play_area; };           // Define el área de juego
    void setCreationTimeEnabled(bool value) { creation_time_enabled_ = value; }; // Activa o desactiva el tiempo de creación de globos
    void setDeployBalloons(bool value) { can_deploy_balloons_ = value; };        // Activa o desactiva la generación de globos

    // Obtención de información
    int getMenace(); // Obtiene el nivel de amenaza generado por los globos
    float getBalloonSpeed() const { return balloon_speed_; }
    Balloons &getBalloons() { return balloons_; }
    int getNumBalloons() const { return balloons_.size(); }

private:
    Balloons balloons_;                                     // Vector con los globos activos
    std::unique_ptr<Explosions> explosions_;                // Objeto para gestionar explosiones
    std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para manejar formaciones enemigas

    std::vector<std::shared_ptr<Texture>> balloon_textures_;    // Texturas de los globos
    std::vector<std::shared_ptr<Texture>> explosions_textures_; // Texturas de explosiones

    std::vector<std::vector<std::string>> balloon_animations_;    // Animaciones de los globos
    std::vector<std::vector<std::string>> explosions_animations_; // Animaciones de las explosiones

    // Variables de control de globos
    float balloon_speed_ = BALLOON_SPEED[0];
    float default_balloon_speed_ = BALLOON_SPEED[0];
    int balloon_deploy_counter_ = 0;
    bool power_ball_enabled_ = false;
    int power_ball_counter_ = 0;
    int last_balloon_deploy_ = 0;
    SDL_FRect play_area_ = param.game.play_area.rect;
    bool creation_time_enabled_ = true;
    bool can_deploy_balloons_ = true;

    // Inicialización interna
    void init();
};
