#pragma once

#include "stage_interface.h"
#include <vector>
#include <optional>
#include <string>
#include <functional>

// --- Estados posibles para la recolección de poder ---
enum class PowerCollectionState {
    ENABLED,    // Recolección habilitada
    DISABLED    // Recolección deshabilitada
};

// --- Estados posibles para una fase del juego ---
enum class StageStatus {
    LOCKED,      // Fase bloqueada
    IN_PROGRESS, // Fase en progreso
    COMPLETED    // Fase completada
};

// --- Representa los datos de una fase del juego ---
class StageData {
private:
    int power_to_complete_;  // Poder necesario para completar la fase
    int min_menace_;         // Nivel mínimo de amenaza
    int max_menace_;         // Nivel máximo de amenaza
    std::string name_;       // Nombre de la fase
    StageStatus status_;     // Estado actual de la fase

public:
    // Constructor de una fase
    StageData(int power_to_complete, int min_menace, int max_menace, const std::string& name = "");

    // --- Getters ---
    int getPowerToComplete() const { return power_to_complete_; }
    int getMinMenace() const { return min_menace_; }
    int getMaxMenace() const { return max_menace_; }
    const std::string& getName() const { return name_; }
    StageStatus getStatus() const { return status_; }

    // --- Setters ---
    void setStatus(StageStatus status) { status_ = status; }
    
    // --- Utilidades ---
    bool isCompleted() const { return status_ == StageStatus::COMPLETED; }
};

// --- Gestor principal del sistema de fases del juego ---
class StageManager : public IStageInfo {
private:
    std::vector<StageData> stages_;              // Lista de todas las fases
    int current_power_;                          // Poder actual en la fase activa
    int total_power_;                            // Poder total acumulado en todo el juego
    size_t current_stage_index_;                 // Índice de la fase actual
    PowerCollectionState power_collection_state_; // Estado de recolección de poder

public:
    using PowerChangeCallback = std::function<void(int)>;

    StageManager();
    
    // --- Métodos principales del juego ---
    void initialize();                     // Inicializa el gestor de fases
    void initialize(const std::string& stages_file); // Inicializa con archivo personalizado
    void reset();                         // Reinicia el progreso del juego
    bool advanceToNextStage();           // Avanza a la siguiente fase
    
    // --- Gestión de poder ---
    bool subtractPower(int amount);      // Resta poder de la fase actual
    void enablePowerCollection();        // Habilita la recolección de poder
    void disablePowerCollection();       // Deshabilita la recolección de poder
    
    // --- Navegación ---
    bool jumpToStage(size_t target_stage_index); // Salta a una fase específica
    
    // --- Consultas de estado ---
    std::optional<StageData> getCurrentStage() const;  // Obtiene la fase actual
    std::optional<StageData> getStage(size_t index) const; // Obtiene una fase específica
    size_t getCurrentStageIndex() const { return current_stage_index_; }
    int getCurrentPower() const { return current_power_; }
    int getTotalPower() const { return total_power_; }
    int getTotalPowerNeededToCompleteGame() const; // Poder total necesario para completar el juego
    size_t getTotalStages() const { return stages_.size(); }
    
    // --- Seguimiento de progreso ---
    bool isCurrentStageCompleted() const;              // Verifica si la fase actual está completada
    bool isGameCompleted() const;                      // Verifica si el juego está completado
    double getProgressPercentage() const;              // Progreso total del juego (0-100%)
    double getCurrentStageProgressPercentage() const;  // Progreso de la fase actual (0-100%)
    double getCurrentStageProgressFraction() const;    // Progreso de la fase actual (0.0-1.0)
    int getPowerNeededForCurrentStage() const;         // Poder restante para completar la fase actual
    
    // --- Gestión de callbacks ---
    void setPowerChangeCallback(PowerChangeCallback callback);  // Establece callback para cambios de poder
    void removePowerChangeCallback();                          // Elimina callback de cambios de poder

    // --- Implementación de la interfaz IStageInfo ---
    bool canCollectPower() const override;
    void addPower(int amount) override;
    int getCurrentMenaceLevel() const override;

private:
    PowerChangeCallback power_change_callback_; // Callback para notificar cambios de poder

    // --- Métodos privados ---
    void createDefaultStages();           // Crea las fases predeterminadas del juego
    bool loadStagesFromFile(const std::string& filename); // Carga fases desde archivo
    bool validateStageIndex(size_t index) const; // Valida que un índice de fase sea válido
    void updateStageStatuses();           // Actualiza los estados de todas las fases
};