/**
 * AI Software Factory — API load suite (TASK-0135).
 *
 * Four scenarios (the spec's k6 matrix), each a `ramping-arrival-rate` with
 * three phases — 5-min ramp 0→(its share of 1k rps), 3-min hold, 1-min ramp
 * down. Together they peak at 1,000 rps:
 *
 *   - tree-load     400 rps — GET /workspaces/:id/pages?parentId=<hub> across
 *                   200 distinct seeded hub pages (the sidebar tree load).
 *   - record-list   300 rps — POST /databases/:id/query (first table page,
 *                   50 rows) across the 5 seeded 100k-adjacent databases
 *                   (K6_DB_ID may list up to 5 comma-separated ids).
 *   - search        200 rps — POST /search across 100 distinct queries (the
 *                   seeded record titles are searchable).
 *   - record-create 100 rps — POST /databases/:id/records.
 *
 *   Note: the spec's table lists record-create as "100 vusers / ~5% of
 *   traffic"; 100 of 1000 is 10%, not 5%. We follow the explicit 1k-rps
 *   profile (400+300+200+100) and record the discrepancy here rather than
 *   guessing (the 5% reads as an approximation of the small create share).
 *
 * Endpoints (verified live against the dev API):
 *   - tree load is `GET /workspaces/:id/pages?parentId=` — the web client's
 *     `/page-tree` route is NOT in the API (pre-existing client/server drift;
 *     recorded, not fixed here — this suite is test-only).
 *   - the table view reads through `POST /databases/:id/query`
 *     (`{pageSize, cursor}`) — the web's real path (TASK-0124 repair).
 *
 * Thresholds (staging-hard, in `options.thresholds`):
 *   overall p95 < 300 ms; per-scenario p95 < 300 ms; http_req_failed < 0.1%.
 *   p99 < 800 ms is SOFT/reported (this k6 build rejects the `warn:` soft-
 *   threshold prefix, so p99 is surfaced via the summary trend stats, not a
 *   blocking threshold — see the thresholds comment in the script).
 *
 * Report-only vs hard (the CI matrix):
 *   - K6_STRICT=1 (default, staging) → thresholds are HARD: a breach makes
 *     `k6 run` exit 99, which fails the pipeline step.
 *   - K6_STRICT=0 (local + dev/PR) → every threshold is replaced with a
 *     trivially-true expression; the run never fails, but the k6 summary still
 *     PRINTS the real p95/p99/error values (uploaded as the PR artifact).
 *
 * Env:
 *   K6_API_URL        API base (default http://localhost:4000)
 *   K6_EMAIL          perf user (default demo@factory.local)
 *   K6_PASSWORD       perf password (default Factory!2345 — the seeded demo
 *                     password; the pre-TASK-0135 default was stale)
 *   K6_WORKSPACE_ID   seeded workspace (required — from seed-100k.mjs marker)
 *   K6_PAGE_IDS       comma-separated hub page ids (200 from the marker)
 *   K6_DB_ID          comma-separated database ids (up to 5 from the marker)
 *   K6_STRICT         "1" hard (default) / "0" report-only
 *
 * Run (full):  pnpm --dir tests/performance api-load
 * Run (smoke): K6_PROFILE=smoke pnpm --dir tests/performance api-load
 */
import http from "k6/http";
import { check, group } from "k6";
import { Trend, Rate } from "k6/metrics";

// ---- custom metrics (per-scenario latencies + global error rate) ----------
const treeLoadMs = new Trend("tree_load_ms", true);
const recordListMs = new Trend("record_list_ms", true);
const searchMs = new Trend("search_ms", true);
const recordCreateMs = new Trend("record_create_ms", true);
const overallMs = new Trend("overall_ms", true);
const apiErrors = new Rate("api_error_rate");

const API = __ENV.K6_API_URL || "http://localhost:4000";
const EMAIL = __ENV.K6_EMAIL || "demo@factory.local";
const PASSWORD = __ENV.K6_PASSWORD || "Factory!2345";
const STRICT = (__ENV.K6_STRICT || "1") !== "0";
const SMOKE = __ENV.K6_PROFILE === "smoke";
// K6_SKIP_SEARCH: the search scenario needs a POPULATED OpenSearch corpus. The
// seed-100k.mjs fixture inserts its 100k records via Prisma directly (no
// indexing events, no search_documents mirror), and the content index is only
// ever created by the worker (which these CI lanes do not run) — so in a CI
// lane the search endpoint has no index/corpus to query and 100% of its
// requests fail (a corpus/fixture limitation, NOT a suite defect). Search
// query perf at the 100k-doc scale is the DEDICATED perf-search job's job
// (search-search.k6.js + fixtures/search-100k.ts, which DO seed the index),
// so the CI lanes set K6_SKIP_SEARCH=1 and measure the other three scenarios
// (tree-load / record-list / record-create) at scale. Local full runs keep the
// default (search included — a live dev OpenSearch has the real corpus).
const SKIP_SEARCH = __ENV.K6_SKIP_SEARCH === "1";

