import { describe, expect, test } from "bun:test";
import { extractWikilinks, renderMarkdown } from "../../src/lib/markdown.ts";

describe("renderMarkdown", () => {
	test("does not render raw HTML (XSS prevention)", () => {
		const { html } = renderMarkdown('<script>alert("xss")</script>');
		expect(html).not.toContain("<script>");
	});

	test("renders empty string without error", () => {
		const { html } = renderMarkdown("");
		expect(html).toBe("");
	});

	test("defaults content images to lazy loading + async decode", () => {
		const { html } = renderMarkdown("![a diagram](https://example.com/x.png)");
		expect(html).toContain('loading="lazy"');
		expect(html).toContain('decoding="async"');
	});

	test("applies lazy loading to titled and inline images", () => {
		const { html } = renderMarkdown(
			'text ![alt](https://example.com/y.jpg "title") more',
		);
		expect(html).toContain('loading="lazy"');
		expect(html).toContain('decoding="async"');
		expect(html).toContain('title="title"');
	});

	test("reads an Obsidian width off the alt text", () => {
		const { html } = renderMarkdown(
			"![diagram|300](https://example.com/x.png)",
		);
		expect(html).toContain('width="300"');
		expect(html).toContain('alt="diagram"');
		expect(html).not.toContain("diagram|300");
	});

	test("reads an Obsidian width and height off the alt text", () => {
		const { html } = renderMarkdown(
			"![diagram|300x200](https://example.com/x.png)",
		);
		expect(html).toContain('width="300"');
		expect(html).toContain('height="200"');
		expect(html).toContain('alt="diagram"');
	});

	test("reads an Obsidian width off a wholly numeric alt", () => {
		const { html } = renderMarkdown("![300](https://example.com/x.png)");
		expect(html).toContain('width="300"');
		expect(html).toContain('alt=""');
	});

	test("reads width and height off a wholly numeric alt", () => {
		const { html } = renderMarkdown("![300x200](https://example.com/x.png)");
		expect(html).toContain('width="300"');
		expect(html).toContain('height="200"');
		expect(html).toContain('alt=""');
	});

	test("leaves an alt that only starts with digits alone", () => {
		const { html } = renderMarkdown("![300 dpi](https://example.com/x.png)");
		expect(html).toContain('alt="300 dpi"');
		expect(html).not.toContain("width=");
	});

	test("leaves a non-numeric pipe in the alt alone", () => {
		const { html } = renderMarkdown("![a|b](https://example.com/x.png)");
		expect(html).toContain('alt="a|b"');
		expect(html).not.toContain("width=");
	});

	test("sizes an image whose alt carries markup", () => {
		const { html } = renderMarkdown(
			"![**bold**|300](https://example.com/x.png)",
		);
		expect(html).toContain('width="300"');
		expect(html).toContain('alt="bold"');
	});

	test("wraps tables in a scroll container that survives sanitization", () => {
		const { html } = renderMarkdown("| a | b |\n| - | - |\n| 1 | 2 |");
		expect(html).toContain('<div class="table-wrap">');
		expect(html).toContain("</table>");
		expect(html.indexOf('<div class="table-wrap">')).toBeLessThan(
			html.indexOf("<table>"),
		);
	});

	test("leaves prose without a table unwrapped", () => {
		const { html } = renderMarkdown("just a paragraph");
		expect(html).not.toContain("table-wrap");
	});

	test("renders inline KaTeX math", () => {
		const { html } = renderMarkdown("Energy is $E = mc^2$.");
		expect(html).toContain('class="katex"');
		expect(html).toContain("katex-mathml");
		expect(html).toContain("E = mc^2");
	});

	test("renders block KaTeX math", () => {
		const { html } = renderMarkdown("$$\\int_0^1 x^2 \\; dx$$");
		expect(html).toContain('class="katex-display"');
		expect(html).toContain("katex-mathml");
		expect(html).toContain(String.raw`\int_0^1 x^2 \; dx`);
	});

	test("escapes invalid KaTeX to prevent XSS", () => {
		const malicious = "$<img src=x onerror=alert(1)>";
		const { html } = renderMarkdown(malicious);
		expect(html).not.toContain("<img");
		expect(html).toContain("&lt;img");
	});

	test("hasMath is true for inline math", () => {
		const result = renderMarkdown("Energy is $E = mc^2$.");
		expect(result.hasMath).toBe(true);
	});

	test("hasMath is true for block math", () => {
		const result = renderMarkdown("$$\\int_0^1 x^2 \\; dx$$");
		expect(result.hasMath).toBe(true);
	});

	test("hasMath is false when no math present", () => {
		const result = renderMarkdown("Just plain text.");
		expect(result.hasMath).toBe(false);
	});
});

