package gallery

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

	"amadan.net/rastrillo/fiesta"
)

// The shell every page is drawn in: the sidebar shell Fiesta ships,
// with the rail and its filter, the pinned bar, the phone index and
// its way back, the display settings menu, and the scripts a gallery
// page loads. These read the rendered bytes; the drives in the
// browser-tagged files beside this one read what the scripts do to
// them. Where a gate below is Rastrillo's, its name is kept and its
// expectations are read off pageKinds() and the manifest, so a page
// kind or an example added later is covered the day it lands.

// railOf cuts the sidebar's nav out of a page. Everything below reads
// this slice rather than the whole document, so a stray anchor
// somewhere in a sample cannot make the rail look complete.
func railOf(t *testing.T, name, page string) string {
	t.Helper()
	_, after, ok := strings.Cut(page, `<nav class="ds-nav" rst-shell-nav id="ds-nav"`)
	if !ok {
		t.Errorf("%s: no sidebar nav", name)
		return ""
	}
	rail, _, ok := strings.Cut(after, "</nav>")
	if !ok {
		t.Errorf("%s: the sidebar nav never closes", name)
		return ""
	}
	return rail
}

// pageNames lists the pages a whole-tree gate reads, sorted: every
// page-kind page of every theme and locale, and every page of the
// default theme in English, the example pages included. The example
// pages are one template over one body each, so reading the hundred
// or so of one directory proves the shell on them; a regexp gate over
// all 3,888 took over a minute.
func pageNames(s *site, files map[string][]byte) []string {
	var out []string
	for _, dir := range dirs() {
		if dir == fiesta.ThemeNames()[0]+"/en/" {
			for name := range files {
				if strings.HasPrefix(name, dir) && strings.HasSuffix(name, ".html") && !isSampleDocument(name) {
					out = append(out, name)
				}
			}
			continue
		}
		for _, pk := range s.pageKinds() {
			out = append(out, dir+pk.File)
		}
	}
	sort.Strings(out)
	return out
}

// kindPage is one page-kind page of one directory, by file, with a
// fatal if the renderer did not produce it.
func kindPage(t *testing.T, files map[string][]byte, theme, locale, file string) string {
	t.Helper()
	name := theme + "/" + locale + "/" + file
	page := string(files[name])
	if page == "" {
		t.Fatalf("no %s in the rendered tree", name)
	}
	return page
}

var (
	anchorMarker = regexp.MustCompile(`id="([^"]*)" data-ds-anchor`)
	navHref      = regexp.MustCompile(`<a[^>]*\shref="([^"]*)"`)
	elementID    = regexp.MustCompile(`\bid="([^"]*)"`)
	shellRoot    = regexp.MustCompile(`<div rst-shell-sidebar="([a-z]+)">`)
	backLink     = regexp.MustCompile(`<a rst-skip href="#main">[^<]*</a>\n<div rst-shell-back><a data-gallery-nav href="([^"]*)" rel="up" aria-label="([^"]*)">([^<]*)</a>`)
	prefsCard    = regexp.MustCompile(`(?s)<details rst-dropdown class="ds-prefs" id="ds-prefs" name="ds-prefs"><summary aria-label="([^"]*)">(.*?)</summary><div rst-dropdown-menu>(.*?)</div></details>`)
	barCtl       = regexp.MustCompile(`(?s)<div class="ds-top__controls">(.*?)</header>`)
	indexNav     = regexp.MustCompile(`(?s)<nav class="ds-index" rst-shell-nav aria-label="([^"]*)">(.*?)</nav>`)
	schemeMenu   = regexp.MustCompile(`(?s)<details rst-dropdown rst-scheme.*?</details>`)
)

// TestTheGalleryIsTheShippedShell: every page's body opens the
// sidebar shell, "index" on the Overview and "page" everywhere else,
// with the back control right after the skip link on a content page,
// in the page's language, and never on the index; the index pieces (the shell title, the lead
// and the rows) on the Overview alone; one display settings menu per
// page, in the index's header row or in the back strip; shell.css
// linked hashed and shell.js loaded deferred and render-blocking, as
// the layouts load it.
func TestTheGalleryIsTheShippedShell(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	checked := 0
	for _, name := range pageNames(s, files) {
		page := string(files[name])
		locale := "en"
		if parts := strings.Split(name, "/"); len(parts) == 3 {
			locale = parts[1]
		}
		label := s.say(locale, "gallery.up.label")
		aria := template.HTMLEscapeString(s.say(locale, "gallery.up", "name", label))
		index := strings.HasSuffix(name, "/index.html")
		want := map[bool]string{true: "index", false: "page"}[index]
		if m := shellRoot.FindAllStringSubmatch(page, -1); len(m) != 1 || m[0][1] != want {
			t.Errorf("%s: shell root %v, want one rst-shell-sidebar=%q", name, m, want)
		}
		backs := backLink.FindAllStringSubmatch(page, -1)
		if n := strings.Count(page, "<div rst-shell-back>"); index && n != 0 || !index && (n != 1 || len(backs) != 1) {
			t.Errorf("%s: %d back controls (%d right after the skip link), want %d", name, n, len(backs), map[bool]int{false: 1}[index])
		} else if !index && (backs[0][2] != aria || backs[0][3] != template.HTMLEscapeString(label)) {
			t.Errorf("%s: the back control reads %q named %q, want %q named %q", name, backs[0][3], backs[0][2], label, aria)
		}
		for _, piece := range []string{`<h1 rst-shell-title>`, `<p class="ds-index-lead">`, `<nav class="ds-index"`} {
			if strings.Contains(page, piece) != index {
				t.Errorf("%s: %s present=%v; it belongs on the Overview and nowhere else", name, piece, !index)
			}
		}
		if strings.Contains(page, "<div rst-shell-rail-foot") {
			t.Errorf("%s: the rail has a foot; the controls are in the display settings menu", name)
		}
		if n := strings.Count(page, `class="ds-prefs"`); n != 1 {
			t.Errorf("%s: %d display settings menus, want one", name, n)
		}
		where := `<div rst-shell-back><a `
		if index {
			where = `<h1 rst-shell-title><span></span><span>` + template.HTMLEscapeString(s.say("en", "gallery.brand")) + `</span></h1>` + "\n" + `<details rst-dropdown class="ds-prefs"`
		}
		if !strings.Contains(page, where) {
			t.Errorf("%s: the display settings menu is not where a phone looks for it (%s)", name, where)
		}
		if i := strings.Index(page, "<div rst-shell-back>"); !index && i >= 0 {
			strip := page[i:]
			if strings.Index(strip, `class="ds-prefs"`) > strings.Index(strip, "</div>\n") {
				t.Errorf("%s: the display settings menu is not inside the back strip", name)
			}
		}
		for _, want := range []string{
			`<link rel="stylesheet" href="` + s.asset("css/shell.css") + `">`,
			`<script defer blocking="render" src="` + s.asset("js/shell.js") + `"></script>`,
		} {
			if !strings.Contains(page, want) {
				t.Errorf("%s: no %s; the slide, Back through history and the focus return are shell.css and shell.js", name, want)
			}
		}
		checked++
	}
	if checked < 36*len(s.pageKinds())+len(s.m.Examples) {
		t.Fatalf("%d pages checked; the tree has more", checked)
	}
}

