#include "tabs.h"
#include "viz/data_table.h"
#include "core/data_table_types.h"
#include "core/icons_tabler.h"
#include "core/empty_state.h"

#include <imgui.h>
#include <implot.h>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <map>

namespace dag_ui_tabs {

// ---------------------------------------------------------------------------
// Globals
// ---------------------------------------------------------------------------

Selection& selection() {
    static Selection s;
    return s;
}

Caches& caches() {
    static Caches c;
    return c;
}

// data_table::State persistente por panel (issue 0081-J pattern).
static data_table::State g_st_dag_list;
static data_table::State g_st_dag_runs;
static data_table::State g_st_run_steps;

// Backing storage para cells de cada tabla. Owner del char* const* en TableInput.
static std::vector<std::string> g_back_dag_list;
static std::vector<const char*> g_ptrs_dag_list;

static std::vector<std::string> g_back_dag_runs;
static std::vector<const char*> g_ptrs_dag_runs;

static std::vector<std::string> g_back_run_steps;
static std::vector<const char*> g_ptrs_run_steps;

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

static void cells_to_ptrs(const std::vector<std::string>& backing,
                          std::vector<const char*>& ptrs) {
    ptrs.resize(backing.size());
    for (size_t i = 0; i < backing.size(); i++) ptrs[i] = backing[i].c_str();
}

static std::string format_duration(long long ms) {
    if (ms <= 0) return "-";
    if (ms < 1000) return std::to_string(ms) + "ms";
    char buf[32];
    std::snprintf(buf, sizeof(buf), "%.2fs", ms / 1000.0);
    return buf;
}

static std::string status_for_dag(const std::string& dag_name,
                                  const dag_ui::DagInfo& info,
                                  const std::vector<dag_ui::DagRunRow>& live_runs) {
    // Find most recent live run that matches this DAG.
    const dag_ui::DagRunRow* best = nullptr;
    for (auto& r : live_runs) {
        if (r.dag_name != dag_name) continue;
        if (!best || r.started_at > best->started_at) best = &r;
    }
    if (best) return best->status;
    if (info.has_last_run) return info.last_run_status;
    return "-";
}

// ---------------------------------------------------------------------------
// DAG List
// ---------------------------------------------------------------------------

// Forward decl — main.cpp owns the cache and the refresh trigger.
extern "C" void dag_list_request_refresh();

void draw_dag_list(const std::string& api_url,
                   const std::vector<dag_ui::DagInfo>& dags,
                   const std::vector<dag_ui::DagRunRow>& live_runs)
{
    if (!ImGui::Begin(TI_LIST " DAGs")) {
        ImGui::End();
        return;
    }

    if (ImGui::Button(TI_REFRESH " Refresh##dag_list")) {
        dag_list_request_refresh();
    }
    ImGui::SameLine();
    ImGui::TextDisabled("Double-click row -> inspect. Recent = last 5 runs inline.");

    if (dags.empty()) {
        empty_state("( no DAGs )", "Empty registry",
                    "Place a YAML in apps/dag_engine/dags_migrated/ and reload the server.");
        ImGui::End();
        return;
    }

    // Build TableInput. 6 columns (was 10 with R1..R5 as separate Badge cols —
    // that was an antipattern fixed in issue 0081-O.5). "Recent" uses CellRenderer::Dots
    // to show up to 5 inline colored dots from a comma-separated status string.
    data_table::TableInput ti;
    ti.name    = "dags";
    ti.headers = {"Name", "Schedule", "Status", "Recent", "Tags", "Valid"};
    ti.types   = {
        data_table::ColumnType::String, // Name
        data_table::ColumnType::String, // Schedule
        data_table::ColumnType::String, // Status (last run)
        data_table::ColumnType::String, // Recent (dots: up to 5 runs)
        data_table::ColumnType::String, // Tags
        data_table::ColumnType::String, // Valid
    };
    ti.rows = static_cast<int>(dags.size());
    ti.cols = static_cast<int>(ti.headers.size());

    // BadgeRule set: shared by Status (Badge) and Recent (Dots).
    auto run_status_badges = [](){
        std::vector<data_table::BadgeRule> rules;
        rules.push_back({"success",   "#22c55e", ""}); // verde
        rules.push_back({"failed",    "#ef4444", ""}); // rojo
        rules.push_back({"running",   "#eab308", ""}); // amarillo
        rules.push_back({"pending",   "#94a3b8", ""}); // gris azulado
        rules.push_back({"cancelled", "#6b7280", ""}); // gris
        return rules;
    };

    // ColumnSpec per column.
    ti.column_specs.resize(ti.cols);
    for (int i = 0; i < ti.cols; i++) ti.column_specs[i].id = ti.headers[i];

    // idx 2 — "Status": Badge renderer for the single last-run status string.
    ti.column_specs[2].renderer = data_table::CellRenderer::Badge;
    ti.column_specs[2].badges   = run_status_badges();

    // idx 3 — "Recent": Dots renderer — each dot = one of the last 5 runs.
    ti.column_specs[3].renderer        = data_table::CellRenderer::Dots;
    ti.column_specs[3].badges          = run_status_badges();
    ti.column_specs[3].dots_max        = 5;
    ti.column_specs[3].dots_show_count = false;
    ti.column_specs[3].tooltip_on_hover = true;  // hover each dot -> show status string

    g_back_dag_list.clear();
    g_back_dag_list.reserve(dags.size() * ti.cols);
    for (auto& d : dags) {
        g_back_dag_list.push_back(d.name);
        g_back_dag_list.push_back(d.schedule.empty() ? "-" : d.schedule[0]);
        g_back_dag_list.push_back(status_for_dag(d.name, d, live_runs));
        // "Recent": join up to 5 last run statuses as comma-separated string.
        // Most-recent first. Only include runs that exist (no padding with "-").
        {
            std::string recent;
            int n = std::min(5, static_cast<int>(d.last_runs_status.size()));
            for (int i = 0; i < n; i++) {
                if (i) recent += ',';
                recent += d.last_runs_status[i];
            }
            g_back_dag_list.push_back(recent);
        }
        std::string tags_csv;
        for (size_t i = 0; i < d.tags.size(); i++) {
            if (i) tags_csv += ",";
            tags_csv += d.tags[i];
        }
        g_back_dag_list.push_back(tags_csv);
        g_back_dag_list.push_back(d.valid ? "yes" : "no");
    }
    cells_to_ptrs(g_back_dag_list, g_ptrs_dag_list);
    ti.cells = g_ptrs_dag_list.data();

    std::vector<data_table::TableEvent> events;
    ImGui::BeginChild("##dag_list_wrap", ImVec2(-1, -1));
    data_table::render("##dt_dag_list", {ti}, g_st_dag_list, &events);
    ImGui::EndChild();

    // Handle row events -> select DAG.
    for (auto& ev : events) {
        if (ev.kind == data_table::TableEventKind::RowDoubleClick && ev.row >= 0 &&
            ev.row < static_cast<int>(dags.size())) {
            selection().dag_name        = dags[ev.row].name;
            caches().dag_detail_loaded  = false; // force reload
        }
    }

    ImGui::End();
}

// ---------------------------------------------------------------------------
// DAG Detail
// ---------------------------------------------------------------------------

static void load_dag_detail(const std::string& api_url) {
    auto& sel = selection();
    auto& c = caches();
    c.dag_detail = {};
    if (sel.dag_name.empty()) {
        c.dag_detail_loaded = false;
        return;
    }
    if (dag_ui::get_dag_http(api_url, sel.dag_name, c.dag_detail)) {
        c.dag_detail_loaded = true;
    }
}

void draw_dag_detail(const std::string& api_url) {
    if (!ImGui::Begin(TI_INFO_CIRCLE " DAG Detail")) {
        ImGui::End();
        return;
    }
    auto& sel = selection();
    auto& c = caches();

    if (sel.dag_name.empty()) {
        empty_state("( nothing selected )", "Pick a DAG",
                    "Double-click a row in the DAG list to inspect it here.");
        ImGui::End();
        return;
    }

    if (!c.dag_detail_loaded) load_dag_detail(api_url);

    auto& info = c.dag_detail.info;
    ImGui::Text("%s %s", TI_HASH, info.name.empty() ? sel.dag_name.c_str() : info.name.c_str());
    if (!info.description.empty()) ImGui::TextWrapped("%s", info.description.c_str());
    if (!info.schedule.empty()) ImGui::Text("Schedule: %s", info.schedule[0].c_str());

    ImGui::Separator();

    if (ImGui::Button(TI_PLAYER_PLAY " Run Now")) {
        std::string run_id, err;
        if (dag_ui::trigger_dag_http(api_url, sel.dag_name, run_id, err)) {
            sel.run_id = run_id;
            c.run_detail_loaded = false;
        } else {
            // Surface error via console; UI banner could be added later.
            fprintf(stderr, "[dag_detail] trigger failed: %s\n", err.c_str());
        }
    }
    ImGui::SameLine();
    if (ImGui::Button(TI_REFRESH " Refresh")) {
        c.dag_detail_loaded = false;
    }

    ImGui::Separator();
    ImGui::TextUnformatted("Recent runs:");

    auto& runs = c.dag_detail.recent_runs;
    if (runs.empty()) {
        ImGui::TextDisabled("( no runs yet )");
        ImGui::End();
        return;
    }

    data_table::TableInput ti;
    ti.name    = "runs";
    ti.headers = {"Run ID", "Status", "Trigger", "Started", "Finished", "Error"};
    ti.types   = {
        data_table::ColumnType::String,
        data_table::ColumnType::String,
        data_table::ColumnType::String,
        data_table::ColumnType::Date,
        data_table::ColumnType::Date,
        data_table::ColumnType::String,
    };
    ti.rows = static_cast<int>(runs.size());
    ti.cols = static_cast<int>(ti.headers.size());

    g_back_dag_runs.clear();
    g_back_dag_runs.reserve(runs.size() * ti.cols);
    for (auto& r : runs) {
        g_back_dag_runs.push_back(r.id);
        g_back_dag_runs.push_back(r.status);
        g_back_dag_runs.push_back(r.trigger);
        g_back_dag_runs.push_back(r.started_at);
        g_back_dag_runs.push_back(r.finished_at);
        g_back_dag_runs.push_back(r.error);
    }
    cells_to_ptrs(g_back_dag_runs, g_ptrs_dag_runs);
    ti.cells = g_ptrs_dag_runs.data();

    std::vector<data_table::TableEvent> events;
    ImGui::BeginChild("##dag_runs_wrap", ImVec2(-1, -1));
    data_table::render("##dt_dag_runs", {ti}, g_st_dag_runs, &events);
    ImGui::EndChild();

    for (auto& ev : events) {
        if (ev.kind == data_table::TableEventKind::RowDoubleClick && ev.row >= 0 &&
            ev.row < static_cast<int>(runs.size())) {
            sel.run_id = runs[ev.row].id;
            caches().run_detail_loaded = false;
        }
    }
    ImGui::End();
}

// ---------------------------------------------------------------------------
// Run Detail
// ---------------------------------------------------------------------------

static void load_run_detail(const std::string& api_url) {
    auto& sel = selection();
    auto& c = caches();
    c.run_detail = {};
    if (sel.run_id.empty()) {
        c.run_detail_loaded = false;
        return;
    }
    if (dag_ui::get_run_http(api_url, sel.run_id, c.run_detail)) {
        c.run_detail_loaded = true;
    }
}

void draw_run_detail(const std::string& api_url) {
    if (!ImGui::Begin(TI_CLIPBOARD_LIST " Run Detail")) {
        ImGui::End();
        return;
    }
    auto& sel = selection();
    auto& c = caches();

    if (sel.run_id.empty()) {
        empty_state("( nothing selected )", "Pick a run",
                    "Double-click a row in DAG Detail recent runs.");
        ImGui::End();
        return;
    }

    if (!c.run_detail_loaded) load_run_detail(api_url);

    auto& run = c.run_detail.run;
    ImGui::Text("%s %s", TI_HASH, run.id.empty() ? sel.run_id.c_str() : run.id.c_str());
    ImGui::Text("Status: %s | Trigger: %s", run.status.c_str(), run.trigger.c_str());
    ImGui::Text("Started: %s | Finished: %s",
                run.started_at.c_str(), run.finished_at.empty() ? "-" : run.finished_at.c_str());
    if (!run.error.empty()) {
        ImGui::TextColored(ImVec4(1, 0.4f, 0.4f, 1), "Error: %s", run.error.c_str());
    }
    ImGui::SameLine();
    if (ImGui::Button(TI_REFRESH " Refresh##run")) {
        c.run_detail_loaded = false;
    }

    ImGui::Separator();
    auto& steps = c.run_detail.steps;
    if (steps.empty()) {
        ImGui::TextDisabled("( no steps yet )");
        ImGui::End();
        return;
    }

    data_table::TableInput ti;
    ti.name    = "steps";
    ti.headers = {"Step", "Status", "Exit", "Duration", "Started"};
    ti.types   = {
        data_table::ColumnType::String,
        data_table::ColumnType::String,
        data_table::ColumnType::Int,
        data_table::ColumnType::String,
        data_table::ColumnType::Date,
    };
    ti.rows = static_cast<int>(steps.size());
    ti.cols = static_cast<int>(ti.headers.size());

    g_back_run_steps.clear();
    g_back_run_steps.reserve(steps.size() * ti.cols);
    for (auto& s : steps) {
        g_back_run_steps.push_back(s.step_name);
        g_back_run_steps.push_back(s.status);
        g_back_run_steps.push_back(std::to_string(s.exit_code));
        g_back_run_steps.push_back(format_duration(s.duration_ms));
        g_back_run_steps.push_back(s.started_at);
    }
    cells_to_ptrs(g_back_run_steps, g_ptrs_run_steps);
    ti.cells = g_ptrs_run_steps.data();

    ImGui::BeginChild("##run_steps_wrap", ImVec2(-1, ImGui::GetContentRegionAvail().y * 0.5f));
    data_table::render("##dt_run_steps", {ti}, g_st_run_steps);
    ImGui::EndChild();

    // stdout/stderr expandible por step.
    ImGui::Separator();
    ImGui::TextUnformatted("Step output:");
    for (size_t i = 0; i < steps.size(); i++) {
        char hdr[256];
        std::snprintf(hdr, sizeof(hdr), "%s##step_%zu", steps[i].step_name.c_str(), i);
        if (ImGui::CollapsingHeader(hdr)) {
            if (!steps[i].stdout_text.empty()) {
                ImGui::TextUnformatted("stdout:");
                ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0.08f, 0.08f, 0.08f, 1));
                ImGui::BeginChild((std::string("##stdout_") + std::to_string(i)).c_str(),
                                   ImVec2(-1, 80), false);
                ImGui::TextUnformatted(steps[i].stdout_text.c_str());
                ImGui::EndChild();
                ImGui::PopStyleColor();
            }
            if (!steps[i].stderr_text.empty()) {
                ImGui::TextColored(ImVec4(1, 0.4f, 0.4f, 1), "stderr:");
                ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0.12f, 0.06f, 0.06f, 1));
                ImGui::BeginChild((std::string("##stderr_") + std::to_string(i)).c_str(),
                                   ImVec2(-1, 80), false);
                ImGui::TextUnformatted(steps[i].stderr_text.c_str());
                ImGui::EndChild();
                ImGui::PopStyleColor();
            }
        }
    }
    ImGui::End();
}

