/**
 * KHAELOR
 * File: tests/session/fixtures.ts
 * Description: Test fixtures — one realistic sample for every durable and ephemeral event type.
 *
 * Author: Simon-Pierre Boucher
 * Contact: contact@spboucher.ai
 */

import { EVENT_SCHEMA_VERSION } from "../../src/session/events.js";
import type {
  DurableEvent,
  DurableEventInput,
  EphemeralEvent,
  EphemeralEventInput,
} from "../../src/session/events.js";
import { ulid } from "../../src/shared/index.js";

export const SESSION_ID = "01TESTSESSION0000000000000";

export function envelope<T extends DurableEventInput>(seq: number, input: T): DurableEvent {
  return {
    v: EVENT_SCHEMA_VERSION,
    id: ulid(),
    sessionId: SESSION_ID,
    seq,
    ts: 1_700_000_000_000 + seq,
    type: input.type,
    payload: input.payload,
  } as DurableEvent;
}

export function ephemeralEnvelope<T extends EphemeralEventInput>(input: T): EphemeralEvent {
  return {
    id: ulid(),
    sessionId: SESSION_ID,
    ts: 1_700_000_000_000,
    type: input.type,
    payload: input.payload,
  } as EphemeralEvent;
}

/** One input per durable event type — 32 total, matching DURABLE_EVENT_TYPES. */
export function sampleDurableInputs(): DurableEventInput[] {
  return [
    {
      type: "session.started",
      payload: {
        title: "Fix the session store",
        projectHash: "abc123",
        workingDirectory: "/home/user/project",
        gitBranch: "main",
        model: "claude-sonnet-4-5",
        auxModel: "claude-haiku-4-5",
        khaelorVersion: "0.1.0",
      },
    },
    {
      type: "session.resumed",
      payload: {
        khaelorVersion: "0.1.0",
        replayedSeq: 42,
        model: "claude-sonnet-4-5",
        toolNames: ["read", "write", "edit", "grep", "glob", "bash", "process"],
      },
    },
    { type: "session.renamed", payload: { title: "New title" } },
    {
      type: "session.model-changed",
      payload: { from: "claude-sonnet-4-5", to: "claude-opus-4-6", reason: "user" },
    },
    {
      type: "git.baseline-recorded",
      payload: {
        when: "session-start",
        baseline: {
          branch: "main",
          dirtyFiles: ["src/a.ts"],
          untrackedFiles: ["notes.txt"],
          diffHash: "deadbeef",
        },
      },
    },
    {
      type: "user.message-created",
      payload: {
        text: "Fix the bug in @src/store.ts",
        mentions: [{ path: "src/store.ts", range: { start: 10, end: 20 } }],
      },
    },
    { type: "user.steering-queued", payload: { text: "Also add tests" } },
    {
      type: "user.steering-injected",
      payload: { queuedEventId: "01QUEUED000000000000000000", seam: "post-tool-batch", afterSeq: 7 },
    },
    { type: "user.interrupted", payload: { scope: "turn", pendingToolUseIds: ["toolu_1"] } },
    {
      type: "model.request-started",
      payload: {
        requestId: "req_1",
        model: "claude-sonnet-4-5",
        purpose: "main",
        contextStats: {
          estimatedInputTokens: 1234,
          sections: [{ name: "system", estimatedTokens: 400 }],
        },
      },
    },
    {
      type: "model.text-block-completed",
      payload: { requestId: "req_1", blockIndex: 1, text: "I found the bug." },
    },
    {
      type: "model.thinking-block-completed",
      payload: { requestId: "req_1", blockIndex: 0, thinking: "Let me check…", signature: "sig_abc" },
    },
    {
      type: "tool.requested",
      payload: {
        requestId: "req_1",
        blockIndex: 2,
        toolUseId: "toolu_1",
        toolName: "read",
        input: { path: "src/store.ts" },
      },
    },
    {
      type: "model.response-completed",
      payload: {
        requestId: "req_1",
        stopReason: "tool_use",
        usage: { inputTokens: 100, outputTokens: 50, cacheReadTokens: 80, cacheWriteTokens: 20 },
        durationMs: 1500,
      },
    },
    {
      type: "model.request-failed",
      payload: {
        requestId: "req_2",
        kind: "retryable",
        message: "overloaded",
        status: 529,
        retriesExhausted: false,
      },
    },
    {
      type: "permission.requested",
      payload: {
        permissionRequestId: "perm_1",
        toolUseId: "toolu_2",
        capability: "process.execute",
        descriptor: "Run `npm install` in ~/project",
        suggestion: { capability: "process.execute", pattern: "npm install *" },
      },
    },
    { type: "permission.granted", payload: { permissionRequestId: "perm_1", scope: "once" } },
    {
      type: "permission.denied",
      payload: { permissionRequestId: "perm_2", source: "user", feedback: "Do not run that." },
    },
    { type: "tool.approved", payload: { toolUseId: "toolu_1", via: "policy-allow" } },
    { type: "tool.started", payload: { toolUseId: "toolu_1", toolName: "read" } },
    {
      type: "tool.completed",
      payload: {
        toolUseId: "toolu_1",
        modelText: "1  const x = 1;",
        spillFile: "/home/user/.khaelor/spill/toolu_1.txt",
        durationMs: 12,
        ui: { kind: "read", summary: "Read src/store.ts", matchCount: 0 },
      },
    },
    {
      type: "tool.failed",
      payload: {
        toolUseId: "toolu_2",
        modelText: "File not found: src/missing.ts",
        errorKind: "not-found",
        durationMs: 3,
      },
    },
    {
      type: "tool.cancelled",
      payload: {
        toolUseId: "toolu_3",
        reason: "interrupted",
        modelText: "[Tool execution cancelled by user]",
      },
    },
    {
      type: "file.read",
      payload: {
        path: "src/store.ts",
        range: { start: 1, end: 50 },
        bytes: 2048,
        mtimeMs: 1_700_000_000_000,
        toolUseId: "toolu_1",
      },
    },
    {
      type: "file.modified",
      payload: {
        path: "src/store.ts",
        operation: "edit",
        diffStats: { added: 3, removed: 1 },
        diff: "--- a/src/store.ts\n+++ b/src/store.ts\n",
        toolUseId: "toolu_4",
      },
    },
    {
      type: "process.started",
      payload: {
        processId: "proc_1",
        pid: 4242,
        command: "npm run dev",
        cwd: "/home/user/project",
        name: "dev-server",
        toolUseId: "toolu_5",
      },
    },
    {
      type: "process.exited",
      payload: { processId: "proc_1", exitCode: 0, cause: "exited", durationMs: 60000 },
    },
    {
      type: "context.pruned",
      payload: {
        toolUseIds: ["toolu_1"],
        placeholder: "[Old tool result removed to save context]",
        tokensReclaimedEstimate: 900,
      },
    },
    {
      type: "context.compacted",
      payload: {
        checkpointYaml: "objective: fix the bug\ncompleted: []\n",
        cut: { fromSeq: 2, toSeq: 9 },
        trigger: "proactive-token-budget",
        tokensBefore: 150000,
        summaryModel: "claude-haiku-4-5",
      },
    },
    {
      type: "task.verification-requested",
      payload: { attempt: 1, detectedChecks: ["npm test"], withheldCandidateSeq: 30 },
    },
    {
      type: "task.completed",
      payload: {
        evidence: {
          objective: "Fix the bug",
          changedFiles: ["src/store.ts"],
          checks: [{ command: "npm test", exitCode: 0, summary: "12 passed", durationMs: 2100 }],
          unresolvedIssues: [],
        },
      },
    },
    {
      type: "task.failed",
      payload: { reason: "iteration-budget-exhausted", detail: "gave up after 50 iterations" },
    },
    { type: "phase.entered", payload: { phase: "design", via: "design-submitted" } },
    {
      type: "phase.artifact",
      payload: {
        artifactId: "art_1",
        artifact: {
          goal: "fix the renderer leak",
          filesTouched: ["src/tui/render.ts"],
          approach: "ring buffer instead of growing array",
          risks: ["scrollback regression"],
          verification: "vitest run tests/tui",
          outOfScope: ["theming"],
        },
      },
    },
    {
      type: "phase.approved",
      payload: { phase: "design", approvedBy: "auto-policy", artifactId: "art_1" },
    },
    { type: "phase.rejected", payload: { phase: "design", reason: "too broad", artifactId: "art_1" } },
    {
      type: "verify.result",
      payload: {
        check: "typecheck",
        command: "npx tsc --noEmit",
        ok: false,
        exitCode: 2,
        output: "src/a.ts(42): TS2345",
        durationMs: 4200,
      },
    },
    {
      type: "memory.written",
      payload: {
        section: "conventions",
        entry: "errors flow through Result<T, KError>",
        confidence: "high",
        toolUseId: "toolu_9",
      },
    },
    {
      type: "subtask.created",
      payload: {
        taskId: "t1",
        description: "add rate limiting",
        childSessionId: "01CHILD",
        worktreePath: "/repo/.khaelor/worktrees/t1",
        branch: "khaelor/t1",
      },
    },
    {
      type: "subtask.completed",
      payload: {
        taskId: "t1",
        outcome: "done",
        diffStats: { added: 42, removed: 13 },
        verifyOk: true,
        detail: "rate limiting added",
      },
    },
  ];
}

/** One input per ephemeral event type — 6 total, matching EPHEMERAL_EVENT_TYPES. */
export function sampleEphemeralInputs(): EphemeralEventInput[] {
  return [
    { type: "model.text-delta", payload: { requestId: "req_1", blockIndex: 1, text: "Hel" } },
    { type: "model.thinking-delta", payload: { requestId: "req_1", blockIndex: 0, text: "hmm" } },
    {
      type: "model.tool-call-started",
      payload: { requestId: "req_1", blockIndex: 2, toolUseId: "toolu_1", toolName: "read" },
    },
    {
      type: "model.tool-input-delta",
      payload: { requestId: "req_1", blockIndex: 2, toolUseId: "toolu_1", partialJson: '{"pa' },
    },
    { type: "tool.output", payload: { toolUseId: "toolu_1", chunk: "line 1\n" } },
    { type: "process.output", payload: { processId: "proc_1", stream: "stdout", chunk: "ready\n" } },
  ];
}