import { describe, expect, it, vi } from "vite-plus/test";
import { EnvironmentId, ThreadId, type TerminalSummary } from "@t3tools/contracts";
import { selectRunningSubprocessTerminalIds } from "@t3tools/client-runtime/state/terminal";

import { selectKnownTerminalSessions } from "./terminalSessions";

vi.mock("./terminal", () => ({ terminalEnvironment: {} }));

const environmentA = EnvironmentId.make("environment-a");
const environmentB = EnvironmentId.make("environment-b");
const threadA = ThreadId.make("thread-a");
const threadB = ThreadId.make("thread-b");

function summary(
  threadId: string,
  terminalId: string,
  changes: Partial<TerminalSummary> = {},
): TerminalSummary {
  return {
    threadId,
    terminalId,
    cwd: "/repo",
    worktreePath: null,
    status: "running",
    pid: 123,
    exitCode: null,
    exitSignal: null,
    hasRunningSubprocess: true,
    label: "Terminal",
    updatedAt: "2026-09-04T00:00:00.000Z",
    ...changes,
  };
}

describe("selectKnownTerminalSessions", () => {
  it("preserves numeric terminal order and stable picker ties across threads", () => {
    const metadata = [
      summary(threadB, "terminal-2"),
      summary(threadA, "terminal-10"),
      summary(threadB, "terminal-1"),
      summary(threadA, "terminal-1"),
      summary(threadA, "terminal-01"),
    ];
    const all = selectKnownTerminalSessions(metadata, environmentA, null);
    const selected = selectKnownTerminalSessions(metadata, environmentA, threadB);
    expect(all.map((session) => `${session.target.threadId}/${session.target.terminalId}`)).toEqual(
      [
        "thread-b/terminal-1",
        "thread-a/terminal-1",
        "thread-a/terminal-01",
        "thread-b/terminal-2",
        "thread-a/terminal-10",
      ],
    );
    expect(selected.map((session) => session.target.terminalId)).toEqual([
      "terminal-1",
      "terminal-2",
    ]);
    const repeated = [...metadata];
    expect(selectKnownTerminalSessions(repeated, environmentA, null)).toBe(all);
    expect(selectKnownTerminalSessions(repeated, environmentA, threadB)).toBe(selected);

    const reordered = metadata.toReversed();
    expect(selectKnownTerminalSessions(reordered, environmentA, threadB)).toBe(selected);
    expect(
      selectKnownTerminalSessions(reordered, environmentA, null).map(
        (session) => `${session.target.threadId}/${session.target.terminalId}`,
      ),
    ).toEqual([
      "thread-a/terminal-01",
      "thread-a/terminal-1",
      "thread-b/terminal-1",
      "thread-b/terminal-2",
      "thread-a/terminal-10",
    ]);
  });

  it("changes only the affected group and preserves earlier snapshots", () => {
    const first = summary(threadA, "terminal-1");
    const second = summary(threadA, "terminal-2");
    const other = summary(threadB, "terminal-1");
    const metadata = [first, second, other];
    const beforeA = selectKnownTerminalSessions(metadata, environmentA, threadA);
    const beforeB = selectKnownTerminalSessions(metadata, environmentA, threadB);
    Object.freeze(beforeA);
    Object.freeze(beforeB);
    const exited = {
      ...second,
      status: "exited" as const,
      pid: null,
      exitCode: 0,
      hasRunningSubprocess: false,
      label: "Finished",
      updatedAt: "2026-09-04T00:00:01.000Z",
    };
    const next = [first, other, exited];
    const afterA = selectKnownTerminalSessions(next, environmentA, threadA);
    expect(selectKnownTerminalSessions(next, environmentA, threadB)).toBe(beforeB);
    expect(afterA).not.toBe(beforeA);
    expect(afterA[0]).toBe(beforeA[0]);
    expect(afterA[1]?.state).toMatchObject({
      status: "exited",
      hasRunningSubprocess: false,
      summary: { label: "Finished", pid: null, exitCode: 0 },
    });
    expect(selectRunningSubprocessTerminalIds(afterA)).toEqual(["terminal-1"]);
    expect(beforeA[1]?.state).toMatchObject({
      status: "running",
      hasRunningSubprocess: true,
      summary: { label: "Terminal", pid: 123 },
    });
    expect(selectKnownTerminalSessions(metadata, environmentA, threadA)).toBe(beforeA);

    const renamed = [first, exited, { ...other, label: "Renamed" }];
    expect(selectKnownTerminalSessions(renamed, environmentA, threadA)).toBe(afterA);
    expect(
      selectKnownTerminalSessions(renamed, environmentA, threadB)[0]?.state.summary?.label,
    ).toBe("Renamed");
    expect(selectKnownTerminalSessions([other], environmentA, threadA)).toEqual([]);
    expect(selectKnownTerminalSessions([other], environmentA, threadB)).toBe(beforeB);
  });

  it("keeps environment targets separate when snapshots share the same objects", () => {
    const metadata = [summary(threadA, "terminal-1")];
    const first = selectKnownTerminalSessions(metadata, environmentA, threadA);
    const second = selectKnownTerminalSessions(metadata, environmentB, threadA);
    expect(first[0]?.target.environmentId).toBe(environmentA);
    expect(second[0]?.target.environmentId).toBe(environmentB);
    expect(first).not.toBe(second);
    expect(first[0]).not.toBe(second[0]);
    expect(selectKnownTerminalSessions([...metadata], environmentA, threadA)).toBe(first);
    expect(selectKnownTerminalSessions([...metadata], environmentB, threadA)).toBe(second);
  });

  it("returns stable empty results without a connected environment or matching sessions", () => {
    const metadata = [summary(threadA, "terminal-1")];
    const empty = selectKnownTerminalSessions(null, environmentA, threadA);
    expect(selectKnownTerminalSessions(metadata, null, threadA)).toBe(empty);
    expect(selectKnownTerminalSessions([], environmentA, null)).toBe(empty);
    expect(selectKnownTerminalSessions(metadata, environmentA, threadB)).toBe(empty);
  });

  it("does not materialize unrelated raw thread identifiers", () => {
    const metadata = [summary(" untrimmed-thread ", "terminal-1"), summary(threadA, "terminal-2")];
    expect(
      selectKnownTerminalSessions(metadata, environmentA, threadA).map(
        (session) => session.target.threadId,
      ),
    ).toEqual([threadA]);
  });

  it("reads the metadata array once for all thread selectors", () => {
    const source = Array.from({ length: 40 }, (_, index) =>
      summary(`thread-${index}`, "terminal-1"),
    );
    let reads = 0;
    const metadata = new Proxy(source, {
      get(target, property, receiver) {
        if (typeof property === "string" && /^(0|[1-9]\d*)$/.test(property)) reads += 1;
        return Reflect.get(target, property, receiver);
      },
    });
    for (const item of source) {
      expect(
        selectKnownTerminalSessions(metadata, environmentA, ThreadId.make(item.threadId)),
      ).toHaveLength(1);
    }
    expect(selectKnownTerminalSessions(metadata, environmentA, null)).toHaveLength(source.length);
    expect(reads).toBe(source.length);
  });
});