// bench_runner.cpp — frame-by-frame benchmark harness for data_table::render().
// Issue 0133: perf gate for 10M-row refactor.
//
// Design: Runner::tick() is called once per fn::run_app frame.
// Each frame it renders the table for the current scenario and measures the
// frame time (wall clock from tick() entry to exit). After duration_s seconds
// it finalizes the scenario, moves to the next one, and eventually sets done_.
//
// This avoids any nested-frame or out-of-context ImGui calls — tick() runs
// inside a valid ImGui frame, after NewFrame() and before Render().

#include "bench_runner.h"
#include "data_table/data_table.h"
#include "core/logger.h"

#include <imgui.h>

#include <sqlite3.h>

#include <algorithm>
#include <chrono>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>

#ifdef __linux__
#  include <sys/resource.h>
#endif
#ifdef _WIN32
#  include <windows.h>
#  include <psapi.h>
#endif

namespace bench {

// ---------------------------------------------------------------------------
// System metrics
// ---------------------------------------------------------------------------

double measure_rss_mb() {
#ifdef __linux__
    FILE* f = fopen("/proc/self/status", "r");
    if (!f) return 0.0;
    char line[256];
    while (fgets(line, sizeof(line), f)) {
        long kb = 0;
        if (sscanf(line, "VmRSS: %ld kB", &kb) == 1) {
            fclose(f);
            return static_cast<double>(kb) / 1024.0;
        }
    }
    fclose(f);
    return 0.0;
#elif defined(_WIN32)
    PROCESS_MEMORY_COUNTERS pmc;
    if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc)))
        return static_cast<double>(pmc.WorkingSetSize) / (1024.0 * 1024.0);
    return 0.0;
#else
    return 0.0;
#endif
}

double measure_cpu_pct(double wall_s, double user_s, double sys_s) {
    if (wall_s < 1e-9) return 0.0;
    return 100.0 * (user_s + sys_s) / wall_s;
}

static void get_rusage_times(double& user_s, double& sys_s) {
#ifdef __linux__
    struct rusage ru;
    getrusage(RUSAGE_SELF, &ru);
    user_s = ru.ru_utime.tv_sec + ru.ru_utime.tv_usec * 1e-6;
    sys_s  = ru.ru_stime.tv_sec + ru.ru_stime.tv_usec * 1e-6;
#else
    user_s = 0.0; sys_s = 0.0;
#endif
}

// ---------------------------------------------------------------------------
// ScenarioState — holds TableInput + data_table::State for one scenario.
// ---------------------------------------------------------------------------

struct Runner::ScenarioState {
    data_table::TableInput ti;
    data_table::State      st;
};

// ---------------------------------------------------------------------------
// Dataset generation — deterministic, 20 columns, 5 int / 5 float / 5 str / 5 ts.
// ---------------------------------------------------------------------------

Runner::Runner(const Config& cfg) : cfg_(cfg) {
    seed_dataset();
}

