//go:build fiestaseed && browser

// The Fiesta seed exporter for ui. hack/seed/run.sh copies this file
// into a scratch rastrillo worktree at the seed commit and runs TestFiestaSeed
// there, beside the browser drives Fiesta ports,
// so it can call their page builders. It writes, under FIESTA_SEED_OUT:
//
//   - check/testdata/fixtures/sizing.html, the whole sizing fixture;
//   - check/testdata/fixtures/spelling-class.html, the whole class
//     fixture in class spelling;
//   - check/testdata/fixtures/<file>/<builder>[-<case>].html, every
//     case of every page builder in the ported files, listed in
//     check/testdata/fixtures/index.json;
//   - check/testdata/legacy/{sidebar,console}.html, the pre-phone-index
//     layouts rendered the way their drives render them.
//
// Three kinds of fixture. A "document" is a whole page: what a builder
// that returns an http.Handler served for one request, or what a
// layout builder rendered, with /rastrillo.js read as /fiesta.js. A
// "body" is what a builder handed sizingDoc. A "piece" is one rendered
// partial a test glues into its own literal markup; the port keeps the
// literal and reads the piece. Where a builder is a plain function it
// is called, so its own wrapper markup is in the fixture and the port
// retypes nothing; where a render sits inside a Test function the
// exporter repeats that one call with rastrillo's data.
//
// The layout drives fill the chrome outside the
// content slot with their own blocks: brand Harbour, nav-invoices,
// #rail-locale, a blank brand, a whitespace view. No layout-* example
// carries that chrome, so every one of their pages is seeded as a
// document, with the defines the drive gives it, and the words rastrillo
// gives it, exactly: these are test data the ported assertions match.
//
// With FIESTA_SEED_DRYRUN set it writes nothing. The browser tag is
// needed because the builders live in browser-tagged files; nothing
// here starts a browser.
package ui

import (
	"encoding/json"
	"errors"
	"fmt"
	"html/template"
	"io/fs"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"amadan.net/rastrillo/rastrillo"
)

type fixtureEntry struct {
	File     string `json:"file"`
	Builder  string `json:"builder"`
	Case     string `json:"case"`
	Path     string `json:"path"`
	Kind     string `json:"kind,omitempty"`
	Request  string `json:"request,omitempty"`
	Example  string `json:"example,omitempty"`
	Unseeded string `json:"unseeded,omitempty"`
	Note     string `json:"note,omitempty"`
}

type fixtureWriter struct {
	t       *testing.T
	out     string
	dry     bool
	index   []fixtureEntry
	written int
}

// The drives' own words, kept exactly as rastrillo writes them, because the
// ported assertions match them.
const (
	postsNav3   = `<a href="#" aria-current="page">Posts</a><a href="#">Drafts</a><a href="#">Settings</a>`
	postsNav2   = `<a href="#" aria-current="page">Posts</a><a href="#">Drafts</a>`
	viewIndex   = `{{define "view"}}index{{end}}`
	upInvoices  = `{{define "up"}}/#nav-invoices{{end}}`
	upOrders    = `{{define "up"}}/#nav-orders{{end}}`
	upTeam      = `{{define "up"}}/#nav-team{{end}}`
	topbarLinks = `<h1>Posts</h1><div class="spacer"></div><p><a id="main-link" href="/go/main">A link in the page</a></p><div class="spacer"></div>`
)

