package example_test

import (
	"io/fs"
	"path"
	"regexp"
	"slices"
	"sort"
	"strconv"
	"strings"
	"testing"
	"testing/fstest"

	"golang.org/x/net/html"

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

// ── The package on a synthetic tree ──────────────────────────────────

// synthBody is a body with a nested container and a <template>, the
// two shapes a tokenizer that reads structure rather than bytes gets
// wrong: a <section rst-box> is not a <body>, and a <template>'s
// content is inert in the DOM but is bytes on disk all the same.
const synthBody = `<section rst-box><form rst-form method="post" action="#">
<template id="row"><div rst-field><label rst-field-label for="t">Title</label><input rst-input id="t" name="t"></div></template>
<div rst-field><label rst-field-label for="f_bare">Title</label><input rst-input id="f_bare" name="f_bare"></div>
</form></section>`

func synthDoc(body string) string {
	return "<!doctype html>\n<html lang=\"en\" dir=\"ltr\">\n<head>\n<meta charset=\"utf-8\">\n" +
		"<meta name=\"viewport\" content=\"width=device-width\">\n<title>field</title>\n" +
		"<link rel=\"stylesheet\" href=\"../../css/tokens.css\">\n</head>\n<body>\n" + body + "\n</body>\n</html>\n"
}

func synthFS() fstest.MapFS {
	return fstest.MapFS{
		"examples/examples.json":   {Data: []byte(`{"examples":[{"name":"field","title":"field","family":"form","kind":"component","document":false,"wrapper":"form","scripts":[],"default":"bare","states":[{"id":"bare","label":"Bare","sampleURLs":[]}]}],"idioms":{}}`)},
		"examples/field/bare.html": {Data: []byte(synthDoc(synthBody))},
	}
}

func TestMarkupReturnsTheBodyAsWritten(t *testing.T) {
	got, err := example.Markup(synthFS(), "field", "bare")
	if err != nil {
		t.Fatalf("Markup: %v", err)
	}
	if got != synthBody {
		t.Fatalf("Markup returned\n%s\nwant\n%s", got, synthBody)
	}
	// Exactly one newline is trimmed at each end: a body that ends in a
	// blank line keeps it.
	fsys := synthFS()
	fsys["examples/field/blank.html"] = &fstest.MapFile{Data: []byte(synthDoc(synthBody + "\n"))}
	got, err = example.Markup(fsys, "field", "blank")
	if err != nil {
		t.Fatalf("Markup: %v", err)
	}
	if got != synthBody+"\n" {
		t.Fatalf("Markup trimmed more than one trailing newline:\n%q", got[len(got)-20:])
	}
}

func TestMarkupRefusesAMissingState(t *testing.T) {
	if _, err := example.Markup(synthFS(), "field", "with-a-hint"); err == nil {
		t.Fatal("Markup of a state with no file returned no error")
	}
	if _, err := example.Markup(synthFS(), "nothing", "bare"); err == nil {
		t.Fatal("Markup of an example with no directory returned no error")
	}
}

func TestSlotReplacesOnlyTheSlot(t *testing.T) {
	doc := "<main>\n<!-- fiesta:slot -->\n<h1>Posts</h1>\n<!-- /fiesta:slot -->\n</main>"
	got, err := example.Slot(doc, "<p>Hello</p>")
	if err != nil {
		t.Fatalf("Slot: %v", err)
	}
	want := "<main>\n<!-- fiesta:slot --><p>Hello</p><!-- /fiesta:slot -->\n</main>"
	if got != want {
		t.Fatalf("Slot returned\n%s\nwant\n%s", got, want)
	}
	if _, err := example.Slot("<main><h1>Posts</h1></main>", "<p>Hello</p>"); err == nil {
		t.Fatal("Slot on a document with no slot returned no error")
	}
}

func TestSlotRefusesTwoSlots(t *testing.T) {
	doc := "<!-- fiesta:slot -->a<!-- /fiesta:slot --><!-- fiesta:slot -->b<!-- /fiesta:slot -->"
	if _, err := example.Slot(doc, "c"); err == nil {
		t.Fatal("Slot on a document with two slots returned no error")
	}
}

func TestSlotRefusesReversedMarkers(t *testing.T) {
	doc := "<main><!-- /fiesta:slot -->a<!-- fiesta:slot --></main>"
	if _, err := example.Slot(doc, "c"); err == nil {
		t.Fatal("Slot on a document whose slot closes before it opens returned no error")
	}
}

// ── The real examples ────────────────────────────────────────────────

// tree is the embedded design system, which carries examples/ from
// this task on.
func tree(t *testing.T) fs.FS {
	t.Helper()
	fsys := fiesta.FS()
	if _, err := fs.Stat(fsys, "examples/examples.json"); err != nil {
		t.Fatalf("the embedded tree has no examples/examples.json: %v", err)
	}
	return fsys
}

func manifest(t *testing.T) (fs.FS, *example.Manifest) {
	t.Helper()
	fsys := tree(t)
	m, err := example.Load(fsys)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	if len(m.Examples) == 0 {
		t.Fatal("the manifest lists no examples")
	}
	return fsys, m
}

func TestDefaultIsAState(t *testing.T) {
	_, m := manifest(t)
	for _, e := range m.Examples {
		id, ok := m.Default(e.Name)
		if !ok {
			t.Errorf("%s: Default reports no default", e.Name)
			continue
		}
		if id != e.Default {
			t.Errorf("%s: Default returned %q, the entry says %q", e.Name, id, e.Default)
		}
		if !slices.ContainsFunc(e.States, func(s example.State) bool { return s.ID == id }) {
			t.Errorf("%s: the default state %q is not one of its states", e.Name, id)
		}
	}
	if _, ok := m.Default("no-such-example"); ok {
		t.Error("Default of an unknown example reports ok")
	}
}

var (
	kinds    = []string{"component", "idiom", "layout", "format", "screen"}
	wrappers = []string{"", "list", "form", "box", "stats"}
)

func TestTheManifestMatchesTheFiles(t *testing.T) {
	fsys, m := manifest(t)
	scripts := fiesta.ScriptNames()
	seen := map[string]bool{}
	for _, e := range m.Examples {
		if seen[e.Name] {
			t.Errorf("%s is listed twice", e.Name)
		}
		seen[e.Name] = true
		if !slices.Contains(kinds, e.Kind) {
			t.Errorf("%s: kind %q is not one of %v", e.Name, e.Kind, kinds)
		}
		if !slices.Contains(wrappers, e.Wrapper) {
			t.Errorf("%s: wrapper %q is not one of %v", e.Name, e.Wrapper, wrappers)
		}
		for _, s := range e.Scripts {
			if !slices.Contains(scripts, s) {
				t.Errorf("%s: script %q is not one fiesta ships (%v)", e.Name, s, scripts)
			}
		}
		entries, err := fs.ReadDir(fsys, path.Join("examples", e.Name))
		if err != nil {
			t.Errorf("%s: no directory: %v", e.Name, err)
			continue
		}
		files := map[string]bool{}
		for _, f := range entries {
			files[f.Name()] = true
		}
		ids := map[string]bool{}
		if len(e.States) == 0 {
			t.Errorf("%s: no states", e.Name)
		}
		for _, s := range e.States {
			if ids[s.ID] {
				t.Errorf("%s: state id %q is used twice", e.Name, s.ID)
			}
			ids[s.ID] = true
			if !files[s.ID+".html"] {
				t.Errorf("%s: state %q has no file", e.Name, s.ID)
			}
			delete(files, s.ID+".html")
		}
		for f := range files {
			t.Errorf("%s: %s is not a state in the manifest", e.Name, f)
		}
		if _, ok := m.Entry(e.Name); !ok {
			t.Errorf("%s: Entry reports no entry", e.Name)
		}
	}
	entries, err := fs.ReadDir(fsys, "examples")
	if err != nil {
		t.Fatal(err)
	}
	for _, d := range entries {
		if d.IsDir() && d.Name() != "assets" && !seen[d.Name()] {
			t.Errorf("examples/%s is a directory no entry names", d.Name())
		}
	}
}

// attr returns one attribute of a start tag, and whether it is there.
func attr(tok html.Token, name string) (string, bool) {
	for _, a := range tok.Attr {
		if a.Key == name {
			return a.Val, true
		}
	}
	return "", false
}

// walk tokenizes one document and hands each start or self-closing
// tag to fn with whether it sits inside <head>.
func walk(t *testing.T, doc string, fn func(tok html.Token, inHead bool)) {
	t.Helper()
	z := html.NewTokenizer(strings.NewReader(doc))
	inHead := false
	for {
		switch z.Next() {
		case html.ErrorToken:
			return
		case html.StartTagToken, html.SelfClosingTagToken:
			tok := z.Token()
			if tok.Data == "head" {
				inHead = true
			}
			fn(tok, inHead)
		case html.EndTagToken:
			if z.Token().Data == "head" {
				inHead = false
			}
		}
	}
}

func everyDocument(t *testing.T, fn func(e example.Entry, s example.State, doc string)) {
	t.Helper()
	fsys, m := manifest(t)
	for _, e := range m.Examples {
		for _, s := range e.States {
			doc, err := example.Document(fsys, e.Name, s.ID)
			if err != nil {
				t.Errorf("%s/%s: %v", e.Name, s.ID, err)
				continue
			}
			fn(e, s, doc)
		}
	}
}

func TestExamplesLinkOnlyFiestasOwnFiles(t *testing.T) {
	fsys := tree(t)
	everyDocument(t, func(e example.Entry, s example.State, doc string) {
		where := e.Name + "/" + s.ID
		walk(t, doc, func(tok html.Token, inHead bool) {
			for _, name := range []string{"href", "src"} {
				v, ok := attr(tok, name)
				if !ok || !inHead {
					continue
				}
				if !strings.HasPrefix(v, "../../css/") && !strings.HasPrefix(v, "../../js/") {
					t.Errorf("%s: the head's %s=%q is not under ../../css or ../../js", where, name, v)
					continue
				}
				if _, err := fs.Stat(fsys, strings.TrimPrefix(v, "../../")); err != nil {
					t.Errorf("%s: the head links %s, which the tree does not have", where, v)
				}
			}
			if inHead {
				return
			}
			for _, name := range []string{"src", "srcset", "poster"} {
				v, ok := attr(tok, name)
				if !ok {
					continue
				}
				for _, cand := range strings.Split(v, ",") {
					fields := strings.Fields(cand)
					if len(fields) == 0 {
						t.Errorf("%s: the body's %s=%q has an empty candidate", where, name, v)
						continue
					}
					file := fields[0]
					if !strings.HasPrefix(file, "../assets/") {
						t.Errorf("%s: the body's %s=%q is not under ../assets/", where, name, v)
						continue
					}
					if _, err := fs.Stat(fsys, path.Join("examples", strings.TrimPrefix(file, "../"))); err != nil {
						t.Errorf("%s: the body names %s, which examples/assets does not have", where, file)
					}
				}
			}
		})
	})
}

func TestEveryIdiomIsMapped(t *testing.T) {
	_, m := manifest(t)
	if len(m.Idioms) == 0 {
		t.Fatal("the manifest maps no idioms")
	}
	for key, ref := range m.Idioms {
		name, state, ok := m.Idiom(key)
		if !ok || name != ref.Example || state != ref.State {
			t.Errorf("Idiom(%q) = %q, %q, %v; the manifest says %q, %q", key, name, state, ok, ref.Example, ref.State)
		}
		e, ok := m.Entry(ref.Example)
		if !ok {
			t.Errorf("idiom %q names example %q, which does not exist", key, ref.Example)
			continue
		}
		if !slices.ContainsFunc(e.States, func(s example.State) bool { return s.ID == ref.State }) {
			t.Errorf("idiom %q names state %q of %q, which does not exist", key, ref.State, ref.Example)
		}
	}
	if name, state, ok := m.Idiom("dropdown"); !ok || name != "dropdown" || state != "menu-idiom" {
		t.Errorf("Idiom(dropdown) = %q, %q, %v; want dropdown, menu-idiom, true", name, state, ok)
	}
	if _, _, ok := m.Idiom("no-such-idiom"); ok {
		t.Error("Idiom of an unknown key reports ok")
	}
}

// applicationURL says whether a link or action is one of the routes a
// sample stands for: not a fragment, not one of Fiesta's own files and
// not one of the example pictures.
func applicationURL(v string) bool {
	return v != "" && !strings.HasPrefix(v, "#") && !strings.HasPrefix(v, "../../") && !strings.HasPrefix(v, "../assets/")
}

func TestSampleURLsAreDeclared(t *testing.T) {
	everyDocument(t, func(e example.Entry, s example.State, doc string) {
		where := e.Name + "/" + s.ID
		found := map[string]bool{}
		walk(t, doc, func(tok html.Token, inHead bool) {
			if inHead {
				return
			}
			if v, ok := attr(tok, "href"); ok && applicationURL(v) {
				found[v] = true
			}
			if v, ok := attr(tok, "action"); ok && tok.Data == "form" && applicationURL(v) {
				found[v] = true
			}
		})
		var want []string
		for v := range found {
			want = append(want, v)
		}
		sort.Strings(want)
		got := s.SampleURLs
		if got == nil {
			got = []string{}
		}
		if !sort.StringsAreSorted(got) {
			t.Errorf("%s: sampleURLs are not sorted: %v", where, got)
		}
		if !slices.Equal(got, want) {
			t.Errorf("%s: sampleURLs are %v; the markup links %v", where, got, want)
		}
	})
}

func TestEveryStateIsValidOnItsOwn(t *testing.T) {
	everyDocument(t, func(e example.Entry, s example.State, doc string) {
		where := e.Name + "/" + s.ID
		ids := map[string]bool{}
		type ref struct{ attr, id string }
		var refs []ref
		walk(t, doc, func(tok html.Token, _ bool) {
			if id, ok := attr(tok, "id"); ok {
				if ids[id] {
					t.Errorf("%s: id %q is used twice", where, id)
				}
				ids[id] = true
			}
			if v, ok := attr(tok, "for"); ok {
				refs = append(refs, ref{"for", v})
			}
			for _, name := range []string{"aria-labelledby", "aria-describedby", "aria-controls"} {
				if v, ok := attr(tok, name); ok {
					for _, id := range strings.Fields(v) {
						refs = append(refs, ref{name, id})
					}
				}
			}
		})
		for _, r := range refs {
			if !ids[r.id] {
				t.Errorf("%s: %s=%q names no id in the document", where, r.attr, r.id)
			}
		}
	})
}

// headProblems lists what is wrong with one document's standard head:
// the doctype, <html lang="en" dir="ltr"> (with the scheme store
// attribute only where store says so), the charset, the viewport, a
// non-empty <title>, and the two stylesheets.
func headProblems(t *testing.T, doc string, store bool) []string {
	t.Helper()
	var problems []string
	if !strings.HasPrefix(doc, "<!doctype html>\n") {
		problems = append(problems, "no <!doctype html> first")
	}
	var sawHTML, charset, viewport, title, tokens, day bool
	walk(t, doc, func(tok html.Token, inHead bool) {
		switch {
		case tok.Data == "html":
			sawHTML = true
			if v, _ := attr(tok, "lang"); v != "en" {
				problems = append(problems, "<html> lang is "+strconv.Quote(v)+", want en")
			}
			if v, _ := attr(tok, "dir"); v != "ltr" {
				problems = append(problems, "<html> dir is "+strconv.Quote(v)+", want ltr")
			}
			if v, ok := attr(tok, "data-rst-scheme-store"); ok != store || (ok && v != "local") {
				problems = append(problems, "<html> data-rst-scheme-store is "+strconv.Quote(v)+", present "+strconv.FormatBool(ok)+", want present "+strconv.FormatBool(store))
			}
		case !inHead:
		case tok.Data == "meta":
			if v, ok := attr(tok, "charset"); ok && strings.EqualFold(v, "utf-8") {
				charset = true
			}
			if v, _ := attr(tok, "name"); v == "viewport" {
				viewport = true
			}
		case tok.Data == "link":
			v, _ := attr(tok, "href")
			tokens = tokens || v == "../../css/tokens.css"
			day = day || v == "../../css/themes/day.css"
		}
	})
	if m := titlePattern.FindStringSubmatch(doc); m != nil && strings.TrimSpace(m[1]) != "" {
		title = true
	}
	for _, c := range []struct {
		ok   bool
		what string
	}{{sawHTML, "no <html> tag"}, {charset, "no <meta charset=\"utf-8\"> in the head"}, {viewport, "no viewport meta in the head"},
		{title, "no non-empty <title>"}, {tokens, "the head does not link ../../css/tokens.css"}, {day, "the head does not link ../../css/themes/day.css"}} {
		if !c.ok {
			problems = append(problems, c.what)
		}
	}
	return problems
}

var titlePattern = regexp.MustCompile(`(?s)<title>(.*?)</title>`)

// TestEveryExampleHasTheStandardHead holds the example file format
// the exporter wrote and the README now calls hand-owned: a hand edit
// that drops the viewport or the theme fails here. The control leg
// plants each fault in a copy of a real document and expects the
// checker to name it, so the pass below is not vacuous.
func TestEveryExampleHasTheStandardHead(t *testing.T) {
	fsys, m := manifest(t)
	t.Run("control", func(t *testing.T) {
		doc, err := example.Document(fsys, m.Examples[0].Name, m.Examples[0].Default)
		if err != nil {
			t.Fatal(err)
		}
		for _, c := range []struct {
			name, from, to, want string
		}{
			{"doctype", "<!doctype html>\n", "", "no <!doctype html> first"},
			{"lang", `lang="en"`, `lang="es"`, `<html> lang is "es", want en`},
			{"viewport", `<meta name="viewport" content="width=device-width">`, "", "no viewport meta in the head"},
			{"theme", `href="../../css/themes/day.css"`, `href="../../css/themes/night.css"`, "the head does not link ../../css/themes/day.css"},
			{"store", `dir="ltr"`, `dir="ltr" data-rst-scheme-store="local"`, `<html> data-rst-scheme-store is "local", present true, want present false`},
		} {
			mutated := strings.Replace(doc, c.from, c.to, 1)
			if mutated == doc {
				t.Fatalf("%s: the mutation changed nothing; the control proves nothing", c.name)
			}
			if got := headProblems(t, mutated, false); !slices.Contains(got, c.want) {
				t.Errorf("%s: the checker reported %v, want it to include %q", c.name, got, c.want)
			}
		}
		if got := headProblems(t, doc, false); len(got) != 0 {
			t.Errorf("the unmutated document reports %v", got)
		}
	})
	everyDocument(t, func(e example.Entry, s example.State, doc string) {
		store := e.Name == "scheme-menu" && s.ID == "standalone"
		for _, p := range headProblems(t, doc, store) {
			t.Errorf("%s/%s: %s", e.Name, s.ID, p)
		}
	})
}

// layoutProblems lists what is wrong with a layout entry and its one
// document: it has exactly one state, default, which is its Default,
// and the document has exactly one slot. A non-layout document has no
// slot at all.
func layoutProblems(e example.Entry, doc string) []string {
	var problems []string
	if !e.Document {
		if strings.Contains(doc, "<!-- fiesta:slot -->") || strings.Contains(doc, "<!-- /fiesta:slot -->") {
			problems = append(problems, "a non-layout document carries a slot marker")
		}
		return problems
	}
	if len(e.States) != 1 || e.States[0].ID != "default" {
		var ids []string
		for _, s := range e.States {
			ids = append(ids, s.ID)
		}
		problems = append(problems, "a layout must have the one state default, has "+strings.Join(ids, ", "))
	}
	if e.Default != "default" {
		problems = append(problems, "a layout's default must be default, is "+e.Default)
	}
	if _, err := example.Slot(doc, "<p>x</p>"); err != nil {
		problems = append(problems, err.Error())
	}
	return problems
}

func TestEveryLayoutHasOneDefaultAndOneSlot(t *testing.T) {
	fsys, m := manifest(t)
	t.Run("control", func(t *testing.T) {
		e, ok := m.Entry("layout-sidebar")
		if !ok || !e.Document {
			t.Fatal("no layout-sidebar layout to mutate")
		}
		doc, err := example.Document(fsys, e.Name, "default")
		if err != nil {
			t.Fatal(err)
		}
		two := e
		two.States = append(append([]example.State(nil), e.States...), example.State{ID: "wide"})
		if got := layoutProblems(two, doc); len(got) == 0 {
			t.Error("an entry with two states passed")
		}
		if got := layoutProblems(e, strings.Replace(doc, "<!-- fiesta:slot -->", "<!-- fiesta:slot --><!-- fiesta:slot -->", 1)); len(got) == 0 {
			t.Error("a document with two slots passed")
		}
		if got := layoutProblems(e, strings.ReplaceAll(doc, "<!-- fiesta:slot -->", "")); len(got) == 0 {
			t.Error("a document with no slot passed")
		}
		plain := e
		plain.Document = false
		if got := layoutProblems(plain, doc); len(got) == 0 {
			t.Error("a non-layout document with a slot passed")
		}
		if got := layoutProblems(e, doc); len(got) != 0 {
			t.Errorf("the unmutated layout reports %v", got)
		}
	})
	layouts := 0
	everyDocument(t, func(e example.Entry, s example.State, doc string) {
		if e.Document {
			layouts++
		}
		for _, p := range layoutProblems(e, doc) {
			t.Errorf("%s/%s: %s", e.Name, s.ID, p)
		}
	})
	if layouts != 7 {
		t.Errorf("%d layout documents, want 7", layouts)
	}
}

func TestTheStandaloneSchemeStateOwnsItsStorage(t *testing.T) {
	fsys, m := manifest(t)
	def, ok := m.Default("scheme-menu")
	if !ok {
		t.Fatal("no scheme-menu example")
	}
	if def != "standalone" {
		t.Errorf("scheme-menu's default is %q, want standalone", def)
	}
	htmlAttr := func(doc string) (string, bool) {
		var v string
		var found bool
		walk(t, doc, func(tok html.Token, _ bool) {
			if tok.Data == "html" {
				v, found = attr(tok, "data-rst-scheme-store")
			}
		})
		return v, found
	}
	doc, err := example.Document(fsys, "scheme-menu", "standalone")
	if err != nil {
		t.Fatal(err)
	}
	if v, ok := htmlAttr(doc); !ok || v != "local" {
		t.Errorf("scheme-menu/standalone: <html> carries data-rst-scheme-store=%q, %v; want \"local\"", v, ok)
	}
	if strings.Contains(doc, " action=") {
		t.Error("scheme-menu/standalone: a form still names an action")
	}
	everyDocument(t, func(e example.Entry, s example.State, doc string) {
		if e.Name == "scheme-menu" && s.ID == "standalone" {
			return
		}
		if _, ok := htmlAttr(doc); ok {
			t.Errorf("%s/%s: <html> carries data-rst-scheme-store; only scheme-menu/standalone does", e.Name, s.ID)
		}
	})
}

func TestAllWalksTheManifestInOrder(t *testing.T) {
	fsys, m := manifest(t)
	pieces, err := example.All(fsys)
	if err != nil {
		t.Fatal(err)
	}
	var want []string
	for _, e := range m.Examples {
		if e.Document {
			continue
		}
		for _, s := range e.States {
			want = append(want, e.Name+"/"+s.ID)
		}
	}
	var got []string
	for _, p := range pieces {
		got = append(got, p.Name+"/"+p.State)
		markup, err := example.Markup(fsys, p.Name, p.State)
		if err != nil {
			t.Errorf("%s/%s: %v", p.Name, p.State, err)
		} else if markup != p.Markup {
			t.Errorf("%s/%s: All's markup differs from Markup's", p.Name, p.State)
		}
		if strings.Contains(p.Markup, "<body") || strings.Contains(p.Markup, "</body>") {
			t.Errorf("%s/%s: the markup holds a body tag", p.Name, p.State)
		}
	}
	if !slices.Equal(got, want) {
		t.Errorf("All returned %d pieces in this order:\n%v\nwant %d:\n%v", len(got), got, len(want), want)
	}
}

// ── Reading one component out of its row ─────────────────────────────

// rowed is a dropdown in a section head, the shape the reworked states
// take: a heading, then the menu, whose panel holds a nested <details>
// that a reader counting the wrong tag would end the menu on.
const (
	rowedMenu = `<details rst-dropdown name="a"><summary>S</summary><div rst-dropdown-menu><details rst-menu-group><summary>G</summary></details></div></details>`
	rowed     = `<div rst-box-head><h2>Posts</h2>` + rowedMenu + `</div>`
)

func TestElementReturnsTheCarrierAsWritten(t *testing.T) {
	got, err := example.Element(rowed, "rst-dropdown")
	if err != nil {
		t.Fatalf("Element: %v", err)
	}
	if got != rowedMenu {
		t.Fatalf("Element returned\n%s\nwant\n%s", got, rowedMenu)
	}
}

func TestContentsReturnsWhatLiesInside(t *testing.T) {
	got, err := example.Contents(rowed, "rst-box-head")
	if err != nil {
		t.Fatalf("Contents: %v", err)
	}
	if want := `<h2>Posts</h2>` + rowedMenu; got != want {
		t.Fatalf("Contents returned\n%s\nwant\n%s", got, want)
	}
}

func TestElementReadsAVoidElement(t *testing.T) {
	got, err := example.Element(`<p><input rst-input name="q"></p>`, "rst-input")
	if err != nil {
		t.Fatalf("Element: %v", err)
	}
	if want := `<input rst-input name="q">`; got != want {
		t.Fatalf("Element returned %q, want %q", got, want)
	}
}

// refusal holds one call to an error that names the attribute, since
// an error that does not say which component was missing sends its
// reader through every row on the page.
func refusal(t *testing.T, markup, why string) {
	t.Helper()
	got, err := example.Element(markup, "rst-dropdown")
	if err == nil {
		t.Fatalf("Element of %s returned %q and no error", why, got)
	}
	if !strings.Contains(err.Error(), "rst-dropdown") {
		t.Errorf("Element of %s: the error %q does not name rst-dropdown", why, err)
	}
}

func TestElementRefusesAMissingCarrier(t *testing.T) {
	refusal(t, `<div rst-box-head><h2>Posts</h2></div>`, "markup with no dropdown")
}

func TestElementRefusesTwoCarriers(t *testing.T) {
	refusal(t, `<div rst-box-head><h2>Posts</h2>`+rowedMenu+rowedMenu+`</div>`, "two sibling dropdowns")
}

func TestElementRefusesAnUnclosedCarrier(t *testing.T) {
	refusal(t, `<div rst-box-head><h2>Posts</h2><details rst-dropdown name="a"><summary>S</summary>`, "a dropdown cut short")
}

func TestANestedCarrierCountsOnce(t *testing.T) {
	outer := `<details rst-dropdown name="o"><summary>O</summary><div rst-dropdown-menu>` + rowedMenu + `</div></details>`
	got, err := example.Element(`<div rst-box-head>`+outer+`</div>`, "rst-dropdown")
	if err != nil {
		t.Fatalf("Element: %v", err)
	}
	if got != outer {
		t.Fatalf("Element returned\n%s\nwant the outer dropdown\n%s", got, outer)
	}
}

// TestEachRowedStateHoldsOneComponent: the five component states that
// show their menu in a row still give a reader the bare component, the
// way part 2's golden tests and the gallery take it out: Element for
// four, and for the menu idiom Contents of its toolbar, since the idiom
// is the menu and its applied-filter chip together. The standalone
// scheme state's component is the partial with its forms' action
// removed, as the seeder made it, so it must carry no action.
func TestEachRowedStateHoldsOneComponent(t *testing.T) {
	cases := []struct {
		name, state, attribute string
		read                   func(markup, attribute string) (string, error)
	}{
		{"dropdown", "a-filter-menu-with-one-choice-applied", "rst-dropdown", example.Element},
		{"dropdown", "menu-idiom", "rst-lbar", example.Contents},
		{"locale-menu", "twelve-languages-current-highlighted", "rst-locale", example.Element},
		{"scheme-menu", "three-choices-dark-current", "rst-scheme", example.Element},
		{"scheme-menu", "standalone", "rst-scheme", example.Element},
	}
	for _, c := range cases {
		m, err := example.Markup(fiesta.FS(), c.name, c.state)
		if err != nil {
			t.Fatal(err)
		}
		component, err := c.read(m, c.attribute)
		if err != nil {
			t.Errorf("%s/%s: %v", c.name, c.state, err)
			continue
		}
		switch c.name + "/" + c.state {
		case "dropdown/menu-idiom":
			for _, part := range []string{"rst-dropdown", "rst-ftok"} {
				if _, err := example.Element(component, part); err != nil {
					t.Errorf("dropdown/menu-idiom: the toolbar should hold one %s: %v", part, err)
				}
			}
		case "scheme-menu/standalone":
			if strings.Contains(component, " action=") {
				t.Error("scheme-menu/standalone: the component's forms name an action")
			}
		}
	}
}