#include "tabs.h"
#include "core/icons_tabler.h"
#include "core/empty_state.h"
#include "core/badge.h"

#include <imgui.h>
#include <algorithm>
#include <cstdio>
#include <ctime>
#include <map>
#include <string>

namespace data_factory_ui {

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

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

FunctionCache& function_cache() {
    static FunctionCache fc;
    return fc;
}

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

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 format_bytes(long long bytes) {
    if (bytes <= 0) return "-";
    const double kb = 1024.0;
    const double mb = kb * 1024.0;
    const double gb = mb * 1024.0;
    char buf[32];
    if (bytes < (long long)kb)      std::snprintf(buf, sizeof(buf), "%lld B", bytes);
    else if (bytes < (long long)mb) std::snprintf(buf, sizeof(buf), "%.1f KB", bytes / kb);
    else if (bytes < (long long)gb) std::snprintf(buf, sizeof(buf), "%.1f MB", bytes / mb);
    else                            std::snprintf(buf, sizeof(buf), "%.2f GB", bytes / gb);
    return buf;
}

static time_t parse_rfc3339(const std::string& s) {
    if (s.size() < 19) return 0;
    std::tm tm{};
    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 BadgeVariant variant_for_status(const std::string& st) {
    if (st == "success")   return BadgeVariant::Success;
    if (st == "failed")    return BadgeVariant::Error;
    if (st == "running")   return BadgeVariant::Warning;
    if (st == "cancelled") return BadgeVariant::Default;
    return BadgeVariant::Default;
}

// Pick most-recent run per node from runs_all.
static const data_factory::Run* last_run_for(
    const std::string& node_id,
    const std::vector<data_factory::Run>& runs_all)
{
    const data_factory::Run* best = nullptr;
    for (auto& r : runs_all) {
        if (r.node_id != node_id) continue;
        if (!best || r.started_at > best->started_at) best = &r;
    }
    return best;
}

// ---------------------------------------------------------------------------
// Generic kind table — used by extractors / transformers / sinks
// ---------------------------------------------------------------------------

static void draw_node_table(const char* table_id,
                            const std::vector<data_factory::Node>& nodes,
                            const std::string& filter_kind,
                            const std::vector<data_factory::Run>& runs_all,
                            bool show_schedule)
{
    int cols = show_schedule ? 6 : 5;
    if (!ImGui::BeginTable(table_id, cols,
            ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
            ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY))
    {
        return;
    }
    ImGui::TableSetupColumn("Name",     ImGuiTableColumnFlags_WidthStretch, 0.20f);
    ImGui::TableSetupColumn("Function", ImGuiTableColumnFlags_WidthStretch, 0.30f);
    if (show_schedule)
        ImGui::TableSetupColumn("Schedule", ImGuiTableColumnFlags_WidthStretch, 0.12f);
    ImGui::TableSetupColumn("Last Run", ImGuiTableColumnFlags_WidthStretch, 0.18f);
    ImGui::TableSetupColumn("Status",   ImGuiTableColumnFlags_WidthStretch, 0.10f);
    ImGui::TableSetupColumn("Rows/KB",  ImGuiTableColumnFlags_WidthStretch, 0.10f);
    ImGui::TableHeadersRow();

    int row_idx = 0;
    for (auto& n : nodes) {
        if (n.kind != filter_kind) continue;
        ImGui::PushID(row_idx++);
        ImGui::TableNextRow();

        // Name (selectable -> sets selection)
        ImGui::TableNextColumn();
        bool selected = (selection().node_id == n.id);
        if (ImGui::Selectable(n.name.c_str(), selected,
                              ImGuiSelectableFlags_SpanAllColumns))
        {
            selection().node_id = n.id;
            // Invalidate function cache if function_id changed.
            if (function_cache().function_id != n.function_id) {
                function_cache() = {};
                function_cache().function_id = n.function_id;
            }
        }
        if (!n.enabled) {
            ImGui::SameLine();
            badge("disabled", BadgeVariant::Default);
        }

        // Function id
        ImGui::TableNextColumn();
        if (n.function_id.empty()) ImGui::TextDisabled("(none)");
        else ImGui::TextUnformatted(n.function_id.c_str());

        // Schedule
        if (show_schedule) {
            ImGui::TableNextColumn();
            if (n.schedule_cron.empty()) ImGui::TextDisabled("manual");
            else ImGui::TextUnformatted(n.schedule_cron.c_str());
        }

        // Last run
        const data_factory::Run* lr = last_run_for(n.id, runs_all);
        ImGui::TableNextColumn();
        if (lr) ImGui::TextUnformatted(lr->started_at.c_str());
        else    ImGui::TextDisabled("-");

        // Status badge
        ImGui::TableNextColumn();
        if (lr) badge(lr->status.c_str(), variant_for_status(lr->status));
        else    ImGui::TextDisabled("-");

        // Rows / KB
        ImGui::TableNextColumn();
        if (lr) ImGui::Text("%lld / %lld", lr->rows_out, lr->kb_out);
        else    ImGui::TextDisabled("-");

        ImGui::PopID();
    }
    ImGui::EndTable();
}

// ---------------------------------------------------------------------------
// Extractors
// ---------------------------------------------------------------------------

void draw_extractors(const std::string& /*api_url*/,
                     const std::vector<data_factory::Node>& nodes,
                     const std::vector<data_factory::Run>& runs_all)
{
    if (!ImGui::Begin(TI_DOWNLOAD " Extractors")) {
        ImGui::End();
        return;
    }
    int count = 0;
    for (auto& n : nodes) if (n.kind == "extractor") count++;
    if (count == 0) {
        empty_state(TI_DOWNLOAD, "No extractors",
                    "Register an extractor node via sqlite_api.");
        ImGui::End();
        return;
    }
    ImGui::TextDisabled("%d extractor nodes. Click row -> see Node Detail.", count);
    draw_node_table("##df_extractors", nodes, "extractor", runs_all, true);
    ImGui::End();
}

// ---------------------------------------------------------------------------
// Transformers
// ---------------------------------------------------------------------------

void draw_transformers(const std::string& /*api_url*/,
                       const std::vector<data_factory::Node>& nodes,
                       const std::vector<data_factory::Run>& runs_all)
{
    if (!ImGui::Begin(TI_REFRESH " Transformers")) {
        ImGui::End();
        return;
    }
    int count = 0;
    for (auto& n : nodes) if (n.kind == "transformer") count++;
    if (count == 0) {
        empty_state(TI_REFRESH, "No transformers",
                    "Register a transformer node via sqlite_api.");
        ImGui::End();
        return;
    }
    ImGui::TextDisabled("%d transformer nodes.", count);
    draw_node_table("##df_transformers", nodes, "transformer", runs_all, false);
    ImGui::End();
}

// ---------------------------------------------------------------------------
// Sinks
// ---------------------------------------------------------------------------

void draw_sinks(const std::string& /*api_url*/,
                const std::vector<data_factory::Node>& nodes,
                const std::vector<data_factory::Run>& runs_all)
{
    if (!ImGui::Begin(TI_UPLOAD " Sinks")) {
        ImGui::End();
        return;
    }
    int count = 0;
    for (auto& n : nodes) if (n.kind == "sink") count++;
    if (count == 0) {
        empty_state(TI_UPLOAD, "No sinks",
                    "Register a sink node via sqlite_api.");
        ImGui::End();
        return;
    }
    ImGui::TextDisabled("%d sink nodes.", count);
    draw_node_table("##df_sinks", nodes, "sink", runs_all, false);
    ImGui::End();
}

// ---------------------------------------------------------------------------
// Databases
// ---------------------------------------------------------------------------

void draw_databases(const std::string& /*api_url*/,
                    const std::vector<data_factory::DatabaseInfo>& dbs)
{
    if (!ImGui::Begin(TI_DATABASE " Databases")) {
        ImGui::End();
        return;
    }
    if (dbs.empty()) {
        empty_state(TI_DATABASE, "No databases registered",
                    "POST /api/datafactory/databases to register a DB.");
        ImGui::End();
        return;
    }
    if (ImGui::BeginTable("##df_databases", 6,
            ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
            ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY))
    {
        ImGui::TableSetupColumn("Label",    ImGuiTableColumnFlags_WidthStretch, 0.18f);
        ImGui::TableSetupColumn("Kind",     ImGuiTableColumnFlags_WidthStretch, 0.10f);
        ImGui::TableSetupColumn("URI",      ImGuiTableColumnFlags_WidthStretch, 0.32f);
        ImGui::TableSetupColumn("Tables",   ImGuiTableColumnFlags_WidthStretch, 0.10f);
        ImGui::TableSetupColumn("Size",     ImGuiTableColumnFlags_WidthStretch, 0.15f);
        ImGui::TableSetupColumn("Last Seen",ImGuiTableColumnFlags_WidthStretch, 0.15f);
        ImGui::TableHeadersRow();

        for (auto& d : dbs) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::TextUnformatted(d.label.empty() ? d.id.c_str() : d.label.c_str());
            ImGui::TableNextColumn();
            badge(d.kind.c_str(), BadgeVariant::Info);
            ImGui::TableNextColumn();
            ImGui::TextUnformatted(d.uri.c_str());
            ImGui::TableNextColumn();
            ImGui::Text("%lld", d.table_count);
            ImGui::TableNextColumn();
            ImGui::TextUnformatted(format_bytes(d.size_bytes).c_str());
            ImGui::TableNextColumn();
            if (d.last_seen_at.empty()) ImGui::TextDisabled("-");
            else ImGui::TextUnformatted(d.last_seen_at.c_str());
        }
        ImGui::EndTable();
    }
    ImGui::End();
}

// ---------------------------------------------------------------------------
// Health
// ---------------------------------------------------------------------------

void draw_health(const std::string& /*api_url*/,
                 const std::vector<data_factory::Run>& runs_all)
{
    if (!ImGui::Begin(TI_ACTIVITY " Health")) {
        ImGui::End();
        return;
    }
    if (runs_all.empty()) {
        empty_state(TI_ACTIVITY, "No runs yet",
                    "Trigger a node to populate health metrics.");
        ImGui::End();
        return;
    }

    const time_t now = std::time(nullptr);
    const time_t cutoff_24h = now - 86400;

    int runs_24h = 0, success_24h = 0, failed_24h = 0;
    int pending_total = 0;
    long long rows_24h = 0, kb_24h = 0;
    int success_all = 0, failed_all = 0, cancelled_all = 0;

    for (auto& r : runs_all) {
        if (r.status == "running" || r.status == "pending") pending_total++;
        if (r.status == "success")   success_all++;
        if (r.status == "failed")    failed_all++;
        if (r.status == "cancelled") cancelled_all++;

        time_t t = parse_rfc3339(r.started_at);
        if (t == 0 || t < cutoff_24h) continue;
        runs_24h++;
        rows_24h += r.rows_out;
        kb_24h   += r.kb_out;
        if (r.status == "success") success_24h++;
        if (r.status == "failed")  failed_24h++;
    }

    int terminal = success_all + failed_all + cancelled_all;
    float success_rate = (terminal > 0)
        ? (100.0f * (float)success_all / (float)terminal) : 0.0f;

    if (ImGui::BeginTable("##df_kpis", 4,
            ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchSame))
    {
        ImGui::TableNextRow();

        ImGui::TableNextColumn();
        ImGui::Text("%s Runs (24h)", TI_ACTIVITY);
        ImGui::Text("%d", runs_24h);
        ImGui::TextDisabled("success: %d", success_24h);

        ImGui::TableNextColumn();
        ImGui::Text("%s Success rate", TI_CHECK);
        ImGui::TextColored(ImVec4(0.30f, 0.85f, 0.40f, 1), "%.1f%%", success_rate);
        ImGui::TextDisabled("%d / %d terminal", success_all, terminal);

        ImGui::TableNextColumn();
        ImGui::Text("%s Failed (24h)", TI_ALERT_TRIANGLE);
        if (failed_24h > 0)
            ImGui::TextColored(ImVec4(0.95f, 0.35f, 0.30f, 1), "%d", failed_24h);
        else
            ImGui::Text("%d", failed_24h);
        ImGui::TextDisabled("pending: %d", pending_total);

        ImGui::TableNextColumn();
        ImGui::Text("%s Throughput (24h)", TI_BOLT);
        ImGui::Text("%lld rows", rows_24h);
        ImGui::TextDisabled("%lld KB", kb_24h);

        ImGui::EndTable();
    }

    ImGui::Separator();
    ImGui::TextDisabled("Computed client-side from %zu runs in cache.", runs_all.size());
    ImGui::End();
}

// ---------------------------------------------------------------------------
// Map (placeholder: flat tree by kind)
// ---------------------------------------------------------------------------

void draw_map(const std::string& /*api_url*/,
              const std::vector<data_factory::Node>& nodes)
{
    if (!ImGui::Begin(TI_LIST " Map")) {
        ImGui::End();
        return;
    }
    if (nodes.empty()) {
        empty_state(TI_LIST, "No nodes",
                    "Register nodes via sqlite_api /api/datafactory/nodes.");
        ImGui::End();
        return;
    }

    // Group by kind.
    std::map<std::string, std::vector<const data_factory::Node*>> by_kind;
    for (auto& n : nodes) by_kind[n.kind].push_back(&n);

    static const char* kind_order[] = {
        "extractor", "transformer", "database", "sink", "validator"
    };
    static const char* kind_label[] = {
        "Extractors", "Transformers", "Databases", "Sinks", "Validators"
    };
    const int n_kinds = sizeof(kind_order) / sizeof(kind_order[0]);

    for (int i = 0; i < n_kinds; i++) {
        auto it = by_kind.find(kind_order[i]);
        int count = (it != by_kind.end()) ? (int)it->second.size() : 0;
        char header[128];
        std::snprintf(header, sizeof(header), "%s (%d)###%s_hdr",
                      kind_label[i], count, kind_order[i]);
        if (!ImGui::TreeNodeEx(header, ImGuiTreeNodeFlags_DefaultOpen)) continue;
        if (count == 0) {
            ImGui::TextDisabled("  (empty)");
        } else {
            for (auto* p : it->second) {
                ImGui::PushID(p->id.c_str());
                ImGui::Bullet();
                ImGui::SameLine();
                bool sel = (selection().node_id == p->id);
                if (ImGui::Selectable(p->name.c_str(), sel)) {
                    selection().node_id = p->id;
                    if (function_cache().function_id != p->function_id) {
                        function_cache() = {};
                        function_cache().function_id = p->function_id;
                    }
                }
                ImGui::SameLine();
                if (!p->function_id.empty()) {
                    ImGui::TextDisabled("  -> %s", p->function_id.c_str());
                }
                ImGui::PopID();
            }
        }
        ImGui::TreePop();
    }

    ImGui::End();
}

// ---------------------------------------------------------------------------
// Node detail panel (side)
// ---------------------------------------------------------------------------

void draw_node_detail_panel(const std::string& api_url,
                            const std::vector<data_factory::Node>& nodes,
                            const std::vector<data_factory::Run>& runs_all,
                            bool* p_open)
{
    if (!ImGui::Begin(TI_INFO_CIRCLE " Node Detail", p_open)) {
        ImGui::End();
        return;
    }
    const std::string& nid = selection().node_id;
    if (nid.empty()) {
        empty_state(TI_INFO_CIRCLE, "Nothing selected",
                    "Click a row in any tab to inspect the node.");
        ImGui::End();
        return;
    }

    const data_factory::Node* node = nullptr;
    for (auto& n : nodes) if (n.id == nid) { node = &n; break; }
    if (!node) {
        ImGui::TextDisabled("Node not in current cache: %s", nid.c_str());
        ImGui::End();
        return;
    }

    // Header
    ImGui::Text("%s %s", TI_INFO_CIRCLE, node->name.c_str());
    ImGui::SameLine();
    badge(node->kind.c_str(), BadgeVariant::Info);
    if (!node->enabled) {
        ImGui::SameLine();
        badge("disabled", BadgeVariant::Default);
    }
    ImGui::Separator();

    if (!node->description.empty()) {
        ImGui::TextWrapped("%s", node->description.c_str());
        ImGui::Separator();
    }
    ImGui::Text("id:       %s", node->id.c_str());
    ImGui::Text("kind:     %s", node->kind.c_str());
    if (!node->function_id.empty()) {
        ImGui::Text("function: %s", node->function_id.c_str());
    }
    if (!node->schedule_cron.empty()) {
        ImGui::Text("schedule: %s", node->schedule_cron.c_str());
    }
    if (!node->tags.empty()) {
        ImGui::Text("tags:");
        for (auto& t : node->tags) {
            ImGui::SameLine();
            badge(t.c_str(), BadgeVariant::Default);
        }
    }

    // Function metadata card (lazy load)
    if (!node->function_id.empty()) {
        ImGui::Separator();
        auto& fc = function_cache();
        if (fc.function_id != node->function_id) {
            fc = {};
            fc.function_id = node->function_id;
        }
        if (!fc.loaded && fc.error.empty()) {
            if (data_factory::get_function_http(api_url, fc.function_id, fc.info)) {
                fc.loaded = true;
            } else {
                fc.error = "Failed to fetch /api/functions/" + fc.function_id;
            }
        }
        if (fc.loaded) {
            ImGui::Text("%s Registry function", TI_BOX);
            if (!fc.info.domain.empty()) {
                ImGui::SameLine();
                badge(fc.info.domain.c_str(), BadgeVariant::Info);
            }
            if (!fc.info.purity.empty()) {
                ImGui::SameLine();
                BadgeVariant v = (fc.info.purity == "pure")
                    ? BadgeVariant::Success : BadgeVariant::Warning;
                badge(fc.info.purity.c_str(), v);
            }
            if (!fc.info.lang.empty()) {
                ImGui::SameLine();
                badge(fc.info.lang.c_str(), BadgeVariant::Default);
            }
            if (!fc.info.signature.empty()) {
                ImGui::TextWrapped("sig: %s", fc.info.signature.c_str());
            }
            if (!fc.info.description.empty()) {
                ImGui::TextWrapped("%s", fc.info.description.c_str());
            }
        } else if (!fc.error.empty()) {
            ImGui::TextColored(ImVec4(0.95f, 0.4f, 0.4f, 1), "%s", fc.error.c_str());
        } else {
            ImGui::TextDisabled("Loading function metadata...");
        }
    }

    // Recent runs (top 10)
    ImGui::Separator();
    ImGui::Text("%s Recent runs", TI_HISTORY);
    int shown = 0;
    if (ImGui::BeginTable("##df_node_runs", 5,
            ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg))
    {
        ImGui::TableSetupColumn("Started",  ImGuiTableColumnFlags_WidthStretch, 0.30f);
        ImGui::TableSetupColumn("Status",   ImGuiTableColumnFlags_WidthStretch, 0.12f);
        ImGui::TableSetupColumn("Duration", ImGuiTableColumnFlags_WidthStretch, 0.13f);
        ImGui::TableSetupColumn("Rows",     ImGuiTableColumnFlags_WidthStretch, 0.10f);
        ImGui::TableSetupColumn("Trigger",  ImGuiTableColumnFlags_WidthStretch, 0.15f);
        ImGui::TableHeadersRow();

        for (auto& r : runs_all) {
            if (r.node_id != nid) continue;
            if (shown >= 10) break;
            shown++;
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::TextUnformatted(r.started_at.c_str());
            ImGui::TableNextColumn();
            badge(r.status.c_str(), variant_for_status(r.status));
            ImGui::TableNextColumn();
            ImGui::TextUnformatted(format_duration(r.duration_ms).c_str());
            ImGui::TableNextColumn();
            ImGui::Text("%lld", r.rows_out);
            ImGui::TableNextColumn();
            ImGui::TextUnformatted(r.trigger.c_str());
        }
        ImGui::EndTable();
    }
    if (shown == 0) {
        ImGui::TextDisabled("(no runs for this node yet)");
    }

    ImGui::End();
}

} // namespace data_factory_ui