#pragma once

#include <vector>
#include <utility>
#include <string>
#include <memory>
#include <SDL3/SDL.h>
#include "utils.h"

class Text;

class ServiceMenu
{
public:
    // --- Métodos de Singleton ---
    static void init();        // Inicializa la instancia única de ServiceMenu
    static void destroy();     // Libera la instancia única de ServiceMenu
    static ServiceMenu *get(); // Devuelve el puntero a la instancia única

    // --- Métodos principales ---
    void toggle(); // Muestra u oculta el menú de servicio
    void render(); // Dibuja el menú de servicio en pantalla
    void update(); // Actualiza el estado del menú de servicio

    // --- Métodos de control de navegación ---
    void setSelectorUp();              // Mueve el selector hacia arriba
    void setSelectorDown();            // Mueve el selector hacia abajo
    void adjustOption(bool adjust_up); // Ajusta el valor de la opción seleccionada
    void selectOption();               // Selecciona la opción actual
    void moveBack();                   // Vuelve al grupo de opciones anterior

    // --- Getters ---
    bool isEnabled() const { return enabled_; } // Indica si el menú de servicio está activo

private:
    // --- Tipos internos ---
    using OptionPairs = std::vector<std::pair<std::string, std::string>>;

    // --- Constantes ---
    static constexpr const char *MENU_SOUND_ = "clock.wav"; // Sonido al navegar por el menú
    static constexpr int OPTIONS_HORIZONTAL_PADDING_ = 20;  // Relleno horizontal de las opciones

    // --- Enumeraciones internas ---
    enum class Aspect
    {
        ASPECT1, // Fondo opaco y proyecta sombra
        ASPECT2  // Fondo translúcido
    };

    enum class SettingsGroup
    {
        VIDEO,  // Configuraciones de vídeo
        AUDIO,  // Opciones de audio
        GAME,   // Opciones de juego
        SYSTEM, // Opciones del sistema
        MAIN    // Menú principal
    };

    enum class OptionBehavior
    {
        ADJUST, // Modificable con izquierda/derecha
        SELECT  // Activable con ENTER
    };

    enum class ValueType
    {
        BOOL,   // Valor booleano
        INT,    // Valor entero
        FOLDER, // Referencia a otro grupo
        NONE    // Sin valor asociado
    };

    enum class GroupAlignment
    {
        CENTERED, // Opciones centradas
        LEFT      // Opciones alineadas a la izquierda
    };

    // --- Estructura de opción del menú ---
    struct OptionEntry
    {
        std::string caption;     // Texto visible en el menú
        SettingsGroup group;     // Categoría de la opción
        OptionBehavior behavior; // Cómo se interactúa con la opción
        void *linked_variable;   // Puntero a la variable que controla la opción
        ValueType type;          // Tipo de la variable (bool, int, folder, none)

        int min_value;  // Valor mínimo (solo aplicable si type == INT)
        int max_value;  // Valor máximo (solo aplicable si type == INT)
        int step_value; // Incremento al modificar la opción (solo aplicable si type == INT)

        SettingsGroup target_group; // Grupo al que hace referencia la opción si es de tipo FOLDER

        // Constructor para opciones de tipo BOOL, NONE o FOLDER
        OptionEntry(std::string cap, SettingsGroup grp, OptionBehavior beh, void *var, ValueType t)
            : caption(cap), group(grp), behavior(beh), linked_variable(var), type(t),
              min_value(0), max_value(0), step_value(0), target_group(SettingsGroup::SYSTEM) {}

        // Constructor para opciones de tipo INT con valores mínimos, máximos e incremento
        OptionEntry(std::string cap, SettingsGroup grp, OptionBehavior beh, void *var, ValueType t, int min, int max, int step)
            : caption(cap), group(grp), behavior(beh), linked_variable(var), type(t),
              min_value(min), max_value(max), step_value(step), target_group(SettingsGroup::SYSTEM) {}

        // Constructor para opciones de tipo FOLDER que referencian otro grupo
        OptionEntry(std::string cap, SettingsGroup grp, OptionBehavior beh, SettingsGroup tgtGrp)
            : caption(cap), group(grp), behavior(beh), linked_variable(nullptr), type(ValueType::FOLDER),
              min_value(0), max_value(0), step_value(0), target_group(tgtGrp) {}

