package gallery

import (
	"html"
	"html/template"
	"io/fs"
	"regexp"
	"strings"
	"testing"

	"amadan.net/rastrillo/fiesta"
	"amadan.net/rastrillo/fiesta/example"
	"amadan.net/rastrillo/fiesta/internal/codeview"
)

// The preview widget as the render writes it: Desktop, Mobile and HTML
// behind three radios, one widget per state or one per grouped
// example, the HTML tab without the wrapper and with the line naming
// it, the row documents, the Copy blocks, the frame titles and the
// shells' open buttons. The browser drives in view_browser_test.go and
// its siblings take over where the engine has to answer.

// examplePage is one example's page in one directory, failed loudly.
func examplePage(t *testing.T, files map[string][]byte, theme, locale, name string) string {
	t.Helper()
	page := string(files[theme+"/"+locale+"/"+name+".html"])
	if page == "" {
		t.Fatalf("no %s/%s/%s.html in the rendered tree", theme, locale, name)
	}
	return page
}

// widgetOpen is a widget's opening tag, matched exactly: `<div
// class="ds-view` alone also matches the stage and the box inside
// every widget.
var widgetOpen = regexp.MustCompile(`<div class="ds-view(?: ds-view--[a-z]+)*" style="`)

// widgetsOf cuts a page into its preview widgets: everything from one
// widget's opening tag up to the next one, or to the end.
func widgetsOf(page string) []string {
	parts := widgetOpen.Split(page, -1)
	if len(parts) < 2 {
		return nil
	}
	return parts[1:]
}

// tabClass reads a widget's tabs in order, by their modifier letter.
var tabClass = regexp.MustCompile(`class="ds-view__tab ds-view__tab--([a-z])"`)

var radioInput = regexp.MustCompile(`<input type="radio" name="([^"]*)"( checked)?>`)

// panelOf is a widget's HTML panel, or "" when it has none.
func panelOf(widget string) string {
	return regexp.MustCompile(`(?s)<div class="ds-view__code ds-view__code--h">.*?</div>`).FindString(widget)
}

// sourceBlock finds every source block on a page: the code a reader
// copies, highlighted.
var sourceBlock = regexp.MustCompile(`(?s)<pre class="ds-src[^"]*"[^>]*><code>(.*?)</code></pre>`)

var anyElement = regexp.MustCompile(`<[^>]*>`)

// sourceTexts is every source block in a fragment as a reader sees and
// copies it: the highlighting removed and the entities decoded.
func sourceTexts(fragment string) []string {
	var out []string
	for _, m := range sourceBlock.FindAllStringSubmatch(fragment, -1) {
		out = append(out, html.UnescapeString(anyElement.ReplaceAllString(m[1], "")))
	}
	return out
}

