#pragma once

#include <cstddef>
#include <functional>

// Forward declarations para evitar incluir headers pesados aqui. Las
// definiciones reales viven en cpp/functions/core/*.h y se incluyen desde
// app_base.cpp.
namespace fn_ui {
    struct PanelToggle;
    struct LayoutCallbacks;

    // Info estatica para la ventana About. Si name != nullptr, fn::run_app
    // llama about_window_set_info(name, version, description) tras settings_load().
    struct AppAboutInfo {
        const char* name        = nullptr;
        const char* version     = nullptr;
        const char* description = nullptr;
    };

    // Config de logging. Si file_path != nullptr, fn::run_app llama
    // fn_log::logger_init(file_path, level) al inicio y fn_log::logger_close()
    // al exit. file_path se interpreta relativo al cwd (junto al ejecutable,
    // igual que app_settings.ini). Si file_path == nullptr, no se escribe a
    // disco — la ventana Logs sigue funcionando contra el buffer in-memory.
    //
    // level: 0=Debug, 1=Info, 2=Warn, 3=Error. Default Info.
    struct AppLogConfig {
        const char* file_path = nullptr;
        int         level     = 1; // fn_log::Level::Info
    };
}

namespace fn {

// ----------------------------------------------------------------------------
// Local files — separacion de archivos distribuibles vs estado local.
// ----------------------------------------------------------------------------
//
// Convencion del registry: TODA app coloca sus archivos escribibles
// (settings, DBs, layouts ImGui, caches, proyectos del usuario) bajo
// `<exe_dir>/local_files/`. Los archivos distribuibles (.exe, .ttf,
// .dll, runtime/, enrichers/) viven directos en `<exe_dir>/`.
//
// Esto mantiene la carpeta del .exe limpia para distribuir, separa
// nitidamente "lo que vino con el zip" de "lo que el PC genero", y
// facilita el reset (basta con borrar local_files/).
//
// `fn::run_app` configura `io.IniFilename = local_path("imgui.ini")` y
// `app_settings.ini` se lee/escribe desde local_files/ automaticamente.
// Cualquier archivo escribible adicional de la app debe usar
// `fn::local_path("nombre")` al construir su path.
//
// La carpeta se crea on-demand en la primera llamada a `local_dir()`.
// Si existen archivos viejos en el cwd (compat con versiones previas
// del registry), `migrate_to_local_files()` los mueve.

// Devuelve el directorio del ejecutable actual (sin trailing slash).
// "" si no se puede resolver (raro — fallback al cwd).
const char* exe_dir();

// Devuelve el path absoluto a `<exe_dir>/local_files/`. Crea la
// carpeta si no existe. Sin trailing slash.
const char* local_dir();

// Construye `<local_dir>/<name>`. El puntero retornado apunta a un
// std::string interno por-thread que permanece valido hasta la
// proxima llamada — copia el valor si vas a guardarlo.
const char* local_path(const char* name);

// Mueve los archivos listados de cwd o exe_dir a local_files/ si
// existen ahi pero NO existen ya en local_files/. Idempotente. Las
// apps lo llaman al iniciar para migrar instalaciones viejas.
void migrate_to_local_files(const char* const* names, std::size_t n);

// Modos de tema para run_app.
enum class ThemeMode {
    FnDark,    // Identidad del registry (Mantine v9 dark + indigo). DEFAULT.
    ImGuiDark, // Tema estandar de ImGui (ImGui::StyleColorsDark).
    ImGuiLight,
    None,      // No tocar el ImGuiStyle — la app lo configura.
};

struct AppConfig {
    const char* title = "fn_registry";
    int width = 1280;
    int height = 720;
    bool vsync = true;
    bool viewports = true; // Multi-viewport ON por defecto: ventanas ImGui arrastrables fuera del main window
    ThemeMode theme = ThemeMode::FnDark; // Identidad visual unificada por defecto
    float bg_r = 0.102f; // fn_tokens::colors::bg (dark.7 #1A1B1E)
    float bg_g = 0.106f;
    float bg_b = 0.118f;

    // About window. Si about.name != nullptr, run_app llama
    // fn_ui::about_window_set_info(name, version, description) tras settings_load().
    fn_ui::AppAboutInfo about{};

    // Paneles toggleables del menubar. Si panels != nullptr y panel_count > 0,
    // run_app llama fn_ui::app_menubar(panels, panel_count, layouts_cb) cada frame
    // ANTES de render_fn().
    const fn_ui::PanelToggle* panels      = nullptr;
    std::size_t               panel_count = 0;

    // Callbacks de layouts persistentes. Si layouts_cb != nullptr, run_app
    // llama fn_ui::app_menubar(panels, panel_count, layouts_cb) cada frame.
    fn_ui::LayoutCallbacks*   layouts_cb  = nullptr;

    // Si true, run_app llama fn::gfx::gl_loader_init() tras crear el contexto
    // GL y antes del primer frame. Necesario para apps que llaman gl* directo
    // en Windows (en Linux es no-op).
    bool init_gl_loader = false;

    // Logging opcional. Si log.file_path != nullptr, run_app inicializa el
    // logger global antes del primer frame y lo cierra al exit. La ventana
    // "Logs..." en el menubar siempre esta disponible (lee del buffer
    // in-memory aunque no haya archivo).
    fn_ui::AppLogConfig log{};
};

// Run an ImGui application. The render_fn is called every frame
// between ImGui::NewFrame() and ImGui::Render().
// Returns 0 on clean exit, 1 on error.
int run_app(AppConfig config, std::function<void()> render_fn);

// Convenience: run with default config
int run_app(std::function<void()> render_fn);

} // namespace fn