func TestFiestaSeed(t *testing.T) {
	out := os.Getenv("FIESTA_SEED_OUT")
	dry := os.Getenv("FIESTA_SEED_DRYRUN") != ""
	if out == "" && !dry {
		t.Skip("FIESTA_SEED_OUT is unset; this test is the Fiesta seed exporter, run by hack/seed/run.sh")
	}
	w := &fixtureWriter{t: t, out: out, dry: dry}
	if !dry {
		w.clearFixtures()
	}
	layout := func(shell string) []byte {
		src, ok := Layout(shell)
		if !ok {
			t.Fatalf("no %s layout", shell)
		}
		return src
	}

	// The two whole fixtures.
	w.whole("sizing_fixture_test.go", "sizingFixture", "sizing.html", sizingFixture(t), "the whole fixture, every adversarial case included; the port wraps it in sizingDoc")
	w.whole("markup_v3_browser_test.go", "classFixture", "spelling-class.html", classSpelling(t, classFixture(t)), "classSpelling(t, classFixture(t)): the whole fixture in class spelling; markup.Respell derives the attribute twin")

	// The legacy layouts, rendered with shellLayoutPage's defaults.
	for _, name := range []string{"sidebar", "console"} {
		w.write("check/testdata/legacy/"+name+".html", []byte(fiestaScripts(shellLayoutPage(t, legacyLayout(t, name), "ltr"))))
		w.add(fixtureEntry{File: "index_browser_test.go", Builder: "legacyLayout", Case: name, Path: "../legacy/" + name + ".html", Kind: "document",
			Note: "shellLayoutPage(t, legacyLayout(t, " + name + "), \"ltr\") with no extra defines"})
	}

	// ── browser_test.go's handlers, and scheme_browser_test.go ───────
	h, _ := page(t, 40)
	w.document("browser_test.go", "page", "40", "/", h, "page(t, 40)")
	h, _ = datePage(t, "field-date", "due")
	w.document("browser_test.go", "datePage", "field-date", "/", h, `datePage(t, "field-date", "due")`)
	w.document("browser_test.go", "datePage", "field-date-nocal", "/?nocal", h, `datePage(t, "field-date", "due"), without calendar.js`)
	h, _ = datePage(t, "field-time", "at")
	w.document("browser_test.go", "datePage", "field-time", "/", h, `datePage(t, "field-time", "at")`)
	h, _ = groupPage(t)
	w.document("browser_test.go", "groupPage", "", "/", h, "")
	w.document("browser_test.go", "menuPage", "", "/", menuPage(t), "")
	w.document("browser_test.go", "menuPage", "old-spelling", "/old-spelling", menuPage(t), "the mid-upgrade page in class spelling")
	w.document("browser_test.go", "modalPage", "", "/", modalPage(t), `Styleguide()["modal"] in a bare page; the same markup is example modal/default`)
	w.document("browser_test.go", "fieldRowPage", "ltr", "/?dir=ltr", fieldRowPage(t), "")
	w.document("browser_test.go", "fieldRowPage", "rtl", "/?dir=rtl", fieldRowPage(t), "")
	h, _ = busyPage(t)
	w.document("browser_test.go", "busyPage", "", "/", h, "")
	w.document("browser_test.go", "bidiRowPage", "", "/", bidiRowPage(t), "")
	w.document("scheme_browser_test.go", "schemeApp", "", "/", schemeApp(t),
		"the column shell through ui.Pages with no scheme cookie, so System is current; its server-backed tests stay in rastrillo; only the three literal schemeFlipBody tests are ported")

	// ── The component drives ─────────────────────────────────────────
	w.piece("sizing_browser_test.go", "TestTheCalendarDocksAndItsDaysAreTaps", "field",
		render(t, "field-date", map[string]any{"Name": "due", "Label": "Due", "Value": "2026-08-28"}), "the field both pages hold")
	w.add(fixtureEntry{File: "sizing_browser_test.go", Builder: "TestDesktopDensityIsPinned", Case: "modal", Example: "modal/default", Note: `Styleguide()["modal"]`})
	w.add(fixtureEntry{File: "sizing_browser_test.go", Builder: "TestEveryTapTargetIsAtLeast44Pixels", Case: "modal", Example: "modal/default", Note: `Styleguide()["modal"]`})
	w.add(fixtureEntry{File: "sizing_browser_test.go", Builder: "TestTheFloorChangesNothingButSizeOnADesktop", Case: "", Path: "sizing.html", Kind: "body", Note: "sizingFixture(t) plus a literal tail the test keeps"})

	w.body("rows_browser_test.go", "rowsFixture", "", rowsFixture(t), "")
	w.body("rows_browser_test.go", "narrowRowsPage", "", bodyOf(t, narrowRowsPage(t)["/"]), "the / page's body")

	w.body("blocks_browser_test.go", "segTabsPage", "", bodyOf(t, segTabsPage(t)["/"]), "segTabsPage(t)[\"/\"]: the tabs over the card and over the box, with their ids")
	w.piece("blocks_browser_test.go", "TestADetailListsLabelSitsOnItsValuesFirstLine", "dl", render(t, "detail-list", map[string]any{"Items": []any{
		map[string]any{"Label": "Audience", "Value": "Members"},
		map[string]any{"Label": "Published", "Value": "2 August 2026", "DateTime": "2026-08-02"},
		map[string]any{"Label": "Reference", "Value": "post_01H9ZQ", "Mono": true},
		map[string]any{"Label": "Summary", "Value": "Release notes for August: the new export, faster search, a fix for invoices that never arrived, and the rest of the month's small changes."},
	}}), "")

	w.body("bulkbar_browser_test.go", "bulkBarPage", "", bodyOf(t, bulkBarPage(t, "ltr")), "bulkBarPage(t, \"ltr\"): every bulkBarCases entry in its <div rst-list id=\"bulk-<id>\">; the port flips dir on the document")

	dropdown := func() string {
		return render(t, "dropdown", map[string]any{"Label": "Newest", "Aria": "Sort: Newest", "Items": []any{
			map[string]any{"Href": "/o?sort=new", "Label": "Newest", "Current": true},
			map[string]any{"Href": "/o?sort=old", "Label": "Oldest"},
		}})
	}
	w.piece("dropdown_browser_test.go", "TestADropdownOpensUnderItsOwnSummary", "partial", dropdown(), "the partial; the sample is example dropdown/menu-idiom")
	w.piece("dropdown_browser_test.go", "TestADropdownWithoutAnchorsOrScriptsStaysOnScreen", "partial", dropdown(), "the partial; the sample is example dropdown/menu-idiom")
	w.piece("dropdown_browser_test.go", "TestAnOpenDropdownIsPlacedAgainWhenTheWindowChanges", "menu", dropdown(), "")

	w.body("pagination_browser_test.go", "paginationPage", "", bodyOf(t, paginationPage(t, "ltr")), "paginationPage(t, \"ltr\"): every paginationCases entry in its <div id=\"pg-<id>\">; the port flips dir on the document")

	rowMenuPages, _ := rowMenuPage(t)
	w.body("rowmenu_browser_test.go", "rowMenuPage", "root", bodyOf(t, rowMenuPages["/"]), "the / page: #outside and the three-row list with #row-a (/act/a, /go/view-a, the hidden fields), #row-b and #row-c (the long POST label)")
	w.body("rowmenu_browser_test.go", "rowMenuPage", "bottom", bodyOf(t, rowMenuPages["/bottom"]), "the /bottom page: the same list under a 150vh spacer; /go/ is a literal landing page")
	w.piece("rowmenu_browser_test.go", "TestARowMenuOpensBesideItsOwnKebab", "menu", render(t, "row-menu", map[string]any{"Name": "Grace Hopper", "Items": []any{
		map[string]any{"Label": "Edit", "Href": "/go/edit"},
		map[string]any{"Label": "Archive", "Action": "/act/a"},
		map[string]any{"Label": "Delete order…", "Href": "/go/delete", "Danger": true},
	}}), "")

	w.body("mediagrid_browser_test.go", "mediaPage", "", bodyOf(t, mediaPage(t, "ltr")), "the ltr body; the port flips dir on the document; pictures at /images/tall.svg and /images/wide.svg")
	w.body("apitokens_browser_test.go", "tokensPageDoc", "", bodyOf(t, tokensPageDoc(t)), "")

	w.document("signin_browser_test.go", "signinPage", "", "/", signinPage(t),
		"the live cases link <script type=\"module\" src=\"/static/passkey-signin.mjs\">, which rastrillo's signinServer answered with an empty script: serve /static/passkey-signin.mjs or strip it")
	var signinBody strings.Builder
	for i, c := range signinStates() {
		for _, preview := range []bool{false, true} {
			if !preview && c.st.Door() == "continue" {
				continue
			}
			data := signinData(c.st)
			data["Brand"] = map[string]any{"Name": "Harbour", "Pitch": "Moorings and berths, booked in a minute."}
			if preview {
				data["Preview"] = true
			}
			fmt.Fprintf(&signinBody, `<div id="case-%d-%v" title=%q>%s</div>`, i, preview, c.name, render(t, "signin", data))
		}
	}
	w.body("signin_browser_test.go", "TestSigninControlsStayInsideTheCardOnAPhone", "", signinBody.String(), "every signinStates entry, live and in Preview, as the test builds them; the live cases link /static/passkey-signin.mjs: serve it or strip it")

	// ── The shell drives ─────────────────────────────────────────────
	w.piece("shell_browser_test.go", "TestAMenuOpenedInsideAListCardEscapesTheCard", "bulk-bar", render(t, "bulk-bar", map[string]any{
		"DoneHref": "/posts", "Count": "3 selected",
		"MenuLabel": "Actions",
		"Actions": []any{
			map[string]any{"Value": "export", "Label": "Export"},
			map[string]any{"Value": "unpublish", "Label": "Unpublish"},
			map[string]any{"Value": "delete", "Label": "Delete…", "Danger": true},
		},
	}), "")
	w.piece("shell_browser_test.go", "TestSelfShapedChildrenKeepTheirCornersInsideACard", "list-bar-search", render(t, "list-bar-search", map[string]any{"Action": "/posts"}), "the test strips the <search> wrapper itself")
	var menuItems []any
	for _, name := range []string{
		"English", "Espanol", "Portugues", "Gaeilge", "Arabiyya", "Hindi",
		"Bangla", "Nihongo", "Russkiy", "Tieng Viet", "Jyutping", "Zhongwen",
	} {
		menuItems = append(menuItems, map[string]any{"Href": "#", "Label": name})
	}
	for _, c := range menuCorners {
		items := menuItems
		if c.short {
			items = items[:3]
		}
		if c.rowMenu {
			var b strings.Builder
			b.WriteString(`<details rst-row-menu name="rst-menu-` + c.id + `">` +
				`<summary aria-label="Actions">` + string(rastrillo.Icon("kebab")) + `</summary>` +
				`<div rst-row-menu-panel>`)
			for _, it := range items {
				b.WriteString(`<a href="#">` + it.(map[string]any)["Label"].(string) + `</a>`)
			}
			b.WriteString(`</div></details>`)
			w.piece("shell_browser_test.go", "TestMenusCapTheirHeightScrollAndFlipToFitTheViewport", c.id, b.String(), "the hand-written row menu around rastrillo.Icon(\"kebab\"), which fiesta.Icon(\"kebab\") gives")
			continue
		}
		w.piece("shell_browser_test.go", "TestMenusCapTheirHeightScrollAndFlipToFitTheViewport", c.id, render(t, "dropdown", map[string]any{
			"Label": "Language", "Items": items, "MenuGroup": "rst-menu-" + c.id,
		}), "one menuCorners entry")
	}
	w.piece("shell_browser_test.go", "TestClearingASearchIsALinkAndTheNativeCrossIsGone", "search", render(t, "list-bar-search", map[string]any{
		"Action": "/posts", "Query": "sere", "Placeholder": "Search posts",
		"Hidden": [][2]string{{"status", "paid"}},
	}), "")
	for _, m := range []struct {
		id    string
		items []any
	}{{"short", menuItems[:3]}, {"long", menuItems}} {
		w.piece("shell_browser_test.go", "TestAMenuOpenedInsideAShortFrameIsStillUsable", m.id, render(t, "dropdown", map[string]any{
			"Label": "Menu", "Items": m.items, "MenuGroup": "rst-menu-" + m.id,
		}), "")
	}

	// The two shell_browser_test.go drives that build their own
	// template: the sidebar's index, page and tall-rail pages, and the
	// topbar.
	railDefs := []string{
		`{{define "content"}}<p>Content.</p>{{end}}`,
		`{{define "nav"}}` + postsNav2 + `{{end}}`,
		`{{define "profile"}}<span rst-person-av aria-hidden="true">G</span><span rst-person-name>Grace Hopper</span><span rst-person-email>grace@example.com</span>{{end}}`,
		`{{define "account"}}<a id="acct-profile" href="#">Profile</a>{{end}}`,
		`{{define "locale"}}<details rst-dropdown rst-locale id="rail-locale" name="rst-menus"><summary>Language</summary><div rst-dropdown-menu><a href="#" lang="en">English</a><a href="#" lang="ga">Gaeilge</a></div></details>{{end}}`,
	}
	const railTest = "TestTheSidebarRailPutsThePersonAtItsFootAndTheProfileMenuOpensUpward"
	w.page("shell_browser_test.go", railTest, "index", layoutWith(t, layout("sidebar"), append(railDefs, viewIndex)...), "the index: the drive's own defines plus the view")
	w.page("shell_browser_test.go", railTest, "page", layoutWith(t, layout("sidebar"), railDefs...), "the content page")
	w.page("shell_browser_test.go", railTest, "tall", layoutWith(t, layout("sidebar"), append(railDefs, `{{define "nav"}}`+railTallNav+`{{end}}`)...), "the page with railTallNav, the twenty-link rail")
	w.page("shell_browser_test.go", "TestTheTopbarCollapsesItsTailBehindOneDisclosure", "", layoutWith(t, layout("topbar"),
		`{{define "content"}}<p>Content.</p>{{end}}`,
		`{{define "nav"}}`+postsNav2+`{{end}}`,
		`{{define "account"}}<a href="#">Profile</a><a href="#">Sign out</a>{{end}}`,
		`{{define "locale"}}<details rst-dropdown rst-locale id="bar-locale" name="rst-menus"><summary>Language</summary><div rst-dropdown-menu><a href="#" lang="en">English</a><a href="#" lang="ga">Gaeilge</a></div></details>{{end}}`,
	), "")

	// index_browser_test.go: shellLayoutPage with the defines each
	// drive gives it. The rows no ported drive reads say so in their
	// note: the drives that ran on them now run on the layout examples,
	// and the pages stay as what rastrillo rendered, for comparison.
	const (
		unreadExample = "; read by no drive: the ported test runs on the layout example, and this is the page rastrillo's drive rendered, kept for comparison"
		unreadDefault = "; read by no drive: the helper's own defaults, kept for comparison with the layout examples"
	)
	for _, shell := range LayoutNames() {
		w.page("index_browser_test.go", "shellLayoutPage", shell, shellLayoutPage(t, layout(shell), "ltr"), "the helper's own defaults: brand Harbour, nav-invoices/orders/team, #rail-locale, the Invoices content"+unreadDefault)
	}
	for _, shell := range []string{"sidebar", "console"} {
		for _, dir := range []string{"ltr", "rtl"} {
			src := layout(shell)
			w.page("index_browser_test.go", "TestThePhoneIndexWorksWithNoScript", shell+"-"+dir+"-index", shellLayoutPage(t, src, dir, viewIndex), "/")
			w.page("index_browser_test.go", "TestThePhoneIndexWorksWithNoScript", shell+"-"+dir+"-invoices", shellLayoutPage(t, src, dir, upInvoices), "/invoices")
			w.page("index_browser_test.go", "TestThePhoneIndexWorksWithScripts", shell+"-"+dir+"-index", shellLayoutPage(t, src, dir, viewIndex), "/")
			w.page("index_browser_test.go", "TestThePhoneIndexWorksWithScripts", shell+"-"+dir+"-invoices", shellLayoutPage(t, src, dir, upInvoices), "/invoices")
			w.page("index_browser_test.go", "TestThePhoneIndexWorksWithScripts", shell+"-"+dir+"-orders", shellLayoutPage(t, src, dir, upOrders), "/orders")
			w.page("index_browser_test.go", "TestTheWideLayoutIsUnchanged", shell+"-"+dir+"-index", shellLayoutPage(t, src, dir, viewIndex), "/index")
			w.page("index_browser_test.go", "TestTheWideLayoutIsUnchanged", shell+"-"+dir+"-page", shellLayoutPage(t, src, dir), "/page")
			w.page("index_browser_test.go", "TestTheWideLayoutIsUnchanged", shell+"-"+dir+"-legacy", shellLayoutPage(t, legacyLayout(t, shell), dir), "/legacy: the pre-phone-index layout")
		}
	}
	w.add(fixtureEntry{File: "index_browser_test.go", Builder: "TestAnOldSidebarLayoutKeepsItsDrawer", Case: "", Path: "../legacy/sidebar.html", Kind: "document",
		Note: "shellLayoutPage(t, legacyLayout(t, \"sidebar\"), \"ltr\") with no extra defines: the seeded legacy sidebar"})
	// A slice, not a map: the rows land in index.json in this order,
	// and a reseed must write the same file.
	for _, c := range []struct{ kase, nav string }{
		{"group-first", `<p rst-shell-group>Sales</p><a href="/a">A</a><a href="/b">B</a><p rst-shell-group>Settings</p><a href="/c">C</a>`},
		{"one", `<a href="/a">A</a>`},
		{"no-groups", `<a href="/a">A</a><a href="/b">B</a><a href="/c" aria-current="page">C</a>`},
	} {
		w.page("index_browser_test.go", "TestTheIndexRowsRoundEachRunOfLinks", c.kase, shellLayoutPage(t, layout("sidebar"), "ltr", viewIndex, `{{define "nav"}}`+c.nav+`{{end}}`), "/"+c.kase)
	}
	{
		short := `<a id="nav-invoices" href="/invoices">Invoices</a><a id="nav-orders" href="/orders">Orders</a>`
		var long strings.Builder
		for i := 1; i <= 30; i++ {
			fmt.Fprintf(&long, `<a id="nav-%d" href="/s%d">Section %d</a>`, i, i, i)
		}
		foot := `{{define "foot"}}<a href="/about">About</a>{{end}}`
		src := layout("console")
		w.page("index_browser_test.go", "TestTheConsoleIndexRailFillsTheScreen", "short", shellLayoutPage(t, src, "ltr", viewIndex, `{{define "nav"}}`+short+`{{end}}`, foot), "/short")
		w.page("index_browser_test.go", "TestTheConsoleIndexRailFillsTheScreen", "nofoot", shellLayoutPage(t, src, "ltr", viewIndex, `{{define "nav"}}`+short+`{{end}}`), "/nofoot")
		w.page("index_browser_test.go", "TestTheConsoleIndexRailFillsTheScreen", "long", shellLayoutPage(t, src, "ltr", viewIndex, `{{define "nav"}}`+long.String()+`{{end}}`, foot), "/long: thirty sections")
	}
	w.page("index_browser_test.go", "TestAWhitespaceViewIsTheIndexInTheBrowser", "", shellLayoutPage(t, layout("sidebar"), "ltr", "{{define \"view\"}}\n  index\n{{end}}"), "the view block written with whitespace around index")
	w.page("index_browser_test.go", "TestAnOldConsoleLayoutKeepsItsRailOpen", "", shellLayoutPage(t, legacyLayout(t, "console"), "ltr",
		`{{define "nav"}}<p rst-shell-group id="group">Sales</p><a id="nav-invoices" href="/invoices">Invoices</a><a id="nav-orders" href="/orders">Orders</a>{{end}}`,
		`{{define "content"}}<h1>Invoices</h1><details rst-dropdown id="page-menu" name="rst-menus"><summary>Sort</summary><div rst-dropdown-menu><a href="/go/new">Newest</a></div></details>{{end}}`),
		"the legacy console with the drive's own nav and content")
	{
		content := `{{define "content"}}<h1>Invoices</h1><div style="block-size: 150vh"></div><h2 id="target">Target</h2><div style="block-size: 150vh"></div>{{end}}`
		for _, shell := range []string{"sidebar", "console"} {
			w.page("index_browser_test.go", "TestAFragmentLinkLandsBelowTheBackStrip", shell, shellLayoutPage(t, layout(shell), "ltr", content), "/page"+unreadExample)
		}
	}
	for _, shell := range []string{"sidebar", "console"} {
		src := layout(shell)
		w.page("index_browser_test.go", "TestThePhoneHeaderStripIs56Pixels", shell+"-index", shellLayoutPage(t, src, "ltr", append(profileDefs("Harbour"), viewIndex)...), "/"+unreadExample)
		w.page("index_browser_test.go", "TestThePhoneHeaderStripIs56Pixels", shell+"-page", shellLayoutPage(t, src, "ltr", profileDefs("Harbour")...), "/page"+unreadExample)
	}

	// console_shell_browser_test.go. consolePage returns the page and a
	// control twin, which is the page with consoleControlCSS injected
	// before </head>; the port derives the twin the same way.
	const controlNote = "; the control twin is this page with <style>consoleControlCSS</style> injected before </head>"
	{
		page, _ := consolePage(t, postsNav3, "ltr")
		w.page("console_shell_browser_test.go", "consolePage", "ltr", page, "consolePage(t, <Posts, Drafts, Settings>, \"ltr\")"+controlNote)
		page, _ = consolePage(t, postsNav3, "ltr", viewIndex)
		w.page("console_shell_browser_test.go", "consolePage", "ltr-index", page, "consolePage(t, <Posts, Drafts, Settings>, \"ltr\", view index)"+controlNote)
		page, _ = consolePage(t, postsNav2, "rtl")
		w.page("console_shell_browser_test.go", "consolePage", "rtl", page, "consolePage(t, <Posts, Drafts>, \"rtl\")"+controlNote)
		page, _ = consolePage(t, railTallNav, "ltr")
		w.page("console_shell_browser_test.go", "consolePage", "tall", page, "consolePage(t, railTallNav, \"ltr\")"+controlNote)
		page, _ = legacyConsolePage(t, postsNav3, "ltr")
		w.page("console_shell_browser_test.go", "legacyConsolePage", "ltr", page, "legacyConsolePage(t, <Posts, Drafts, Settings>, \"ltr\"): the legacy console with consolePageFrom's own blocks"+controlNote)
		page, _ = consolePageFrom(t, layout("console"), postsNav3, "ltr")
		w.page("console_shell_browser_test.go", "consolePageFrom", "console-ltr", page, "consolePageFrom with the console layout and no extra defines; consolePage and legacyConsolePage are its callers"+controlNote+unreadDefault)
	}

	// profile_browser_test.go.
	{
		const long = "Harbour Freight Forwarding and Customs Brokerage"
		for _, shell := range []string{"sidebar", "console"} {
			for _, dir := range []string{"ltr", "rtl"} {
				src := layout(shell)
				w.page("profile_browser_test.go", "TestTheProfileMenuOnThePhoneIndex", shell+"-"+dir+"-index", shellLayoutPage(t, src, dir, append(profileDefs("Harbour"), viewIndex)...), "/")
				w.page("profile_browser_test.go", "TestTheProfileMenuOnThePhoneIndex", shell+"-"+dir+"-long", shellLayoutPage(t, src, dir, append(profileDefs(long), viewIndex)...), "/long: the brand "+long)
			}
		}
		for _, dir := range []string{"ltr", "rtl"} {
			w.page("profile_browser_test.go", "TestTheProfileMenuIsADropUpAtTheRailsFoot", dir, shellLayoutPage(t, layout("sidebar"), dir, profileDefs("Harbour")...), "/")
		}
		src := layout("sidebar")
		noLocale := `{{define "locale"}}{{if false}}x{{end}}{{end}}`
		noScheme := `{{define "scheme"}}{{if false}}x{{end}}{{end}}`
		w.page("profile_browser_test.go", "TestThePersonNeverVanishesFromTheRail", "person", shellLayoutPage(t, src, "ltr", profileDefs("Harbour")[0], profileDefs("Harbour")[1], noLocale), "/person")
		w.page("profile_browser_test.go", "TestThePersonNeverVanishesFromTheRail", "person-idx", shellLayoutPage(t, src, "ltr", profileDefs("Harbour")[0], profileDefs("Harbour")[1], noLocale, viewIndex), "/person-idx")
		w.page("profile_browser_test.go", "TestThePersonNeverVanishesFromTheRail", "placeholder", shellLayoutPage(t, src, "ltr", noLocale, noScheme), "/placeholder")
		w.page("profile_browser_test.go", "TestABlankBrandFallsBackToTheTitle", "", shellLayoutPage(t, src, "ltr", viewIndex,
			`{{define "title"}}Harbour Ledger{{end}}`, "{{define \"brand\"}}\n  {{if false}}<a href=\"/\">x</a>{{end}}\n{{end}}"), "a blank brand and the title Harbour Ledger")
	}

	// card_browser_test.go.
	w.page("card_browser_test.go", "topbarPage", "ltr", topbarPage(t, "ltr"), "topbarPage(t, \"ltr\"): topbarPageWith and the drives' standard content")
	w.page("card_browser_test.go", "topbarPage", "rtl", topbarPage(t, "rtl"), "topbarPage(t, \"rtl\")")
	w.page("card_browser_test.go", "topbarPageWith", "modal", topbarPageWith(t, "ltr", Styleguide()["modal"]), "topbarPageWith(t, \"ltr\", Styleguide()[\"modal\"]); TestAModalCoversTheTopbarOnAPhone's topbar leg"+unreadExample)
	for _, shell := range []string{"sidebar", "console"} {
		w.page("card_browser_test.go", "TestAModalCoversTheTopbarOnAPhone", shell, shellLayoutPage(t, layout(shell), "ltr", upInvoices,
			`{{define "content"}}`+Styleguide()["modal"]+`{{end}}`), "the "+shell+" content page with the modal as its content; the topbar leg is topbarPageWith-modal"+unreadExample)
	}
	for _, dir := range []string{"ltr", "rtl"} {
		w.page("card_browser_test.go", "TestTheConsoleBarIsTheSameCard", dir, shellLayoutPage(t, layout("console"), dir, `{{define "account"}}<a id="acct-profile" href="/go/profile">Profile</a>{{end}}`,
			`{{define "content"}}<h1>Invoices</h1><div style="block-size: 450px"></div><p><a id="main-link" href="/go/main">A link in the page</a></p>{{end}}`), "the same page for scripts on and off")
	}

	// prerender_browser_test.go.
	{
		src, stage := layout("sidebar"), layout("stage")
		w.page("prerender_browser_test.go", "prerenderSite", "index", shellLayoutPage(t, src, "ltr", viewIndex, `{{define "content"}}<h1>Harbour</h1><p><a id="plain" href="/plain">A link in the page</a></p>{{end}}`), "/")
		w.page("prerender_browser_test.go", "prerenderSite", "invoices", shellLayoutPage(t, src, "ltr", upInvoices), "/invoices")
		w.page("prerender_browser_test.go", "prerenderSite", "orders", shellLayoutPage(t, src, "ltr", upOrders), "/orders")
		w.page("prerender_browser_test.go", "prerenderSite", "team", shellLayoutPage(t, src, "ltr", upTeam), "/team")
		w.page("prerender_browser_test.go", "prerenderSite", "plain", shellLayoutPage(t, src, "ltr"), "/plain")
		w.page("prerender_browser_test.go", "prerenderSite", "signin", shellLayoutPage(t, stage, "ltr", `{{define "content"}}<p><a id="stage-link" href="/orders">Orders</a></p>{{end}}`), "/signin: the stage shell")
		w.add(fixtureEntry{File: "prerender_browser_test.go", Builder: "prerenderSite", Case: "legacy", Path: "../legacy/sidebar.html", Kind: "document", Note: "/legacy: shellLayoutPage(t, legacyLayout(t, \"sidebar\"), \"ltr\"), the seeded legacy sidebar"})
	}

	w.writeIndex()
	if dry {
		fmt.Printf("fiesta seed dry run: %d fixture entries\n", len(w.index))
		return
	}
	fmt.Printf("fiesta seed: wrote %d fixture files under %s\n", w.written, out)
}

