// Logica pura del playground data_table. Sin ImGui — testable headless.
// Cuando se promueva al registry, esto sera la base de data_table_cpp_viz.
#pragma once

#include <string>
#include <utility>
#include <vector>

namespace data_table {

enum class Op {
    Eq, Neq, Gt, Gte, Lt, Lte,
    Contains, NotContains, StartsWith, EndsWith
};
const char* op_label(Op o);
bool op_is_string_only(Op o);

// ----------------------------------------------------------------------------
// Column types - declarado por caller con fallback a auto-detect.
// ----------------------------------------------------------------------------
enum class ColumnType {
    Auto, String, Int, Float, Bool, Date, Json
};

const char* column_type_name(ColumnType t);
const char* column_type_icon(ColumnType t); // UTF-8 Tabler icon

// Ops permitidos para cada tipo. Devuelve vector ordenado.
std::vector<Op> ops_for_type(ColumnType t);

// Auto-detect via sample: escanea hasta `sample_n` celdas no-vacias.
ColumnType auto_detect_type(const char* const* cells, int rows, int cols,
                            int col, int sample_n = 64);

// Tipo efectivo: si declared != Auto -> declared; else auto_detect.
ColumnType effective_type(ColumnType declared,
                          const char* const* cells, int rows, int cols, int col);

// Derived column: inmutable. Dos modos:
//   1) Retipo puro: source_col >= 0, formula == "". Cells del origen.
//   2) Formula:     source_col == -1, formula no vacia. Eval por Lua.
struct DerivedColumn {
    int         source_col = -1;
    ColumnType  type       = ColumnType::String;
    std::string name;
    std::string formula;        // "" = retipado puro; resto = body Lua
    int         lua_id  = -1;   // referencia en lua_engine; -1 si no compilado
    std::string compile_error;
};

// Filter movido aqui (antes era despues de State) porque TQL Stage lo necesita.
struct Filter {
    int         col;
    Op          op;
    std::string value;
};

struct ColorRule {
    int          col;
    std::string  equals;
    unsigned int color;
};

// ----------------------------------------------------------------------------
// TQL (Table Query Language) — stage model. Ver docs/TQL.md.
// ----------------------------------------------------------------------------
enum class AggFn {
    Count, Sum, Avg, Min, Max, Distinct, Stddev,
    Median, P25, P75, P90, P99, Percentile
};

const char* agg_fn_name(AggFn f);

struct Aggregation {
    AggFn       fn = AggFn::Count;
    std::string col;         // ignorado para Count
    double      arg = 0.0;   // para Percentile (0..1)
    std::string alias;       // vacio -> auto-generado via aggregation_alias()
};

struct SortClause {
    std::string col;
    bool        desc = false;
};

// Stage: layer de TQL. Stage 0 = Raw (sin breakouts/aggregations).
// Stage 1+ pueden agrupar. Cada stage consume output del anterior.
struct Stage {
    std::vector<Filter>          filters;
    std::vector<DerivedColumn>   derived;       // expressions de este stage
    std::vector<std::string>     breakouts;     // col names del INPUT de este stage
    std::vector<Aggregation>     aggregations;
    std::vector<SortClause>      sorts;
};

// Pure: alias por defecto cuando agg.alias esta vacio.
//   count          -> "count"
//   distinct col   -> "distinct_<col>"
//   percentile p   -> "p<arg*100>_<col>"   (ej. p95_size_kb)
//   resto          -> "<fn>_<col>"          (ej. avg_size_kb)
std::string aggregation_alias(const Aggregation& a);

// Pure: tipo del output de la aggregation.
//   count, distinct   -> Int
//   sum, avg, stddev,
//   median, p*, percentile -> Float
//   min, max          -> mismo tipo que la col origen
ColumnType  aggregation_type(const Aggregation& a,
                              const std::vector<std::string>& in_headers,
                              const std::vector<ColumnType>&  in_types);

// Output de compute_stage. Posee `cell_backing` (strings nuevos para
// resultados agregados) y `cells` (punteros row-major a backing o a
// `in_cells` original para passthrough).
struct StageOutput {
    std::vector<std::string>  cell_backing;
    std::vector<const char*>  cells;
    int                       rows = 0;
    int                       cols = 0;
    std::vector<std::string>  headers;
    std::vector<ColumnType>   types;
};

// Pure: ejecuta un Stage sobre los cells de entrada. Aplica filter -> (group+agg|passthrough) -> sort.
StageOutput compute_stage(const char* const* in_cells, int in_rows, int in_cols,
                          const std::vector<std::string>& in_headers,
                          const std::vector<ColumnType>&  in_types,
                          const Stage& stage);

// Pure: aplica filtros usando headers para resolver f.col (que ahora es
// indice en el array de in_headers, no del dataset original). Devuelve
// indices de filas que pasan.
std::vector<int> apply_filters(const char* const* cells, int rows, int cols,
                               const std::vector<Filter>& filters);

// Pure: helper para drill-down. Devuelve un Filter Op::Eq sobre col_idx con
// el value indicado. col_idx es indice en los headers del INPUT del stage
// previo (donde se va a aplicar el filtro).
Filter make_drill_filter(int col_idx, const std::string& value);

// ----------------------------------------------------------------------------
// ViewMode: tipo de visualizacion a renderizar sobre el output del stage activo.
// "Table" siempre disponible. Resto requiere ciertos tipos de columnas.
// ----------------------------------------------------------------------------
enum class ViewMode {
    Table,
    // Bars
    Bar,           // horizontal bars: 1 cat + 1 num
    Column,        // vertical bars: 1 cat + 1 num
    GroupedBar,    // 1 cat + N num (side-by-side)
    StackedBar,    // 1 cat + N num (stacked)
    // Lines / area
    Line,          // X + 1..N Y series
    Area,          // shaded to y=0
    Stairs,        // step plot
    // Points
    Scatter,       // X + Y
    Bubble,        // X + Y + size
    // Distribution
    Histogram,     // 1 num
    Histogram2D,   // 2 num
    Heatmap,       // matrix from breakouts
    BoxPlot,       // 1 cat + 1 num (min/p25/p50/p75/max per group)
    // Stems / signals
    Stem,
    ErrorBars,
    // Composition
    Pie,
    Donut,
    Funnel,        // ordered descending bars
    Waterfall,     // running sum
    // Single values
    KPI,           // big text + label
    KPIGrid,       // all aggregations as cards
    // Specialized
    Candlestick,   // OHLC: time + open + high + low + close
    Radar,         // multi-axis (1 cat + N num)
};

const char* view_mode_token(ViewMode m);          // "table", "bar", ...
const char* view_mode_label(ViewMode m);          // "Table", "Bar (horizontal)", ...
ViewMode    view_mode_from_token(const char* s);
int         view_mode_min_cols(ViewMode m);
bool        view_mode_needs_numeric(ViewMode m);
bool        view_mode_needs_category(ViewMode m);
// Requiere stage agrupado (breakout+aggregation). Si user esta en stage 0 con
// uno de estos, conviene auto-promote a stage 1.
bool        view_mode_needs_aggregation(ViewMode m);

// Lista completa de modos para el selector UI (orden de display).
const ViewMode* all_view_modes(int* n_out);

// ----------------------------------------------------------------------------
// Joins (MBQL-style). Ver issue 0078.
// ----------------------------------------------------------------------------
enum class JoinStrategy { Left, Inner, Right, Full };
const char*  join_strategy_token(JoinStrategy s);
JoinStrategy join_strategy_from_token(const char* s);
const char*  join_strategy_label(JoinStrategy s);

// Tabla extra pasada al render() para joins. Owner externo (caller).
struct TableInput {
    std::string                 name;       // identificador estable (matchea Join.source)
    std::vector<std::string>    headers;
    std::vector<ColumnType>     types;
    const char* const*          cells = nullptr;  // row-major, headers.size() cols x rows filas
    int                         rows  = 0;
    int                         cols  = 0;
};

// Join clause: une la tabla actual con `source` por las parejas `on`,
// prefijando las cols del derecho con `alias.`.
struct Join {
    std::string                                          alias;
    std::string                                          source;
    std::vector<std::pair<std::string, std::string>>     on;        // {left_col, right_col}
    JoinStrategy                                         strategy = JoinStrategy::Left;
    std::vector<std::string>                             fields;    // vacio = all del derecho
};

// Pure: resuelve indice del main entre `tables` segun `main_source`.
// Vacio -> 0. Nombre desconocido -> 0. tables vacio -> -1.
int resolve_main_idx(const std::vector<TableInput>& tables, const std::string& main_source);

// Pure: aplica un join sobre dos tablas. Resultado: StageOutput con
// `headers` = left + `<alias>.<right_col>` (filtrado por fields si no vacio).
StageOutput join_tables(const char* const* left_cells, int left_rows, int left_cols,
                        const std::vector<std::string>& left_headers,
                        const std::vector<ColumnType>&  left_types,
                        const TableInput& right,
                        const Join& jn);

// ViewConfig: overrides manuales de auto-detect para la vista activa.
// Campos vacios -> auto. Si col name no existe en output, viz cae a auto.
struct ViewConfig {
    std::string                 x_col;        // single: scatter, line, hist2d
    std::vector<std::string>    y_cols;       // 1..N: line/area/bar/etc
    std::string                 size_col;     // bubble
    std::string                 cat_col;      // bar/pie/funnel/box override
    unsigned int                primary_color = 0;     // 0 = ImPlot auto
    int                         hist_bins     = 0;     // 0 = Sturges
    float                       pie_radius    = 0.0f;  // 0 = default
    bool                        show_legend   = true;
    bool                        show_markers  = false; // line/area markers
    bool                        locked        = false; // disable pan/zoom
    mutable bool                fit_request   = false; // consumed by viz::render
};

// VizPanel: viz adicional sobre el mismo StageOutput. State.display + viz_config
// es el panel 0 (siempre visible); extra_panels son los aniadidos por el user.
struct VizPanel {
    ViewMode    display = ViewMode::Bar;
    ViewConfig  config;
    // Memoria del ultimo non-Table display para toggle Table<->View.
    mutable ViewMode last_non_table = ViewMode::Bar;
};

// State: stage pipeline + viz globales.
//
// `stages` siempre tiene tamaño >= 1 (auto-init en compute_visible_rows / render
// si esta vacio: se crea stages[0] vacio). Stage 0 es Raw (filters + derived +
// sorts; SIN breakouts/aggregations). Stages 1+ pueden agrupar.
//
// `active_stage` = indice del stage cuyo output se renderiza.
// `col_visible/col_order/color_rules` aplican al output del stage activo.
struct State {
    std::vector<Stage>          stages;
    int                         active_stage = 0;
    ViewMode                    display = ViewMode::Table;
    ViewConfig                  viz_config;
    std::vector<VizPanel>       extra_panels;
    std::vector<Join>           joins;     // aplicado antes de stages[0]
    std::string                 main_source;  // name de TableInput a usar como main; vacio -> tables[0]