// Profile (seconds). Full: 5-min ramp / 3-min hold / 1-min ramp down.
const RAMP = SMOKE ? 3 : 300;
const HOLD = SMOKE ? 5 : 180;
const RAMP_DOWN = SMOKE ? 3 : 60;
// Each scenario's peak rps (full: sums to 1000). k6 v0.57's arrival-rate
// executors need INTEGER rates (a fractional target — e.g. 0.4 — is rejected
// with "cannot unmarshal number 0.4 into … int64"), so the smoke profile uses
// small integer peaks (2/1/1/1 = 5 rps total) rather than a fractional scale.
const RPS = SMOKE
  ? { tree: 2, list: 1, search: 1, create: 1 }
  : { tree: 400, list: 300, search: 200, create: 100 };

// 100 distinct search queries — seeded record titles, hub titles, statuses.
const QUERIES = [];
for (let i = 0; i < 60; i++) QUERIES.push(`Perf Rec ${i * 7}`);
for (let i = 0; i < 30; i++) QUERIES.push(`Perf Page ${i * 3}`);
for (let i = 0; i < 10; i++) QUERIES.push(["todo", "doing", "done"][i % 3]);

// ---- per-VU auth + one-time fail-fast setup --------------------------------
// In k6, the `setup()` return (`__DATA`) is only reachable from `default()` /
// `teardown()` — NOT from scenario exec functions. So each VU resolves its own
// token on first use and caches it in a top-level `let` (k6 scopes top-level
// state per VU, so each VU authenticates exactly once and reuses the token).
// `setup()` below still does a one-time host-side validation (login works +
// required envs present) so a misconfiguration fails the run fast; its return
// is deliberately not consumed by the execs.
let _DATA = null;
function data() {
  if (!_DATA) _DATA = resolveData();
  return _DATA;
}
function resolveData() {
  let res = http.post(`${API}/api/v1/auth/login`, JSON.stringify({ email: EMAIL, password: PASSWORD }), {
    headers: { "Content-Type": "application/json" },
  });
  if (res.status !== 200) {
    res = http.post(
      `${API}/api/v1/auth/register`,
      JSON.stringify({ email: EMAIL, password: PASSWORD, name: "Perf ApiLoad" }),
      { headers: { "Content-Type": "application/json" } }
    );
    res = http.post(`${API}/api/v1/auth/login`, JSON.stringify({ email: EMAIL, password: PASSWORD }), {
      headers: { "Content-Type": "application/json" },
    });
  }
  if (res.status !== 200) throw new Error(`auth failed: ${res.status} ${res.body.slice(0, 200)}`);
  const body = res.json();
  const token = body.accessToken || body.access_token || body.token;
  if (!token) throw new Error(`no token in auth response: ${res.body.slice(0, 200)}`);

  // Resolve the workspace (env wins; otherwise the user's first one).
  let workspace = __ENV.K6_WORKSPACE_ID || "";
  if (!workspace) {
    const ws = http.get(`${API}/api/v1/workspaces`, { headers: { Authorization: `Bearer ${token}` } });
    if (ws.status !== 200) throw new Error(`workspace list failed: ${ws.status}`);
    const data = ws.json().data || [];
    if (data.length === 0) throw new Error("perf user has no workspaces — run seed-100k.mjs first");
    workspace = data[0].id;
  }

  const pageIds = (__ENV.K6_PAGE_IDS || "").split(",").filter(Boolean);
  const dbIds = (__ENV.K6_DB_ID || "").split(",").filter(Boolean);
  if (pageIds.length === 0) {
    throw new Error("K6_PAGE_IDS is empty — run `node tests/performance/seed-100k.mjs` and export its pageIds (200 hub ids).");
  }
  if (dbIds.length === 0) {
    throw new Error("K6_DB_ID is empty — run `node tests/performance/seed-100k.mjs` and export its databaseIds.");
  }
  return { token, workspace, pageIds, dbIds };
}
export function setup() {
  // One-time host-side validation (fail-fast): the API is reachable, the perf
  // user can log in, and the required envs are present. Its return is not used
  // by the execs (see the per-VU data() note above) — it only surfaces a
  // misconfigured environment before the load starts.
  resolveData();
  return { ok: true };
}

function headers(token) {
  return { "Content-Type": "application/json", Authorization: `Bearer ${token}` };
}

function record(trend, res) {
  trend.add(res.timings.duration);
  overallMs.add(res.timings.duration);
  // Static check labels — k6's goja engine rejects computed (non-literal)
  // object keys inside check(). Per-scenario latency is carried by the Trend
  // metrics above; the checks guard status + body only.
  const ok = check(res, {
    "[api-load] status 2xx": (r) => r.status >= 200 && r.status < 300,
    "[api-load] has body": (r) => r.body.length > 0,
  });
  apiErrors.add(!ok);
  return res;
}

// ---- scenario execs (one per spec scenario) --------------------------------
export function treeLoad() {
  const d = data();
  const parentId = d.pageIds[__ITER % d.pageIds.length];
  const res = http.get(
    `${API}/api/v1/workspaces/${d.workspace}/pages?parentId=${encodeURIComponent(parentId)}&limit=100`,
    { headers: headers(d.token) }
  );
  record(treeLoadMs, res);
}