// layoutWith renders a layout's source with the given defines and
// nothing else, the way the two shell_browser_test.go drives that
// build their own template do. A define repeated later in defs
// replaces the earlier one, as the tall-rail clone's nav does.
func layoutWith(t *testing.T, src []byte, defs ...string) string {
	t.Helper()
	tmpl := template.Must(template.New("layout").Funcs(Funcs()).Funcs(template.FuncMap{
		"asset":      func(p string) string { return "/" + strings.TrimPrefix(p, "static/") },
		"iconAssets": func() template.HTML { return "" },
	}).Parse(string(src)))
	template.Must(tmpl.ParseFS(Templates(), "*.html"))
	for _, d := range defs {
		template.Must(tmpl.Parse(d))
	}
	var b strings.Builder
	if err := tmpl.ExecuteTemplate(&b, "layout", nil); err != nil {
		t.Fatalf("rendering the layout: %v", err)
	}
	return b.String()
}

// fiestaScripts reads /rastrillo.js as /fiesta.js in a served document,
// the one rename Fiesta makes to the scripts it ships.
func fiestaScripts(doc string) string {
	return strings.ReplaceAll(doc, `src="/rastrillo.js"`, `src="/fiesta.js"`)
}

// bodyOf is what a builder handed sizingDoc: the bytes between <body>
// and </body>.
func bodyOf(t *testing.T, doc string) string {
	t.Helper()
	i, j := strings.Index(doc, "<body>"), strings.LastIndex(doc, "</body>")
	if i < 0 || j < i {
		t.Fatalf("no body in\n%s", doc)
	}
	return doc[i+len("<body>") : j]
}