void Runner::seed_dataset() {
    const long long N = cfg_.rows;
    const int       C = cfg_.cols;

    backing_.clear();
    backing_.reserve(static_cast<size_t>(N) * static_cast<size_t>(C));

    static const char* statuses[]   = {"ok", "error", "running", "pending", "blocked"};
    static const char* categories[] = {"alpha", "beta", "gamma", "delta", "epsilon"};
    static const char* tags_a[]     = {"foo", "bar", "baz", "qux", "quux"};
    static const char* labels_a[]   = {"low", "medium", "high", "critical", "unknown"};

    char buf[64];
    for (long long i = 0; i < N; ++i) {
        // 0: id (int)
        snprintf(buf, sizeof(buf), "%lld", i + 1);
        backing_.emplace_back(buf);
        // 1: count (int 0..9999)
        snprintf(buf, sizeof(buf), "%lld", (i * 7 + 3) % 10000);
        backing_.emplace_back(buf);
        // 2: score (int 0..1000)
        snprintf(buf, sizeof(buf), "%lld", (i * 131) % 1001);
        backing_.emplace_back(buf);
        // 3: rank (int 0..499)
        snprintf(buf, sizeof(buf), "%lld", (i * 17) % 500);
        backing_.emplace_back(buf);
        // 4: flags (int 0..15)
        snprintf(buf, sizeof(buf), "%lld", i & 0xF);
        backing_.emplace_back(buf);
        // 5: ratio (float 0..1)
        snprintf(buf, sizeof(buf), "%.6f", static_cast<double>(i % 10000) / 10000.0);
        backing_.emplace_back(buf);
        // 6: pct (float 0..100)
        snprintf(buf, sizeof(buf), "%.4f", static_cast<double>((i * 37) % 10001) / 100.0);
        backing_.emplace_back(buf);
        // 7: value (float 0..9999, for ColorRule p95 scenario)
        snprintf(buf, sizeof(buf), "%.2f", static_cast<double>((i * 71) % 10000));
        backing_.emplace_back(buf);
        // 8: rate (float)
        snprintf(buf, sizeof(buf), "%.4f", static_cast<double>((i * 13) % 5000) / 500.0);
        backing_.emplace_back(buf);
        // 9: weight (float)
        snprintf(buf, sizeof(buf), "%.3f", static_cast<double>((i * 29) % 1000) / 100.0);
        backing_.emplace_back(buf);
        // 10: name (string; "item_foo_N" every 7th row for filter_like)
        if (i % 7 == 0)
            snprintf(buf, sizeof(buf), "item_foo_%lld", i);
        else
            snprintf(buf, sizeof(buf), "item_%lld", i);
        backing_.emplace_back(buf);
        // 11: status
        backing_.emplace_back(statuses[i % 5]);
        // 12: category
        backing_.emplace_back(categories[(i * 3) % 5]);
        // 13: tag
        backing_.emplace_back(tags_a[(i * 5) % 5]);
        // 14: label
        backing_.emplace_back(labels_a[(i * 11) % 5]);
        // 15: created_at (int as string)
        snprintf(buf, sizeof(buf), "%lld", 1700000000LL + i * 60);
        backing_.emplace_back(buf);
        // 16: updated_at
        snprintf(buf, sizeof(buf), "%lld", 1700000000LL + i * 60 + 30);
        backing_.emplace_back(buf);
        // 17: closed_at
        snprintf(buf, sizeof(buf), "%lld", 1700000000LL + i * 60 + (i % 3 == 0 ? 120 : 0));
        backing_.emplace_back(buf);
        // 18: due_at
        snprintf(buf, sizeof(buf), "%lld", 1700000000LL + (i + 1000) * 3600);
        backing_.emplace_back(buf);
        // 19: ts
        snprintf(buf, sizeof(buf), "%lld", 1700000000LL + i);
        backing_.emplace_back(buf);
    }

    ptrs_.clear();
    ptrs_.reserve(backing_.size());
    for (const auto& s : backing_) ptrs_.push_back(s.c_str());
}

// ---------------------------------------------------------------------------
// begin_scenario — sets up TableInput + State for a scenario.
// ---------------------------------------------------------------------------

