import assert from "node:assert/strict";
import { describe, it } from "vitest";
import {
	boardStateFor,
	boardStateForInitialization,
	boardStateSource,
	emptyBoardState,
	parseBoardState,
	updateBoardState,
} from "../board-state.ts";
import type { BundleDocumentRecord, DocumentMetadata } from "../documents.ts";
import { SystemDocumentError } from "../documents.ts";

const document = (metadata: DocumentMetadata): BundleDocumentRecord => ({
	path: `.system/${metadata.type}s/${metadata.id}-fixture/index.md`,
	metadata,
	frontmatter: new Map(),
});
const spec = document({
	id: "PX-SPEC-SPEC0001",
	type: "spec",
	title: "Contract",
});
const planA = document({
	id: "PX-PLAN-PLAN0001",
	type: "plan",
	title: "Build",
	spec: spec.metadata.id,
	status: "approved",
});
const planB = document({
	id: "PX-PLAN-PLAN0002",
	type: "plan",
	title: "Test",
	spec: spec.metadata.id,
	status: "approved",
});
const issue = document({
	id: "PX-ISSUE-ISSUE001",
	type: "issue",
	title: "Bug",
	specs: [spec.metadata.id],
});
const documents = [spec, planA, planB, issue];
const at = "2026-03-20T12:00:00.000Z";

describe("board state", () => {
	it("defaults specs and plans to todo and issues to open", () => {
		const board = emptyBoardState();
		assert.equal(boardStateFor(board, spec.metadata), "todo");
		assert.equal(boardStateFor(board, planA.metadata), "todo");
		assert.equal(boardStateFor(board, issue.metadata), "open");
	});

	it("keeps spec state manual while requiring every existing plan done", () => {
		let board = emptyBoardState();
		assert.throws(
			() =>
				updateBoardState(
					board,
					documents,
					spec.metadata.id,
					"done",
					"manual",
					at,
				),
			(error: unknown) =>
				error instanceof SystemDocumentError &&
				error.code === "board.spec-plans",
		);
		board = updateBoardState(
			board,
			documents,
			planA.metadata.id,
			"done",
			"manual",
			at,
		);
		board = updateBoardState(
			board,
			documents,
			planB.metadata.id,
			"done",
			"manual",
			at,
		);
		assert.equal(boardStateFor(board, spec.metadata), "todo");
		board = updateBoardState(
			board,
			documents,
			spec.metadata.id,
			"done",
			"manual",
			at,
		);
		assert.equal(boardStateFor(board, spec.metadata), "done");
	});

	it("allows a planless spec done and never lets issues demote it", () => {
		let board = updateBoardState(
			emptyBoardState(),
			[spec, issue],
			spec.metadata.id,
			"done",
			"manual",
			at,
		);
		board = updateBoardState(
			board,
			[spec, issue],
			issue.metadata.id,
			"open",
			"manual",
			at,
		);
		assert.equal(boardStateFor(board, spec.metadata), "done");
	});

	it("reopening one plan demotes its spec without changing sibling plans", () => {
		let board = emptyBoardState();
		for (const id of [planA.metadata.id, planB.metadata.id, spec.metadata.id])
			board = updateBoardState(board, documents, id, "done", "manual", at);
		board = updateBoardState(
			board,
			documents,
			planA.metadata.id,
			"todo",
			"manual",
			at,
		);
		assert.equal(boardStateFor(board, spec.metadata), "todo");
		assert.equal(boardStateFor(board, planB.metadata), "done");
	});

	it("round-trips agent entries with notes and clears them on later writes", () => {
		let board = updateBoardState(
			emptyBoardState(),
			documents,
			planA.metadata.id,
			"done",
			"agent",
			at,
			" exec verified: 12 tests pass ",
		);
		assert.deepEqual(board.items[planA.metadata.id], {
			state: "done",
			source: "agent",
			updatedAt: at,
			note: "exec verified: 12 tests pass",
		});
		assert.deepEqual(parseBoardState(boardStateSource(board), "PX"), board);
		board = updateBoardState(
			board,
			documents,
			planA.metadata.id,
			"todo",
			"manual",
			at,
		);
		assert.deepEqual(board.items[planA.metadata.id], {
			state: "todo",
			source: "manual",
			updatedAt: at,
		});
	});

	it("rejects unknown sources and oversized notes", () => {
		const entry = (extra: string) =>
			`{"schemaVersion":0,"items":{"${planA.metadata.id}":{"state":"done","source":${extra}}}}`;
		assert.throws(
			() => parseBoardState(entry(`"robot","updatedAt":"${at}"`), "PX"),
			(error: unknown) =>
				error instanceof SystemDocumentError && error.code === "board.source",
		);
		assert.throws(
			() =>
				parseBoardState(
					entry(`"agent","updatedAt":"${at}","note":"${"x".repeat(201)}"`),
					"PX",
				),
			(error: unknown) =>
				error instanceof SystemDocumentError && error.code === "board.note",
		);
		assert.throws(
			() =>
				parseBoardState(entry(`"agent","updatedAt":"${at}","why":"x"`), "PX"),
			(error: unknown) =>
				error instanceof SystemDocumentError && error.code === "board.keys",
		);
	});

	it("parses strict schema 0 and directly rewrites version mismatches", () => {
		const current = updateBoardState(
			emptyBoardState(),
			documents,
			issue.metadata.id,
			"done",
			"assess",
			at,
		);
		assert.deepEqual(parseBoardState(boardStateSource(current), "PX"), current);
		const mismatched = boardStateSource(current).replace(
			'"schemaVersion": 0',
			'"schemaVersion": 9',
		);
		assert.equal(
			boardStateForInitialization(mismatched, "PX").sourceSchemaVersion,
			9,
		);
		assert.throws(
			() => parseBoardState(mismatched, "PX"),
			(error: unknown) =>
				error instanceof SystemDocumentError && error.code === "board.version",
		);
	});
});