import { describe, expect, test } from "bun:test";
import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { loadCourse } from "@stc/course-format";
import { MEDIA_REFS, parseMediaRefs } from "../src/server/media-refs";
import { BIG_PDF, makeImportedCourse, VIDEO, VIDEO2, videoBytes } from "./import-fixture";
import { ada, extGit, newStore } from "./helpers";

const ino = (p: string) => statSync(p).ino;
const tracked = async (dir: string) => (await extGit(dir, "-c", "core.quotepath=false", "ls-files")).split("\n").filter(Boolean).sort();

describe("convertImported", () => {
  test("builds the repo and published worktree; large media stay out of git as hard links", async () => {
    const { dataDir, store } = await newStore();
    const src = makeImportedCourse(dataDir, { hostile: true });
    const srcVideoIno = ino(join(src, VIDEO));
    const r = await store.convertImported("imp", ada);
    expect(r.media).toBe(3);
    expect(store.isManaged("imp")).toBe(true);
    expect(existsSync(join(dataDir, "studio/repos/imp.git/HEAD"))).toBe(true);
    expect(existsSync(src)).toBe(false);
    const mediaRoot = join(dataDir, "media/imp");
    expect(existsSync(join(mediaRoot, "stcourse.yaml"))).toBe(true);

    const pub = store.paths("imp").published;
    expect(await tracked(pub)).toEqual([
      ".gitignore", MEDIA_REFS, "code/S01 - Basics/.gitignore", "code/S01 - Basics/README.md", "media/cover.jpg", "stcourse.yaml", "transcripts/l1.md",
    ]);
    // the symlink was skipped, never followed; .git contents never copied
    expect(existsSync(join(pub, "code/leak.txt"))).toBe(false);
    expect(existsSync(join(pub, "code/.git"))).toBe(false);
    expect(await extGit(pub, "status", "--porcelain", "--untracked-files=all")).toBe("");

    const refs = parseMediaRefs(readFileSync(join(pub, MEDIA_REFS), "utf8"))!;
    expect(refs.map((x) => x.path).sort()).toEqual([BIG_PDF, VIDEO2, VIDEO].sort());
    const v = refs.find((x) => x.path === VIDEO)!;
    expect(v.size).toBe(4096);
    expect(v.sha256).toBe(new Bun.CryptoHasher("sha256").update(videoBytes(4096, 7)).digest("hex"));
    for (const p of [VIDEO, VIDEO2, BIG_PDF]) expect(ino(join(pub, p))).toBe(ino(join(mediaRoot, p)));
    expect(ino(join(mediaRoot, VIDEO))).toBe(srcVideoIno);

    // the course loads from the published worktree exactly as before
    const c = await loadCourse(join(pub, "stcourse.yaml"));
    expect(c.status).toBe("ok");
    expect(c.manifest?.visibility).toBe("restricted");
    expect(c.manifest?.source?.kind).toBe("video-folder");
    // the commit is attributed to the converting owner
    expect(await extGit(pub, "log", "-1", "--format=%an <%ae>")).toBe(`${ada.name} <${ada.email}>`);
  });

  test("a draft gets the media; listFiles shows them; the media and reference file are read-only", async () => {
    const { dataDir, store } = await newStore();
    makeImportedCourse(dataDir);
    await store.convertImported("imp", ada);
    const draft = await store.ensureDraft("imp", ada.id);
    expect(ino(join(draft, VIDEO))).toBe(ino(join(dataDir, "media/imp", VIDEO)));
    const files = await store.listFiles("imp", ada.id);
    expect(files).toContain(VIDEO);
    expect(files).toContain(BIG_PDF);
    for (const path of [VIDEO, MEDIA_REFS]) {
      await expect(store.saveFiles("imp", ada, [{ path, content: "x" }], "x")).rejects.toMatchObject({ status: 409 });
      await expect(store.saveFiles("imp", ada, [{ path, delete: true }], "x")).rejects.toMatchObject({ status: 409 });
    }
    expect(readFileSync(join(dataDir, "media/imp", VIDEO))).toEqual(Buffer.from(videoBytes(4096, 7)));
  });

  test("a studio write to a hard-linked file breaks the link instead of writing through it", async () => {
    const { dataDir, store } = await newStore();
    makeImportedCourse(dataDir);
    await store.convertImported("imp", ada);
    const draft = await store.ensureDraft("imp", ada.id);
    // a planted hard link at an ordinary (non-referenced) path
    const outside = join(dataDir, "media/imp/transcripts/l1.md");
    rmSync(join(draft, "transcripts/l1.md"));
    const { linkSync } = await import("node:fs");
    linkSync(outside, join(draft, "transcripts/l1.md"));
    expect((await store.saveFiles("imp", ada, [{ path: "transcripts/l1.md", content: "# changed\n" }], "edit")).ok).toBe(true);
    expect(readFileSync(outside, "utf8")).toBe("# Intro\n\n[0:00] Hello.\n");
    expect(readFileSync(join(draft, "transcripts/l1.md"), "utf8")).toBe("# changed\n");
  });

  test("edit and publish: the published worktree keeps its media and stays clean", async () => {
    const { dataDir, store } = await newStore();
    makeImportedCourse(dataDir);
    await store.convertImported("imp", ada);
    const m = (await store.readFile("imp", ada.id, "stcourse.yaml"))!;
    const next = m.content.replace("title: Intro", "title: Welcome aboard");
    expect((await store.saveFiles("imp", ada, [{ path: "stcourse.yaml", content: next, baseHash: m.hash }], "Rename lesson")).ok).toBe(true);
    const r = await store.publish("imp", ada);
    expect(r).toMatchObject({ ok: true, published: true });
    const pub = store.paths("imp").published;
    expect(readFileSync(join(pub, "stcourse.yaml"), "utf8")).toContain("title: Welcome aboard");
    expect(ino(join(pub, VIDEO))).toBe(ino(join(dataDir, "media/imp", VIDEO)));
    expect(await extGit(pub, "status", "--porcelain", "--untracked-files=all")).toBe("");
  });

  test("a non-owner cannot publish the converted course as public; the owner can", async () => {
    const { dataDir, store } = await newStore();
    makeImportedCourse(dataDir);
    await store.convertImported("imp", ada);
    const m = (await store.readFile("imp", ada.id, "stcourse.yaml"))!;
    await store.saveFiles("imp", ada, [{ path: "stcourse.yaml", content: m.content.replace("visibility: restricted", "visibility: public"), baseHash: m.hash }], "go public");
    expect(await store.publish("imp", ada)).toMatchObject({ ok: false, reason: "forbidden" });
    expect(await store.publish("imp", { ...ada, owner: true })).toMatchObject({ ok: true, published: true });
  });

  describe("refusals leave the import untouched and no repo behind", () => {
    const cases: [string, (dataDir: string) => void, number][] = [
      ["no such import", () => {}, 404],
      ["an authored course", (d) => makeImportedCourse(d, { kind: "authored" }), 400],
      ["a manifest id mismatch", (d) => makeImportedCourse(d, { manifestId: "other" }), 400],
      ["a root: field", (d) => makeImportedCourse(d, { root: "." }), 400],
      ["a media store already there", (d) => { makeImportedCourse(d); mkdirSync(join(d, "media/imp"), { recursive: true }); }, 409],
    ];
    test.each(cases)("%s", async (_name, prepare, status) => {
      const { dataDir, store } = await newStore();
      prepare(dataDir);
      const before = existsSync(join(dataDir, "courses/imp/stcourse.yaml")) ? readFileSync(join(dataDir, "courses/imp/stcourse.yaml"), "utf8") : null;
      await expect(store.convertImported("imp", ada)).rejects.toMatchObject({ status });
      expect(existsSync(join(dataDir, "studio/repos/imp.git"))).toBe(false);
      expect(existsSync(join(dataDir, "worktrees/imp"))).toBe(false);
      if (before !== null) expect(readFileSync(join(dataDir, "courses/imp/stcourse.yaml"), "utf8")).toBe(before);
    });

    test("a studio course with the same id", async () => {
      const { store } = await newStore();
      await store.createCourse({ id: "imp", title: "Studio" }, ada);
      await expect(store.convertImported("imp", ada)).rejects.toMatchObject({ status: 409 });
      expect(store.isManaged("imp")).toBe(true);
    });

    test("a large file whose name has a line break", async () => {
      const { dataDir, store } = await newStore();
      const src = makeImportedCourse(dataDir);
      writeFileSync(join(src, "media/bad\nname.mp4"), "x");
      await expect(store.convertImported("imp", ada)).rejects.toMatchObject({ status: 400 });
      expect(existsSync(join(dataDir, "studio/repos/imp.git"))).toBe(false);
      expect(existsSync(join(src, "stcourse.yaml"))).toBe(true);
    });
  });

  describe("restart safety", () => {
    test("a leftover partial repo (no published worktree) is rebuilt", async () => {
      const { dataDir, store } = await newStore();
      makeImportedCourse(dataDir);
      mkdirSync(join(dataDir, "studio/repos/imp.git"), { recursive: true });
      writeFileSync(join(dataDir, "studio/repos/imp.git/junk"), "x");
      await store.convertImported("imp", ada);
      expect(store.isManaged("imp")).toBe(true);
      expect(existsSync(join(dataDir, "studio/repos/imp.git/junk"))).toBe(false);
    });

    test("a managed course whose import folder is still there only finishes the move", async () => {
      const { dataDir, store } = await newStore();
      makeImportedCourse(dataDir);
      await store.convertImported("imp", ada);
      const head = await store.publishedHead("imp");
      // simulate a crash between the checkout and the move
      const { renameSync } = await import("node:fs");
      renameSync(join(dataDir, "media/imp"), join(dataDir, "courses/imp"));
      const r = await store.convertImported("imp", ada);
      expect(r.resumed).toBe(true);
      expect(await store.publishedHead("imp")).toBe(head);
      expect(existsSync(join(dataDir, "courses/imp"))).toBe(false);
      expect(existsSync(join(dataDir, "media/imp", VIDEO))).toBe(true);
    });
  });
});