export function recordList() {
  const d = data();
  const dbId = d.dbIds[__ITER % d.dbIds.length];
  const res = http.post(`${API}/api/v1/databases/${dbId}/query`, JSON.stringify({ pageSize: 50 }), {
    headers: headers(d.token),
  });
  record(recordListMs, res);
}

export function search() {
  const d = data();
  const q = QUERIES[__ITER % QUERIES.length];
  const res = http.post(`${API}/api/v1/search`, JSON.stringify({ q, limit: 20 }), {
    headers: headers(d.token),
  });
  record(searchMs, res);
}

export function recordCreate() {
  const d = data();
  const dbId = d.dbIds[__ITER % d.dbIds.length];
  const res = http.post(
    `${API}/api/v1/databases/${dbId}/records`,
    JSON.stringify({ title: `Perf ApiLoad ${__VU}-${__ITER}` }),
    { headers: headers(d.token) }
  );
  record(recordCreateMs, res);
}

// ---- thresholds -------------------------------------------------------------
// Blocking (staging-hard) thresholds: overall + per-scenario p95 < 300 ms and
// error rate < 0.1%. A breach makes `k6 run` exit non-zero (k6 exit code 99),
// which fails the pipeline step.
//
// The spec's "p99 < 800 ms (soft, reported)" is implemented as REPORTED, not
// blocking: this k6 build (v0.57.0, the CI pin) rejects the `warn:` soft-
// threshold prefix (its expression parser fails on any method after `warn:` —
// verified), so a soft p99 cannot be a threshold expression here. Instead p99
// is surfaced via `summaryTrendStats` (the run summary + uploaded artifact
// always print p(99) of `http_req_duration` / `overall_ms`). A p99 breach
// without a p95 breach is a warning a human reads, not an automatic block —
// exactly the "soft, reported" semantics.
const HARD_THRESHOLDS = {
  http_req_duration: ["p(95)<300"],
  tree_load_ms: ["p(95)<300"],
  record_list_ms: ["p(95)<300"],
  search_ms: ["p(95)<300"],
  record_create_ms: ["p(95)<300"],
  overall_ms: ["p(95)<300"],
  http_req_failed: ["rate<0.001"],
  api_error_rate: ["rate<0.001"],
};
// Report-only (K6_STRICT=0, local + dev/PR): trivially-true so the run never
// fails (k6 still prints the real p95/p99/error values for the PR artifact).
const SOFT_THRESHOLDS = {
  http_req_duration: ["avg<1e15"],
  tree_load_ms: ["avg<1e15"],
  record_list_ms: ["avg<1e15"],
  search_ms: ["avg<1e15"],
  record_create_ms: ["avg<1e15"],
  overall_ms: ["avg<1e15"],
  // k6 Rate thresholds are a FRACTION (0..1), so `rate<=1` (not `<1`) is the
  // always-pass bound — a true 100% failure rate (e.g. the search endpoint
  // down for the whole run) is exactly 1.0, which would fail `rate<1` and
  // red the report-only tier. `<=` keeps the dev/main lane green while the
  // real values still print.
  http_req_failed: ["rate<=1"],
  api_error_rate: ["rate<=1"],
};

// k6 v0.57's `ramping-arrival-rate` takes `startRate` + `stages` (it rejects
// `duration`/`phases`/`targetRate` — probed; the CI comment records the same
// goja/shape traps). A stage whose `target` equals the running rate is a
// hold, so each spec scenario = ONE ramping-arrival-rate with three stages:
//   [0→peak over RAMP] [peak held HOLD] [peak→0 over RAMP_DOWN]
const MAX_VUS = SMOKE ? 50 : 2000; // fleet-wide ceiling for the 1k-rps peak
// When K6_SKIP_SEARCH=1 (the CI lanes — see the note above) the search
// scenario is dropped from the run. The thresholds still list search_ms: a
// threshold on a metric with ZERO samples passes vacuously in k6 v0.57 (empty
// Trend = 0), so no threshold change is needed — the summary just omits it.
const scenarioList = [
  ["tree-load", RPS.tree, "treeLoad"],
  ["record-list", RPS.list, "recordList"],
  ["record-create", RPS.create, "recordCreate"],
];
if (!SKIP_SEARCH) scenarioList.splice(2, 0, ["search", RPS.search, "search"]);

const scenarios = {};
for (const [name, peak, exec] of scenarioList) {
  scenarios[name] = {
    executor: "ramping-arrival-rate",
    startTime: "0s",
    startRate: 0,
    preAllocatedVUs: SMOKE ? 5 : 100,
    maxVUs: MAX_VUS,
    stages: [
      { duration: `${RAMP}s`, target: peak },
      { duration: `${HOLD}s`, target: peak },
      { duration: `${RAMP_DOWN}s`, target: 0 },
    ],
    exec,
  };
}

export const options = {
  scenarios,
  thresholds: STRICT ? HARD_THRESHOLDS : SOFT_THRESHOLDS,
  summaryTrendStats: ["avg", "min", "med", "p(90)", "p(95)", "p(99)", "max"],
};