func (w *fixtureWriter) write(rel string, body []byte) {
	w.t.Helper()
	if w.dry {
		return
	}
	p := filepath.Join(w.out, filepath.FromSlash(rel))
	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
		w.t.Fatal(err)
	}
	if err := os.WriteFile(p, body, 0o644); err != nil {
		w.t.Fatal(err)
	}
	w.written++
}

// clearFixtures removes what a previous run wrote and this one owns:
// every per-file directory under fixtures/, the two whole fixtures and
// the index, and the rendered legacy layouts. The legacy stylesheets
// beside them are the designsystem exporter's. A directory that is
// not there yet is fine; any other error is not.
func (w *fixtureWriter) clearFixtures() {
	fixtures := filepath.Join(w.out, "check", "testdata", "fixtures")
	w.removeMatching(fixtures, func(e os.DirEntry) bool {
		return e.IsDir() || e.Name() == "sizing.html" || e.Name() == "spelling-class.html" || e.Name() == "index.json"
	})
	w.removeMatching(filepath.Join(w.out, "check", "testdata", "legacy"), func(e os.DirEntry) bool {
		return !e.IsDir() && strings.HasSuffix(e.Name(), ".html")
	})
}

func (w *fixtureWriter) removeMatching(dir string, match func(os.DirEntry) bool) {
	entries, err := os.ReadDir(dir)
	if errors.Is(err, fs.ErrNotExist) {
		return
	}
	if err != nil {
		w.t.Fatal(err)
	}
	for _, e := range entries {
		if match(e) {
			if err := os.RemoveAll(filepath.Join(dir, e.Name())); err != nil {
				w.t.Fatal(err)
			}
		}
	}
}