// shellSkeleton is the shape of a document's shell: for every element
// carrying one of the shell's structural attributes, its tag, the
// attribute, and the nearest such attribute above it. The gallery's
// skeleton has to be drawn from the shell-sidebar example's: the same
// tags carrying the same attributes under the same parents.
func shellSkeleton(doc node) map[string]bool {
	structural := []string{"rst-shell-sidebar", "rst-skip", "rst-shell-back", "rst-shell-rail", "rst-shell-title", "rst-shell-nav", "rst-shell-main", "rst-page"}
	mark := func(n node) string {
		for _, a := range structural {
			if _, ok := n.attr(a); ok {
				return a
			}
		}
		return ""
	}
	out := map[string]bool{}
	for _, n := range doc.find(func(n node) bool { return mark(n) != "" }) {
		parent := ""
		for p := n.n.Parent; p != nil && parent == ""; p = p.Parent {
			parent = mark(node{p})
		}
		out[n.n.Data+"["+mark(n)+"] under "+parent] = true
	}
	return out
}

// TestTheSidebarIsTheShellTheGalleryDocuments: the gallery is laid out
// in the vocabulary it documents. Every structural piece of a page's
// shell (the root, the skip link, the back strip, the rail, its title
// and navs, main and the page column) sits under the same parent, on
// the same tag, as in the shell-sidebar example, and the rail, the
// nav and main are there by name; the filter is a real search input
// in a search landmark naming the nav it filters, with the no-matches
// line rendered by the page and hidden; one disclosure per page kind
// with entries plus Demos, exactly one open; every section named in
// the page's language; the disclosure glyph the icon set's chevron.
func TestTheSidebarIsTheShellTheGalleryDocuments(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	example, ok := files["day/en/frames/shell-sidebar/default.html"]
	if !ok {
		t.Fatal("no shell-sidebar frame to read the shell's skeleton from")
	}
	reference := shellSkeleton(parse(t, example))
	if len(reference) < 6 {
		t.Fatalf("the shell-sidebar example's skeleton has %d pieces; the comparison below would read too little", len(reference))
	}
	disclosing := 1
	for _, pk := range s.pageKinds() {
		if pk.Nav != nil {
			disclosing++
		}
	}
	for _, theme := range fiesta.ThemeNames() {
		for _, locale := range Locales {
			for _, pk := range s.pageKinds() {
				name := theme + "/" + locale + "/" + pk.File
				page := kindPage(t, files, theme, locale, pk.File)
				skeleton := shellSkeleton(parse(t, []byte(page)))
				for piece := range skeleton {
					if !reference[piece] {
						t.Errorf("%s: the shell has %s, which the shell-sidebar example does not", name, piece)
					}
				}
				for _, want := range []string{
					`<aside class="ds-rail" rst-shell-rail>`,
					`<nav class="ds-nav" rst-shell-nav id="ds-nav"`,
					`<main rst-shell-main id="main">`,
				} {
					if !strings.Contains(page, want) {
						t.Errorf("%s: the page is not laid out in the sidebar shell (no %s)", name, want)
					}
				}
				for _, want := range []string{
					`<search class="ds-search">`,
					`<input id="ds-filter" type="search"`,
					`aria-controls="ds-nav"`,
					`data-ds-filter`,
					`data-ds-filter-empty role="status" hidden`,
				} {
					if !strings.Contains(page, want) {
						t.Errorf("%s: the filter box is not there as specified (no %s)", name, want)
					}
				}
				rail := railOf(t, name, page)
				if n := strings.Count(rail, "<details"); n != disclosing {
					t.Errorf("%s: %d sidebar disclosures, want %d", name, n, disclosing)
				}
				want := 0
				if pk.Nav != nil {
					want = 1
				}
				if n := strings.Count(rail, "<details open"); n != want {
					t.Errorf("%s: %d sidebar sections arrive open, want %d (the one this page is)", name, n, want)
				}
				for _, pk2 := range s.pageKinds() {
					title := template.HTMLEscapeString(s.titleOf(locale, pk2))
					if pk2.Nav == nil {
						if !strings.Contains(rail, `class="ds-nav__page"`) || !strings.Contains(rail, `>`+title+`</a>`) {
							t.Errorf("%s: no sidebar link named %q for the page with nothing to list", name, s.titleOf(locale, pk2))
						}
						continue
					}
					if !strings.Contains(rail, `</span>`+title+`</summary>`) {
						t.Errorf("%s: no sidebar section named %q", name, s.titleOf(locale, pk2))
					}
				}
				if title := template.HTMLEscapeString(s.say(locale, "gallery.nav.demos")); !strings.Contains(rail, `</span>`+title+`</summary>`) {
					t.Errorf("%s: no sidebar section named %q", name, s.say(locale, "gallery.nav.demos"))
				}
				if n := strings.Count(rail, `<span rst-caret aria-hidden="true"><svg`); n != disclosing {
					t.Errorf("%s: %d rail disclosures draw a chevron, want %d", name, n, disclosing)
				}
				for _, glyph := range []string{"▸", "▾", `content: "\25b8"`, `content: "\25be"`} {
					if strings.Contains(page, glyph) {
						t.Errorf("%s still draws a disclosure glyph as the character %q", name, glyph)
					}
				}
				if want := `aria-label="` + template.HTMLEscapeString(s.say(locale, "gallery.nav.sections")) + `"`; !strings.Contains(page, want) {
					t.Errorf("%s: the sidebar nav is not named in this page's language", name)
				}
			}
		}
	}
}

