#include "stage.h"
#include <algorithm>

// ===== IMPLEMENTACIÓN DE StageData =====
StageData::StageData(int power_to_complete, int min_menace, int max_menace, const std::string& name)
    : power_to_complete_(power_to_complete), min_menace_(min_menace), 
      max_menace_(max_menace), name_(name), status_(StageStatus::LOCKED) {}

// ===== IMPLEMENTACIÓN DE StageManager =====
StageManager::StageManager()
    : current_power_(0), total_power_(0), current_stage_index_(0), 
      power_collection_state_(PowerCollectionState::ENABLED),
      power_change_callback_(nullptr) {
    initialize();
}

void StageManager::initialize() {
    stages_.clear();
    createDefaultStages();
    reset();
}

void StageManager::reset() {
    current_power_ = 0;
    total_power_ = 0;
    current_stage_index_ = 0;
    power_collection_state_ = PowerCollectionState::ENABLED;
    updateStageStatuses();
}

void StageManager::createDefaultStages() {
    // Crear las 10 fases como en tu código original
    stages_.emplace_back(200, 7 + (4 * 1), 7 + (4 * 3), "Tutorial");
    stages_.emplace_back(300, 7 + (4 * 2), 7 + (4 * 4), "Primeros pasos");
    stages_.emplace_back(600, 7 + (4 * 3), 7 + (4 * 5), "Intensificación");
    stages_.emplace_back(600, 7 + (4 * 3), 7 + (4 * 5), "Persistencia");
    stages_.emplace_back(600, 7 + (4 * 4), 7 + (4 * 6), "Desafío medio");
    stages_.emplace_back(600, 7 + (4 * 4), 7 + (4 * 6), "Resistencia");
    stages_.emplace_back(650, 7 + (4 * 5), 7 + (4 * 7), "Aproximación final");
    stages_.emplace_back(750, 7 + (4 * 5), 7 + (4 * 7), "Penúltimo obstáculo");
    stages_.emplace_back(850, 7 + (4 * 6), 7 + (4 * 8), "Clímax");
    stages_.emplace_back(950, 7 + (4 * 7), 7 + (4 * 10), "Maestría");
}

bool StageManager::advanceToNextStage() {
    if (!isCurrentStageCompleted() || current_stage_index_ >= stages_.size() - 1) {
        return false;
    }
    
    current_stage_index_++;
    current_power_ = 0; // Reiniciar poder para la nueva fase
    updateStageStatuses();
    return true;
}

bool StageManager::jumpToStage(size_t target_stage_index) {
    if (!validateStageIndex(target_stage_index)) {
        return false;
    }
    
    // Calcular el poder total acumulado hasta la fase objetivo
    int accumulated_power = 0;
    for (size_t i = 0; i < target_stage_index; ++i) {
        accumulated_power += stages_[i].getPowerToComplete();
    }
    
    // Actualizar estado
    current_stage_index_ = target_stage_index;
    current_power_ = 0;  // Empezar la fase objetivo sin poder
    total_power_ = accumulated_power;  // Poder total como si hubiéramos completado las anteriores
    
    updateStageStatuses();
    return true;
}

bool StageManager::subtractPower(int amount) {
    if (amount <= 0 || current_power_ < amount) {
        return false;
    }
    
    current_power_ -= amount;
    updateStageStatuses();
    return true;
}

void StageManager::enablePowerCollection() {
    power_collection_state_ = PowerCollectionState::ENABLED;
}

void StageManager::disablePowerCollection() {
    power_collection_state_ = PowerCollectionState::DISABLED;
}

std::optional<StageData> StageManager::getCurrentStage() const {
    return getStage(current_stage_index_);
}

std::optional<StageData> StageManager::getStage(size_t index) const {
    if (!validateStageIndex(index)) {
        return std::nullopt;
    }
    return stages_[index];
}

bool StageManager::isCurrentStageCompleted() const {
    auto current_stage = getCurrentStage();
    if (!current_stage.has_value()) {
        return false;
    }
    
    return current_power_ >= current_stage->getPowerToComplete();
}

bool StageManager::isGameCompleted() const {
    return current_stage_index_ >= stages_.size() - 1 && isCurrentStageCompleted();
}

double StageManager::getProgressPercentage() const {
    if (stages_.empty()) return 0.0;
    
    int total_power_needed = getTotalPowerNeededToCompleteGame();  // ⬅️ Usar el nuevo método
    if (total_power_needed == 0) return 100.0;
    
    return (static_cast<double>(total_power_) / total_power_needed) * 100.0;
}

double StageManager::getCurrentStageProgressPercentage() const {
    return getCurrentStageProgressFraction() * 100.0;
}

double StageManager::getCurrentStageProgressFraction() const {
    auto current_stage = getCurrentStage();
    if (!current_stage.has_value()) {
        return 0.0;
    }
    
    int power_needed = current_stage->getPowerToComplete();
    if (power_needed == 0) {
        return 1.0;
    }
    
    // Retorna fracción entre 0.0 y 1.0
    double fraction = static_cast<double>(current_power_) / power_needed;
    return std::min(fraction, 1.0);
}

int StageManager::getPowerNeededForCurrentStage() const {
    auto current_stage = getCurrentStage();
    if (!current_stage.has_value()) {
        return 0;
    }
    
    return std::max(0, current_stage->getPowerToComplete() - current_power_);
}

int StageManager::getTotalPowerNeededToCompleteGame() const {
    int total_power_needed = 0;
    for (const auto& stage : stages_) {
        total_power_needed += stage.getPowerToComplete();
    }
    return total_power_needed;
}

// ===== IMPLEMENTACIÓN DE IStageInfo (lo que ven Player y Balloon) =====
bool StageManager::canCollectPower() const {
    return power_collection_state_ == PowerCollectionState::ENABLED;
}

void StageManager::addPower(int amount) {
    if (amount <= 0 || !canCollectPower()) {
        return;
    }
    
    current_power_ += amount;
    total_power_ += amount;

    if (power_change_callback_) {
    power_change_callback_(amount);
}
    
    // Verificar si se completó la fase actual
    if (isCurrentStageCompleted()) {
        auto current_stage = getCurrentStage();
        if (current_stage.has_value()) {
            stages_[current_stage_index_].setStatus(StageStatus::COMPLETED);
        }
    }
    
    updateStageStatuses();
}

int StageManager::getCurrentMenaceLevel() const {
    auto current_stage = getCurrentStage();
    if (!current_stage.has_value()) {
        return 0;
    }
    
    return current_stage->getMinMenace();
}

// ===== MÉTODOS PRIVADOS =====
bool StageManager::validateStageIndex(size_t index) const {
    return index < stages_.size();
}

void StageManager::updateStageStatuses() {
    for (size_t i = 0; i < stages_.size(); ++i) {
        if (i < current_stage_index_) {
            stages_[i].setStatus(StageStatus::COMPLETED);
        } else if (i == current_stage_index_) {
            stages_[i].setStatus(StageStatus::IN_PROGRESS);
        } else {
            stages_[i].setStatus(StageStatus::LOCKED);
        }
    }
}

void StageManager::setPowerChangeCallback(PowerChangeCallback callback) {
    power_change_callback_ = callback;
}

void StageManager::removePowerChangeCallback() {
    power_change_callback_ = nullptr;
}