// TestEveryExampleIsFramedDesktopMobileAndHTML: on every example page
// of day/en, one widget per state, or one per grouped example; three
// radios in each, one name per widget and the name unique on the page,
// none checked; the HTML panel on every widget, one block per state;
// ds-view--page on the page-frame examples and on no other; and the
// rules that make the tabs switch anything, in view.css.
func TestEveryExampleIsFramedDesktopMobileAndHTML(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	theme := fiesta.ThemeNames()[0]
	total := 0
	var pageClass []string
	for _, e := range s.m.Examples {
		page := examplePage(t, files, theme, "en", e.Name)
		widgets := widgetsOf(page)
		want := len(e.States)
		if grouped[e.Name] {
			want = 1
		}
		if len(widgets) != want {
			t.Errorf("%s: %d preview widgets, want %d", e.Name, len(widgets), want)
		}
		if strings.Contains(page, "ds-view--page") {
			pageClass = append(pageClass, e.Name)
		}
		if n := strings.Count(page, "ds-view--page"); n != 0 && n != len(widgets) {
			t.Errorf("%s: %d of %d widgets take the page class; a page's widgets are all one class", e.Name, n, len(widgets))
		}
		total += len(widgets)
		groups := map[string]bool{}
		for i, w := range widgets {
			radios := radioInput.FindAllStringSubmatch(w, -1)
			if len(radios) != 3 {
				t.Errorf("%s widget %d has %d tabs, want 3: Desktop, Mobile and HTML", e.Name, i, len(radios))
				continue
			}
			for _, r := range radios {
				if r[1] != radios[0][1] {
					t.Errorf("%s widget %d: tabs in one widget carry two names (%q, %q), so they are not one group", e.Name, i, radios[0][1], r[1])
				}
				if r[2] != "" {
					t.Errorf("%s widget %d: a tab starts checked; none may, or the stylesheet cannot tell a reader's choice from the markup's default", e.Name, i)
				}
			}
			if groups[radios[0][1]] {
				t.Errorf("%s widget %d: the radio name %q is already used by another widget on this page", e.Name, i, radios[0][1])
			}
			groups[radios[0][1]] = true
			var order string
			for _, m := range tabClass.FindAllStringSubmatch(w, -1) {
				order += m[1]
			}
			if order != "dmh" {
				t.Errorf("%s widget %d: tabs %q, want Desktop, Mobile, HTML", e.Name, i, order)
			}
			if n := strings.Count(w, `<iframe class="ds-view__frame"`); n != 1 {
				t.Errorf("%s widget %d frames %d documents, want 1", e.Name, i, n)
			}
			if !strings.Contains(w, `<div class="ds-view__stage"><div class="ds-view__box"><iframe`) {
				t.Errorf("%s widget %d: the frame is not in a box on the stage", e.Name, i)
			}
			panel := panelOf(w)
			if panel == "" {
				t.Errorf("%s widget %d has no HTML panel", e.Name, i)
				continue
			}
			blocks, wantBlocks := strings.Count(panel, `<pre class="ds-src`), 1
			if grouped[e.Name] {
				wantBlocks = len(e.States)
				for _, st := range e.States {
					if !strings.Contains(panel, `<p class="ds-state">`+template.HTMLEscapeString(st.Label)+`</p>`) {
						t.Errorf("%s: the HTML panel does not label the %s row", e.Name, st.ID)
					}
				}
			}
			if blocks != wantBlocks {
				t.Errorf("%s widget %d: %d source blocks in the HTML panel, want %d", e.Name, i, blocks, wantBlocks)
			}
		}
	}
	// The page class: every layout document, the two shell idioms and
	// the modal, and nothing else. The sign-in screens are components,
	// as in Rastrillo: a card, not a window.
	var wantPage []string
	for _, e := range s.m.Examples {
		if e.Document || strings.HasPrefix(e.Name, "shell-") || e.Name == "modal" {
			wantPage = append(wantPage, e.Name)
		}
	}
	if len(wantPage) != 10 {
		t.Errorf("%d examples should take the page class (%v), the manifest was written with 10", len(wantPage), wantPage)
	}
	if strings.Join(pageClass, " ") != strings.Join(wantPage, " ") {
		t.Errorf("the page class is on %v, want %v", pageClass, wantPage)
	}
	if total < 100 {
		t.Errorf("the whole gallery frames %d widgets on day/en; it has well over a hundred states to frame", total)
	}
	// The mechanism, in the widget's half of the stylesheet. Without
	// these the tabs are three radios that change nothing.
	css := string(viewCSS)
	for _, rule := range []string{
		`.ds-view:has(.ds-view__tab--m input:checked) .ds-view__box`,
		`.ds-view:has(.ds-view__tab--h input:checked) .ds-view__stage { display: none; }`,
		`.ds-view:has(.ds-view__tab--h input:checked) .ds-view__code--h { display: block; }`,
		`.ds-view__box { --ds-k: clamp(var(--ds-kmin), tan(atan2(100cqw, var(--ds-w))), 1); }`,
		`container-name: ds-view; container-type: inline-size;`,
		`@container ds-view (min-width: 40.5rem) { .ds-view:not(.ds-view--page):not(:has(input:checked)) .ds-view__tab--d {`,
		`.ds-view:not(.ds-view--page):not(:has(input:checked)) .ds-view__tab--m {`,
		`.ds-view:not(.ds-view--page):not(:has(.ds-view__tab--d input:checked)) .ds-view__box { --ds-h: var(--ds-hm); --ds-w: var(--ds-wm); }`,
		`@container ds-view (min-width: 54rem) { .ds-view--page:not(:has(input:checked)) .ds-view__tab--d {`,
		`.ds-view--page:not(:has(input:checked)) .ds-view__tab--m {`,
		`.ds-view--page:not(:has(.ds-view__tab--d input:checked)) .ds-view__box { --ds-h: var(--ds-hm); --ds-w: var(--ds-wm); }`,
		`.ds-view { --ds-wm: min(390px, 100cqw); }`,
		`[dir="rtl"] .ds-view__frame { transform-origin: top right; }`,
		`.ds-view { --ds-wd: 900px; --ds-w: var(--ds-wd);`,
		`.ds-view--page { --ds-wd: 1200px; }`,
		`overflow: hidden; overflow-x: auto; overscroll-behavior-x: contain;`,
		`scrollbar-width: thin;`,
		`min-block-size: calc(var(--ds-h) * var(--ds-kmin));`,
		`@supports not (container-type: inline-size) { .ds-view:not(:has(input:checked)) .ds-view__tab--d {`,
		`:root[data-gallery-js] .ds-view__frame:not([data-gallery-painted]) { visibility: hidden; }`,
	} {
		if !strings.Contains(css, rule) {
			t.Errorf("view.css carries no rule %q; the tabs would switch nothing", rule)
		}
	}
	if strings.Contains(css, "ds-view__tab--t") {
		t.Error("view.css still carries the Template tab's rules, which Fiesta has no tab for")
	}
	// And nothing scripted, anywhere in the tree: an inline handler
	// would be a widget that stops working with scripts off.
	for name, body := range files {
		if !strings.HasSuffix(name, ".html") {
			continue
		}
		for _, on := range []string{" onclick=", " onchange=", " oninput=", " onload=", " onsubmit="} {
			if strings.Contains(string(body), on) {
				t.Errorf("%s carries an inline%shandler", name, on)
			}
		}
	}
	t.Logf("%d preview widgets across %d example pages", total, len(s.m.Examples))
}