// TestTheRailIsTheSameOnEveryPage: the rail is the same on every page
// of a directory, byte for byte apart from which section and entry
// carry aria-current="page". That is the promise the rail makes to a
// reader: the whole vocabulary is one list, and moving between the
// pages does not move the list under them.
func TestTheRailIsTheSameOnEveryPage(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	current := strings.NewReplacer(` open aria-current="page"`, "", ` aria-current="page"`, "")
	for _, dir := range dirs() {
		var first, firstName string
		for _, name := range pageNames(s, files) {
			if !strings.HasPrefix(name, dir) {
				continue
			}
			rail := current.Replace(railOf(t, name, string(files[name])))
			if rail == "" {
				continue
			}
			if first == "" {
				first, firstName = rail, name
				continue
			}
			if rail != first {
				t.Errorf("%s and %s carry different rails", firstName, name)
			}
		}
		if first == "" {
			t.Errorf("%s: no rail on any page", dir)
		}
	}
}

// TestTheRailSaysWhichPageYouAreOn: on a page-kind page exactly one
// section of the rail is marked current and it is the page's own,
// open where it discloses and a plain link where it does not; on an
// example page its family's section is open and current and the
// example's own entry is current too, and nothing else is.
func TestTheRailSaysWhichPageYouAreOn(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	for _, theme := range fiesta.ThemeNames() {
		for _, locale := range Locales {
			for _, pk := range s.pageKinds() {
				name := theme + "/" + locale + "/" + pk.File
				rail := railOf(t, name, kindPage(t, files, theme, locale, pk.File))
				if n := strings.Count(rail, `aria-current="page"`); n != 1 {
					t.Errorf("%s: %d things in the rail are marked current, want 1", name, n)
					continue
				}
				title := template.HTMLEscapeString(s.titleOf(locale, pk))
				open := regexp.MustCompile(`(?s)<details open aria-current="page"><summary><span rst-caret aria-hidden="true"><svg.*?</svg></span>` + regexp.QuoteMeta(title) + `</summary>`)
				link := `<a class="ds-nav__page" data-gallery-nav href="` + s.href(theme, locale, pk.File) + `" aria-current="page">` + title + `</a>`
				if !strings.Contains(rail, link) && !open.MatchString(rail) {
					t.Errorf("%s: the current section of the rail is not %q", name, s.titleOf(locale, pk))
				}
			}
		}
	}
	theme, locale := fiesta.ThemeNames()[0], "en"
	for _, e := range s.m.Examples {
		name := theme + "/" + locale + "/" + e.Name + ".html"
		rail := railOf(t, name, string(files[name]))
		if n := strings.Count(rail, `aria-current="page"`); n != 2 {
			t.Errorf("%s: %d things in the rail are marked current, want 2 (the family's section and the example's entry)", name, n)
			continue
		}
		f, _ := s.familyByKey(e.Family)
		open := regexp.MustCompile(`(?s)<details open aria-current="page"><summary><span rst-caret aria-hidden="true"><svg.*?</svg></span>` + regexp.QuoteMeta(template.HTMLEscapeString(f.Title)) + `</summary>`)
		if !open.MatchString(rail) {
			t.Errorf("%s: the open section of the rail is not the %s family", name, e.Family)
		}
		if want := `<a data-gallery-nav href="` + s.href(theme, locale, e.Name+".html") + `" aria-current="page" class="rst-mono"`; !strings.Contains(rail, want) {
			t.Errorf("%s: the rail does not mark the example's own entry current (no %s)", name, want)
		}
	}
}

