import { describe, expect, it } from "bun:test";
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { getClineSessionsStreaming } from "./cline";

describe("cline ingestion", () => {
  it("filters default-location sessions by cwd and keeps unresolved cwd", async () => {
    const storageRoot = await mkdtemp(
      join(tmpdir(), "scribe-cline-filter-test-"),
    );
    const fixtures = [
      { id: "inside", cwd: "/Users/test/code/project" },
      { id: "outside", cwd: "/Users/test/other/project" },
      { id: "unresolved", cwd: undefined },
    ];

    try {
      await mkdir(join(storageRoot, "state"), { recursive: true });
      await writeFile(
        join(storageRoot, "state", "taskHistory.json"),
        JSON.stringify(
          fixtures.map((fixture) => ({
            id: fixture.id,
            ts: Date.UTC(2026, 1, 9, 12),
            task: fixture.id,
            tokensIn: 0,
            tokensOut: 0,
            totalCost: 0,
            cwdOnTaskInitialization: fixture.cwd,
          })),
        ),
        "utf8",
      );

      for (const fixture of fixtures) {
        const taskDir = join(storageRoot, "tasks", fixture.id);
        await mkdir(taskDir, { recursive: true });
        await writeFile(
          join(taskDir, "ui_messages.json"),
          JSON.stringify([
            {
              ts: Date.UTC(2026, 1, 9, 12),
              type: "say",
              say: "task",
              text: fixture.id,
            },
          ]),
          "utf8",
        );
      }

      const filtered = [];
      for await (const session of getClineSessionsStreaming(
        ["/Users/test/code"],
        undefined,
        { dataRoots: [storageRoot] },
      )) {
        filtered.push(session.externalThreadId);
      }
      expect(filtered.sort()).toEqual(["inside", "unresolved"]);

      const unfiltered = [];
      for await (const session of getClineSessionsStreaming([], undefined, {
        dataRoots: [storageRoot],
      })) {
        unfiltered.push(session.externalThreadId);
      }
      expect(unfiltered.sort()).toEqual(["inside", "outside", "unresolved"]);
    } finally {
      await rm(storageRoot, { recursive: true, force: true });
    }
  });
});