// wrapperOpenings are the first tags the four wrappers put around a
// body. A source block opening with one is a block a reader would
// copy twice-wrapped.
var wrapperOpenings = []string{"<section rst-box>", "<div rst-list>", "<div rst-stats>"}

// TestTheHTMLTabNeverCarriesTheWrapper: the 22 wrapped examples show
// their body without its outer wrapper element(s) in the HTML tab,
// while the frame document still carries it; the seeded
// action="#" leaves with the wrapper; and the line above the block
// names the container with its opening markup.
func TestTheHTMLTabNeverCarriesTheWrapper(t *testing.T) {
	files := render(t, "")
	theme := fiesta.ThemeNames()[0]
	wrapped, states := 0, 0
	for _, e := range manifest(t).Examples {
		page := examplePage(t, files, theme, "en", e.Name)
		if e.Wrapper == "" {
			if strings.Contains(page, `class="ds-wrap"`) {
				t.Errorf("%s has no wrapper and its page carries a wrapper line", e.Name)
			}
			continue
		}
		wrapped++
		open, err := wrapperMarkup(e.Wrapper)
		if err != nil || open == "" {
			t.Fatalf("%s: wrapperMarkup(%q) = %q, %v", e.Name, e.Wrapper, open, err)
		}
		line := `<p class="ds-wrap">Put this inside <code>` + template.HTMLEscapeString(open) + `</code>.</p>`
		if n := strings.Count(page, line); n != len(e.States) {
			t.Errorf("%s: %d widgets say %q, want one per state (%d)", e.Name, n, line, len(e.States))
		}
		for _, st := range e.States {
			states++
			tab := strings.TrimSpace(htmlTab(t, []byte(page), e.Name, st.ID))
			for _, w := range wrapperOpenings {
				if strings.HasPrefix(tab, w) {
					t.Errorf("%s/%s: the HTML tab opens with the wrapper %s", e.Name, st.ID, w)
				}
			}
			if strings.Contains(tab, `action="#"`) {
				t.Errorf("%s/%s: the HTML tab carries the placeholder action=\"#\"", e.Name, st.ID)
			}
			// The control: the frame body still opens with it.
			frame := string(files[theme+"/en/frames/"+e.Name+"/"+st.ID+".html"])
			body := frame[strings.Index(frame, "<body"):]
			body = strings.TrimSpace(body[strings.Index(body, ">")+1:])
			if !strings.HasPrefix(body, strings.Split(open, ">")[0]) {
				t.Errorf("%s/%s: the frame body does not open with %s:\n%.80s", e.Name, st.ID, open, body)
			}
		}
	}
	if wrapped != 22 {
		t.Errorf("%d wrapped examples in the manifest, the spec counts 22", wrapped)
	}
	if states == 0 {
		t.Fatal("no wrapped state was checked")
	}
}

