import { afterEach, describe, expect, it, vi } from "vite-plus/test";
import {
  applyTerminalAttachStreamEvent,
  DEFAULT_MAX_TERMINAL_BUFFER_BYTES,
  INITIAL_TERMINAL_OUTPUT_CURSOR,
  nextTerminalAttachSeedState,
  readTerminalOutputUpdate,
  terminalOutputText,
  type TerminalBufferState,
} from "@t3tools/client-runtime/state/terminal";

import { writeTerminalOutputUpdate } from "../../components/ThreadTerminalDrawer";
import { GHOSTTY_CELL_WIDE, GhosttyTerminalCore, ghosttyCellText } from "./core";
import { loadGhosttyRuntime } from "./runtime";

vi.mock("./vendor/ghostty-vt.wasm?url", async () => ({
  default: (await import("./vendor/ghostty-vt.wasm?inline")).default,
}));
vi.mock("./vendor/ghostty-write-pty.wasm?url&no-inline", async () => ({
  default: (await import("./vendor/ghostty-write-pty.wasm?inline")).default,
}));

function codepointView(codepoints: ReadonlyArray<number>): DataView {
  const view = new DataView(new ArrayBuffer(codepoints.length * 4));
  codepoints.forEach((codepoint, index) => view.setUint32(index * 4, codepoint, true));
  return view;
}

describe("ghosttyCellText", () => {
  it("converts oversized grapheme clusters without hitting engine spread limits", () => {
    // A program printing one base character followed by a huge run of
    // combining marks packs the whole cluster into one cell; spreading that
    // many arguments into String.fromCodePoint once overflows the call stack.
    const graphemeLength = 130_000;
    const view = new DataView(new ArrayBuffer(graphemeLength * 4));
    for (let index = 0; index < graphemeLength; index += 1) {
      view.setUint32(index * 4, index === 0 ? "a".codePointAt(0)! : 0x301, true);
    }
    const text = ghosttyCellText(view, graphemeLength);
    expect(text.length).toBe(graphemeLength);
    expect(text.codePointAt(0)).toBe("a".codePointAt(0));
    expect(text.codePointAt(1)).toBe(0x301);
    expect(text.codePointAt(graphemeLength - 1)).toBe(0x301);
  });

  it("converts small clusters including astral codepoints", () => {
    const text = ghosttyCellText(codepointView([0x1f642, 0x20e3]), 2);
    expect([...text]).toEqual(["\u{1F642}", "\u{20E3}"]);
  });

  it("converts a single astral codepoint", () => {
    expect(ghosttyCellText(codepointView([0x1f642]), 1)).toBe("🙂");
  });

  it("returns an empty string for empty cells", () => {
    expect(ghosttyCellText(codepointView([]), 0)).toBe("");
  });
});