// TestTheSidebarLinksEverythingOnThePageExactlyOnce: the rail is a
// reading of the page. On a page that anchors things (Tokens, Icons)
// the fragments the rail links into it, in rail order, are exactly
// the anchored elements on the page, in page order; on a family page
// the section's entries are exactly the page's own list of examples,
// in order. Everything the rail links is a page of this tree, and the
// links out of the gallery's pages are the Demos alone: the five shell
// demos, the modal route and the demo application.
func TestTheSidebarLinksEverythingOnThePageExactlyOnce(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	anchored, listed := 0, 0
	for _, theme := range fiesta.ThemeNames() {
		for _, locale := range Locales {
			for _, pk := range s.pageKinds() {
				name := theme + "/" + locale + "/" + pk.File
				page := kindPage(t, files, theme, locale, pk.File)
				rail := railOf(t, name, page)
				if rail == "" {
					continue
				}
				self := s.href(theme, locale, pk.File)
				var anchors []string
				for _, m := range anchorMarker.FindAllStringSubmatch(page, -1) {
					anchors = append(anchors, m[1])
				}
				var fragments []string
				for _, m := range navHref.FindAllStringSubmatch(rail, -1) {
					if strings.HasPrefix(m[1], self+"#") {
						fragments = append(fragments, strings.TrimPrefix(m[1], self+"#"))
					}
				}
				if len(anchors) > 0 {
					anchored++
				}
				if strings.Join(fragments, " ") != strings.Join(anchors, " ") {
					t.Errorf("%s: the sidebar links the fragments %v, the page anchors %v", name, fragments, anchors)
				}
				if _, isFamily := s.familyByKey(pk.Kind); isFamily {
					listed++
					doc := parse(t, []byte(page))
					var examples []string
					if routes, ok := doc.first(byClass("ds-routes")); ok {
						for _, a := range routes.find(func(n node) bool { return n.n.Data == "a" }) {
							href, _ := a.attr("href")
							examples = append(examples, href)
						}
					}
					var items []string
					for _, g := range railSections(rail) {
						if g.Title == template.HTMLEscapeString(s.titleOf(locale, pk)) {
							for i, m := range navHref.FindAllStringSubmatch(g.Body, -1) {
								if i > 0 {
									items = append(items, m[1])
								}
							}
						}
					}
					if len(examples) == 0 || strings.Join(items, " ") != strings.Join(examples, " ") {
						t.Errorf("%s: the section lists %v, the page lists %v", name, items, examples)
					}
				}
				away := 0
				for _, m := range navHref.FindAllStringSubmatch(rail, -1) {
					path, _, _ := strings.Cut(strings.TrimPrefix(m[1], "/"), "#")
					if !strings.HasPrefix(m[1], "/") {
						t.Errorf("%s: the sidebar links %q, which is not an absolute path", name, m[1])
						continue
					}
					if _, ok := files[path]; !ok {
						t.Errorf("%s: the sidebar links %q, which is not a page of this tree", name, m[1])
						continue
					}
					if isSampleDocument(path) {
						away++
					}
				}
				if want := len(shellNames) + 2; away != want {
					t.Errorf("%s: the sidebar has %d links out of the gallery's pages, want %d (one per shell demo, the modal route and the demo application)", name, away, want)
				}
			}
		}
	}
	if anchored == 0 || listed == 0 {
		t.Fatalf("%d anchored pages and %d family pages read; the check above read one side only", anchored, listed)
	}
}

// railSection is one group of the rail as the page renders it: a
// <details> holding a title and a run of links, or the plain link a
// section with nothing to list renders as instead.
var railSection = regexp.MustCompile(`(?s)<details([^>]*)><summary>.*?</summary>(.*?)</details>|<a class="ds-nav__page" data-gallery-nav href="([^"]*)"[^>]*>(.*?)</a>`)

// railTitle reads the section's own name out of either shape: past the
// caret icon in a <summary>, or the whole text of the plain link.
var railTitle = regexp.MustCompile(`(?s)<summary>(?:<span rst-caret aria-hidden="true">.*?</span>)?(.*?)</summary>`)

type railGroup struct {
	Title string
	Body  string // the links inside a disclosure; empty for a plain link
	Href  string // set only for the plain-link shape
	Open  bool   // true for the disclosure shape
}

// railSections splits one rendered rail into its groups, in order.
func railSections(rail string) []railGroup {
	var out []railGroup
	for _, m := range railSection.FindAllString(rail, -1) {
		sub := railSection.FindStringSubmatch(m)
		if strings.HasPrefix(m, "<details") {
			title := ""
			if t := railTitle.FindStringSubmatch(m); t != nil {
				title = t[1]
			}
			out = append(out, railGroup{Title: title, Body: sub[2], Open: true})
			continue
		}
		out = append(out, railGroup{Title: sub[4], Href: sub[3]})
	}
	return out
}

// TestEverySectionOfTheRailRoutesToItsOwnPage: every section of the
// rail has a route to the top of its own page, and it is the first
// thing under the section's name: the plain link where the section
// lists nothing, and otherwise an Overview item named for a screen
// reader by its section, whose accessible name contains its visible
// label (WCAG 2.2 SC 2.5.3). Exactly one route per page kind, and
// none in Demos, which is not a page of this gallery.
func TestEverySectionOfTheRailRoutesToItsOwnPage(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	for _, theme := range fiesta.ThemeNames() {
		for _, locale := range Locales {
			label := s.say(locale, "gallery.nav.overview")
			for _, pk := range s.pageKinds() {
				name := theme + "/" + locale + "/" + pk.File
				rail := railOf(t, name, kindPage(t, files, theme, locale, pk.File))
				if rail == "" {
					continue
				}
				groups := railSections(rail)
				if want := len(s.pageKinds()) + 1; len(groups) != want {
					t.Errorf("%s: the rail has %d sections, want %d (one per page kind, plus Demos)", name, len(groups), want)
					continue
				}
				overviews := 0
				for i, pk2 := range s.pageKinds() {
					g := groups[i]
					want := s.href(theme, locale, pk2.File)
					title := template.HTMLEscapeString(s.titleOf(locale, pk2))
					if g.Title != title {
						t.Errorf("%s: rail section %d is %q, want %q", name, i, g.Title, title)
						continue
					}
					if n := strings.Count(rail, `href="`+want+`"`); n != 1 {
						t.Errorf("%s: the rail carries %d links to %s, want exactly 1", name, n, want)
					}
					if !g.Open {
						if g.Href != want {
							t.Errorf("%s: the %s section links %q, want %q", name, pk2.Kind, g.Href, want)
						}
						continue
					}
					first := navHref.FindStringIndex(g.Body)
					if first == nil {
						t.Errorf("%s: the %s section of the rail has no links at all", name, pk2.Kind)
						continue
					}
					item := g.Body[first[0]:]
					if i := strings.Index(item, "</a>"); i >= 0 {
						item = item[:i+len("</a>")]
					}
					spoken := s.say(locale, "gallery.nav.overview.aria", "section", s.titleOf(locale, pk2))
					wantItem := `<a data-gallery-nav href="` + want + `" aria-label="` + template.HTMLEscapeString(spoken) + `">` + template.HTMLEscapeString(label) + `</a>`
					if item != wantItem {
						t.Errorf("%s: the first item under %s is\n  %s\nwant\n  %s", name, pk2.Kind, item, wantItem)
						continue
					}
					overviews++
					if !strings.Contains(strings.ToLower(spoken), strings.ToLower(label)) {
						t.Errorf("%s: the %s section's accessible name %q does not contain its visible label %q (WCAG 2.2 SC 2.5.3)", name, pk2.Kind, spoken, label)
					}
				}
				var bodies string
				for _, g := range groups {
					bodies += g.Body
				}
				if n := strings.Count(bodies, ` aria-label="`); n != overviews {
					t.Errorf("%s: %d rail links carry an accessible name, want %d (one per section that discloses, and none in Demos)", name, n, overviews)
				}
				if demos := groups[len(groups)-1]; demos.Title != template.HTMLEscapeString(s.say(locale, "gallery.nav.demos")) {
					t.Errorf("%s: the last rail section is %q, want Demos", name, demos.Title)
				} else if strings.Contains(demos.Body, ` aria-label="`) {
					t.Errorf("%s: the Demos section carries an overview link; it is not a page of this gallery", name)
				}
			}
		}
	}
}