// ---------------------------------------------------------------------------
// Timeline (ImPlot scatter X=tiempo, Y=DAG)
// ---------------------------------------------------------------------------

// Parse RFC3339 "2026-05-15T17:01:20+02:00" -> epoch seconds (local time).
// Devuelve 0 si parse falla.
static time_t parse_rfc3339(const std::string& s) {
    if (s.empty()) return 0;
    std::tm tm{};
    // strptime no acepta timezone offsets en todos los libc. Hacemos manual:
    // "YYYY-MM-DDTHH:MM:SS" -> los primeros 19 chars. Ignoramos el offset y
    // tratamos como local time (coherente con ImPlot::UseLocalTime=true).
    if (s.size() < 19) return 0;
    tm.tm_year = std::atoi(s.substr(0, 4).c_str()) - 1900;
    tm.tm_mon  = std::atoi(s.substr(5, 2).c_str()) - 1;
    tm.tm_mday = std::atoi(s.substr(8, 2).c_str());
    tm.tm_hour = std::atoi(s.substr(11, 2).c_str());
    tm.tm_min  = std::atoi(s.substr(14, 2).c_str());
    tm.tm_sec  = std::atoi(s.substr(17, 2).c_str());
    tm.tm_isdst = -1;
    return std::mktime(&tm);
}