describe("wikilinks", () => {
	const WIKI = "test-wiki";
	const HANDLE = "alice.test";

	test("renders [[slug]] as a link with wiki prefix", () => {
		const { html } = renderMarkdown("see [[my-page]]", WIKI, HANDLE);
		expect(html).toContain('href="/@alice.test/test-wiki/my-page"');
		expect(html).toContain('class="wikilink"');
	});

	test("drops the ! of an embed rather than rendering it", () => {
		const { html } = renderMarkdown("![[my-page]]", WIKI, HANDLE);
		expect(html).toContain('href="/@alice.test/test-wiki/my-page"');
		expect(html).not.toContain("!<a");
		expect(html).toBe(
			'<p><a href="/@alice.test/test-wiki/my-page" class="wikilink" rel="noopener noreferrer">my-page</a></p>\n',
		);
	});

	test("keeps an escaped ! before a wikilink", () => {
		const { html } = renderMarkdown("\\![[my-page]]", WIKI, HANDLE);
		expect(html).toContain("!<a");
	});

	test("leaves exclamation marks in ordinary text alone", () => {
		const { html } = renderMarkdown("Hello! World", WIKI, HANDLE);
		expect(html).toContain("Hello! World");
	});

	test("renders [[slug|label]] with custom label", () => {
		const { html } = renderMarkdown(
			"see [[my-page|My Page Title]]",
			WIKI,
			HANDLE,
		);
		expect(html).toContain('href="/@alice.test/test-wiki/my-page"');
		expect(html).toContain("My Page Title");
	});

	test("renders cross-wiki links with explicit @handle/wiki/note", () => {
		const { html } = renderMarkdown(
			"see [[@alice.test/other-wiki/my-page]]",
			WIKI,
			HANDLE,
		);
		expect(html).toContain('href="/@alice.test/other-wiki/my-page"');
		expect(html).toContain(">@alice.test/other-wiki/my-page<");
	});

	test("renders cross-wiki links with custom label", () => {
		const { html } = renderMarkdown(
			"see [[@alice.test/other-wiki/my-page|Other Page]]",
			WIKI,
			HANDLE,
		);
		expect(html).toContain('href="/@alice.test/other-wiki/my-page"');
		expect(html).toContain("Other Page");
	});

	test("ignores wiki/note without @handle (invalid syntax)", () => {
		const { html } = renderMarkdown("see [[other-wiki/my-page]]", WIKI, HANDLE);
		expect(html).not.toContain("wikilink");
		expect(html).toContain("[[other-wiki/my-page]]");
	});

	test("renders same-wiki link with section anchor", () => {
		const { html } = renderMarkdown(
			"see [[my-page#introduction]]",
			WIKI,
			HANDLE,
		);
		expect(html).toContain(
			'href="/@alice.test/test-wiki/my-page#introduction"',
		);
		expect(html).toContain(">my-page#introduction<");
	});

	test("renders cross-wiki link with section anchor", () => {
		const { html } = renderMarkdown(
			"see [[@alice.test/other-wiki/my-page#details]]",
			WIKI,
			HANDLE,
		);
		expect(html).toContain('href="/@alice.test/other-wiki/my-page#details"');
		expect(html).toContain(">@alice.test/other-wiki/my-page#details<");
	});

	test("renders wiki home page link", () => {
		const { html } = renderMarkdown(
			"see [[@alice.test/other-wiki/]]",
			WIKI,
			HANDLE,
		);
		expect(html).toContain('href="/@alice.test/other-wiki"');
		expect(html).toContain(">@alice.test/other-wiki<");
	});

	test("renders bare anchor on current page", () => {
		const { html } = renderMarkdown("jump to [[#section]]", WIKI);
		expect(html).toContain('href="#section"');
		expect(html).toContain(">section<");
	});

	test("section links with custom labels", () => {
		const { html } = renderMarkdown(
			"[[my-page#intro|Introduction]]",
			WIKI,
			HANDLE,
		);
		expect(html).toContain('href="/@alice.test/test-wiki/my-page#intro"');
		expect(html).toContain("Introduction");
	});

	test("handles multiple wikilinks in one line", () => {
		const { html } = renderMarkdown("[[page-a]] and [[page-b]]", WIKI, HANDLE);
		expect(html).toContain('href="/@alice.test/test-wiki/page-a"');
		expect(html).toContain('href="/@alice.test/test-wiki/page-b"');
	});

	test("handles pipe in label (preserves extra pipes)", () => {
		const { html } = renderMarkdown("[[slug|label with | pipe]]", WIKI, HANDLE);
		expect(html).toContain('href="/@alice.test/test-wiki/slug"');
		expect(html).toContain("label with | pipe");
	});

	test("does not match unclosed brackets", () => {
		const { html } = renderMarkdown("[[unclosed", WIKI);
		expect(html).not.toContain("wikilink");
		expect(html).toContain("[[unclosed");
	});

	test("trims whitespace in slug and label", () => {
		const { html } = renderMarkdown("[[ my-page | My Page ]]", WIKI, HANDLE);
		expect(html).toContain('href="/@alice.test/test-wiki/my-page"');
		expect(html).toContain("My Page");
	});

	test("falls back to bare slug when no wikiSlug provided", () => {
		const { html } = renderMarkdown("see [[my-page]]");
		expect(html).toContain('href="my-page"');
	});

	test("XSS in wikilink slug: quote breakout in href is escaped", () => {
		const { html } = renderMarkdown('[[" onclick="alert(1)]]', WIKI);
		// The injected sequence only survives as inert text content; no element
		// gets a real onclick attribute, and the href is a slugified safe value.
		expect(html).not.toMatch(/<[a-z]+\s[^>]*onclick\s*=/i);
		expect(html).toContain("wikilink");
	});

	test("XSS in wikilink label: HTML tags are escaped", () => {
		const { html } = renderMarkdown(
			"[[safe-slug|<img src=x onerror=alert(1)>]]",
			WIKI,
			HANDLE,
		);
		expect(html).toContain('href="/@alice.test/test-wiki/safe-slug"');
		expect(html).not.toContain("<img");
		expect(html).toContain("&lt;img");
	});

	test("renders [[slug#heading]] with anchor fragment and default label", () => {
		const { html } = renderMarkdown("see [[my-page#My Heading]]", WIKI, HANDLE);
		expect(html).toContain('href="/@alice.test/test-wiki/my-page#my-heading"');
		expect(html).toContain(">my-page#My Heading<");
	});

	test("renders [[slug#heading|label]] with custom label", () => {
		const { html } = renderMarkdown("see [[my-page#Intro|Jump]]", WIKI, HANDLE);
		expect(html).toContain('href="/@alice.test/test-wiki/my-page#intro"');
		expect(html).toContain(">Jump<");
	});
});