func (w *fixtureWriter) add(e fixtureEntry) {
	if e.Path == "" && e.Example == "" && e.Unseeded == "" {
		w.t.Fatalf("%s %s %q has no path, example or unseeded reason", e.File, e.Builder, e.Case)
	}
	for _, x := range w.index {
		if x.File == e.File && x.Builder == e.Builder && x.Case == e.Case {
			w.t.Fatalf("%s %s %q listed twice", e.File, e.Builder, e.Case)
		}
	}
	w.index = append(w.index, e)
}

func fixturePath(file, builder, kase string) string {
	name := builder
	if kase != "" {
		name += "-" + kase
	}
	return strings.TrimSuffix(file, ".go") + "/" + name + ".html"
}

func (w *fixtureWriter) whole(file, builder, path, markup, note string) {
	w.write("check/testdata/fixtures/"+path, []byte(markup))
	w.add(fixtureEntry{File: file, Builder: builder, Path: path, Kind: "body", Note: note})
}

func (w *fixtureWriter) piece(file, builder, kase, markup, note string) {
	p := fixturePath(file, builder, kase)
	w.write("check/testdata/fixtures/"+p, []byte(markup))
	w.add(fixtureEntry{File: file, Builder: builder, Case: kase, Path: p, Kind: "piece", Note: note})
}