void Runner::begin_scenario(Scenario s) {
    delete sc_state_;
    sc_state_ = new ScenarioState();

    // TableInput.
    sc_state_->ti.name = "bench_data";
    sc_state_->ti.headers = {
        "id", "count", "score", "rank", "flags",
        "ratio", "pct", "value", "rate", "weight",
        "name", "status", "category", "tag", "label",
        "created_at", "updated_at", "closed_at", "due_at", "ts"
    };
    using CT = data_table::ColumnType;
    sc_state_->ti.types = {
        CT::Int,    CT::Int,    CT::Int,    CT::Int,    CT::Int,
        CT::Float,  CT::Float,  CT::Float,  CT::Float,  CT::Float,
        CT::String, CT::String, CT::String, CT::String, CT::String,
        CT::Int,    CT::Int,    CT::Int,    CT::Int,    CT::Int
    };
    sc_state_->ti.cells = ptrs_.data();
    sc_state_->ti.rows  = static_cast<int>(cfg_.rows);
    sc_state_->ti.cols  = cfg_.cols;

    // State.
    sc_state_->st = data_table::State{};
    sc_state_->st.ensure_stage0();

    switch (s) {
    case Scenario::FilterLike: {
        data_table::Filter f;
        f.col   = 10;  // name column
        f.op    = data_table::Op::Contains;
        f.value = "foo";
        sc_state_->st.raw().filters.push_back(f);
        break;
    }
    case Scenario::SortNumeric: {
        data_table::SortClause sc;
        sc.col  = "score";
        sc.desc = true;
        sc_state_->st.raw().sorts.push_back(sc);
        break;
    }
    case Scenario::ColorRule: {
        data_table::ColorRule cr;
        cr.col        = 7;  // value column
        cr.kind       = data_table::ColorRuleKind::NumericRange;
        cr.range_min  = 0.0;
        cr.range_max  = 9999.0;
        cr.range_alpha = 0.3f;
        cr.range_stops.push_back({0.0f, "#22c55e"});
        cr.range_stops.push_back({1.0f, "#ef4444"});
        sc_state_->st.color_rules.push_back(cr);
        break;
    }
    case Scenario::LinearScroll:
        break;
    }

    // Timing init.
    frame_fps_.clear();
    frame_fps_.reserve(4096);
    scroll_row_          = 0;
    scenario_wall_start_ = Clock::now();
    last_frame_start_    = Clock::now();
    get_rusage_times(user_start_, sys_start_);

    fprintf(stderr, "[bench] scenario: %s (rows=%lld duration=%.0fs)\n",
            scenario_name(s), cfg_.rows, cfg_.duration_s);
    fflush(stderr);
}

// ---------------------------------------------------------------------------
// finish_scenario — collects stats from frame_fps_ and stores result.
// ---------------------------------------------------------------------------

void Runner::finish_scenario() {
    Scenario s = kScenarios[current_scenario_];

    double user1 = 0.0, sys1 = 0.0;
    get_rusage_times(user1, sys1);
    double wall_s = std::chrono::duration<double>(
        Clock::now() - scenario_wall_start_).count();

    ScenarioResult res;
    res.scenario   = s;
    res.duration_s = wall_s;
    res.mem_rss_mb = measure_rss_mb();
    res.cpu_pct    = measure_cpu_pct(wall_s, user1 - user_start_, sys1 - sys_start_);

    if (!frame_fps_.empty()) {
        std::sort(frame_fps_.begin(), frame_fps_.end());
        size_t n    = frame_fps_.size();
        res.fps_p50 = frame_fps_[n / 2];
        size_t p1i  = n * 1 / 100;
        res.fps_p1  = frame_fps_[p1i];
    }
    res.pass = (res.fps_p1 >= cfg_.fps_threshold);

    fn_log::log_info("bench: scenario=%s frames=%zu fps_p50=%.1f fps_p1=%.1f "
                     "mem=%.1fMB cpu=%.1f%% %s",
        scenario_name(s), frame_fps_.size(),
        res.fps_p50, res.fps_p1, res.mem_rss_mb, res.cpu_pct,
        res.pass ? "PASS" : "FAIL");

    fprintf(stderr, "[bench] %s: fps_p50=%.1f fps_p1=%.1f mem=%.1fMB %s\n",
        scenario_name(s), res.fps_p50, res.fps_p1, res.mem_rss_mb,
        res.pass ? "PASS" : "FAIL");
    fflush(stderr);

    results_.push_back(res);

    delete sc_state_;
    sc_state_ = nullptr;
}