describe("strikethrough", () => {
	test("renders strikethrough", () => {
		const { html } = renderMarkdown("~~deleted~~");
		expect(html).toContain("<s>");
		expect(html).toContain("deleted");
	});
});

describe("highlights", () => {
	test("renders highlight markup", () => {
		const { html } = renderMarkdown("This is ==highlighted== text.");
		expect(html).toContain("<mark>");
		expect(html).toContain("highlighted");
	});

	test("highlight does not collide with other inline", () => {
		const { html } = renderMarkdown("**bold** and ==highlight== and `code`");
		expect(html).toContain("<mark>");
		expect(html).toContain("<strong>");
		expect(html).toContain("<code>");
	});
});

describe("callouts", () => {
	test("renders basic callout", () => {
		const { html } = renderMarkdown("> [!NOTE]\n> This is a note.");
		expect(html).toContain('class="callout callout-note"');
		expect(html).toContain("callout-title");
		expect(html).toContain("Note");
		expect(html).toContain("This is a note.");
	});

	test("renders custom title", () => {
		const { html } = renderMarkdown("> [!WARNING] Be careful\n> Details here.");
		expect(html).toContain("Be careful");
		expect(html).toContain("callout-warning");
	});

	test("normalizes type aliases", () => {
		const { html } = renderMarkdown("> [!HINT]\n> A hint.");
		expect(html).toContain("callout-tip");
	});

	test("unknown type uses raw name as class", () => {
		const { html } = renderMarkdown("> [!CUSTOM]\n> Custom.");
		expect(html).toContain("callout-custom");
	});

	test("regular blockquotes are unaffected", () => {
		const { html } = renderMarkdown("> Just a normal quote.");
		expect(html).toContain("<blockquote>");
		expect(html).not.toContain("callout");
	});

	test("multi-paragraph callout", () => {
		const src = "> [!TIP]\n> First para.\n>\n> Second para.";
		const { html } = renderMarkdown(src);
		expect(html).toContain("First para");
		expect(html).toContain("Second para");
		expect(html).toContain("callout-tip");
	});

	test("callout without a fold marker stays a plain div", () => {
		const { html } = renderMarkdown("> [!NOTE] Plain\n> body");
		expect(html).toContain('<div class="callout callout-note"');
		expect(html).not.toContain("<details");
	});

	test("minus marker renders a collapsed disclosure", () => {
		const { html } = renderMarkdown("> [!NOTE]- Collapsed\n> body");
		expect(html).toContain('<details class="callout callout-note">');
		expect(html).toContain("<summary");
		expect(html).not.toContain("open>");
	});

	test("plus marker renders an open disclosure", () => {
		const { html } = renderMarkdown("> [!NOTE]+ Expanded\n> body");
		expect(html).toContain('<details class="callout callout-note" open>');
	});

	test("fold marker never leaks into the title", () => {
		for (const marker of ["-", "+"]) {
			const { html } = renderMarkdown(`> [!NOTE]${marker} Real title\n> body`);
			expect(html).toContain("Real title");
			expect(html).not.toContain(`${marker} Real title`);
		}
	});

	test("folded callout with no title keeps the default title", () => {
		const { html } = renderMarkdown("> [!WARNING]-\n> body");
		expect(html).toContain("<summary");
		expect(html).toContain("Warning");
	});

	test("nested folded callouts each close correctly", () => {
		const { html } = renderMarkdown(
			"> [!NOTE]- Outer\n> > [!TIP]- Inner\n> > deep",
		);
		expect(html.match(/<details/g)).toHaveLength(2);
		expect(html.match(/<\/details>/g)).toHaveLength(2);
	});
});

