// Diagnostic stability bundle tests cover stable diagnostic bundle generation.
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { emitDiagnosticEvent, resetDiagnosticEventsForTest } from "../infra/diagnostic-events.js";
import { registerFatalErrorHook, runFatalErrorHooks } from "../infra/fatal-error-hooks.js";
import {
  installDiagnosticStabilityFatalHook,
  MAX_DIAGNOSTIC_STABILITY_BUNDLE_BYTES,
  readDiagnosticStabilityBundleFileSync,
  readLatestDiagnosticStabilityBundleSync,
  uninstallDiagnosticStabilityFatalHook,
  writeDiagnosticStabilityBundleForFailureSync,
  writeDiagnosticStabilityBundleSync,
  type DiagnosticStabilityBundle,
} from "./diagnostic-stability-bundle.js";
import {
  resetDiagnosticStabilityRecorderForTest,
  startDiagnosticStabilityRecorder,
  stopDiagnosticStabilityRecorder,
} from "./diagnostic-stability.js";

describe("diagnostic stability bundles", () => {
  let tempDir: string;

  function resetStabilityBundleTestState(): void {
    resetDiagnosticEventsForTest();
    resetDiagnosticStabilityRecorderForTest();
    uninstallDiagnosticStabilityFatalHook();
  }

  beforeEach(() => {
    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-stability-bundle-"));
    resetStabilityBundleTestState();
  });

  afterEach(() => {
    stopDiagnosticStabilityRecorder();
    resetStabilityBundleTestState();
    fs.rmSync(tempDir, { recursive: true, force: true });
  });

  function readBundle(file: string): DiagnosticStabilityBundle {
    return JSON.parse(fs.readFileSync(file, "utf8")) as DiagnosticStabilityBundle;
  }

  function createImportedBundle(): Record<string, unknown> {
    return {
      version: 1,
      generatedAt: "2026-04-22T12:00:00.000Z",
      reason: "gateway.restart_startup_failed",
      process: {
        pid: 123,
        platform: "darwin",
        arch: "arm64",
        node: "24.14.1",
        uptimeMs: 1000,
      },
      host: {
        hostname: "<redacted-hostname>",
      },
      snapshot: {
        generatedAt: "2026-04-22T12:00:00.000Z",
        capacity: 1000,
        count: 1,
        dropped: 0,
        events: [{ seq: 1, ts: 1, type: "webhook.received" }],
        summary: { byType: { "webhook.received": 1 } },
      },
    };
  }

  it("writes a payload-free bundle with safe failure metadata", () => {
    startDiagnosticStabilityRecorder();
    emitDiagnosticEvent({
      type: "webhook.error",
      channel: "telegram",
      chatId: "chat-secret",
      error: "raw diagnostic error with message body",
    });
    emitDiagnosticEvent({
      type: "payload.large",
      surface: "gateway.http.json",
      action: "rejected",
      bytes: 2048,
      limitBytes: 1024,
      reason: "json_body_limit",
    });

    const secret = "sk-1234567890abcdef";
    const error = Object.assign(
      new Error(
        `Startup failed: OPENAI_API_KEY=${secret} while opening google/web-search-contract-api.js`,
      ),
      { code: "ERR_TEST" },
    );
    const result = writeDiagnosticStabilityBundleSync({
      reason: "gateway.restart_startup_failed",
      error,
      stateDir: tempDir,
      now: new Date("2026-04-22T12:00:00.000Z"),
    });

    expect(result.status).toBe("written");
    const file = result.status === "written" ? result.path : "";
    const bundle = readBundle(file);
    const raw = fs.readFileSync(file, "utf8");

    expect(bundle.version).toBe(1);
    expect(bundle.generatedAt).toBe("2026-04-22T12:00:00.000Z");
    expect(bundle.reason).toBe("gateway.restart_startup_failed");
    expect(bundle.error?.name).toBe("Error");
    expect(bundle.error?.code).toBe("ERR_TEST");
    expect(bundle.host.hostname).toBe("<redacted-hostname>");
    expect(bundle.snapshot.count).toBe(2);
    expect(bundle.snapshot.events[0]?.type).toBe("webhook.error");
    expect(bundle.snapshot.events[0]?.channel).toBe("telegram");
    expect(bundle.snapshot.events[0]).not.toHaveProperty("chatId");
    expect(bundle.snapshot.events[0]).not.toHaveProperty("error");
    expect(bundle.error?.message).toContain("google/web-search-contract-api.js");
    expect(bundle.error?.message).not.toContain(secret);
    expect(raw).not.toContain("chat-secret");
    expect(raw).not.toContain("message body");
    expect(raw).not.toContain(secret);
    expect(raw).not.toContain(os.hostname());
  });

  it("skips empty recorder snapshots by default", () => {
    const result = writeDiagnosticStabilityBundleSync({
      reason: "uncaught_exception",
      stateDir: tempDir,
    });

    expect(result).toEqual({ status: "skipped", reason: "empty" });
    expect(fs.existsSync(path.join(tempDir, "logs", "stability"))).toBe(false);
  });

  it("writes failure bundles even when the recorder snapshot is empty", () => {
    const result = writeDiagnosticStabilityBundleForFailureSync(
      "gateway.restart_startup_failed",
      Object.assign(new Error("raw startup config payload"), { code: "ERR_CONFIG_PARSE" }),
      {
        stateDir: tempDir,
        now: new Date("2026-04-22T12:00:00.000Z"),
      },
    );

    if (result.status !== "written") {
      throw new Error(`expected written bundle, got ${result.status}`);
    }
    const bundle = readBundle(result.path);
    const raw = fs.readFileSync(result.path, "utf8");
    expect(bundle.reason).toBe("gateway.restart_startup_failed");
    expect(bundle.error).toEqual({
      name: "Error",
      code: "ERR_CONFIG_PARSE",
      message: "raw startup config payload",
    });
    expect(bundle.snapshot.count).toBe(0);
    expect(bundle.snapshot.events).toEqual([]);
    expect(raw).not.toContain("stack");
  });

  it("keeps bounded failure messages UTF-16 safe", () => {
    const prefix = "a".repeat(499);
    const result = writeDiagnosticStabilityBundleForFailureSync(
      "gateway.restart_startup_failed",
      new Error(`${prefix}😀${"b".repeat(500)}`),
      { stateDir: tempDir },
    );

    expect(result.status).toBe("written");
    if (result.status !== "written") {
      return;
    }
    expect(readBundle(result.path).error?.message).toBe(`${prefix}...`);
  });

  it("preserves redacted shutdown causes and stacks through bundle readback", () => {
    const secret = "sk-1234567890abcdef";
    const cause = new TypeError(`fixture close failed: OPENAI_API_KEY=${secret}`);
    cause.stack = `${cause.name}: ${cause.message}\n    at closeOwner (fixture.js:12:3)`;
    const stepError = new Error("shutdown step failed (gateway lifetime sidecars)", { cause });
    const error = new AggregateError([stepError], "Gateway shutdown did not complete cleanly");
    const result = writeDiagnosticStabilityBundleForFailureSync(
      "gateway.restart_close_failed",
      error,
      {
        stateDir: tempDir,
        shutdownStep: "gateway-server-close",
      },
    );
    if (result.status !== "written") {
      throw new Error(`expected written bundle, got ${result.status}`);
    }
    const readback = readDiagnosticStabilityBundleFileSync(result.path);
    expect(readback.status).toBe("found");
    if (readback.status !== "found") {
      return;
    }
    expect(readback.bundle.evidence?.shutdown).toMatchObject({
      step: "gateway-server-close",
      errors: [
        { name: "AggregateError", message: "Gateway shutdown did not complete cleanly" },
        { name: "Error", message: "shutdown step failed (gateway lifetime sidecars)" },
        {
          name: "TypeError",
          message: expect.stringContaining("fixture close failed"),
          stack: expect.stringContaining("at closeOwner (fixture.js:12:3)"),
        },
      ],
    });
    expect(fs.readFileSync(result.path, "utf8")).not.toContain(secret);
    expect(JSON.stringify(readback.bundle)).not.toContain(secret);
  });

  it("bounds cyclic shutdown error graphs and stack text without losing non-Error throws", () => {
    const error = new AggregateError(
      Array.from({ length: 100 }, (_, index) => new Error(`failure ${index}`)),
      "shutdown failures",
    );
    error.cause = error;
    error.stack = "a".repeat(7_999) + "😀" + "b".repeat(1_000);
    const result = writeDiagnosticStabilityBundleSync({
      reason: "gateway.stop_close_failed",
      error,
      shutdownStep: "gateway-server-close",
      stateDir: tempDir,
      includeEmpty: true,
    });
    expect(result.status).toBe("written");
    if (result.status !== "written") {
      return;
    }
    expect(result.bundle.evidence?.shutdown?.errors.length).toBeLessThanOrEqual(32);
    expect(result.bundle.evidence?.shutdown?.errors[0]?.stack).toBe("a".repeat(7_999));
    const nonError = writeDiagnosticStabilityBundleSync({
      reason: "gateway.stop_close_failed",
      error: "fixture string failure",
      shutdownStep: "startup-operations",
      stateDir: tempDir,
      includeEmpty: true,
    });
    expect(nonError.status === "written" && nonError.bundle.evidence?.shutdown).toEqual({
      step: "startup-operations",
      errors: [{ message: "fixture string failure" }],
    });
  });

  it("registers a fatal hook only while installed", () => {
    startDiagnosticStabilityRecorder();
    emitDiagnosticEvent({ type: "webhook.received", channel: "telegram" });
    installDiagnosticStabilityFatalHook({ stateDir: tempDir });

    const messages = runFatalErrorHooks({
      reason: "fatal_unhandled_rejection",
      error: Object.assign(new Error("raw text"), { code: "ERR_OUT_OF_MEMORY" }),
    });

    expect(messages).toHaveLength(1);
    expect(messages[0]).toContain("wrote stability bundle:");
    expect(messages[0]).toContain(tempDir);

    uninstallDiagnosticStabilityFatalHook();
    expect(runFatalErrorHooks({ reason: "uncaught_exception" })).toStrictEqual([]);

    const unsubscribeIndependent = registerFatalErrorHook(() => "independent diagnostic");
    try {
      const reinstalledDir = path.join(tempDir, "reinstalled");
      installDiagnosticStabilityFatalHook({ stateDir: reinstalledDir });
      const reinstalledMessages = runFatalErrorHooks({ reason: "uncaught_exception" });
      expect(reinstalledMessages).toHaveLength(2);
      expect(reinstalledMessages[0]).toBe("independent diagnostic");
      expect(reinstalledMessages[1]).toContain("wrote stability bundle:");
      expect(reinstalledMessages[1]).toContain(reinstalledDir);

      uninstallDiagnosticStabilityFatalHook();
      expect(runFatalErrorHooks({ reason: "uncaught_exception" })).toEqual([
        "independent diagnostic",
      ]);
      uninstallDiagnosticStabilityFatalHook();
      expect(runFatalErrorHooks({ reason: "uncaught_exception" })).toEqual([
        "independent diagnostic",
      ]);
    } finally {
      uninstallDiagnosticStabilityFatalHook();
      unsubscribeIndependent();
    }
  });

  it("retains only the newest bundle files", () => {
    startDiagnosticStabilityRecorder();
    emitDiagnosticEvent({ type: "webhook.received", channel: "telegram" });

    for (let index = 0; index < 4; index += 1) {
      const result = writeDiagnosticStabilityBundleSync({
        reason: "gateway.restart_respawn_failed",
        stateDir: tempDir,
        now: new Date(`2026-04-22T12:00:0${index}.000Z`),
        retention: 2,
      });
      expect(result.status).toBe("written");
    }

    const bundleDir = path.join(tempDir, "logs", "stability");
    const files = fs.readdirSync(bundleDir).toSorted();
    expect(files).toHaveLength(2);
    expect(files[0]).toContain("12-00-02");
    expect(files[1]).toContain("12-00-03");
  });

  it.each([1, 2])(
    "keeps the published bundle within retention %i despite future mtimes",
    (retention) => {
      for (let index = 0; index < retention; index++) {
        const older = writeDiagnosticStabilityBundleForFailureSync(
          "gateway.startup_failed",
          undefined,
          {
            stateDir: tempDir,
            retention,
            now: new Date(Date.UTC(2026, 3, 22, 12, 0, index)),
          },
        );
        expect(older.status).toBe("written");
        if (older.status !== "written") {
          throw new Error("Fixture publication failed");
        }
        const future = new Date(Date.UTC(2036, 3, 22, 12, 0, index));
        fs.utimesSync(older.path, future, future);
      }

      const current = writeDiagnosticStabilityBundleForFailureSync(
        "gateway.restart_respawn_failed",
        undefined,
        {
          stateDir: tempDir,
          retention,
          now: new Date("2026-04-22T12:01:00.000Z"),
        },
      );
      expect(current.status).toBe("written");
      if (current.status !== "written") {
        throw new Error("Current publication failed");
      }
      expect(current.message).toContain(current.path);
      expect(fs.existsSync(current.path)).toBe(true);
      expect(readDiagnosticStabilityBundleFileSync(current.path).status).toBe("found");
      expect(fs.readdirSync(path.dirname(current.path))).toHaveLength(retention);
    },
  );

  it("reads the newest retained bundle", () => {
    startDiagnosticStabilityRecorder();
    emitDiagnosticEvent({ type: "webhook.received", channel: "telegram" });

    const older = writeDiagnosticStabilityBundleSync({
      reason: "gateway.restart_startup_failed",
      stateDir: tempDir,
      now: new Date("2026-04-22T12:00:00.000Z"),
    });
    const newer = writeDiagnosticStabilityBundleSync({
      reason: "gateway.restart_respawn_failed",
      stateDir: tempDir,
      now: new Date("2026-04-22T12:00:01.000Z"),
    });

    expect(older.status).toBe("written");
    expect(newer.status).toBe("written");

    const latest = readLatestDiagnosticStabilityBundleSync({ stateDir: tempDir });

    expect(latest.status).toBe("found");
    expect(latest.status === "found" ? latest.path : "").toContain("12-00-01");
    expect(latest.status === "found" ? latest.bundle.reason : "").toBe(
      "gateway.restart_respawn_failed",
    );
  });

  it("sanitizes imported bundles before returning them", () => {
    const file = path.join(tempDir, "imported.json");
    const bundle = createImportedBundle();
    const retainedRuntimeEvidence = {
      heapStatistics: { heapSizeLimitBytes: 8192, usedHeapSizeBytes: 1536 },
      heapSpaces: [
        {
          spaceName: "old_space",
          spaceSizeBytes: 2048,
          spaceUsedBytes: 1536,
          spaceAvailableBytes: 512,
          physicalSpaceSizeBytes: 2048,
        },
      ],
      cgroup: {
        version: "v2",
        values: { current: 4096, max: "max" },
        events: { high: 2, "events.local.oom": 1 },
      },
      activeResources: { total: 3, byType: { Timeout: 2, PipeWrap: 1 } },
    };
    Object.assign(bundle, {
      reason: "private reason token=secret",
      privateTopLevel: "top-level-secret",
      evidence: {
        memoryPressure: {
          ...retainedRuntimeEvidence,
          heapStatistics: {
            ...retainedRuntimeEvidence.heapStatistics,
            totalHeapSizeBytes: 1536.75,
          },
          level: "critical",
          reason: "rss_threshold",
          thresholdBytes: 0,
          rssGrowthBytes: -1,
          windowMs: 0.5,
          memory: {
            rssBytes: 4096,
            heapTotalBytes: 2048,
            heapUsedBytes: 1536,
            externalBytes: 128,
            arrayBuffersBytes: 64,
          },
          topSessionFiles: [
            {
              relativePath: "agents/main/sessions/raw-secret-session.jsonl",
              sizeBytes: 4096,
              mtimeMs: 1,
            },
          ],
        },
      },
      error: {
        name: "private error name",
        code: "ERR_TEST",
        message: "OPENAI_API_KEY=sk-1234567890abcdef",
      },
    });
    Object.assign(bundle.process as Record<string, unknown>, {
      command: "process-command-secret",
    });
    Object.assign(bundle.host as Record<string, unknown>, {
      hostname: "private-hostname",
      fqdn: "host-extra-secret",
    });
    const snapshot = bundle.snapshot as Record<string, unknown>;
    Object.assign(snapshot, {
      count: 3,
      privateSnapshot: "snapshot-secret",
      events: [
        {
          seq: 1,
          ts: 1,
          type: "webhook.error",
          channel: "telegram",
          reason: "private event reason",
          chatId: "chat-id-secret",
          error: "event-error-secret",
        },
        {
          seq: 2,
          ts: 2,
          type: "exec.approval.followup_suppressed",
          approvalId: "approval-imported-123",
          reason: "session_rebound",
          phase: "gateway_preflight",
          command: "raw command secret",
        },
        {
          seq: 3,
          ts: 3,
          type: "model.usage",
          costUsd: 0,
          durationMs: 0,
          usage: {},
          context: {},
        },
      ],
      summary: {
        byType: {
          "webhook.error": 1,
          "exec.approval.followup_suppressed": 1,
          "model.usage": 1,
          "private summary type": 1,
        },
        privateSummary: "summary-secret",
      },
    });
    fs.writeFileSync(file, `${JSON.stringify(bundle, null, 2)}\n`, "utf8");

    const result = readDiagnosticStabilityBundleFileSync(file);

    expect(result.status).toBe("found");
    if (result.status !== "found") {
      return;
    }
    expect(result.bundle.reason).toBe("unknown");
    expect(result.bundle.host).toEqual({ hostname: "<redacted-hostname>" });
    expect(result.bundle.error?.code).toBe("ERR_TEST");
    expect(result.bundle.error?.message).toContain("OPENAI_API_KEY=");
    expect(result.bundle.error?.message).not.toContain("sk-1234567890abcdef");
    expect(result.bundle.evidence?.memoryPressure?.topSessionFiles?.[0]?.relativePath).toBe(
      "agents/<agent>/sessions/<session>.jsonl",
    );
    expect(result.bundle.evidence?.memoryPressure).toMatchObject(retainedRuntimeEvidence);
    expect(result.bundle.evidence?.memoryPressure).toMatchObject({
      thresholdBytes: 0,
      rssGrowthBytes: -1,
      windowMs: 0.5,
      heapStatistics: { totalHeapSizeBytes: 1536 },
    });
    expect(Object.keys(result.bundle.evidence?.memoryPressure?.heapStatistics ?? {})).toEqual([
      "totalHeapSizeBytes",
      "usedHeapSizeBytes",
      "heapSizeLimitBytes",
    ]);
    expect(result.bundle.snapshot.events[0]).toEqual({
      seq: 1,
      ts: 1,
      type: "webhook.error",
      channel: "telegram",
    });
    expect(result.bundle.snapshot.events[1]).toEqual({
      seq: 2,
      ts: 2,
      type: "exec.approval.followup_suppressed",
      approvalId: "approval-imported-123",
      reason: "session_rebound",
      phase: "gateway_preflight",
    });
    expect(JSON.stringify(result.bundle.snapshot.events[2])).toBe(
      JSON.stringify({
        seq: 3,
        ts: 3,
        type: "model.usage",
        durationMs: 0,
        costUsd: 0,
        usage: {},
        context: {},
      }),
    );
    expect(result.bundle.snapshot.summary.byType).toEqual({
      "webhook.error": 1,
      "exec.approval.followup_suppressed": 1,
      "model.usage": 1,
    });
    const sanitized = JSON.stringify(result.bundle);
    for (const secret of [
      "private reason",
      "top-level-secret",
      "private error name",
      "sk-1234567890abcdef",
      "process-command-secret",
      "private-hostname",
      "host-extra-secret",
      "snapshot-secret",
      "private event reason",
      "raw-secret-session",
      "chat-id-secret",
      "event-error-secret",
      "raw command secret",
      "private summary type",
      "summary-secret",
    ]) {
      expect(sanitized).not.toContain(secret);
    }
  });

  it("rejects malformed bundle files", () => {
    const file = path.join(tempDir, "invalid.json");
    fs.writeFileSync(file, "{}\n", "utf8");

    const result = readDiagnosticStabilityBundleFileSync(file);

    expect(result.status).toBe("failed");
    expect(result.status === "failed" ? String(result.error) : "").toContain(
      "Unsupported stability bundle version",
    );
  });

  it("rejects oversized bundle files before reading them", () => {
    const file = path.join(tempDir, "oversized.json");
    fs.closeSync(fs.openSync(file, "w"));
    fs.truncateSync(file, MAX_DIAGNOSTIC_STABILITY_BUNDLE_BYTES + 1);

    const result = readDiagnosticStabilityBundleFileSync(file);

    expect(result.status).toBe("failed");
    expect(result.status === "failed" ? String(result.error) : "").toContain(
      "Stability bundle is too large",
    );
  });

  it("rejects malformed bundle snapshots before returning them", () => {
    const baseBundle = createImportedBundle();
    const baseSnapshot = baseBundle.snapshot as Record<string, unknown>;
    const cases = [
      {
        name: "malformed-event",
        bundle: {
          ...baseBundle,
          snapshot: {
            ...baseSnapshot,
            events: [{ type: "webhook.received", ts: 1 }],
          },
        },
        error: "snapshot.events[0].seq",
      },
      {
        name: "out-of-range-event-timestamp",
        bundle: {
          ...baseBundle,
          snapshot: {
            ...baseSnapshot,
            events: [{ seq: 1, ts: 9e15, type: "webhook.received" }],
          },
        },
        error: "snapshot.events[0].ts",
      },
      {
        name: "null-summary",
        bundle: {
          ...baseBundle,
          snapshot: {
            ...baseSnapshot,
            summary: null,
          },
        },
        error: "snapshot.summary",
      },
      {
        name: "optional-code-before-number",
        bundle: {
          ...baseBundle,
          snapshot: {
            ...baseSnapshot,
            events: [{ seq: 1, ts: 1, type: "model.usage", channel: null, durationMs: null }],
          },
        },
        error: "snapshot.events[0].channel",
      },
      {
        name: "optional-usage-before-context",
        bundle: {
          ...baseBundle,
          snapshot: {
            ...baseSnapshot,
            events: [
              { seq: 1, ts: 1, type: "model.usage", usage: { input: null }, context: false },
            ],
          },
        },
        error: "snapshot.events[0].usage.input",
      },
      {
        name: "heap-statistics-before-required-memory",
        bundle: {
          ...baseBundle,
          evidence: {
            memoryPressure: {
              level: "critical",
              reason: "rss_threshold",
              heapStatistics: { totalHeapSizeBytes: null },
              memory: null,
            },
          },
        },
        error: "evidence.memoryPressure.heapStatistics.totalHeapSizeBytes",
      },
    ];

    for (const testCase of cases) {
      const file = path.join(tempDir, `${testCase.name}.json`);
      fs.writeFileSync(file, `${JSON.stringify(testCase.bundle, null, 2)}\n`, "utf8");

      const result = readDiagnosticStabilityBundleFileSync(file);

      expect(result.status).toBe("failed");
      expect(result.status === "failed" ? String(result.error) : "").toContain(testCase.error);
    }
  });
});