import { describe, expect, it, vi } from "vitest";

import { ProviderManager } from "./providerManager";

describe("ProviderManager", () => {
  it("detaches provider event listener and ends thread log streams on dispose", () => {
    const manager = new ProviderManager();
    const internals = manager as unknown as {
      codex: { listenerCount: (event: string) => number };
      onCodexEvent: (event: {
        id: string;
        kind: "notification";
        provider: "codex";
        sessionId: string;
        createdAt: string;
        method: string;
        threadId: string;
      }) => void;
      threadLogStreams: Map<string, { writableEnded: boolean; destroyed: boolean }>;
    };
    internals.onCodexEvent({
      id: "evt-1",
      kind: "notification",
      provider: "codex",
      sessionId: "sess-1",
      createdAt: new Date().toISOString(),
      method: "thread/started",
      threadId: "thread-1",
    });
    const stream = internals.threadLogStreams.get("thread-1");
    expect(stream).toBeDefined();
    if (!stream) return;

    expect(internals.codex.listenerCount("event")).toBe(1);
    manager.dispose();

    expect(internals.codex.listenerCount("event")).toBe(0);
    expect(stream.writableEnded || stream.destroyed).toBe(true);
    expect(internals.threadLogStreams.size).toBe(0);
  });

  it("allows multiple dispose calls", () => {
    const manager = new ProviderManager();

    manager.dispose();
    expect(() => manager.dispose()).not.toThrow();
  });

  it("rejects request responses for unknown sessions", async () => {
    const manager = new ProviderManager();

    await expect(
      manager.respondToRequest({
        sessionId: "missing-session",
        requestId: "req-1",
        decision: "accept",
      }),
    ).rejects.toThrow("Unknown provider session: missing-session");

    manager.dispose();
  });

  it("rejects checkpoint operations for unknown sessions", async () => {
    const manager = new ProviderManager();

    await expect(
      manager.listCheckpoints({
        sessionId: "missing-session",
      }),
    ).rejects.toThrow("Unknown provider session: missing-session");

    await expect(
      manager.revertToCheckpoint({
        sessionId: "missing-session",
        turnCount: 0,
      }),
    ).rejects.toThrow("Unknown provider session: missing-session");

    manager.dispose();
  });

  it("derives checkpoints from thread turns", async () => {
    const manager = new ProviderManager();
    const codex = (
      manager as unknown as {
        codex: {
          hasSession: (sessionId: string) => boolean;
          readThread: (sessionId: string) => Promise<{
            threadId: string;
            turns: Array<{ id: string; items: unknown[] }>;
          }>;
        };
      }
    ).codex;

    codex.hasSession = () => true;
    codex.readThread = async () => ({
      threadId: "thr_1",
      turns: [
        {
          id: "turn_1",
          items: [
            {
              type: "userMessage",
              content: [{ type: "text", text: "Refactor the logger" }],
            },
            {
              type: "agentMessage",
              text: "I refactored it.",
            },
          ],
        },
      ],
    });

    const result = await manager.listCheckpoints({
      sessionId: "sess_1",
    });

    expect(result).toEqual({
      threadId: "thr_1",
      checkpoints: [
        {
          id: "root",
          turnCount: 0,
          messageCount: 0,
          label: "Start of conversation",
          isCurrent: false,
        },
        {
          id: "turn_1",
          turnCount: 1,
          messageCount: 2,
          label: "Turn 1",
          preview: "Refactor the logger",
          isCurrent: true,
        },
      ],
    });

    manager.dispose();
  });

  it("rolls back from a selected checkpoint turn count", async () => {
    const manager = new ProviderManager();
    const codex = (
      manager as unknown as {
        codex: {
          hasSession: (sessionId: string) => boolean;
          readThread: (sessionId: string) => Promise<{
            threadId: string;
            turns: Array<{ id: string; items: unknown[] }>;
          }>;
          rollbackThread: (sessionId: string, numTurns: number) => Promise<{
            threadId: string;
            turns: Array<{ id: string; items: unknown[] }>;
          }>;
        };
      }
    ).codex;

    const rollbackCalls: Array<{ sessionId: string; numTurns: number }> = [];
    codex.hasSession = () => true;
    codex.readThread = async () => ({
      threadId: "thr_1",
      turns: [
        { id: "turn_1", items: [] },
        { id: "turn_2", items: [] },
        { id: "turn_3", items: [] },
      ],
    });
    codex.rollbackThread = async (sessionId, numTurns) => {
      rollbackCalls.push({ sessionId, numTurns });
      return {
        threadId: "thr_1",
        turns: [{ id: "turn_1", items: [] }],
      };
    };

    const result = await manager.revertToCheckpoint({
      sessionId: "sess_1",
      turnCount: 1,
    });

    expect(rollbackCalls).toEqual([{ sessionId: "sess_1", numTurns: 2 }]);
    expect(result.threadId).toBe("thr_1");
    expect(result.turnCount).toBe(1);
    expect(result.messageCount).toBe(0);
    expect(result.rolledBackTurns).toBe(2);
    expect(result.checkpoints).toHaveLength(2);

    manager.dispose();
  });

  it("restores filesystem checkpoint when reverting and checkpointing is enabled", async () => {
    const manager = new ProviderManager();
    const internals = manager as unknown as {
      codex: {
        hasSession: (sessionId: string) => boolean;
        readThread: (sessionId: string) => Promise<{
          threadId: string;
          turns: Array<{ id: string; items: unknown[] }>;
        }>;
        rollbackThread: (sessionId: string, numTurns: number) => Promise<{
          threadId: string;
          turns: Array<{ id: string; items: unknown[] }>;
        }>;
      };
      filesystemCheckpointStore: {
        hasCheckpoint: (input: { cwd: string; threadId: string; turnCount: number }) => Promise<boolean>;
        restoreCheckpoint: (input: {
          cwd: string;
          threadId: string;
          turnCount: number;
        }) => Promise<boolean>;
        pruneAfterTurn: (input: { cwd: string; threadId: string; maxTurnCount: number }) => Promise<void>;
      };
      sessionCheckpointCwds: Map<string, string>;
    };

    internals.codex.hasSession = () => true;
    internals.codex.readThread = async () => ({
      threadId: "thr_1",
      turns: [
        { id: "turn_1", items: [] },
        { id: "turn_2", items: [] },
      ],
    });
    internals.codex.rollbackThread = async () => ({
      threadId: "thr_1",
      turns: [{ id: "turn_1", items: [] }],
    });
    const hasCheckpoint = vi.fn(async () => true);
    const restoreCheckpoint = vi.fn(async () => true);
    const pruneAfterTurn = vi.fn(async () => undefined);
    internals.filesystemCheckpointStore.hasCheckpoint = hasCheckpoint;
    internals.filesystemCheckpointStore.restoreCheckpoint = restoreCheckpoint;
    internals.filesystemCheckpointStore.pruneAfterTurn = pruneAfterTurn;
    internals.sessionCheckpointCwds.set("sess_1", "/repo");

    const result = await manager.revertToCheckpoint({
      sessionId: "sess_1",
      turnCount: 1,
    });

    expect(result.turnCount).toBe(1);
    expect(hasCheckpoint).toHaveBeenCalledWith({
      cwd: "/repo",
      threadId: "thr_1",
      turnCount: 1,
    });
    expect(restoreCheckpoint).toHaveBeenCalledWith({
      cwd: "/repo",
      threadId: "thr_1",
      turnCount: 1,
    });
    expect(pruneAfterTurn).toHaveBeenCalledWith({
      cwd: "/repo",
      threadId: "thr_1",
      maxTurnCount: 1,
    });

    manager.dispose();
  });

  it("fails before rollback when filesystem checkpoint is missing", async () => {
    const manager = new ProviderManager();
    const internals = manager as unknown as {
      codex: {
        hasSession: (sessionId: string) => boolean;
        readThread: (sessionId: string) => Promise<{
          threadId: string;
          turns: Array<{ id: string; items: unknown[] }>;
        }>;
        rollbackThread: (sessionId: string, numTurns: number) => Promise<{
          threadId: string;
          turns: Array<{ id: string; items: unknown[] }>;
        }>;
      };
      filesystemCheckpointStore: {
        hasCheckpoint: (input: { cwd: string; threadId: string; turnCount: number }) => Promise<boolean>;
      };
      sessionCheckpointCwds: Map<string, string>;
    };

    const rollbackSpy = vi.fn(async () => ({
      threadId: "thr_1",
      turns: [{ id: "turn_1", items: [] }],
    }));

    internals.codex.hasSession = () => true;
    internals.codex.readThread = async () => ({
      threadId: "thr_1",
      turns: [
        { id: "turn_1", items: [] },
        { id: "turn_2", items: [] },
      ],
    });
    internals.codex.rollbackThread = rollbackSpy;
    internals.filesystemCheckpointStore.hasCheckpoint = async () => false;
    internals.sessionCheckpointCwds.set("sess_1", "/repo");

    await expect(
      manager.revertToCheckpoint({
        sessionId: "sess_1",
        turnCount: 1,
      }),
    ).rejects.toThrow("Filesystem checkpoint is unavailable for turn 1 in thread thr_1.");
    expect(rollbackSpy).not.toHaveBeenCalled();

    manager.dispose();
  });
});