/**
 * @file event-payload.js
 * @description Trims a hook payload before it is stored as `events.data`. A
 * PostToolUse payload carries whole files — Edit's `originalFile`, Read's file
 * `content`/`base64`, Write's `content` — and long command output, none of which
 * any analysis reads: the server reads only `tool_input.skill`, the event views
 * only preview. The full text stays in the session's transcript (and AgentHub's
 * snapshot of it under `<data dir>/transcripts/`), which the Conversation tab
 * reads. Kept: every field outside `tool_input`/`tool_response`, every number and
 * flag, `structuredPatch` (the +/- line counts), and each long string's head and
 * tail. Dropped fields are named in `_trimmed`, so a view can say so.
 * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
 */

// Strings inside tool_input / tool_response longer than this keep head + tail.
const STR_CAP = 8192;
const HEAD = 6000;
const TAIL = 2000;
// A payload this short cannot hold anything worth trimming, so it is not parsed.
const SKIP_UNDER = STR_CAP;

// Per tool, the tool_response fields that mirror a whole file or repeat
// tool_input. Other tools' fields (Grep's `content` is its matches) only get capped.
const EDIT_DROP = ["originalFile", "oldString", "newString"];
const DROP_RESPONSE = {
  Edit: EDIT_DROP,
  MultiEdit: EDIT_DROP,
  NotebookEdit: EDIT_DROP,
  Write: [...EDIT_DROP, "content"],
};
const DROP_RESPONSE_FILE = { Read: ["content", "base64"] };

function capString(s) {
  if (s.length <= STR_CAP) return s;
  return `${s.slice(0, HEAD)}\n…[${s.length - HEAD - TAIL} chars trimmed]…\n${s.slice(-TAIL)}`;
}

// Caps every string at any depth; `structuredPatch` is left whole.
function capDeep(v, key) {
  if (typeof v === "string") return capString(v);
  if (key === "structuredPatch" || v === null || typeof v !== "object") return v;
  if (Array.isArray(v)) return v.map((x) => capDeep(x));
  const out = {};
  for (const [k, x] of Object.entries(v)) out[k] = capDeep(x, k);
  return out;
}

/**
 * @param {object} data A parsed hook payload.
 * @returns {object} A trimmed copy (the input is not mutated).
 */
function trimHookPayload(data) {
  if (!data || typeof data !== "object" || Array.isArray(data)) return data;
  const out = { ...data };
  const dropped = new Set(Array.isArray(data._trimmed) ? data._trimmed : []);
  const res = out.tool_response;
  if (res && typeof res === "object" && !Array.isArray(res)) {
    const r = { ...res };
    for (const k of DROP_RESPONSE[data.tool_name] || []) {
      if (typeof r[k] === "string" && r[k].length > 0) {
        delete r[k];
        dropped.add(`tool_response.${k}`);
      }
    }
    const fileDrop = DROP_RESPONSE_FILE[data.tool_name];
    if (fileDrop && r.file && typeof r.file === "object") {
      const f = { ...r.file };
      for (const k of fileDrop) {
        if (typeof f[k] === "string" && f[k].length > 0) {
          delete f[k];
          dropped.add(`tool_response.file.${k}`);
        }
      }
      r.file = f;
    }
    out.tool_response = r;
  }
  if ("tool_response" in out) out.tool_response = capDeep(out.tool_response);
  if ("tool_input" in out) out.tool_input = capDeep(out.tool_input);
  if (dropped.size > 0) out._trimmed = [...dropped];
  return out;
}

/**
 * The SQL-side entry point (`trim_event_data(?)`, registered in `server/db.js`):
 * a JSON string in, a JSON string out. Short, null or unparseable input is
 * returned unchanged, and trimming is idempotent.
 * @param {string|null} json
 * @returns {string|null}
 */
function trimEventData(json) {
  if (typeof json !== "string" || json.length <= SKIP_UNDER) return json;
  let parsed;
  try {
    parsed = JSON.parse(json);
  } catch {
    return json;
  }
  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return json;
  return JSON.stringify(trimHookPayload(parsed));
}

/**
 * Trims the rows stored before trimming existed, a chunk per write transaction
 * so a hook never waits long for the lock. Idempotent: a crash just resumes from
 * the start on the next run.
 * @param {import("better-sqlite3").Database} db
 * @param {{chunk?: number}} [opts]
 * @returns {Promise<{rows: number, bytesSaved: number}>}
 */
function sweepEventPayloads(db, { chunk = 200 } = {}) {
  const select = db.prepare(
    "SELECT id, data FROM events WHERE id > ? AND length(data) > ? ORDER BY id LIMIT ?"
  );
  const update = db.prepare("UPDATE events SET data = ? WHERE id = ?");
  const out = { rows: 0, bytesSaved: 0 };
  const trimChunk = db.transaction((rows) => {
    for (const r of rows) {
      const t = trimEventData(r.data);
      if (t === r.data) continue;
      update.run(t, r.id);
      out.rows++;
      out.bytesSaved += r.data.length - t.length;
    }
  });
  let lastId = 0;
  return new Promise((resolve, reject) => {
    const step = () => {
      try {
        const rows = select.all(lastId, SKIP_UNDER, chunk);
        if (rows.length === 0) return resolve(out);
        trimChunk(rows);
        lastId = rows[rows.length - 1].id;
        setImmediate(step);
      } catch (err) {
        reject(err);
      }
    };
    step();
  });
}

module.exports = { trimHookPayload, trimEventData, sweepEventPayloads, STR_CAP };