// ---------------------------------------------------------------------------
// render_table_frame — render one frame for the current scenario.
// Called inside an active ImGui frame (after NewFrame, before Render).
// ---------------------------------------------------------------------------

void Runner::render_table_frame(Scenario s) {
    if (!sc_state_) return;

    ImGui::SetNextWindowSize(ImVec2(1920, 1080), ImGuiCond_Always);
    ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
    ImGui::Begin("##bench_table", nullptr,
        ImGuiWindowFlags_NoDecoration |
        ImGuiWindowFlags_NoNav |
        ImGuiWindowFlags_NoBringToFrontOnFocus |
        ImGuiWindowFlags_NoMove |
        ImGuiWindowFlags_NoResize);

    if (s == Scenario::LinearScroll && sc_state_->ti.rows > 0) {
        float row_h = ImGui::GetTextLineHeightWithSpacing();
        ImGui::SetScrollY(static_cast<float>(scroll_row_) * row_h);
        scroll_row_ = (scroll_row_ + 1) % sc_state_->ti.rows;
    }

    data_table::render("##bench_tbl",
        {sc_state_->ti}, sc_state_->st, nullptr, false);

    ImGui::End();
}

// ---------------------------------------------------------------------------
// tick — one frame of the benchmark state machine.
// ---------------------------------------------------------------------------

bool Runner::tick() {
    if (done_) return true;

    Scenario s = kScenarios[current_scenario_];
    auto now   = Clock::now();

    // Start new scenario on first tick or after transition.
    if (!scenario_started_) {
        begin_scenario(s);
        scenario_started_ = true;
        last_frame_start_ = now;
    }

    // Measure frame time from last tick entry.
    double frame_ms = std::chrono::duration<double, std::milli>(
        now - last_frame_start_).count();
    last_frame_start_ = now;

    // Record FPS (skip the very first frame — it includes scenario setup time).
    if (frame_ms > 0.01 && results_.size() == static_cast<size_t>(current_scenario_)) {
        frame_fps_.push_back(1000.0 / frame_ms);
    }

    // Render table for this frame.
    render_table_frame(s);

    // Check if scenario duration has elapsed.
    double elapsed = std::chrono::duration<double>(
        Clock::now() - scenario_wall_start_).count();

    if (elapsed >= cfg_.duration_s) {
        finish_scenario();
        current_scenario_++;
        scenario_started_ = false;

        if (current_scenario_ >= kNumScenarios) {
            done_ = true;
            return true;
        }
    }

    return false;
}

// ---------------------------------------------------------------------------
// Accessors
// ---------------------------------------------------------------------------

bool Runner::all_passed() const {
    if (results_.empty()) return false;
    for (const auto& r : results_)
        if (!r.pass) return false;
    return true;
}

// ---------------------------------------------------------------------------
// JSON output
// ---------------------------------------------------------------------------

void Runner::print_json() const {
    printf("{\n");
    printf("  \"rows\": %lld,\n", cfg_.rows);
    printf("  \"fps_threshold\": %.1f,\n", cfg_.fps_threshold);
    printf("  \"scenarios\": [\n");
    for (size_t i = 0; i < results_.size(); ++i) {
        const auto& r = results_[i];
        printf("    {\n");
        printf("      \"scenario\": \"%s\",\n", scenario_name(r.scenario));
        printf("      \"fps_p50\": %.2f,\n",    r.fps_p50);
        printf("      \"fps_p1\": %.2f,\n",     r.fps_p1);
        printf("      \"mem_rss_mb\": %.1f,\n", r.mem_rss_mb);
        printf("      \"cpu_pct\": %.1f,\n",    r.cpu_pct);
        printf("      \"duration_s\": %.2f,\n", r.duration_s);
        printf("      \"pass\": %s\n",          r.pass ? "true" : "false");
        printf("    }%s\n", (i + 1 < results_.size()) ? "," : "");
    }
    printf("  ],\n");
    printf("  \"overall_pass\": %s\n", all_passed() ? "true" : "false");
    printf("}\n");
}