describe("syntax highlighting", () => {
	test("highlights known language", () => {
		const { html } = renderMarkdown("```typescript\nconst x = 1;\n```");
		expect(html).toContain("shiki");
		expect(html).toContain("const");
	});

	test("falls back gracefully for unknown language", () => {
		const { html } = renderMarkdown("```unknownlang\nfoo bar\n```");
		expect(html).toContain("foo bar");
		expect(html).toContain("<code");
		expect(html).not.toContain("shiki");
	});

	test("plain code block (no language) renders without highlighting", () => {
		const { html } = renderMarkdown("```\nplain text\n```");
		expect(html).toContain("plain text");
		expect(html).not.toContain("shiki");
	});

	test("does not interfere with viz blocks", () => {
		const src = '```viz-graph\n{"nodes":[],"links":[]}\n```';
		const { html } = renderMarkdown(src);
		expect(html).toContain("data-viz-type");
		expect(html).not.toContain("shiki");
	});

	test("preserves dark theme CSS vars through sanitizer", () => {
		const { html } = renderMarkdown("```typescript\nconst x = 1;\n```");
		expect(html).toContain("--shiki-dark");
	});
});

describe("task lists", () => {
	test("renders unchecked task", () => {
		const { html } = renderMarkdown("- [ ] Todo item");
		expect(html).toContain('type="checkbox"');
		expect(html).not.toContain("checked");
	});

	test("renders checked task", () => {
		const { html } = renderMarkdown("- [x] Done item");
		expect(html).toContain('type="checkbox"');
		expect(html).toContain("checked");
	});

	test("checkboxes are disabled (read-only)", () => {
		const { html } = renderMarkdown("- [x] Item");
		expect(html).toContain("disabled");
	});

	test("mixes regular list items and tasks", () => {
		const src = "- Regular item\n- [ ] Task item\n- Another regular";
		const { html } = renderMarkdown(src);
		expect(html).toContain('type="checkbox"');
		expect(html).toContain("Regular item");
	});

	test("exposes the state of a plain task as data-task", () => {
		expect(renderMarkdown("- [ ] Todo").html).toContain('data-task=" "');
		expect(renderMarkdown("- [x] Done").html).toContain('data-task="x"');
	});

	test("renders an alternate state as a checkbox", () => {
		const { html } = renderMarkdown("- [/] Partially done");
		expect(html).toContain('type="checkbox"');
		expect(html).toContain('data-task="/"');
		expect(html).toContain("task-alt");
		expect(html).toContain("Partially done");
		expect(html).not.toContain("[/]");
	});

	test("leaves an alternate state unchecked", () => {
		const { html } = renderMarkdown("- [?] Unsure");
		expect(html).not.toContain("checked");
	});

	test("marks a mixed list once, not once per task", () => {
		const { html } = renderMarkdown("- [ ] plain\n- [/] alt\n- [>] other");
		expect(html.match(/contains-task-list/g)).toHaveLength(1);
	});

	test("does not checkbox a list item opening with a link", () => {
		const { html } = renderMarkdown("- [/](https://example.com) not a task");
		expect(html).not.toContain('type="checkbox"');
		expect(html).toContain("<a");
	});

	test("carries a quote marker into the attribute intact", () => {
		const { html } = renderMarkdown('- ["] Quoted marker');
		expect(html).toContain(
			'class="task-list-item-checkbox" data-task="&quot;"',
		);
	});

	test("does not checkbox a paragraph outside a list", () => {
		const { html } = renderMarkdown("> [/] quoted, not a task");
		expect(html).not.toContain('type="checkbox"');
		expect(html).toContain("[/]");
	});
});