// demoHrefs are the Demos' addresses in one directory: the five shell
// demos (the layout examples' default frame documents), the modal route
// and the demo application.
func demoHrefs(t *testing.T, s *site, theme, locale string) map[string]bool {
	t.Helper()
	out := map[string]bool{}
	for _, shell := range shellNames {
		state, ok := s.m.Default("layout-" + shell)
		if !ok {
			t.Fatalf("no layout-%s example", shell)
		}
		out[s.href(theme, locale, "frames/layout-"+shell+"/"+state+".html")] = true
	}
	out[s.href(theme, locale, "demo-modal.html")] = true
	out[s.href(theme, locale, "demo.html")] = true
	return out
}

// TestEveryDemoLinkOpensInANewTab: every link the renderer owns that
// leaves the gallery's pages for a demo opens in a new tab, and the
// rail carries one to each of the seven on every page: the five shells,
// the modal route and the demo application. The three primitives that
// are pages of their own (the modal, and the sidebar and topbar shell
// idioms) each end with a link to that page, in a new tab, saying so.
// A reader is a long way down a page with a filter typed into the
// rail; losing that to look at a demo is a poor trade. The switchers
// are not in this set: a theme or a language is the same page again.
func TestEveryDemoLinkOpensInANewTab(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	away := regexp.MustCompile(`<a[^>]*\shref="([^"]*)"[^>]*>`)
	for _, theme := range fiesta.ThemeNames() {
		for _, locale := range Locales {
			demos := demoHrefs(t, s, theme, locale)
			if len(demos) != len(shellNames)+2 {
				t.Fatalf("%d demos, want %d", len(demos), len(shellNames)+2)
			}
			seen := map[string]int{}
			pages := 0
			for _, name := range pageNames(s, files) {
				if !strings.HasPrefix(name, theme+"/"+locale+"/") {
					continue
				}
				pages++
				for _, m := range away.FindAllStringSubmatch(string(files[name]), -1) {
					if !demos[m[1]] {
						continue
					}
					seen[m[1]]++
					if !strings.Contains(m[0], `target="_blank"`) || !strings.Contains(m[0], `rel="noopener"`) {
						t.Errorf("%s: %s does not open in a new tab", name, m[0])
					}
				}
			}
			for href := range demos {
				if seen[href] < pages {
					t.Errorf("%s/%s: %s is linked %d times, want at least %d (the rail, on every page)", theme, locale, href, seen[href], pages)
				}
			}
			// The primitives' own links, on their pages in every
			// directory.
			newTab := `<span class="rst-sr-only"> (` + template.HTMLEscapeString(s.say(locale, "gallery.newtab")) + `)</span></a>`
			for _, live := range []struct{ example, label, href string }{
				{"modal", "gallery.primitives.modal.live", s.href(theme, locale, "demo-modal.html")},
				{"shell-sidebar", "gallery.primitives.sidebar.live", s.href(theme, locale, "frames/layout-sidebar/"+mustEntry(t, "layout-sidebar").Default+".html")},
				{"shell-topbar", "gallery.primitives.topbar.live", s.href(theme, locale, "frames/layout-topbar/"+mustEntry(t, "layout-topbar").Default+".html")},
			} {
				want := `<a data-gallery-nav href="` + live.href + `" target="_blank" rel="noopener">` + template.HTMLEscapeString(s.say(locale, live.label)) + newTab
				if n := strings.Count(examplePage(t, files, theme, locale, live.example), want); n != 1 {
					t.Errorf("%s/%s/%s.html carries %d links %s, want one", theme, locale, live.example, n, want)
				}
			}
		}
	}
}