// ---------------------------------------------------------------------------
// SQLite persistence
// ---------------------------------------------------------------------------

static const char* kCreateSQL =
    "CREATE TABLE IF NOT EXISTS bench_runs ("
    "  id           TEXT PRIMARY KEY,"
    "  started_at   INTEGER NOT NULL,"
    "  rows         INTEGER NOT NULL,"
    "  scenario     TEXT NOT NULL,"
    "  fps_p50      REAL NOT NULL,"
    "  fps_p1       REAL NOT NULL,"
    "  mem_rss_mb   REAL NOT NULL,"
    "  cpu_pct      REAL NOT NULL,"
    "  duration_s   REAL NOT NULL,"
    "  commit_sha   TEXT NOT NULL DEFAULT '',"
    "  summary_json TEXT NOT NULL DEFAULT '{}'"
    ");";

void Runner::persist(const std::string& db_path) const {
    if (db_path.empty()) return;

    sqlite3* db = nullptr;
    if (sqlite3_open(db_path.c_str(), &db) != SQLITE_OK) {
        fprintf(stderr, "[bench] sqlite3_open(%s) failed: %s\n",
                db_path.c_str(), sqlite3_errmsg(db));
        if (db) sqlite3_close(db);
        return;
    }

    sqlite3_exec(db, "PRAGMA journal_mode=WAL;", nullptr, nullptr, nullptr);
    sqlite3_exec(db, kCreateSQL, nullptr, nullptr, nullptr);

    auto now_ts = static_cast<long long>(
        std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::system_clock::now().time_since_epoch()).count());

    const char* kInsert =
        "INSERT OR REPLACE INTO bench_runs "
        "(id, started_at, rows, scenario, fps_p50, fps_p1, mem_rss_mb, cpu_pct, "
        " duration_s, commit_sha, summary_json) "
        "VALUES (?,?,?,?,?,?,?,?,?,?,?);";

    for (const auto& r : results_) {
        char id_buf[128];
        snprintf(id_buf, sizeof(id_buf), "%lld_%s", now_ts, scenario_name(r.scenario));

        char json_buf[256];
        snprintf(json_buf, sizeof(json_buf),
            "{\"fps_p50\":%.2f,\"fps_p1\":%.2f,\"mem_rss_mb\":%.1f,"
            "\"cpu_pct\":%.1f,\"pass\":%s}",
            r.fps_p50, r.fps_p1, r.mem_rss_mb, r.cpu_pct,
            r.pass ? "true" : "false");

        sqlite3_stmt* stmt = nullptr;
        sqlite3_prepare_v2(db, kInsert, -1, &stmt, nullptr);
        sqlite3_bind_text  (stmt,  1, id_buf,                    -1, SQLITE_TRANSIENT);
        sqlite3_bind_int64 (stmt,  2, now_ts);
        sqlite3_bind_int64 (stmt,  3, cfg_.rows);
        sqlite3_bind_text  (stmt,  4, scenario_name(r.scenario), -1, SQLITE_STATIC);
        sqlite3_bind_double(stmt,  5, r.fps_p50);
        sqlite3_bind_double(stmt,  6, r.fps_p1);
        sqlite3_bind_double(stmt,  7, r.mem_rss_mb);
        sqlite3_bind_double(stmt,  8, r.cpu_pct);
        sqlite3_bind_double(stmt,  9, r.duration_s);
        sqlite3_bind_text  (stmt, 10, cfg_.commit_sha.c_str(),   -1, SQLITE_TRANSIENT);
        sqlite3_bind_text  (stmt, 11, json_buf,                  -1, SQLITE_TRANSIENT);
        sqlite3_step(stmt);
        sqlite3_finalize(stmt);
    }

    sqlite3_close(db);
}

} // namespace bench