// TestUnwrapStripsTheWrapperAndRefusesABodyWithoutIt: unwrap takes the
// outer wrapper element(s) off a body, the seeded form attributes with
// them, keeps an inner form that is the component's own, leaves an
// unwrapped body alone, and is an error for a body that does not open
// with its wrapper or a wrapper the manifest does not have.
func TestUnwrapStripsTheWrapperAndRefusesABodyWithoutIt(t *testing.T) {
	for _, c := range []struct{ wrapper, in, want string }{
		{"form", `<section rst-box><form rst-form method="post" action="#"><div rst-field>\n<input></div></form></section>`, `<div rst-field>\n<input></div>`},
		{"form", "<section rst-box>\n<form rst-form>\n<p>a</p>\n</form>\n</section>\n", "\n<p>a</p>\n"},
		{"box", `<section rst-box><form rst-form-actions method="post" action="/x"><button>Go</button></form></section>`, `<form rst-form-actions method="post" action="/x"><button>Go</button></form>`},
		{"list", `<div rst-list><div rst-row>r</div></div>`, `<div rst-row>r</div>`},
		{"stats", `<div rst-stats><div rst-stat>1</div></div>`, `<div rst-stat>1</div>`},
		{"", `<span rst-status>Draft</span>`, `<span rst-status>Draft</span>`},
	} {
		got, err := unwrap(c.in, c.wrapper)
		if err != nil || got != c.want {
			t.Errorf("unwrap(%q, %q) = %q, %v; want %q", c.in, c.wrapper, got, err, c.want)
		}
	}
	for _, c := range []struct{ wrapper, in, why string }{
		{"form", `<div rst-field><input></div>`, "a body with no wrapper"},
		{"form", `<section rst-box><div rst-field><input></div></section>`, "a box without the form"},
		{"box", `<section><p>a</p></section>`, "a section without rst-box"},
		{"list", `<div rst-list><div rst-row>r</div>`, "a wrapper never closed"},
		{"card", `<div rst-card>a</div>`, "a wrapper the manifest does not have"},
	} {
		if got, err := unwrap(c.in, c.wrapper); err == nil {
			t.Errorf("unwrap(%q, %q) = %q with no error; %s should fail", c.in, c.wrapper, got, c.why)
		}
	}
	for w, want := range map[string]string{"list": "<div rst-list>", "form": "<section rst-box><form rst-form>", "box": "<section rst-box>", "stats": "<div rst-stats>", "": ""} {
		if got, err := wrapperMarkup(w); err != nil || got != want {
			t.Errorf("wrapperMarkup(%q) = %q, %v; want %q", w, got, err, want)
		}
	}
	if _, err := wrapperMarkup("card"); err == nil {
		t.Error("wrapperMarkup accepted a wrapper the manifest does not have")
	}
}

// TestABodyWithoutItsWrapperFailsTheRender: a seeded document whose
// body has lost its wrapper fails the render naming the state, rather
// than being shown with a wrapper line over markup that has none.
func TestABodyWithoutItsWrapperFailsTheRender(t *testing.T) {
	const file = "examples/field-text/bare.html"
	raw, err := fs.ReadFile(fiesta.FS(), file)
	if err != nil {
		t.Fatal(err)
	}
	stripped := strings.Replace(string(raw), "<section rst-box>", "", 1)
	stripped = strings.Replace(stripped, "</section>", "", 1)
	if stripped == string(raw) {
		t.Fatal("the control did not change the document")
	}
	_, err = Render(overlay{fiesta.FS(), map[string][]byte{file: []byte(stripped)}}, Options{})
	if err == nil {
		t.Fatal("a body without its wrapper rendered")
	}
	if !strings.Contains(err.Error(), "field-text/bare") {
		t.Errorf("the error does not name the state: %v", err)
	}
}