// TestThePhoneIndexSaysItsDemosOpenANewTab: the phone index's Demos
// rows open a new tab and say so to a screen reader; a reader who is
// not told finds Back dead and their filter gone.
func TestThePhoneIndexSaysItsDemosOpenANewTab(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	blank := regexp.MustCompile(`<a data-gallery-nav href="[^"]*" target="_blank" rel="noopener">(.*?)</a>`)
	for _, locale := range Locales {
		m := indexNav.FindStringSubmatch(kindPage(t, files, fiesta.ThemeNames()[0], locale, "index.html"))
		if m == nil {
			t.Fatalf("%s: no rows nav on the Overview", locale)
		}
		rows := blank.FindAllStringSubmatch(m[2], -1)
		if len(rows) == 0 {
			t.Fatalf("%s: no Demos row opens a new tab, so this checked nothing", locale)
		}
		say := `<span class="rst-sr-only"> (` + template.HTMLEscapeString(s.say(locale, "gallery.newtab")) + `)</span>`
		for _, r := range rows {
			if !strings.HasSuffix(r[1], say) {
				t.Errorf("%s: the Demos row %q opens a new tab without saying %s", locale, r[1], say)
			}
		}
	}
}

// TestEveryWayUpNamesItsRow: every content page's back control
// returns to its own row on the index, index.html#nav-<kind>, a
// fragment naming a link in the rows nav whose href is that page; an
// example page's way up is its family's row. The rows are the rail's
// sections in its order, but the Overview and Demos, and the rows end
// with the Demos group.
func TestEveryWayUpNamesItsRow(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	for _, theme := range fiesta.ThemeNames() {
		for _, locale := range Locales {
			overview := kindPage(t, files, theme, locale, "index.html")
			m := indexNav.FindStringSubmatch(overview)
			if m == nil {
				t.Fatalf("%s/%s: no rows nav on the Overview", theme, locale)
			}
			if want := template.HTMLEscapeString(s.say(locale, "gallery.up.label")); m[1] != want {
				t.Errorf("%s/%s: the rows nav is labelled %q, want the back control's word %q, so Back to it lands on a list of that name", theme, locale, m[1], want)
			}
			rows := m[2]
			for _, pk := range s.pageKinds() {
				if pk.Kind == "overview" {
					continue
				}
				b := backLink.FindStringSubmatch(kindPage(t, files, theme, locale, pk.File))
				if want := s.href(theme, locale, "index.html") + "#nav-" + pk.Kind; b == nil || b[1] != want {
					t.Errorf("%s/%s/%s: way up %v, want %s", theme, locale, pk.File, b, want)
				}
				if row := `<a id="nav-` + pk.Kind + `" data-gallery-nav href="` + s.href(theme, locale, pk.File) + `">`; !strings.Contains(rows, row) {
					t.Errorf("%s/%s: no row %s", theme, locale, row)
				}
			}
			for _, e := range s.m.Examples {
				b := backLink.FindStringSubmatch(string(files[theme+"/"+locale+"/"+e.Name+".html"]))
				if want := s.href(theme, locale, "index.html") + "#nav-" + e.Family; b == nil || b[1] != want {
					t.Errorf("%s/%s/%s.html: way up %v, want its family's row %s", theme, locale, e.Name, b, want)
				}
			}
			var tree, listed []string
			for _, g := range railSections(railOf(t, "overview", overview)) {
				tree = append(tree, g.Title)
			}
			for _, r := range regexp.MustCompile(`<a id="nav-[^"]+" data-gallery-nav href="[^"]*">([^<]*)</a>`).FindAllStringSubmatch(rows, -1) {
				listed = append(listed, r[1])
			}
			if len(tree) < 3 {
				t.Fatalf("%s/%s: the rail has %d sections", theme, locale, len(tree))
			}
			if want := tree[1 : len(tree)-1]; strings.Join(listed, "|") != strings.Join(want, "|") {
				t.Errorf("%s/%s: rows %v, want the tree's sections but the Overview and Demos, %v", theme, locale, listed, want)
			}
			if !strings.Contains(rows, `<p rst-shell-group>`+tree[len(tree)-1]+`</p>`) {
				t.Errorf("%s/%s: the rows do not end with the Demos group", theme, locale)
			}
		}
	}
}

// TestTheTwoCopiesOfTheControlsAgree: every page writes its controls
// twice, in the bar for a wide screen and in the display settings menu
// for a phone, and only one is ever shown. Same themes, the same
// scheme menu, same languages in the same order, no fragment on either
// (gallery.js adds the reader's place at the click), and no id in
// either, since an id written twice is two elements one fragment
// cannot both reach. The menu's button is the cog, named with the
// approved string.
func TestTheTwoCopiesOfTheControlsAgree(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	for _, theme := range fiesta.ThemeNames() {
		for _, locale := range Locales {
			for _, pk := range s.pageKinds() {
				where := theme + "/" + locale + "/" + pk.File
				page := kindPage(t, files, theme, locale, pk.File)
				card, bar := prefsCard.FindStringSubmatch(page), barCtl.FindStringSubmatch(page)
				if card == nil || bar == nil {
					t.Fatalf("%s: display settings found %v, bar found %v", where, card != nil, bar != nil)
				}
				if want := template.HTMLEscapeString(s.say(locale, "gallery.prefs")); card[1] != want {
					t.Errorf("%s: the display settings button is named %q, want %q", where, card[1], want)
				}
				if !strings.HasPrefix(card[2], `<svg class="icon"`) || !strings.Contains(card[2], `aria-hidden="true"`) || strings.Contains(card[2], "<span") {
					t.Errorf("%s: the display settings button is not the bare, hidden icon its name stands for: %s", where, card[2])
				}
				if !strings.Contains(card[2], `<circle cx="12" cy="12" r="3"/>`) || !strings.Contains(card[2], `<path d="M9.671 4.136`) {
					t.Errorf("%s: the display settings button is not the cog: %s", where, card[2])
				}
				ch, bh := navHref.FindAllStringSubmatch(card[3], -1), navHref.FindAllStringSubmatch(bar[1], -1)
				if len(ch) == 0 || len(ch) != len(bh) {
					t.Errorf("%s: %d links in the menu, %d in the bar", where, len(ch), len(bh))
					continue
				}
				for i := range ch {
					if strings.Contains(bh[i][1], "#") || ch[i][1] != bh[i][1] {
						t.Errorf("%s link %d: menu %s, bar %s; want the same address and no fragment", where, i, ch[i][1], bh[i][1])
					}
				}
				a, b := schemeMenu.FindString(card[3]), schemeMenu.FindString(bar[1])
				if a == "" || a != b || strings.Count(a, "<form") != 3 {
					t.Errorf("%s: the scheme menu in the menu and in the bar differ, or one is missing", where)
				}
				for what, html := range map[string]string{"menu": card[3], "bar": bar[1]} {
					if elementID.MatchString(html) {
						t.Errorf("%s: the %s's controls carry an id", where, what)
					}
				}
			}
		}
	}
}