describe("footnotes", () => {
	test("renders reference + definition", () => {
		const { html } = renderMarkdown("Sentence.[^1]\n\n[^1]: Note text.");
		expect(html).toContain('class="footnote-ref"');
		expect(html).toContain('class="footnotes"');
		expect(html).toContain("Note text");
	});

	test("renders inline footnote (^[...])", () => {
		const { html } = renderMarkdown("Inline.^[Inline note]");
		expect(html).toContain('class="footnote-ref"');
		expect(html).toContain("Inline note");
	});

	test("supports multi-paragraph footnotes", () => {
		const src = "Ref.[^a]\n\n[^a]: First para.\n\n    Second para.";
		const { html } = renderMarkdown(src);
		expect(html).toContain("First para");
		expect(html).toContain("Second para");
	});

	test("does not collide with wikilinks", () => {
		const { html } = renderMarkdown(
			"See [[other-note]] and ref.[^1]\n\n[^1]: foo",
			"wiki",
			"alice.test",
		);
		expect(html).toContain('class="wikilink"');
		expect(html).toContain('class="footnote-ref"');
	});

	test("sanitizer preserves <section>", () => {
		const { html } = renderMarkdown("x[^1]\n\n[^1]: y");
		expect(html).toContain("<section");
		expect(html).toContain('class="footnotes"');
	});
});

describe("comments", () => {
	test("inline comment is stripped", () => {
		const { html } = renderMarkdown("Hello %%hidden%% world");
		expect(html).toContain("Hello");
		expect(html).toContain("world");
		expect(html).not.toContain("hidden");
		expect(html).not.toContain("%%");
	});

	test("block comment is stripped", () => {
		const src = "Before\n\n%%\nThis is hidden\nacross lines\n%%\n\nAfter";
		const { html } = renderMarkdown(src);
		expect(html).toContain("Before");
		expect(html).toContain("After");
		expect(html).not.toContain("hidden");
		expect(html).not.toContain("across lines");
	});

	test("whole-line %% comment %% is stripped entirely", () => {
		const { html } = renderMarkdown("%% just a comment %%");
		expect(html.trim()).toBe("");
	});

	test("preserves visible text after a same-line %% close", () => {
		const { html } = renderMarkdown("%% hidden %% visible text");
		expect(html).toContain("visible text");
		expect(html).not.toContain("hidden");
	});

	test("does not affect single percent signs", () => {
		const { html } = renderMarkdown("50% complete and 100% done");
		expect(html).toContain("50% complete");
		expect(html).toContain("100% done");
	});

	test("does not affect unclosed %%", () => {
		const { html } = renderMarkdown("This has %% but no close");
		expect(html).toContain("%%");
	});
});

describe("security", () => {
	test("callout type rejects non-word characters", () => {
		const { html } = renderMarkdown("> [!no<script>te]\n> test");
		expect(html).toContain("<blockquote>");
		expect(html).not.toContain("callout");
		expect(html).not.toContain("<script>");
	});

	test("callout custom title does not inject attributes", () => {
		const { html } = renderMarkdown('> [!NOTE]" onclick="alert(1)\n> test');
		expect(html).not.toMatch(/<[a-z]+\s[^>]*onclick\s*=/i);
	});

	test("comment strips hidden markup completely", () => {
		const { html } = renderMarkdown("Before %%**bold** and [[link]]%% after");
		expect(html).toContain("Before");
		expect(html).toContain("after");
		expect(html).not.toContain("bold");
		expect(html).not.toContain("link");
		expect(html).not.toContain("<strong>");
		expect(html).not.toContain("wikilink");
	});
});