func (w *fixtureWriter) body(file, builder, kase, markup, note string) {
	p := fixturePath(file, builder, kase)
	w.write("check/testdata/fixtures/"+p, []byte(markup))
	w.add(fixtureEntry{File: file, Builder: builder, Case: kase, Path: p, Kind: "body", Note: note})
}

// page keeps a whole rendered page.
func (w *fixtureWriter) page(file, builder, kase, html, note string) {
	p := fixturePath(file, builder, kase)
	w.write("check/testdata/fixtures/"+p, []byte(fiestaScripts(html)))
	w.add(fixtureEntry{File: file, Builder: builder, Case: kase, Path: p, Kind: "document", Note: note})
}

// document requests one path of a handler and keeps the response.
func (w *fixtureWriter) document(file, builder, kase, request string, h http.Handler, note string) {
	w.t.Helper()
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest("GET", request, nil))
	if rec.Code != http.StatusOK {
		w.t.Fatalf("%s %s: GET %s answered %d:\n%s", file, builder, request, rec.Code, rec.Body.String())
	}
	p := fixturePath(file, builder, kase)
	w.write("check/testdata/fixtures/"+p, []byte(fiestaScripts(rec.Body.String())))
	w.add(fixtureEntry{File: file, Builder: builder, Case: kase, Path: p, Kind: "document", Request: request, Note: note})
}

func (w *fixtureWriter) writeIndex() {
	b, err := json.MarshalIndent(w.index, "", "  ")
	if err != nil {
		w.t.Fatal(err)
	}
	w.write("check/testdata/fixtures/index.json", append(b, '\n'))
}