import { describe, expect, it, vi } from "vite-plus/test";

import { EnvironmentId, TerminalSessionSnapshot, ThreadId } from "@t3tools/contracts";

import {
  applyTerminalAttachStreamEvent,
  applyTerminalMetadataStreamEvent,
  combineTerminalSessionState,
  DEFAULT_MAX_TERMINAL_BUFFER_BYTES,
  EMPTY_TERMINAL_BUFFER_STATE,
  INITIAL_TERMINAL_OUTPUT_CURSOR,
  nextTerminalAttachSeedState,
  readTerminalOutputUpdate,
  selectRunningSubprocessTerminalIds,
  terminalOutputText,
} from "./terminalSession.ts";

const TARGET = {
  environmentId: EnvironmentId.make("env-local"),
  threadId: ThreadId.make("thread-1"),
  terminalId: "term-1",
} as const;

const BASE_SNAPSHOT: TerminalSessionSnapshot = {
  threadId: TARGET.threadId,
  terminalId: TARGET.terminalId,
  cwd: "/repo",
  worktreePath: null,
  status: "running",
  pid: 123,
  history: "hello",
  exitCode: null,
  exitSignal: null,
  label: "Terminal 1",
  updatedAt: "2026-04-01T00:00:00.000Z",
};

describe("terminal session reducers", () => {
  it("prefers live attach status over stale metadata after the attach stream starts", () => {
    const summary = applyTerminalMetadataStreamEvent([], {
      type: "snapshot",
      terminals: [
        {
          threadId: BASE_SNAPSHOT.threadId,
          terminalId: BASE_SNAPSHOT.terminalId,
          cwd: BASE_SNAPSHOT.cwd,
          worktreePath: BASE_SNAPSHOT.worktreePath,
          status: "running",
          pid: BASE_SNAPSHOT.pid,
          exitCode: BASE_SNAPSHOT.exitCode,
          exitSignal: BASE_SNAPSHOT.exitSignal,
          updatedAt: BASE_SNAPSHOT.updatedAt,
          hasRunningSubprocess: false,
          label: BASE_SNAPSHOT.label,
        },
      ],
    })[0]!;
    const attached = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "error",
      threadId: TARGET.threadId,
      terminalId: TARGET.terminalId,
      message: "Terminal disconnected.",
    });

    expect(combineTerminalSessionState(summary, attached)).toMatchObject({
      status: "error",
      error: "Terminal disconnected.",
      version: 1,
    });
  });

  it("uses metadata status before an attach stream has emitted", () => {
    const summary = applyTerminalMetadataStreamEvent([], {
      type: "snapshot",
      terminals: [
        {
          threadId: BASE_SNAPSHOT.threadId,
          terminalId: BASE_SNAPSHOT.terminalId,
          cwd: BASE_SNAPSHOT.cwd,
          worktreePath: BASE_SNAPSHOT.worktreePath,
          status: "running",
          pid: BASE_SNAPSHOT.pid,
          exitCode: BASE_SNAPSHOT.exitCode,
          exitSignal: BASE_SNAPSHOT.exitSignal,
          updatedAt: BASE_SNAPSHOT.updatedAt,
          hasRunningSubprocess: false,
          label: BASE_SNAPSHOT.label,
        },
      ],
    })[0]!;

    expect(combineTerminalSessionState(summary, EMPTY_TERMINAL_BUFFER_STATE).status).toBe(
      "running",
    );
  });

  it("does not treat an idle running shell as a running subprocess", () => {
    const idleSession = {
      target: TARGET,
      state: {
        ...combineTerminalSessionState(null, EMPTY_TERMINAL_BUFFER_STATE),
        status: "running" as const,
        hasRunningSubprocess: false,
      },
    };
    const activeSession = {
      target: { ...TARGET, terminalId: "term-2" },
      state: {
        ...idleSession.state,
        hasRunningSubprocess: true,
      },
    };

    expect(selectRunningSubprocessTerminalIds([idleSession, activeSession])).toEqual(["term-2"]);
  });

  it("reduces attach snapshots and output without an imperative session manager", () => {
    const snapshot = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: BASE_SNAPSHOT,
    });
    const output = applyTerminalAttachStreamEvent(
      snapshot,
      {
        type: "output",
        threadId: TARGET.threadId,
        terminalId: TARGET.terminalId,
        data: " world",
      },
      8,
    );

    expect(output).toMatchObject({
      status: "running",
      error: null,
      version: 2,
    });
    expect(terminalOutputText(output.output)).toBe("lo world");
  });

  it("does not advance the lifecycle for the initial attach snapshot", () => {
    const snapshot = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: BASE_SNAPSHOT,
    });

    expect(snapshot).toMatchObject({ status: "running", lifecycleVersion: 0 });
  });

  it("advances the lifecycle for a live started snapshot", () => {
    const initial = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: BASE_SNAPSHOT,
    });
    const started = applyTerminalAttachStreamEvent(initial, {
      type: "snapshot",
      snapshot: { ...BASE_SNAPSHOT, pid: 456 },
    });

    expect(started).toMatchObject({ status: "running", lifecycleVersion: 1 });
  });

  it("advances the lifecycle when a running terminal restarts in place", () => {
    const snapshot = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: BASE_SNAPSHOT,
    });
    const restarted = applyTerminalAttachStreamEvent(snapshot, {
      type: "restarted",
      threadId: TARGET.threadId,
      terminalId: TARGET.terminalId,
      snapshot: { ...BASE_SNAPSHOT, pid: 456 },
    });

    expect(snapshot).toMatchObject({ status: "running", lifecycleVersion: 0 });
    expect(restarted).toMatchObject({ status: "running", lifecycleVersion: 1 });
  });

  it("reduces terminal metadata snapshots, upserts, and removals", () => {
    const initial = applyTerminalMetadataStreamEvent([], {
      type: "snapshot",
      terminals: [
        {
          threadId: BASE_SNAPSHOT.threadId,
          terminalId: BASE_SNAPSHOT.terminalId,
          cwd: BASE_SNAPSHOT.cwd,
          worktreePath: BASE_SNAPSHOT.worktreePath,
          status: BASE_SNAPSHOT.status,
          pid: BASE_SNAPSHOT.pid,
          exitCode: BASE_SNAPSHOT.exitCode,
          exitSignal: BASE_SNAPSHOT.exitSignal,
          updatedAt: BASE_SNAPSHOT.updatedAt,
          hasRunningSubprocess: false,
          label: BASE_SNAPSHOT.label,
        },
      ],
    });
    const updated = applyTerminalMetadataStreamEvent(initial, {
      type: "upsert",
      terminal: {
        ...initial[0]!,
        hasRunningSubprocess: true,
      },
    });
    const removed = applyTerminalMetadataStreamEvent(updated, {
      type: "remove",
      threadId: TARGET.threadId,
      terminalId: TARGET.terminalId,
    });

    expect(updated).toHaveLength(1);
    expect(updated[0]?.hasRunningSubprocess).toBe(true);
    expect(removed).toEqual([]);
  });

  it("caps retained output by UTF-8 byte length", () => {
    const state = applyTerminalAttachStreamEvent(
      EMPTY_TERMINAL_BUFFER_STATE,
      {
        type: "output",
        threadId: TARGET.threadId,
        terminalId: TARGET.terminalId,
        data: "🙂🙂",
      },
      4,
    );

    expect(terminalOutputText(state.output)).toBe("🙂");
  });

  it("preserves a BOM code point at a new output chunk boundary", () => {
    const initial = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: { ...BASE_SNAPSHOT, history: "" },
    });
    const cursor = readTerminalOutputUpdate(initial.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
    const data = `${"x".repeat(16_384)}\uFEFF${"y".repeat(20)}`;
    const state = applyTerminalAttachStreamEvent(initial, {
      type: "output",
      threadId: TARGET.threadId,
      terminalId: TARGET.terminalId,
      data,
    });

    expect(terminalOutputText(state.output)).toBe(data);
    expect(readTerminalOutputUpdate(state.output, cursor)).toMatchObject({ type: "append", data });
    expect(state.output.retainedBytes).toBe(new TextEncoder().encode(data).byteLength);
  });

  it("preserves a leading BOM in the retained snapshot tail", () => {
    const state = applyTerminalAttachStreamEvent(
      EMPTY_TERMINAL_BUFFER_STATE,
      { type: "snapshot", snapshot: { ...BASE_SNAPSHOT, history: "discard\uFEFFtail" } },
      7,
    );

    expect(terminalOutputText(state.output)).toBe("\uFEFFtail");
    expect(state.output.retainedBytes).toBe(7);
  });

  it("trims whole Unicode code points from a partially retained chunk", () => {
    let state = applyTerminalAttachStreamEvent(
      EMPTY_TERMINAL_BUFFER_STATE,
      { type: "snapshot", snapshot: { ...BASE_SNAPSHOT, history: "é界🙂end" } },
      12,
    );
    let cursor = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
    for (const [data, expected, retainedBytes] of [
      ["x", "界🙂endx", 11],
      ["yz", "🙂endxyz", 10],
      ["abc", "endxyzabc", 9],
    ] as const) {
      state = applyTerminalAttachStreamEvent(
        state,
        { type: "output", threadId: TARGET.threadId, terminalId: TARGET.terminalId, data },
        12,
      );
      const update = readTerminalOutputUpdate(state.output, cursor);
      expect(update).toMatchObject({ type: "append", data });
      expect(terminalOutputText(state.output)).toBe(expected);
      expect(state.output.retainedBytes).toBe(retainedBytes);
      cursor = update.cursor;
    }
  });

  it("delivers all output when several events arrive before a renderer reads", () => {
    const initial = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: BASE_SNAPSHOT,
    });
    const cursor = readTerminalOutputUpdate(initial.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
    let state = initial;
    for (const data of [" one", " two", " three"]) {
      state = applyTerminalAttachStreamEvent(state, {
        type: "output",
        threadId: TARGET.threadId,
        terminalId: TARGET.terminalId,
        data,
      });
    }
    const update = readTerminalOutputUpdate(state.output, cursor);
    expect(update).toMatchObject({ type: "append", data: " one two three" });
    expect(readTerminalOutputUpdate(state.output, update.cursor).type).toBe("none");
  });

  it("preserves the byte-limited tail and resets a cursor before a partially trimmed chunk", () => {
    const initial = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: { ...BASE_SNAPSHOT, history: "" },
    });
    const staleCursor = readTerminalOutputUpdate(
      initial.output,
      INITIAL_TERMINAL_OUTPUT_CURSOR,
    ).cursor;
    const first = applyTerminalAttachStreamEvent(initial, {
      type: "output",
      threadId: TARGET.threadId,
      terminalId: TARGET.terminalId,
      data: "hello",
    });
    const caughtUpCursor = readTerminalOutputUpdate(first.output, staleCursor).cursor;
    const state = applyTerminalAttachStreamEvent(
      first,
      { type: "output", threadId: TARGET.threadId, terminalId: TARGET.terminalId, data: " world" },
      8,
    );

    expect(readTerminalOutputUpdate(state.output, caughtUpCursor)).toMatchObject({
      type: "append",
      data: " world",
    });
    expect(readTerminalOutputUpdate(state.output, staleCursor)).toMatchObject({
      type: "reset",
      data: "lo world",
    });
    expect(state.output.retainedBytes).toBe(8);
  });

  it("does not encode retained history again when appending at the byte limit", () => {
    let state = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: { ...BASE_SNAPSHOT, history: "x".repeat(DEFAULT_MAX_TERMINAL_BUFFER_BYTES) },
    });
    const data = "y".repeat(8192);
    const encode = vi.spyOn(TextEncoder.prototype, "encode");
    try {
      for (let index = 0; index < 100; index += 1) {
        state = applyTerminalAttachStreamEvent(state, {
          type: "output",
          threadId: TARGET.threadId,
          terminalId: TARGET.terminalId,
          data,
        });
      }
      expect(encode.mock.calls.reduce((total, [text]) => total + (text?.length ?? 0), 0)).toBe(
        data.length * 100,
      );
      expect(state.output.retainedBytes).toBe(DEFAULT_MAX_TERMINAL_BUFFER_BYTES);
    } finally {
      encode.mockRestore();
    }
  });

  it.each([0, -1])("discards output without encoding when the byte budget is %s", (maxBytes) => {
    const initial = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: BASE_SNAPSHOT,
    });
    const cursor = readTerminalOutputUpdate(initial.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
    const data = "x".repeat(65_536);
    const encode = vi.spyOn(TextEncoder.prototype, "encode");
    try {
      const discarded = applyTerminalAttachStreamEvent(
        initial,
        { type: "output", threadId: TARGET.threadId, terminalId: TARGET.terminalId, data },
        maxBytes,
      );
      expect(encode).not.toHaveBeenCalled();
      expect(discarded.output.nextOffset).toBe(initial.output.nextOffset + data.length);
      expect(discarded.output.retainedBytes).toBe(0);
      expect(readTerminalOutputUpdate(discarded.output, cursor)).toMatchObject({
        type: "reset",
        data: "",
      });

      const empty = applyTerminalAttachStreamEvent(
        initial,
        { type: "output", threadId: TARGET.threadId, terminalId: TARGET.terminalId, data: "" },
        maxBytes,
      );
      expect(empty.output).toBe(initial.output);
      expect(encode).not.toHaveBeenCalled();
    } finally {
      encode.mockRestore();
    }
  });

  it("resets for repeated snapshots, clear, and restart even when output text repeats", () => {
    let state = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: BASE_SNAPSHOT,
    });
    let cursor = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
    state = applyTerminalAttachStreamEvent(state, { type: "snapshot", snapshot: BASE_SNAPSHOT });
    const repeated = readTerminalOutputUpdate(state.output, cursor);
    expect(repeated).toMatchObject({ type: "reset", data: "hello" });
    expect(state.version).toBe(2);
    cursor = repeated.cursor;

    state = applyTerminalAttachStreamEvent(state, {
      type: "cleared",
      threadId: TARGET.threadId,
      terminalId: TARGET.terminalId,
    });
    const cleared = readTerminalOutputUpdate(state.output, cursor);
    expect(cleared).toMatchObject({ type: "reset", data: "" });
    state = applyTerminalAttachStreamEvent(state, {
      type: "restarted",
      threadId: TARGET.threadId,
      terminalId: TARGET.terminalId,
      snapshot: BASE_SNAPSHOT,
    });
    expect(readTerminalOutputUpdate(state.output, cleared.cursor)).toMatchObject({
      type: "reset",
      data: "hello",
    });
    expect(state.lifecycleVersion).toBe(2);
  });

  it("does not reuse a renderer cursor when a fresh attach has matching counters", () => {
    const first = applyTerminalAttachStreamEvent(nextTerminalAttachSeedState(), {
      type: "snapshot",
      snapshot: BASE_SNAPSHOT,
    });
    const cursor = readTerminalOutputUpdate(first.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
    const next = applyTerminalAttachStreamEvent(nextTerminalAttachSeedState(), {
      type: "snapshot",
      snapshot: { ...BASE_SNAPSHOT, history: "other" },
    });
    expect(next.output.resetVersion).toBe(first.output.resetVersion);
    expect(next.output.nextOffset).toBe(first.output.nextOffset);
    expect(readTerminalOutputUpdate(next.output, cursor)).toMatchObject({
      type: "reset",
      data: "other",
    });
    expect(next.lifecycleVersion).toBe(0);
  });

  it("keeps appending while compacting metadata for many small writes", () => {
    let state = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: { ...BASE_SNAPSHOT, history: "" },
    });
    let cursor = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
    let received = "";
    for (let index = 0; index < 2500; index += 1) {
      state = applyTerminalAttachStreamEvent(state, {
        type: "output",
        threadId: TARGET.threadId,
        terminalId: TARGET.terminalId,
        data: "x",
      });
      const update = readTerminalOutputUpdate(state.output, cursor);
      if (update.type !== "append") throw new Error(`Expected append, received ${update.type}`);
      received += update.data;
      cursor = update.cursor;
    }
    expect(received).toBe("x".repeat(2500));
    expect(state.output.chunks.length).toBeLessThan(1024);
    expect(terminalOutputText(state.output)).toBe(received);
  });

  it("appends every unread character across a compaction boundary", () => {
    let state = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
      type: "snapshot",
      snapshot: { ...BASE_SNAPSHOT, history: "" },
    });
    let cursor = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
    const writes = Array.from({ length: 1200 }, (_, index) => ["x", "é", "界", "🙂"][index % 4]!);
    for (const [index, data] of writes.entries()) {
      state = applyTerminalAttachStreamEvent(state, {
        type: "output",
        threadId: TARGET.threadId,
        terminalId: TARGET.terminalId,
        data,
      });
      if (index === 99) cursor = readTerminalOutputUpdate(state.output, cursor).cursor;
    }
    expect(readTerminalOutputUpdate(state.output, cursor)).toMatchObject({
      type: "append",
      data: writes.slice(100).join(""),
    });
  });
});