// TestAGroupedPartialNeedsNoWrapper: the grouped examples are the three
// Rastrillo groups, each in the manifest and none wrapped: the grouped
// panels carry no wrapper line, so a wrapped one would be copied
// without its container.
func TestAGroupedPartialNeedsNoWrapper(t *testing.T) {
	if len(grouped) == 0 {
		t.Fatal("no example is grouped, so this checked nothing")
	}
	m := manifest(t)
	for _, name := range []string{"status-pill", "badge", "meter"} {
		if !grouped[name] {
			t.Errorf("%s is not grouped", name)
		}
	}
	for name := range grouped {
		e, ok := m.Entry(name)
		if !ok {
			t.Errorf("%s is grouped and not in the manifest", name)
			continue
		}
		if w, err := wrapperMarkup(e.Wrapper); err != nil || w != "" {
			t.Errorf("%s is grouped and wrapped in %s; the grouped panels would drop the line saying so", name, w)
		}
		if len(e.States) < 2 {
			t.Errorf("%s is grouped with %d state; a group is a row of several", name, len(e.States))
		}
	}
}

// TestAGroupedNoteNamesItsStateApart: under a grouped widget, every
// state has a block of its own naming the state in an element of its
// own, with the note, where there is one, as a paragraph after it and
// nothing written between the two: a joiner would be copy no review
// saw, and an ASCII colon is wrong punctuation in ja, zh-Hans and yue.
func TestAGroupedNoteNamesItsStateApart(t *testing.T) {
	files := render(t, "")
	p := loadedProse(t)
	s := newTestSite(t, fiesta.FS(), "")
	m := s.m
	theme := fiesta.ThemeNames()[0]
	notes, blocks := 0, 0
	for _, locale := range Locales {
		for name := range grouped {
			e, ok := m.Entry(name)
			if !ok {
				t.Fatalf("no %s example", name)
			}
			page := examplePage(t, files, theme, locale, name)
			for _, st := range e.States {
				blocks++
				// The label and the note in the page's language, read
				// through the lookups the page renders them with.
				label := s.label(locale, e, st)
				open := `<div class="ds-group-note" id="` + st.ID + `" data-ds-anchor data-gallery-state="` + name + "/" + st.ID + `"><b class="ds-note__state">` + template.HTMLEscapeString(label) + "</b>\n"
				if !strings.Contains(page, open) {
					t.Errorf("%s/%s %s: no block names the %s state apart", theme, locale, name, st.ID)
					continue
				}
				note := s.proseIn(locale, "examples."+name+".states."+st.ID, p.Examples[name].States[st.ID])
				if note == "" {
					if strings.Contains(page, open+`<p class="ds-note">`) {
						t.Errorf("%s/%s %s/%s has a note and the prose has none", theme, locale, name, st.ID)
					}
					continue
				}
				notes++
				if !strings.Contains(page, open+`<p class="ds-note">`+template.HTMLEscapeString(note)+"</p>\n</div>") {
					t.Errorf("%s/%s %s/%s: the note does not follow its state on a line of its own", theme, locale, name, st.ID)
				}
				if joined := template.HTMLEscapeString(label + ": " + note); strings.Contains(page, joined) {
					t.Errorf("%s/%s %s/%s: the note is joined to its state as %q", theme, locale, name, st.ID, joined)
				}
			}
		}
	}
	if notes == 0 || blocks == 0 {
		t.Fatalf("%d grouped notes and %d state blocks checked; the walk read nothing", notes, blocks)
	}
}