// TestTheFilterBoxCarriesTheSearchIcon: the filter box carries the
// search icon at its inline start, drawn by the icon set and hidden
// from the accessible name, which is the field's label.
func TestTheFilterBoxCarriesTheSearchIcon(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	box := regexp.MustCompile(`(?s)<search class="ds-search">(.*?)</search>`)
	for _, pk := range s.pageKinds() {
		m := box.FindStringSubmatch(kindPage(t, files, fiesta.ThemeNames()[0], "en", pk.File))
		if m == nil {
			t.Fatalf("%s: no filter box", pk.File)
		}
		icon, input := strings.Index(m[1], string(s.iconMarkup("search"))), strings.Index(m[1], "<input")
		if icon < 0 || input < icon {
			t.Errorf("%s: the filter box has no search icon before its field: %s", pk.File, m[1])
		}
	}
}

// TestEverySearchTermNamesAnAnchor: every synonym names an example
// that exists, and rides on the rail's link to its page. A synonym
// whose example was renamed would leave its words pointing at
// nothing, and a reader typing "checkbox" would see No matches again.
func TestEverySearchTermNamesAnAnchor(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	theme := fiesta.ThemeNames()[0]
	rail := railOf(t, "overview", kindPage(t, files, theme, "en", "index.html"))
	for name, terms := range searchTerms {
		if _, ok := s.m.Entry(name); !ok {
			t.Errorf("searchTerms names %q, which is no example", name)
		}
		if !regexp.MustCompile(`<a data-gallery-nav href="` + regexp.QuoteMeta(s.href(theme, "en", name+".html")) + `"[^>]* data-ds-terms="` + regexp.QuoteMeta(terms) + `"`).MatchString(rail) {
			t.Errorf("the rail link to %s.html does not carry its terms %q", name, terms)
		}
	}
	if len(searchTerms) == 0 {
		t.Fatal("no search terms")
	}
}

// TestTheChromeCarriesTheThreeSwitchers: on every page-kind page the
// bar sits after the rail and before main, which opens with the page
// column; its brand links the Overview; its controls hold one theme
// link per theme with exactly one current, Fiesta's scheme menu with
// its three forms and System current, and one language link per
// locale (twelve, counted as links, with exactly one current, the one
// in the page's own language), each language named in itself as
// Fiesta's locale-menu example names it; and every switcher link is
// this page in another theme or language, never the Overview.
func TestTheChromeCarriesTheThreeSwitchers(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	names := exampleEndonyms(t)
	localeLink := regexp.MustCompile(`<a data-gallery-nav href="([^"]*)" lang="([^"]*)" dir="[^"]*"( aria-current="true")?>([^<]*)</a>`)
	for _, theme := range fiesta.ThemeNames() {
		for _, locale := range Locales {
			for _, pk := range s.pageKinds() {
				name := theme + "/" + locale + "/" + pk.File
				page := kindPage(t, files, theme, locale, pk.File)
				at := strings.Index(page, `<header class="ds-top">`)
				if at < 0 || !strings.Contains(page[:at], "</aside>") {
					t.Errorf("%s: no bar after the rail", name)
					continue
				}
				bar, rest, ok := strings.Cut(page[at:], "</header>")
				if !ok {
					t.Errorf("%s: the bar never closes", name)
					continue
				}
				if !strings.HasPrefix(strings.TrimSpace(rest), `<main rst-shell-main id="main">`) {
					t.Errorf("%s: main does not follow the bar", name)
				}
				if _, m, _ := strings.Cut(rest, `<main rst-shell-main id="main">`); !strings.HasPrefix(strings.TrimSpace(m), `<div rst-page>`) {
					t.Errorf("%s: main does not open with the content column", name)
				}
				if want := `<a class="ds-top__brand" data-gallery-nav href="` + s.href(theme, locale, "index.html") + `">`; !strings.Contains(bar, want) {
					t.Errorf("%s: the bar's brand does not link the Overview", name)
				}
				_, chrome, ok := strings.Cut(bar, `<div class="ds-top__controls">`)
				if !ok {
					t.Errorf("%s: the bar has no controls", name)
					continue
				}
				if n := strings.Count(chrome, `aria-current="page"`); n != 1 {
					t.Errorf("%s: %d themes marked current, want 1", name, n)
				}
				locales := localeLink.FindAllStringSubmatch(chrome, -1)
				current := 0
				for _, m := range locales {
					if m[3] != "" {
						current++
						if m[2] != locale || m[1] != s.href(theme, locale, pk.File) {
							t.Errorf("%s: the language marked current is %s at %s, want this page's own, %s", name, m[2], m[1], locale)
						}
					}
					if m[4] != names[m[2]] {
						t.Errorf("%s: the %s link reads %q, want %q, the language's name in itself", name, m[2], m[4], names[m[2]])
					}
				}
				if len(locales) != len(Locales) || current != 1 {
					t.Errorf("%s: %d language links with %d marked current, want %d and 1", name, len(locales), current, len(Locales))
				}
				if n := strings.Count(chrome, `<a data-gallery-nav href="`); n != len(fiesta.ThemeNames())+len(Locales) {
					t.Errorf("%s: the chrome has %d in-tree links, want one per theme and one per locale", name, n)
				}
				menu := schemeMenu.FindString(chrome)
				if menu == "" || strings.Count(menu, "<form") != 3 || !strings.Contains(menu, `value="system"`) {
					t.Errorf("%s: the chrome has no scheme menu with its three forms", name)
				}
				if n := strings.Count(menu, `aria-current="true"`); n != 1 || !regexp.MustCompile(`value="system">(?:<input[^>]*>)*<button type="submit" aria-current="true"`).MatchString(menu) {
					t.Errorf("%s: System is not the one scheme marked current with no JavaScript", name)
				}
				for _, label := range []string{s.say(locale, "gallery.theme.label"), s.say(locale, "gallery.language")} {
					if !strings.Contains(chrome, template.HTMLEscapeString(label)) {
						t.Errorf("%s: the chrome does not name %q", name, label)
					}
				}
				for _, m := range navHref.FindAllStringSubmatch(chrome, -1) {
					if !strings.HasSuffix(m[1], "/"+pk.File) {
						t.Errorf("%s: the chrome links %q, which is not this page in another theme or language", name, m[1])
					}
				}
			}
		}
	}
}