describe("embeds", () => {
	const VIDEO = "https://www.youtube.com/watch?v=dQw4w9WgXcQ";

	test("embeds the Obsidian image form", () => {
		const { html } = renderMarkdown(`![](${VIDEO})`);
		expect(html).toContain("youtube-nocookie.com/embed/dQw4w9WgXcQ");
		expect(html).not.toContain("<img");
	});

	test("still embeds a bare URL alone in a paragraph", () => {
		const { html } = renderMarkdown(VIDEO);
		expect(html).toContain("youtube-nocookie.com/embed/dQw4w9WgXcQ");
	});

	test("renders a tweet embed as a plain link, not an image", () => {
		const { html } = renderMarkdown("![](https://x.com/jack/status/20)");
		expect(html).toContain('href="https://x.com/jack/status/20"');
		expect(html).not.toContain("<img");
		expect(html).not.toContain("<iframe");
	});

	test("leaves a real image alone", () => {
		const { html } = renderMarkdown("![photo](https://example.com/p.png)");
		expect(html).toContain("<img");
		expect(html).not.toContain("<iframe");
	});
});

describe("cross-feature interactions", () => {
	test("highlight inside callout", () => {
		const { html } = renderMarkdown(
			"> [!NOTE]\n> This is ==highlighted== inside.",
		);
		expect(html).toContain("callout-note");
		expect(html).toContain("<mark>");
		expect(html).toContain("highlighted");
	});

	test("task list inside callout", () => {
		const { html } = renderMarkdown("> [!TODO]\n> - [ ] Do this\n> - [x] Done");
		expect(html).toContain("callout-todo");
		expect(html).toContain('type="checkbox"');
		expect(html).toContain("checked");
	});

	test("footnote ref inside callout, definition outside", () => {
		const { html } = renderMarkdown(
			"> [!TIP]\n> See this[^1]\n\n[^1]: Footnote text.",
		);
		expect(html).toContain("callout-tip");
		expect(html).toContain('class="footnote-ref"');
		expect(html).toContain("Footnote text");
	});
});

describe("heading anchors", () => {
	test("attaches id to rendered headings", () => {
		const { html } = renderMarkdown("# Hello World\n\n## Another One");
		expect(html).toContain('<h1 id="hello-world">');
		expect(html).toContain('<h2 id="another-one">');
	});

	test("disambiguates duplicate heading anchors", () => {
		const { html } = renderMarkdown("# Intro\n\n## Intro\n\n### Intro");
		expect(html).toContain('<h1 id="intro">');
		expect(html).toContain('<h2 id="intro-1">');
		expect(html).toContain('<h3 id="intro-2">');
	});
});

describe("frontmatter", () => {
	test("strips a leading YAML block instead of rendering it as a heading", () => {
		const { html } = renderMarkdown(
			"---\ntitle: Hello\ntags: [a]\n---\n\nBody",
		);
		expect(html).not.toContain("<h2");
		expect(html).not.toContain("title: Hello");
		expect(html).toContain("Body");
	});

	test("strips an empty frontmatter block", () => {
		const { html } = renderMarkdown("---\n---\nBody");
		expect(html).not.toContain("<hr");
		expect(html).toContain("Body");
	});

	test("leaves an unterminated block alone", () => {
		const { html } = renderMarkdown("---\ntitle: Hello\n\nBody");
		expect(html).toContain("title: Hello");
	});

	test("leaves a horizontal rule further down the note alone", () => {
		const { html } = renderMarkdown("text\n\n---\n\nmore");
		expect(html).toContain("<hr");
	});
});