        // Método para modificar el valor de la opción
        void adjustValue(bool adjust_up)
        {
            if (linked_variable)
            {
                if (type == ValueType::INT)
                {
                    int &value = *(static_cast<int *>(linked_variable));
                    int newValue = adjust_up ? value + step_value : value - step_value;
                    value = std::clamp(newValue, min_value, max_value);
                }
                else if (type == ValueType::BOOL)
                {
                    bool &value = *(static_cast<bool *>(linked_variable));
                    value = !value;
                }
            }
        }

        // Método para obtener el valor como string
        std::string getValueAsString() const
        {
            switch (type)
            {
            case ValueType::BOOL:
                return (*(static_cast<bool *>(linked_variable))) ? "ON" : "OFF";
            case ValueType::INT:
                return std::to_string(*(static_cast<int *>(linked_variable)));
            default:
                return "";
            }
        }
    };

    // --- Variables internas ---
    bool enabled_ = false;                     // Indica si el menú de servicio está activo
    SDL_FRect rect_;                           // Rectángulo que define el área del menú de servicio
    std::shared_ptr<Text> element_text_;       // Objeto para escribir el texto de los elementos
    std::shared_ptr<Text> title_text_;         // Objeto para escribir el texto del título
    size_t selected_ = 0;                      // Índice del elemento del menú seleccionado
    Uint32 counter_ = 0;                       // Contador interno
    std::vector<OptionEntry> options_;         // Listado con todas las opciones del menú de servicio
    std::vector<OptionEntry> display_options_; // Opciones actualmente mostradas en pantalla
    OptionPairs option_pairs_;                 // Opciones actuales del menú (filtradas por grupo)
    SettingsGroup current_settings_group_;     // Grupo de opciones actualmente activo
    SettingsGroup previous_settings_group_;    // Grupo de opciones anterior
    Aspect aspect_ = Aspect::ASPECT2;          // Estilo visual del menú

    // --- Variables de aspecto ---
    Color bg_color_ = SERV_MENU_BG_COLOR;             // Color de fondo
    Color title_color_ = SERV_MENU_TITLE_COLOR;       // Color del título del menú
    Color text_color_ = SERV_MENU_TEXT_COLOR;         // Color del texto de los elementos
    Color selected_color_ = SERV_MENU_SELECTED_COLOR; // Color del elemento seleccionado
    int width_;                                       // Ancho del menú
    int height_;                                      // Alto del menú
    int line_height_;                                 // Espacio entre elementos del menú

    // --- Métodos internos: Anclaje y aspecto ---
    void setAnchors();              // Establece el valor de las variables de anclaje
    Color getSelectedColor() const; // Devuelve el color del elemento seleccionado

    // --- Métodos internos: Gestión de opciones ---
    void initializeOptions();                                              // Crea todas las opciones del menú de servicio
    OptionPairs getOptionPairs(SettingsGroup group) const;                 // Devuelve las opciones como pares de strings para un grupo
    std::vector<OptionEntry> getOptionsByGroup(SettingsGroup group) const; // Devuelve las opciones de un grupo

    // --- Métodos internos: Lógica de menú ---
    void applySettings(SettingsGroup group); // Aplica la configuración de un grupo
    void updateMenu(SettingsGroup group);    // Actualiza las opciones mostradas según el grupo
    void reset();                            // Reinicia el menú al estado inicial

    // --- Métodos internos: Utilidades ---
    void updateCounter();                                        // Actualiza el contador interno
    int calculateMenuHeight() const;                             // Calcula la altura del menú
    int findLargestGroupSize() const;                            // Devuelve el tamaño del grupo más grande
    GroupAlignment getGroupAlignment(SettingsGroup group) const; // Devuelve la alineación del grupo

    // --- Patrón Singleton ---
    ServiceMenu();                                        // Constructor privado
    ~ServiceMenu() = default;                             // Destructor privado
    ServiceMenu(const ServiceMenu &) = delete;            // Evita la copia
    ServiceMenu &operator=(const ServiceMenu &) = delete; // Evita la asignación

    // --- Instancia Singleton ---
    static ServiceMenu *instance_; // Instancia única del menú de servicio

    // --- Método para reproducir el sonido del menú ---
    void playMenuSound(); // Reproduce el sonido del menú
};