// TestEveryPreviewIsAFileOneFrameNames: every frame document in the
// tree is the src of exactly one frame on one page, except the
// per-state documents of a grouped example, which no frame names (the
// accessibility gate scans them one state at a time) and which are
// counted here. The root index is day/en/index.html again and is not
// walked twice.
func TestEveryPreviewIsAFileOneFrameNames(t *testing.T) {
	files := render(t, "")
	named := map[string]int{}
	frames := 0
	for name, body := range files {
		if !strings.HasSuffix(name, ".html") || isFrame(name) || name == "index.html" {
			continue
		}
		attrsOf(t, body, func(tag string, attrs map[string]string) {
			if tag == "iframe" && attrs["class"] == "ds-view__frame" {
				frames++
				named[strings.TrimPrefix(attrs["src"], "/")]++
			}
		})
	}
	if len(grouped) == 0 {
		t.Fatal("no example is grouped, so the exception below is never exercised")
	}
	previews, unframed := 0, 0
	for name := range files {
		if !isFrame(name) {
			continue
		}
		previews++
		parts := strings.Split(name, "/")
		example, state := parts[len(parts)-2], strings.TrimSuffix(parts[len(parts)-1], ".html")
		want := 1
		if grouped[example] && state != "row" {
			want, unframed = 0, unframed+1
		}
		if n := named[name]; n != want {
			t.Errorf("%s is the src of %d frames, want %d", name, n, want)
		}
	}
	if frames == 0 || previews == 0 || unframed == 0 {
		t.Fatalf("%d frames, %d frame documents, %d of them a grouped state's; this gate is checking nothing", frames, previews, unframed)
	}
	t.Logf("%d frames name %d documents; %d grouped state documents are scanned and not framed", frames, previews-unframed, unframed)
}

// TestTheTextOnScreenIsTheTextCopied: every HTML panel's blocks, with
// the highlighting removed, are exactly the source they stand for, in
// order: the formatted body without its wrapper for a component, the
// whole formatted document for a layout, and one block per state for
// a grouped example. In English and in Arabic, where the source is the
// sample in the page's language: the body through localMarkup, the
// layout's document with its body and title in Arabic and its <html>
// saying so, and the money sample the money table's Arabic markup.
func TestTheTextOnScreenIsTheTextCopied(t *testing.T) {
	files := render(t, "")
	m := manifest(t)
	s := newTestSite(t, fiesta.FS(), "")
	theme := fiesta.ThemeNames()[0]
	checked := 0
	for _, locale := range []string{"en", "ar"} {
		for _, e := range m.Examples {
			var want []string
			for _, st := range e.States {
				var src string
				if e.Document {
					doc, err := example.Document(fiesta.FS(), e.Name, st.ID)
					if err != nil {
						t.Fatal(err)
					}
					if doc, err = s.localDocument(locale, e, st, doc); err != nil {
						t.Fatal(err)
					}
					if src, err = localHTML(doc, locale); err != nil {
						t.Fatal(err)
					}
				} else {
					markup, err := example.Markup(fiesta.FS(), e.Name, st.ID)
					if err != nil {
						t.Fatal(err)
					}
					markup = localMarkup(locale, e.Name, markup)
					if e.Name == moneyExample && st.ID == e.Default {
						markup, _ = s.moneyBody(locale)
					}
					if src, err = unwrap(markup, e.Wrapper); err != nil {
						t.Fatalf("%s/%s: %v", e.Name, st.ID, err)
					}
				}
				want = append(want, codeview.Format(src))
			}
			// The control, independent of unwrap: a wrapped example's
			// expected block does not open with its wrapper.
			for i, w := range want {
				if e.Wrapper == "" {
					continue
				}
				for _, open := range wrapperOpenings {
					if strings.HasPrefix(strings.TrimSpace(w), open) {
						t.Errorf("%s/%s block %d: the expected source still opens with %s; unwrap left the wrapper in", locale, e.Name, i, open)
					}
				}
			}
			got := sourceTexts(examplePage(t, files, theme, locale, e.Name))
			if len(got) != len(want) {
				t.Errorf("%s/%s: %d source blocks on the page, want %d", locale, e.Name, len(got), len(want))
				continue
			}
			for i := range want {
				checked++
				if got[i] != want[i] {
					t.Errorf("%s/%s block %d: on screen\n%s\nwant\n%s", locale, e.Name, i, got[i], want[i])
				}
			}
		}
	}
	if checked == 0 {
		t.Fatal("no block was compared")
	}
}