describe("GhosttyTerminalCore snapshots", () => {
  const cores = new Set<GhosttyTerminalCore>();

  async function createCore(onData: (data: string) => void = () => {}) {
    const core = await GhosttyTerminalCore.create(
      12,
      3,
      8,
      16,
      {
        foreground: { r: 255, g: 255, b: 255 },
        background: { r: 0, g: 0, b: 0 },
        cursor: { r: 255, g: 255, b: 255 },
      },
      onData,
    );
    cores.add(core);
    return core;
  }

  function createSession(history: string) {
    return applyTerminalAttachStreamEvent(nextTerminalAttachSeedState(), {
      type: "snapshot",
      snapshot: {
        threadId: "terminal-stream-test",
        terminalId: "term-1",
        cwd: "/repo",
        worktreePath: null,
        status: "running",
        pid: 123,
        history,
        exitCode: null,
        exitSignal: null,
        label: "Terminal",
        updatedAt: "2026-09-04T00:00:00.000Z",
      },
    });
  }

  function append(state: TerminalBufferState, data: string) {
    return applyTerminalAttachStreamEvent(state, {
      type: "output",
      threadId: "terminal-stream-test",
      terminalId: "term-1",
      data,
    });
  }

  afterEach(() => {
    for (const core of cores) core.dispose();
    cores.clear();
    vi.restoreAllMocks();
  });

  it("preserves styles, wide cells, and selection after shared memory grows", async () => {
    const core = await createCore();
    const runtime = await loadGhosttyRuntime();
    const grapheme = `e${"\u0301".repeat(64)}`;
    core.write(`\x1b[1;3;4;8;9;53;38;2;123;45;67;48;2;9;8;7m${grapheme}\x1b[0m界🙂`);
    const cells = core.snapshot().rowData[0]!.cells;
    expect(cells[0]).toEqual({
      text: grapheme,
      wide: 0,
      foreground: { r: 123, g: 45, b: 67 },
      background: { r: 9, g: 8, b: 7 },
      bold: true,
      italic: true,
      invisible: true,
      strikethrough: true,
      overline: true,
      underline: true,
      selected: false,
    });
    expect(cells.slice(1, 5).map(({ text, wide }) => ({ text, wide }))).toEqual([
      { text: "界", wide: 0 },
      { text: "", wide: GHOSTTY_CELL_WIDE.spacerTail },
      { text: "🙂", wide: 0 },
      { text: "", wide: GHOSTTY_CELL_WIDE.spacerTail },
    ]);

    runtime.memory.grow(1);
    core.setSelection({ x: 0, y: 0 }, { x: 2, y: 0 });
    expect(core.snapshot().rowData[0]!.cells[0]).toEqual({ ...cells[0], selected: true });
    core.clearSelection();
    expect(core.snapshot().rowData[0]!.cells[0]).toEqual(cells[0]);

    core.resetAndWrite("\x1b[2;7;38;2;40;100;200;48;2;12;34;56mC\x1b[0m");
    expect(core.snapshot().rowData[0]!.cells[0]).toMatchObject({
      text: "C",
      foreground: { r: 22, g: 59, b: 112 },
      background: { r: 40, g: 100, b: 200 },
      bold: false,
      underline: false,
      selected: false,
    });
  });

  it("reuses a grown grapheme buffer and releases it on disposal", async () => {
    const core = await createCore();
    const runtime = await loadGhosttyRuntime();
    core.write("ASCII");
    core.snapshot();

    const grapheme = `z${"\u0301".repeat(256)}`;
    core.resetAndWrite(`${grapheme}X`);
    const alloc = vi.spyOn(runtime, "alloc");
    const free = vi.spyOn(runtime, "free");
    expect(
      core
        .snapshot()
        .rowData[0]!.cells.slice(0, 2)
        .map((cell) => cell.text),
    ).toEqual([grapheme, "X"]);
    expect(alloc).toHaveBeenCalledTimes(1);
    const allocation = alloc.mock.results[0]!;
    if (allocation.type !== "return") throw new Error("Grapheme allocation did not return");
    const buffer = allocation.value;
    const capacity = alloc.mock.calls[0]![0];

    core.write("\rQ\u0301");
    alloc.mockClear();
    expect(core.snapshot().rowData[0]!.cells[0]!.text).toBe("Q\u0301");
    expect(alloc).not.toHaveBeenCalled();
    core.dispose();
    expect(free).toHaveBeenCalledWith(buffer, capacity);
  });

  it.each(["varied", "identical"] as const)(
    "preserves Ghostty state through a full MiB of %s output without rollover resets",
    async (kind) => {
      const [core, reference] = await Promise.all([createCore(), createCore()]);
      const initial = "\x1b[31m";
      let state = createSession(initial);
      const first = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR);
      writeTerminalOutputUpdate(core, first);
      reference.resetAndWrite(initial);
      let cursor = first.cursor;
      const reset = vi.spyOn(core, "resetAndWrite");
      const inputs: string[] = [];
      let receivedCharacters = 0;

      for (let index = 0; index < 128; index += 1) {
        const data =
          kind === "identical"
            ? "x".repeat(8192)
            : `${index.toString().padStart(4, "0")}\r\n${"x".repeat(8186)}`;
        inputs.push(data);
        state = append(state, data);
        const update = readTerminalOutputUpdate(state.output, cursor);
        if (update.type !== "append") throw new Error(`Expected append, received ${update.type}`);
        receivedCharacters += update.data.length;
        writeTerminalOutputUpdate(core, update);
        cursor = update.cursor;
      }

      reference.write(inputs.join(""));
      expect(receivedCharacters).toBe(1024 * 1024);
      expect(state.output.retainedBytes).toBe(DEFAULT_MAX_TERMINAL_BUFFER_BYTES);
      expect(reset).not.toHaveBeenCalled();
      expect(core.snapshot()).toEqual(reference.snapshot());
    },
  );

  it("preserves Unicode and split ANSI parser state across batched renderer reads", async () => {
    const [core, reference] = await Promise.all([createCore(), createCore()]);
    let state = createSession("");
    const first = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR);
    writeTerminalOutputUpdate(core, first);
    let cursor = first.cursor;
    const reset = vi.spyOn(core, "resetAndWrite");
    const inputs = [
      `${"a".repeat(16_383)}🙂`,
      "\x1b[3",
      "1m",
      "e",
      "\u0301界🙂",
      "\x1b[0",
      "m\r\n",
      "\x1b]8;;https://t3.codes\x1b",
      "\\link",
      "\x1b]8;;\x1b",
      "\\\x1b[?1049h",
      "alternate",
      "\x1b[?1049l",
      "\r\nend",
    ];
    let received = "";
    for (const [index, data] of inputs.entries()) {
      state = append(state, data);
      if (index % 3 !== 0 && index !== inputs.length - 1) continue;
      const update = readTerminalOutputUpdate(state.output, cursor);
      if (update.type !== "append") throw new Error(`Expected append, received ${update.type}`);
      received += update.data;
      writeTerminalOutputUpdate(core, update);
      cursor = update.cursor;
    }

    reference.write(inputs.join(""));
    expect(received).toBe(inputs.join(""));
    expect(reset).not.toHaveBeenCalled();
    expect(core.snapshot()).toEqual(reference.snapshot());
  });

  it("answers a live VT query when batched reads cross a chunk compaction", async () => {
    const replies: string[] = [];
    const core = await createCore((data) => replies.push(data));
    core.write("\x1b[5n");
    expect(replies).toEqual(["\x1b[0n"]);
    replies.length = 0;

    let state = createSession("");
    const initial = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR);
    writeTerminalOutputUpdate(core, initial);
    let cursor = initial.cursor;
    for (let index = 0; index < 1000; index += 1) {
      state = append(state, "x");
      const update = readTerminalOutputUpdate(state.output, cursor);
      writeTerminalOutputUpdate(core, update);
      cursor = update.cursor;
    }
    for (let index = 0; index < 24; index += 1) state = append(state, "x");
    state = append(state, "\x1b[5n");
    const update = readTerminalOutputUpdate(state.output, cursor);
    writeTerminalOutputUpdate(core, update);

    expect({ type: update.type, replies }).toEqual({ type: "append", replies: ["\x1b[0n"] });
  });

  it("recovers a lagging renderer once from bounded output and resumes appending", async () => {
    const [core, reference] = await Promise.all([createCore(), createCore()]);
    let state = createSession("\x1b[31mold");
    const initial = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR);
    writeTerminalOutputUpdate(core, initial);
    const reset = vi.spyOn(core, "resetAndWrite");
    const data = "line\r\n".repeat(8192);
    for (let index = 0; index < 16; index += 1) state = append(state, data);

    const recovery = readTerminalOutputUpdate(state.output, initial.cursor);
    if (recovery.type !== "reset") throw new Error(`Expected reset, received ${recovery.type}`);
    expect(new TextEncoder().encode(recovery.data).byteLength).toBe(
      DEFAULT_MAX_TERMINAL_BUFFER_BYTES,
    );
    writeTerminalOutputUpdate(core, recovery);
    reference.resetAndWrite(recovery.data);
    expect(core.snapshot()).toEqual(reference.snapshot());

    state = append(state, "\r\nlatest");
    const next = readTerminalOutputUpdate(state.output, recovery.cursor);
    expect(next.type).toBe("append");
    writeTerminalOutputUpdate(core, next);
    reference.write("\r\nlatest");
    expect(reset).toHaveBeenCalledTimes(1);
    expect(core.snapshot()).toEqual(reference.snapshot());
  });

  it("replays the latest retained output when WASM arrives after several events", async () => {
    const pendingCore = createCore();
    let state = createSession("before");
    state = append(state, "\r\nduring ");
    state = append(state, "🙂 load");
    const core = await pendingCore;
    const first = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR);
    writeTerminalOutputUpdate(core, first);
    const reference = await createCore();
    reference.resetAndWrite(terminalOutputText(state.output));
    const reset = vi.spyOn(core, "resetAndWrite");

    state = append(state, "\r\nafter");
    const next = readTerminalOutputUpdate(state.output, first.cursor);
    expect(next).toMatchObject({ type: "append", data: "\r\nafter" });
    writeTerminalOutputUpdate(core, next);
    reference.write("\r\nafter");
    expect(reset).not.toHaveBeenCalled();
    expect(core.snapshot()).toEqual(reference.snapshot());
  });

  it("resets real Ghostty for a repeated snapshot, clear, restart, and a fresh attach", async () => {
    const [core, reference] = await Promise.all([createCore(), createCore()]);
    let state = createSession("hello");
    const initial = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR);
    writeTerminalOutputUpdate(core, initial);
    let cursor = initial.cursor;

    const snapshot = {
      threadId: "terminal-stream-test",
      terminalId: "term-1",
      cwd: "/repo",
      worktreePath: null,
      status: "running" as const,
      pid: 456,
      history: "hello",
      exitCode: null,
      exitSignal: null,
      label: "Terminal",
      updatedAt: "2026-09-04T00:00:01.000Z",
    };
    const events = [
      { type: "snapshot", snapshot },
      { type: "cleared", threadId: snapshot.threadId, terminalId: snapshot.terminalId },
      { type: "restarted", threadId: snapshot.threadId, terminalId: snapshot.terminalId, snapshot },
    ] as const;
    for (const event of events) {
      core.write("\r\nstale local text");
      state = applyTerminalAttachStreamEvent(state, event);
      const update = readTerminalOutputUpdate(state.output, cursor);
      expect(update.type).toBe("reset");
      writeTerminalOutputUpdate(core, update);
      cursor = update.cursor;
      reference.resetAndWrite(event.type === "cleared" ? "" : "hello");
      expect(core.snapshot()).toEqual(reference.snapshot());
    }

    core.write("\r\nstale local text");
    state = createSession("hello");
    const reattached = readTerminalOutputUpdate(state.output, cursor);
    expect(reattached.type).toBe("reset");
    writeTerminalOutputUpdate(core, reattached);
    reference.resetAndWrite("hello");
    expect(core.snapshot()).toEqual(reference.snapshot());
  });
});