import { describe, expect, it } from "@effect/vitest";
import { BunServices } from "@effect/platform-bun";
import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import * as Effect from "effect/Effect";

import {
  formatSkillPullSummaryLine,
  formatSkillsTable,
  parseSkillMarker,
  planSkillsPull,
  readExistingSkillEntries,
  removeSkillDirectory,
  resolveEffectiveSkills,
  serializeSkillMarker,
  skillMarkerFor,
  summarizeSkillPullActions,
  writeSkillDirectory,
  SKILL_MARKER_FILENAME,
  type SkillDetail,
  type SkillSummary,
} from "./skills";

const withTmp = <A, E, R>(body: (dir: string) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
  Effect.acquireUseRelease(
    Effect.sync(() => mkdtempSync(join(tmpdir(), "exec-skills-"))),
    body,
    (dir) => Effect.sync(() => rmSync(dir, { recursive: true, force: true })),
  );

const ORIGIN = "https://example.executor.sh";

const summary = (
  input: Partial<SkillSummary> & { owner: "org" | "user"; name: string },
): SkillSummary => ({
  description: "A test skill.",
  files: [{ path: "SKILL.md", size: 10, digest: "sha256:aaa" }],
  updatedAt: Date.parse("2026-01-01T00:00:00.000Z"),
  ...input,
});

describe("resolveEffectiveSkills", () => {
  it("keeps a single skill unaffected", () => {
    const skills = [summary({ owner: "org", name: "docs" })];
    expect(resolveEffectiveSkills(skills)).toEqual(skills);
  });

  it("prefers the user copy over an org copy of the same name", () => {
    const org = summary({ owner: "org", name: "docs", description: "org copy" });
    const user = summary({ owner: "user", name: "docs", description: "user copy" });
    expect(resolveEffectiveSkills([org, user])).toEqual([user]);
    // Order shouldn't matter.
    expect(resolveEffectiveSkills([user, org])).toEqual([user]);
  });

  it("keeps distinct names separate", () => {
    const a = summary({ owner: "org", name: "docs" });
    const b = summary({ owner: "user", name: "release-notes" });
    expect(resolveEffectiveSkills([a, b])).toEqual([a, b]);
  });
});

describe("formatSkillsTable", () => {
  it("reports an empty table", () => {
    expect(formatSkillsTable([])).toEqual(["No skills found."]);
  });

  it("includes a header and one row per skill", () => {
    const lines = formatSkillsTable([summary({ owner: "org", name: "docs" })]);
    expect(lines).toHaveLength(2);
    expect(lines[0]).toContain("OWNER");
    expect(lines[1]).toContain("org");
    expect(lines[1]).toContain("docs");
  });
});

describe("skill markers", () => {
  it("round-trips through serialize/parse", () => {
    const marker = skillMarkerFor({
      origin: ORIGIN,
      skill: { owner: "user", name: "docs" },
      files: [{ path: "SKILL.md", size: 10, digest: "sha256:aaa" }],
    });
    const parsed = parseSkillMarker(serializeSkillMarker(marker));
    expect(parsed).toEqual(marker);
  });

  it("rejects malformed JSON", () => {
    expect(parseSkillMarker("not json")).toBeUndefined();
  });

  it("rejects an object missing required fields", () => {
    expect(parseSkillMarker(JSON.stringify({ origin: ORIGIN }))).toBeUndefined();
  });

  it("rejects an invalid owner", () => {
    expect(
      parseSkillMarker(
        JSON.stringify({ origin: ORIGIN, owner: "nobody", name: "docs", digests: {} }),
      ),
    ).toBeUndefined();
  });

  it("rejects non-string digest values", () => {
    expect(
      parseSkillMarker(
        JSON.stringify({ origin: ORIGIN, owner: "user", name: "docs", digests: { "SKILL.md": 1 } }),
      ),
    ).toBeUndefined();
  });
});

describe("planSkillsPull", () => {
  it("adds a skill with no existing directory", () => {
    const actions = planSkillsPull({
      origin: ORIGIN,
      skills: [summary({ owner: "org", name: "docs" })],
      existing: [],
    });
    expect(actions).toEqual([{ name: "docs", kind: "add" }]);
  });

  it("marks a matching-digest skill unchanged", () => {
    const skill = summary({ owner: "org", name: "docs" });
    const actions = planSkillsPull({
      origin: ORIGIN,
      skills: [skill],
      existing: [
        {
          name: "docs",
          marker: skillMarkerFor({ origin: ORIGIN, skill, files: skill.files }),
        },
      ],
    });
    expect(actions).toEqual([{ name: "docs", kind: "unchanged" }]);
  });

  it("updates a skill whose digests changed", () => {
    const skill = summary({ owner: "org", name: "docs" });
    const staleMarker = skillMarkerFor({
      origin: ORIGIN,
      skill,
      files: [{ path: "SKILL.md", size: 5, digest: "sha256:old" }],
    });
    const actions = planSkillsPull({
      origin: ORIGIN,
      skills: [skill],
      existing: [{ name: "docs", marker: staleMarker }],
    });
    expect(actions).toEqual([{ name: "docs", kind: "update" }]);
  });

  it("never overwrites a directory with no marker", () => {
    const skill = summary({ owner: "org", name: "docs" });
    const actions = planSkillsPull({
      origin: ORIGIN,
      skills: [skill],
      existing: [{ name: "docs", marker: undefined }],
    });
    expect(actions).toEqual([
      { name: "docs", kind: "skip", reason: expect.stringContaining(SKILL_MARKER_FILENAME) },
    ]);
  });

  it("skips a directory owned by a different server", () => {
    const skill = summary({ owner: "org", name: "docs" });
    const otherOriginMarker = skillMarkerFor({
      origin: "https://other.example",
      skill,
      files: skill.files,
    });
    const actions = planSkillsPull({
      origin: ORIGIN,
      skills: [skill],
      existing: [{ name: "docs", marker: otherOriginMarker }],
    });
    expect(actions).toEqual([
      { name: "docs", kind: "skip", reason: expect.stringContaining("different server") },
    ]);
  });

  it("removes a marker-bearing directory whose skill no longer exists upstream", () => {
    const marker = skillMarkerFor({
      origin: ORIGIN,
      skill: { owner: "org", name: "gone" },
      files: [{ path: "SKILL.md", size: 1, digest: "sha256:x" }],
    });
    const actions = planSkillsPull({
      origin: ORIGIN,
      skills: [],
      existing: [{ name: "gone", marker }],
    });
    expect(actions).toEqual([{ name: "gone", kind: "remove", reason: expect.any(String) }]);
  });

  it("never removes an unmanaged directory that has no matching upstream skill", () => {
    const actions = planSkillsPull({
      origin: ORIGIN,
      skills: [],
      existing: [{ name: "my-notes", marker: undefined }],
    });
    expect(actions).toEqual([]);
  });

  it("never removes a directory owned by a different server", () => {
    const marker = skillMarkerFor({
      origin: "https://other.example",
      skill: { owner: "org", name: "gone" },
      files: [],
    });
    const actions = planSkillsPull({
      origin: ORIGIN,
      skills: [],
      existing: [{ name: "gone", marker }],
    });
    expect(actions).toEqual([]);
  });
});

describe("summarizeSkillPullActions / formatSkillPullSummaryLine", () => {
  it("counts each action kind", () => {
    const totals = summarizeSkillPullActions([
      { name: "a", kind: "add" },
      { name: "b", kind: "update" },
      { name: "c", kind: "unchanged" },
      { name: "d", kind: "remove" },
      { name: "e", kind: "skip" },
      { name: "f", kind: "add" },
    ]);
    expect(totals).toEqual({ added: 2, updated: 1, unchanged: 1, removed: 1, skipped: 1 });
    expect(formatSkillPullSummaryLine(totals)).toBe(
      "2 added, 1 updated, 1 removed, 1 skipped (1 unchanged)",
    );
  });

  it("omits the unchanged suffix when there are none", () => {
    const totals = summarizeSkillPullActions([{ name: "a", kind: "add" }]);
    expect(formatSkillPullSummaryLine(totals)).toBe("1 added, 0 updated, 0 removed, 0 skipped");
  });
});

describe("filesystem I/O", () => {
  it.effect("readExistingSkillEntries returns [] for a missing root", () =>
    withTmp((dir) =>
      Effect.gen(function* () {
        const entries = yield* readExistingSkillEntries(join(dir, "does-not-exist"));
        expect(entries).toEqual([]);
      }),
    ).pipe(Effect.provide(BunServices.layer)),
  );

  it.effect("readExistingSkillEntries reports marker and unmarked directories", () =>
    withTmp((dir) =>
      Effect.gen(function* () {
        const managed = join(dir, "docs");
        mkdirSync(managed, { recursive: true });
        const marker = skillMarkerFor({
          origin: ORIGIN,
          skill: { owner: "org", name: "docs" },
          files: [{ path: "SKILL.md", size: 3, digest: "sha256:aaa" }],
        });
        writeFileSync(join(managed, SKILL_MARKER_FILENAME), serializeSkillMarker(marker));

        const unmanaged = join(dir, "my-notes");
        mkdirSync(unmanaged, { recursive: true });

        // A plain file at the root must not be mistaken for a skill directory.
        writeFileSync(join(dir, "readme.txt"), "hi");

        const entries = yield* readExistingSkillEntries(dir);
        const byName = new Map(entries.map((entry) => [entry.name, entry]));
        expect(byName.size).toBe(2);
        expect(byName.get("docs")?.marker).toEqual(marker);
        expect(byName.get("my-notes")?.marker).toBeUndefined();
      }),
    ).pipe(Effect.provide(BunServices.layer)),
  );

  it.effect("writeSkillDirectory writes nested files and a marker", () =>
    withTmp((dir) =>
      Effect.gen(function* () {
        const detail: SkillDetail = {
          owner: "user",
          name: "docs",
          description: "A test skill.",
          updatedAt: Date.now(),
          files: [
            { path: "SKILL.md", size: 5, digest: "sha256:aaa", content: "# Docs" },
            {
              path: "references/guide.md",
              size: 6,
              digest: "sha256:bbb",
              content: "Guide.",
            },
          ],
        };
        yield* writeSkillDirectory({ root: dir, origin: ORIGIN, skill: detail });

        const entries = yield* readExistingSkillEntries(dir);
        expect(entries).toHaveLength(1);
        expect(entries[0]?.marker?.origin).toBe(ORIGIN);
        expect(entries[0]?.marker?.digests).toEqual({
          "SKILL.md": "sha256:aaa",
          "references/guide.md": "sha256:bbb",
        });
      }),
    ).pipe(Effect.provide(BunServices.layer)),
  );

  it.effect("removeSkillDirectory deletes the directory recursively", () =>
    withTmp((dir) =>
      Effect.gen(function* () {
        const target = join(dir, "docs", "references");
        mkdirSync(target, { recursive: true });
        writeFileSync(join(target, "guide.md"), "Guide.");

        yield* removeSkillDirectory(dir, "docs");

        const entries = yield* readExistingSkillEntries(dir);
        expect(entries).toEqual([]);
      }),
    ).pipe(Effect.provide(BunServices.layer)),
  );
});