// exampleEndonyms is each language's name in itself, read off Fiesta's
// locale-menu example, the names the framework's catalogs give them.
func exampleEndonyms(t *testing.T) map[string]string {
	t.Helper()
	doc, err := fs.ReadFile(fiesta.FS(), "examples/locale-menu/twelve-languages-current-highlighted.html")
	if err != nil {
		t.Fatal(err)
	}
	out := map[string]string{}
	for _, b := range parse(t, doc).find(func(n node) bool { return n.n.Data == "button" }) {
		if lang, ok := b.attr("lang"); ok {
			out[lang] = b.text()
		}
	}
	for _, l := range Locales {
		if out[l] == "" {
			t.Fatalf("the locale-menu example names no %s", l)
		}
	}
	return out
}

// TestGalleryScriptLoadsBeforeTheBody: gallery.js is a blocking script
// in <head>, not deferred, so a stored scheme is on the root and the
// frame-hiding rule is armed before the first paint.
func TestGalleryScriptLoadsBeforeTheBody(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	page := kindPage(t, files, fiesta.ThemeNames()[0], "en", "index.html")
	tag := `<script src="` + s.asset("gallery.js") + `"></script>`
	i := strings.Index(page, tag)
	if i < 0 {
		t.Fatalf("no blocking gallery.js tag on the page (want %s)", tag)
	}
	if body := strings.Index(page, "<body>"); i > body {
		t.Error("gallery.js loads after <body>; the scheme it restores will flash")
	}
	if strings.Contains(page, `<script defer src="`+s.asset("gallery.js")+`"></script>`) {
		t.Error("gallery.js is deferred; see its header comment for why it is not")
	}
}

// TestNoGalleryPageLoadsTheEnhancementScripts: a gallery page loads
// exactly gallery.js, fiesta.js, anchor.js and shell.js. The frames
// load what their markup hooks; the page's own buttons do not light
// and its fields are not enhanced.
func TestNoGalleryPageLoadsTheEnhancementScripts(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	want := map[string]bool{"gallery.js": true, "js/fiesta.js": true, "js/anchor.js": true, "js/shell.js": true}
	plain := map[string]string{}
	for name, hashed := range s.hashed {
		plain[s.url("assets/"+hashed)] = name
	}
	checked := 0
	for _, name := range pageNames(s, files) {
		got := map[string]bool{}
		attrsOf(t, files[name], func(tag string, attrs map[string]string) {
			if tag == "script" {
				got[plain[attrs["src"]]] = true
			}
		})
		for script := range got {
			if !want[script] {
				t.Errorf("%s loads %s, which nothing on the page uses", name, script)
			}
		}
		for script := range want {
			if !got[script] {
				t.Errorf("%s does not load %s", name, script)
			}
		}
		checked++
	}
	if checked == 0 {
		t.Fatal("no page was checked")
	}
}

// TestNoGalleryPageAsksForPrerender: no page asks to be prerendered.
// The gallery is static files on a site with no headers file, and an
// inline speculation ruleset would need a CSP the system avoids. The
// slide and the focus return work without it.
func TestNoGalleryPageAsksForPrerender(t *testing.T) {
	files := render(t, "")
	for name, body := range files {
		if strings.Contains(string(body), "speculationrules") || strings.Contains(string(body), "_speculation-rules") {
			t.Errorf("%s asks for prerendering", name)
		}
	}
	if len(files) == 0 {
		t.Fatal("no files rendered")
	}
}

// TestNoPageCarriesAPageWideViewSwitcher: no page carries a page-wide
// view switcher, and neither half of the stylesheet or the script
// draws one or reads the view it once remembered. Each example's own
// tabs are the one view control.
func TestNoPageCarriesAPageWideViewSwitcher(t *testing.T) {
	files := render(t, "")
	pages := 0
	for name, b := range files {
		if !strings.HasSuffix(name, ".html") {
			continue
		}
		pages++
		if page := string(b); strings.Contains(page, "ds-viewall") || strings.Contains(page, "data-ds-view=") {
			t.Errorf("%s carries the page-wide view switcher", name)
		}
	}
	if pages == 0 {
		t.Fatal("no pages rendered, so this checked nothing")
	}
	for name, src := range map[string][]byte{"gallery.css": galleryCSS, "view.css": viewCSS, "gallery.js": galleryJS, "view.js": viewJS} {
		for _, gone := range []string{"ds-viewall", "rst-ds-view", "data-ds-view", "dsView"} {
			if strings.Contains(string(src), gone) {
				t.Errorf("%s mentions %s, which only the page-wide switcher used", name, gone)
			}
		}
	}
}