describe("block ids", () => {
	test("moves a trailing ^id onto the paragraph and out of the text", () => {
		const { html } = renderMarkdown("A paragraph. ^my-id");
		expect(html).toContain('<p id="^my-id">');
		expect(html).not.toContain("^my-id<");
	});

	test("attaches a standalone ^id to the block above it", () => {
		const { html } = renderMarkdown("| a |\n| - |\n| 1 |\n\n^tbl");
		expect(html).toContain('<table id="^tbl">');
		expect(html).not.toContain("<p>^tbl</p>");
	});

	test("attaches a list item id to the item, not its hidden paragraph", () => {
		const { html } = renderMarkdown("- first ^one\n- second");
		expect(html).toContain('<li id="^one">');
	});

	test("leaves headings to their heading anchor", () => {
		const { html } = renderMarkdown("# Title ^h1");
		expect(html).toContain('<h1 id="title-h1">');
	});

	test("ignores carets that are not block markers", () => {
		const { html } = renderMarkdown("2^10 and `a ^id` and x ^bad_id");
		expect(html).not.toContain("id=");
		expect(html).toContain("^bad_id");
	});

	test("ignores a ^id inside a fenced code block", () => {
		const { html } = renderMarkdown("```\nfoo ^id\n```");
		expect(html).toContain("^id");
		expect(html).not.toContain('id="^id"');
	});

	test("links [[note#^id]] to the block anchor, caret intact", () => {
		const { html } = renderMarkdown("[[note#^my-id]]", "wiki", "alice.test");
		expect(html).toContain('href="/@alice.test/wiki/note#^my-id"');
	});

	test("links [[#^id]] within the same note", () => {
		const { html } = renderMarkdown("[[#^local]]", "wiki", "alice.test");
		expect(html).toContain('href="#^local"');
	});

	test("still slugifies heading sections", () => {
		const { html } = renderMarkdown(
			"[[note#Some Heading]]",
			"wiki",
			"alice.test",
		);
		expect(html).toContain('href="/@alice.test/wiki/note#some-heading"');
	});
});

describe("mentions", () => {
	test("links a bare @handle to the profile page", () => {
		const { html } = renderMarkdown("thanks @juprodh.me for the edit");
		expect(html).toContain('href="/@juprodh.me"');
		expect(html).toContain(">@juprodh.me<");
	});

	test("leaves an email address to linkify", () => {
		const { html } = renderMarkdown("write to trash.j@prodhon.net today");
		expect(html).toContain('href="mailto:trash.j@prodhon.net"');
		expect(html).not.toContain('href="/@prodhon.net"');
	});

	test("leaves an email with an underscore in the local part alone", () => {
		const { html } = renderMarkdown("write to first_last@example.com today");
		expect(html).not.toContain('href="/@example.com"');
	});

	test("ignores handles without a dot", () => {
		const { html } = renderMarkdown("use the @decorator pattern");
		expect(html).not.toContain("<a");
	});

	test("ignores scoped package names", () => {
		const { html } = renderMarkdown("run bun add @atcute/client now");
		expect(html).not.toContain("<a");
	});

	test("ignores a numeric TLD", () => {
		const { html } = renderMarkdown("ping @1.2.3.4 to check");
		expect(html).not.toContain("<a");
	});

	test("does not nest a mention inside link text", () => {
		const { html } = renderMarkdown("[see @juprodh.me](/x)");
		expect(html).not.toContain('href="/@juprodh.me"');
		expect(html).toContain('href="/x"');
	});

	test("does not link a mention inside a code span", () => {
		const { html } = renderMarkdown("`@juprodh.me` is a handle");
		expect(html).toContain("<code>@juprodh.me</code>");
		expect(html).not.toContain('href="/@juprodh.me"');
	});

	test("leaves a wikilink to the wikilink plugin", () => {
		const { html } = renderMarkdown("[[@alice.test/docs/note]]");
		expect(html).toContain('class="wikilink"');
		expect(html).not.toContain('class="mention"');
	});

	test("leaves an @ inside a URL path alone", () => {
		const { html } = renderMarkdown("https://example.com/@notahandle.me here");
		expect(html).not.toContain('href="/@notahandle.me"');
	});

	test("stops at trailing punctuation", () => {
		const { html } = renderMarkdown("(@juprodh.me) and @wbur.org.");
		expect(html).toContain('href="/@juprodh.me"');
		expect(html).toContain('href="/@wbur.org"');
		expect(html).not.toContain("org.<");
	});

	test("links a mention wrapped in emphasis", () => {
		const { html } = renderMarkdown("**@alice.example** edited this");
		expect(html).toContain('href="/@alice.example"');
	});

	test("lowercases the href but shows the handle as written", () => {
		const { html } = renderMarkdown("ping @Alice.Example now");
		expect(html).toContain('href="/@alice.example"');
		expect(html).toContain(">@Alice.Example<");
	});
});