// TestEveryCodeBlockOffersTheCopyButton: no block in the tree refuses
// the Copy button (no Fiesta example is an illustration), and on day/en
// every block is a copyable block inside an HTML panel, one per state.
func TestEveryCodeBlockOffersTheCopyButton(t *testing.T) {
	files := render(t, "")
	m := manifest(t)
	theme := fiesta.ThemeNames()[0]
	for name, body := range files {
		if strings.HasSuffix(name, ".html") && strings.Contains(string(body), "data-ds-nocopy") {
			t.Errorf("%s carries a block that refuses the Copy button", name)
		}
	}
	const block = `<pre class="ds-src rst-mono" tabindex="0"><code>`
	blocks, inPanels, states := 0, 0, 0
	for _, e := range m.Examples {
		page := examplePage(t, files, theme, "en", e.Name)
		states += len(e.States)
		blocks += strings.Count(page, block)
		for _, w := range widgetsOf(page) {
			inPanels += strings.Count(panelOf(w), block)
		}
	}
	if blocks == 0 || blocks != states || inPanels != blocks {
		t.Errorf("day/en has %d copyable blocks, %d of them in HTML panels, over %d states; want one per state, every one in a panel", blocks, inPanels, states)
	}
}

// TestEveryFrameTitleIsUniqueOnThePage: a frame's title is an
// accessible name, unique on its page, and never the empty label's
// bare "name: ": a state with no label takes the example's name.
func TestEveryFrameTitleIsUniqueOnThePage(t *testing.T) {
	files := render(t, "")
	titleAttr := regexp.MustCompile(`<iframe class="ds-view__frame"[^>]*\stitle="([^"]*)"`)
	frames := 0
	for name, body := range files {
		if !strings.HasSuffix(name, ".html") || isSampleDocument(name) {
			continue
		}
		seen := map[string]int{}
		for _, m := range titleAttr.FindAllStringSubmatch(string(body), -1) {
			frames++
			title := html.UnescapeString(m[1])
			seen[title]++
			if title == "" || strings.HasSuffix(title, ": ") || strings.HasSuffix(title, ":") {
				t.Errorf("%s has a frame titled %q", name, title)
			}
		}
		for title, n := range seen {
			if n > 1 {
				t.Errorf("%s has %d frames titled %q", name, n, title)
			}
		}
	}
	if frames == 0 {
		t.Fatal("no frame title was read")
	}
}

// TestEveryShellHasABlurb: the seven layout pages have a blurb, and the
// five shells (the -page pair members excluded) end with the button
// that opens the shell's own frame document in a new tab.
func TestEveryShellHasABlurb(t *testing.T) {
	files := render(t, "")
	p := loadedProse(t)
	s := newTestSite(t, fiesta.FS(), "")
	theme := fiesta.ThemeNames()[0]
	layouts := 0
	var shells []string
	for _, e := range s.m.Examples {
		page := examplePage(t, files, theme, "en", e.Name)
		if !e.Document {
			if strings.Contains(page, say("gallery.shell.open", "shell", "")) {
				t.Errorf("%s is not a layout and carries an open-shell button", e.Name)
			}
			continue
		}
		layouts++
		if p.Examples[e.Name].Blurb == "" {
			t.Errorf("the %s layout has no blurb", e.Name)
		}
		shell := strings.TrimPrefix(e.Name, "layout-")
		button := `<p><a rst-btn data-gallery-nav href="` + s.href(theme, "en", "frames/"+e.Name+"/"+e.Default+".html") + `" target="_blank" rel="noopener">` +
			template.HTMLEscapeString(say("gallery.shell.open", "shell", shell)) + `<span class="rst-sr-only"> (` + say("gallery.newtab") + `)</span></a></p>`
		has := strings.Contains(page, button)
		if strings.HasSuffix(e.Name, "-page") {
			if has || strings.Contains(page, `<p><a rst-btn data-gallery-nav`) {
				t.Errorf("%s is the pair's page and carries an open-shell button", e.Name)
			}
			continue
		}
		shells = append(shells, shell)
		if !has {
			t.Errorf("%s does not end with %s", e.Name, button)
		}
		if i, j := strings.Index(page, button), strings.Index(page, `<nav class="ds-updown"`); i >= 0 && j >= 0 && i > j {
			t.Errorf("%s: the open button is after the previous/next pair, not at the end of the body", e.Name)
		}
	}
	if layouts != 7 {
		t.Errorf("%d layout examples, want 7", layouts)
	}
	if want := "column topbar sidebar console stage"; strings.Join(shells, " ") != want {
		t.Errorf("the shells with an open button are %v, want %s", shells, want)
	}
}