coffee_crisis_arcade_edition/source/MenuOption.h

#pragma once

#include <string>
#include <vector>
#include <functional>
#include <memory>
#include <algorithm> // para std::clamp
#include "service_menu.h" // Necesitamos las enums como SettingsGroup
#include "options.h"      // Para acceder a las variables de configuración
#include "lang.h"         // Para las traducciones
#include "section.h"      // Para las acciones como Quit o Reset
#include "text.h"         // Para poder calcular el ancho del texto

// --- Interfaz Base para todas las Opciones del Menú ---

class MenuOption {
public:
    enum class Behavior { ADJUST, SELECT };

    MenuOption(std::string caption, ServiceMenu::SettingsGroup group, bool hidden = false)
        : caption_(std::move(caption)), group_(group), hidden_(hidden) {}
    
    virtual ~MenuOption() = default;

    const std::string& getCaption() const { return caption_; }
    ServiceMenu::SettingsGroup getGroup() const { return group_; }
    bool isHidden() const { return hidden_; }
    void setHidden(bool hidden) { hidden_ = hidden; }

    virtual Behavior getBehavior() const = 0;
    virtual std::string getValueAsString() const { return ""; }
    virtual void adjustValue(bool adjust_up) {}
    virtual ServiceMenu::SettingsGroup getTargetGroup() const { return ServiceMenu::SettingsGroup::MAIN; }
    virtual void executeAction() {}

    // --- AÑADIDO ---
    // Método virtual para que cada opción calcule el ancho de su valor más largo.
    virtual int getMaxValueWidth(Text* text_renderer) const { return 0; }
    // --- FIN AÑADIDO ---

protected:
    std::string caption_;
    ServiceMenu::SettingsGroup group_;
    bool hidden_;
};


// --- Clases Derivadas ---

class BoolOption : public MenuOption {
public:
    BoolOption(const std::string& cap, ServiceMenu::SettingsGroup grp, bool* var)
        : MenuOption(cap, grp), linked_variable_(var) {}

    Behavior getBehavior() const override { return Behavior::ADJUST; }
    std::string getValueAsString() const override {
        return *linked_variable_ ? Lang::getText("[SERVICE_MENU] ON") : Lang::getText("[SERVICE_MENU] OFF");
    }
    void adjustValue(bool /*adjust_up*/) override {
        *linked_variable_ = !*linked_variable_;
    }
    // --- AÑADIDO ---
    int getMaxValueWidth(Text* text_renderer) const override {
        return std::max(
            text_renderer->lenght(Lang::getText("[SERVICE_MENU] ON"), -2),
            text_renderer->lenght(Lang::getText("[SERVICE_MENU] OFF"), -2)
        );
    }
    // --- FIN AÑADIDO ---
private:
    bool* linked_variable_;
};

class IntOption : public MenuOption {
public:
    IntOption(const std::string& cap, ServiceMenu::SettingsGroup grp, int* var, int min, int max, int step)
        : MenuOption(cap, grp), linked_variable_(var), min_value_(min), max_value_(max), step_value_(step) {}

    Behavior getBehavior() const override { return Behavior::ADJUST; }
    std::string getValueAsString() const override { return std::to_string(*linked_variable_); }
    void adjustValue(bool adjust_up) override {
        int newValue = *linked_variable_ + (adjust_up ? step_value_ : -step_value_);
        *linked_variable_ = std::clamp(newValue, min_value_, max_value_);
    }
    // --- AÑADIDO ---
    int getMaxValueWidth(Text* text_renderer) const override {
        return std::max(
            text_renderer->lenght(std::to_string(min_value_), -2),
            text_renderer->lenght(std::to_string(max_value_), -2)
        );
    }
    // --- FIN AÑADIDO ---
private:
    int* linked_variable_;
    int min_value_, max_value_, step_value_;
};

class ListOption : public MenuOption {
public:
    ListOption(const std::string& cap, ServiceMenu::SettingsGroup grp,
               std::vector<std::string> values,
               std::function<std::string()> current_value_getter,
               std::function<void(const std::string&)> new_value_setter)
        : MenuOption(cap, grp),
          value_list_(std::move(values)),
          getter_(std::move(current_value_getter)),
          setter_(std::move(new_value_setter)),
          list_index_(0)
    {
        sync();
    }
    
    void sync() {
        std::string current_value = getter_();
        for (size_t i = 0; i < value_list_.size(); ++i) {
            if (value_list_[i] == current_value) {
                list_index_ = i;
                return;
            }
        }
    }

    Behavior getBehavior() const override { return Behavior::ADJUST; }
    std::string getValueAsString() const override {
        return value_list_.empty() ? "" : value_list_[list_index_];
    }
    void adjustValue(bool adjust_up) override {
        if (value_list_.empty()) return;
        size_t size = value_list_.size();
        list_index_ = (adjust_up) ? (list_index_ + 1) % size
                                  : (list_index_ + size - 1) % size;
        setter_(value_list_[list_index_]);
    }
    // --- AÑADIDO ---
    int getMaxValueWidth(Text* text_renderer) const override {
        int max_w = 0;
        for (const auto& val : value_list_) {
            max_w = std::max(max_w, text_renderer->lenght(val, -2));
        }
        return max_w;
    }
    // --- FIN AÑADIDO ---
private:
    std::vector<std::string> value_list_;
    std::function<std::string()> getter_;
    std::function<void(const std::string&)> setter_;
    size_t list_index_;
};

class FolderOption : public MenuOption {
public:
    FolderOption(const std::string& cap, ServiceMenu::SettingsGroup grp, ServiceMenu::SettingsGroup target)
        : MenuOption(cap, grp), target_group_(target) {}

    Behavior getBehavior() const override { return Behavior::SELECT; }
    ServiceMenu::SettingsGroup getTargetGroup() const override { return target_group_; }
private:
    ServiceMenu::SettingsGroup target_group_;
};

class ActionOption : public MenuOption {
public:
    ActionOption(const std::string& cap, ServiceMenu::SettingsGroup grp, std::function<void()> action, bool hidden = false)
        : MenuOption(cap, grp, hidden), action_(std::move(action)) {}

    Behavior getBehavior() const override { return Behavior::SELECT; }
    void executeAction() override {
        if (action_) action_();
    }
private:
    std::function<void()> action_;
};