describe("extractWikilinks", () => {
	test("returns empty array for content with no wikilinks", () => {
		expect(extractWikilinks("no links here")).toEqual([]);
		expect(extractWikilinks("")).toEqual([]);
	});

	test("extracts targets from [[slug]] and [[slug|label]]", () => {
		expect(extractWikilinks("see [[my-page]]")).toEqual([
			{ noteSlug: "my-page", label: "my-page" },
		]);
		expect(extractWikilinks("see [[my-page|My Page]]")).toEqual([
			{ noteSlug: "my-page", label: "My Page" },
		]);
	});

	// Embeds count as backlinks even though we render them as plain links; transclusion
	// later depends on this staying true.
	test("extracts targets from ![[slug]] embeds", () => {
		expect(extractWikilinks("see ![[my-page]]")).toEqual([
			{ noteSlug: "my-page", label: "my-page" },
		]);
	});

	test("extracts cross-wiki targets", () => {
		expect(extractWikilinks("see [[@alice/docs/intro]]")).toEqual([
			{
				ownerHandle: "alice",
				wikiSlug: "docs",
				noteSlug: "intro",
				label: "@alice/docs/intro",
			},
		]);
		expect(extractWikilinks("see [[@alice/docs/intro|Intro]]")).toEqual([
			{
				ownerHandle: "alice",
				wikiSlug: "docs",
				noteSlug: "intro",
				label: "Intro",
			},
		]);
	});

	test("ignores wiki/note without @handle (invalid syntax)", () => {
		expect(extractWikilinks("see [[docs/intro]]")).toEqual([]);
	});

	test("extracts multiple wikilinks and deduplicates", () => {
		expect(extractWikilinks("[[page-a]] and [[page-b]]")).toEqual([
			{ noteSlug: "page-a", label: "page-a" },
			{ noteSlug: "page-b", label: "page-b" },
		]);
		expect(extractWikilinks("[[foo]] then [[foo]] again")).toEqual([
			{ noteSlug: "foo", label: "foo" },
		]);
	});

	test("trims whitespace from slugs", () => {
		expect(extractWikilinks("[[ spaced ]]")).toEqual([
			{ noteSlug: "spaced", label: "spaced" },
		]);
		expect(extractWikilinks("[[ spaced | Label ]]")).toEqual([
			{ noteSlug: "spaced", label: "Label" },
		]);
	});

	test("applies current wiki slug to local extracted links when provided", () => {
		expect(extractWikilinks("[[home]]", "test-wiki")).toEqual([
			{ wikiSlug: "test-wiki", noteSlug: "home", label: "home" },
		]);
	});

	test("ignores unclosed brackets and empty slugs", () => {
		expect(extractWikilinks("[[unclosed")).toEqual([]);
		expect(extractWikilinks("[[]]")).toEqual([]);
	});

	test("handles wikilinks across multiple lines", () => {
		const result = extractWikilinks("line1 [[a]]\nline2 [[b]]");
		expect(result).toEqual([
			{ noteSlug: "a", label: "a" },
			{ noteSlug: "b", label: "b" },
		]);
	});

	test("excludes anchor-only links from extracted targets", () => {
		expect(extractWikilinks("see [[#section]]")).toEqual([]);
	});

	test("normalises wiki home links to home note slug", () => {
		expect(extractWikilinks("see [[@alice/docs/]]")).toEqual([
			{
				ownerHandle: "alice",
				wikiSlug: "docs",
				noteSlug: "home",
				label: "@alice/docs",
			},
		]);
	});

	test("extracts links with section fragments", () => {
		expect(extractWikilinks("see [[page#section]]", "test-wiki")).toEqual([
			{
				wikiSlug: "test-wiki",
				noteSlug: "page",
				label: "page#section",
				section: "section",
			},
		]);
	});

	test("extracts cross-wiki links with section fragments", () => {
		expect(extractWikilinks("see [[@alice/docs/page#intro]]")).toEqual([
			{
				ownerHandle: "alice",
				wikiSlug: "docs",
				noteSlug: "page",
				label: "@alice/docs/page#intro",
				section: "intro",
			},
		]);
	});

	test("dedupes [[note#heading]] occurrences against the same note", () => {
		const result = extractWikilinks("[[a#one]] and [[a#two]] and [[a]]");
		expect(result).toHaveLength(1);
		expect(result[0]?.noteSlug).toBe("a");
	});
});