static ImVec4 color_for_status(const std::string& st) {
    if (st == "success")   return ImVec4(0.30f, 0.85f, 0.40f, 0.95f); // verde
    if (st == "failed")    return ImVec4(0.95f, 0.35f, 0.30f, 0.95f); // rojo
    if (st == "running")   return ImVec4(0.95f, 0.80f, 0.20f, 0.95f); // amarillo
    if (st == "pending")   return ImVec4(0.60f, 0.65f, 0.75f, 0.85f); // gris azul
    if (st == "cancelled") return ImVec4(0.50f, 0.50f, 0.50f, 0.85f); // gris
    return ImVec4(0.70f, 0.70f, 0.70f, 0.70f);
}

// Ventana de tiempo seleccionable.
static const char* kTLWindowLabels[] = {"15m", "1h", "6h", "24h", "7d"};
static const int   kTLWindowSecs[]   = {900,   3600, 21600, 86400, 604800};
static int g_tl_window_idx = 3; // 24h

void draw_timeline(const std::string& api_url,
                   const std::vector<dag_ui::DagRunRow>& runs_all)
{
    if (!ImGui::Begin(TI_CHART_LINE " Timeline")) {
        ImGui::End();
        return;
    }

    ImGui::SetNextItemWidth(120);
    if (ImGui::BeginCombo("Window", kTLWindowLabels[g_tl_window_idx])) {
        for (int i = 0; i < IM_ARRAYSIZE(kTLWindowLabels); i++) {
            bool sel = (i == g_tl_window_idx);
            if (ImGui::Selectable(kTLWindowLabels[i], sel)) g_tl_window_idx = i;
            if (sel) ImGui::SetItemDefaultFocus();
        }
        ImGui::EndCombo();
    }
    ImGui::SameLine();
    ImGui::TextDisabled("%zu runs en cache", runs_all.size());

    if (runs_all.empty()) {
        empty_state("( no data )", "No runs yet",
                    "Trigger a DAG (DAG Detail -> Run Now) o espera al scheduler.");
        ImGui::End();
        return;
    }

    // Calculate window bounds.
    const double now  = static_cast<double>(std::time(nullptr));
    const int win_s   = kTLWindowSecs[g_tl_window_idx];
    const double left = now - static_cast<double>(win_s);

    // Asignar Y index por DAG. Mantener orden alfabetico estable.
    std::map<std::string, int> dag_y;
    {
        std::vector<std::string> uniq;
        for (auto& r : runs_all) {
            if (!dag_y.count(r.dag_name)) {
                dag_y[r.dag_name] = -1;
                uniq.push_back(r.dag_name);
            }
        }
        std::sort(uniq.begin(), uniq.end());
        for (size_t i = 0; i < uniq.size(); i++) dag_y[uniq[i]] = static_cast<int>(i);
    }

    // Buffers por status -> {xs, ys} para PlotScatter.
    struct StatusBuf { std::vector<double> xs, ys; };
    std::map<std::string, StatusBuf> by_status;

    for (auto& r : runs_all) {
        if (r.dag_name.empty()) continue;
        time_t t = parse_rfc3339(r.started_at);
        if (t == 0) continue;
        double x = static_cast<double>(t);
        if (x < left || x > now + 10.0) continue;
        double y = static_cast<double>(dag_y[r.dag_name]);
        by_status[r.status].xs.push_back(x);
        by_status[r.status].ys.push_back(y);
    }

    ImPlot::GetStyle().UseLocalTime = true;

    // Y ticks = DAG names.
    std::vector<double> ticks;
    std::vector<const char*> labels;
    std::vector<std::string> labels_owner; // backing storage for c_str()
    labels_owner.reserve(dag_y.size());
    ticks.reserve(dag_y.size());
    labels.reserve(dag_y.size());
    // Build sorted-by-y view
    std::vector<std::pair<std::string,int>> pairs(dag_y.begin(), dag_y.end());
    std::sort(pairs.begin(), pairs.end(),
              [](auto& a, auto& b){ return a.second < b.second; });
    for (auto& p : pairs) {
        ticks.push_back(static_cast<double>(p.second));
        labels_owner.push_back(p.first);
    }
    for (auto& s : labels_owner) labels.push_back(s.c_str());

    const float plot_h = ImGui::GetContentRegionAvail().y - 4.0f;
    if (ImPlot::BeginPlot("##dag_timeline", ImVec2(-1, plot_h),
                          ImPlotFlags_NoTitle | ImPlotFlags_NoMouseText))
    {
        ImPlot::SetupAxis(ImAxis_X1, "time",
                          ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoHighlight);
        ImPlot::SetupAxisScale(ImAxis_X1, ImPlotScale_Time);
        ImPlot::SetupAxisLimits(ImAxis_X1, left, now + 10.0, ImPlotCond_Always);

        ImPlot::SetupAxis(ImAxis_Y1, "DAG",
                          ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoHighlight);
        if (!ticks.empty()) {
            ImPlot::SetupAxisTicks(ImAxis_Y1, ticks.data(),
                                   static_cast<int>(ticks.size()),
                                   labels.data());
            ImPlot::SetupAxisLimits(ImAxis_Y1, -0.5,
                                    static_cast<double>(ticks.size()) - 0.5,
                                    ImPlotCond_Always);
        }

        for (auto& kv : by_status) {
            if (kv.second.xs.empty()) continue;
            ImPlotSpec spec;
            spec.Marker          = ImPlotMarker_Circle;
            spec.MarkerSize      = 6.0f;
            ImVec4 col = color_for_status(kv.first);
            spec.MarkerFillColor = col;
            spec.MarkerLineColor = col;
            spec.LineColor       = col;
            ImPlot::PlotScatter(kv.first.c_str(),
                                kv.second.xs.data(),
                                kv.second.ys.data(),
                                static_cast<int>(kv.second.xs.size()),
                                spec);
        }

        // Hover tooltip: closest run.
        if (ImPlot::IsPlotHovered() && !runs_all.empty()) {
            const ImVec2 mp_px = ImGui::GetIO().MousePos;
            const double kHitRadiusPx = 12.0;
            double best_dist = kHitRadiusPx;
            const dag_ui::DagRunRow* best = nullptr;
            for (auto& r : runs_all) {
                if (!dag_y.count(r.dag_name)) continue;
                time_t t = parse_rfc3339(r.started_at);
                if (t == 0) continue;
                double x = static_cast<double>(t);
                if (x < left || x > now + 10.0) continue;
                double y = static_cast<double>(dag_y[r.dag_name]);
                ImVec2 px = ImPlot::PlotToPixels(x, y);
                double dx = px.x - mp_px.x;
                double dy = px.y - mp_px.y;
                double d = std::sqrt(dx*dx + dy*dy);
                if (d < best_dist) { best_dist = d; best = &r; }
            }
            if (best) {
                ImGui::BeginTooltip();
                ImGui::TextColored(color_for_status(best->status), "%s", best->status.c_str());
                ImGui::Text("%s", best->dag_name.c_str());
                ImGui::Separator();
                ImGui::Text("run id: %s", best->id.c_str());
                ImGui::Text("started: %s", best->started_at.c_str());
                if (!best->finished_at.empty())
                    ImGui::Text("finished: %s", best->finished_at.c_str());
                ImGui::Text("trigger: %s", best->trigger.c_str());
                if (!best->error.empty()) {
                    ImGui::TextColored(ImVec4(1,0.4f,0.4f,1), "err: %s", best->error.c_str());
                }
                ImGui::EndTooltip();
            }
        }
        ImPlot::EndPlot();
    }
    ImGui::End();
}

} // namespace dag_ui_tabs