    std::vector<ColorRule>      color_rules;
    std::vector<bool>           col_visible;       // size = effective_cols del stage activo
    std::vector<int>            col_order;         // permutacion [0..effective_cols)

    // --- Compat helpers: shortcuts a stages[0] (Raw) ---
    // Util tras refactor para tests / accesos puntuales. Garantizan stages[0]
    // existe (lo crean vacio si no).
    Stage&       raw();
    const Stage& raw() const;
    Stage&       active();
    const Stage& active_const() const;
    void         ensure_stage0();
};

// Parse "1.23" -> 1.23, true. False si la celda no es numero completo.
bool parse_number(const char* s, double& out);

// Compara dos celdas con operador. Numerico si ambas parseables; lexical si no.
bool compare(const char* a, const char* b, Op op);

// Aplica filtros y ordena. Devuelve indices de filas visibles.
std::vector<int> compute_visible_rows(const char* const* cells,
                                      int rows, int cols,
                                      const State& st);

// Pure: muta col_order de st para colocar `src` en la posicion (en orden visual)
// donde estaba `dst`. No-op si src == dst o cualquiera fuera del array.
void reorder_column(State& st, int src, int dst);

// Pure: dado un buffer y posicion de cursor, busca el `[` abierto sin cerrar
// mas reciente. Devuelve su indice (o -1 si ninguno). Rellena `filter_text`
// con los caracteres entre `[` y cursor.
// Para autocomplete de formulas: cuando el usuario teclea `[` el ImGui callback
// detecta esto y muestra un popup con cols disponibles.
int find_open_bracket(const char* buf, int len, int cursor, std::string& filter_text);

// Pure: reemplaza src[start..cursor) por "[name]". Devuelve nuevo string y
// actualiza `new_cursor` a la posicion despues del `]`.
std::string insert_column_ref(const std::string& src, int start, int cursor,
                              const std::string& name, int& new_cursor);

// CSV: escapa una celda segun RFC 4180 (wrap en " si contiene , " o newline).
std::string csv_escape(const char* s);

// Construye TSV de un rect de seleccion. Headers SIEMPRE incluidos.
// view_row_lo/hi: indices en visible_rows.
// view_col_lo/hi: indices en col_order. Cols ocultas se omiten.
std::string build_tsv(const char* const* cells, int rows, int cols,
                      const char* const* headers,
                      const std::vector<int>&  col_order,
                      const std::vector<bool>& col_visible,
                      const std::vector<int>&  visible_rows,
                      int view_row_lo, int view_row_hi,
                      int view_col_lo, int view_col_hi);

// Construye CSV (full visible view). Headers incluidos, cells escapados.
std::string build_csv(const char* const* cells, int rows, int cols,
                      const char* const* headers,
                      const std::vector<int>&  col_order,
                      const std::vector<bool>& col_visible,
                      const std::vector<int>&  visible_rows);

struct ColStats {
    int    total          = 0;     // filas escaneadas
    int    empty_count    = 0;     // cells == "" o null
    int    unique_count   = 0;     // distintas (cap configurable)
    bool   unique_capped  = false; // true si se alcanzo el cap
    bool   numeric        = false; // true si todas las cells no-vacias parsean como numero
    int    numeric_count  = 0;
    double min            = 0;
    double max            = 0;
    double sum            = 0;
    double mean           = 0;
    double p25            = 0;
    double p50            = 0;
    double p75            = 0;
    std::vector<float> hist;                                   // bins (HIST_BINS) si numeric
    std::vector<std::pair<std::string,int>> top_categories;    // top 8 por count desc
};

constexpr int HIST_BINS = 24;

// Pure: escanea una columna y devuelve estadisticas. `unique_cap` corta el
// conteo de unicos si excede (para datasets de millones). 0 = sin cap.
// Si `indices != nullptr` y `n_indices > 0`, recorre solo las filas indicadas
// (uso tipico: stats sobre filas visibles post-filtro).
ColStats compute_column_stats(const char* const* cells, int rows, int cols,
                              int col, int unique_cap = 100000,
                              const int* indices = nullptr, int n_indices = 0);

} // namespace data_table