package chrome

import (
	"bytes"
	"html/template"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os/exec"
	"regexp"
	"strings"
	"testing"

	"amadan.net/oficina/estilo.git/internal/tokencheck"
	"amadan.net/oficina/estilo.git/menu"
	"amadan.net/oficina/estilo.git/sky"
	"github.com/carlosframework/rastrillo/ui"
)

func TestChromeUsesDefinedTokens(t *testing.T) {
	missing, n := tokencheck.Undefined(CSS())
	if n == 0 {
		t.Fatal("chrome.css reads no rastrillo token; the check would pass vacuously")
	}
	if len(missing) > 0 {
		t.Fatal("chrome.css reads undefined tokens:", missing)
	}
}

// The bar's height is public contract and must be fixed, never a minimum:
// nothing inside it may grow it.
func TestBarHeightIsFixedAndPublic(t *testing.T) {
	src := string(CSS())
	for _, want := range []string{
		"--estilo-bar-block-size: 3.25rem;",
		"--estilo-z-bar: 45;",
		"block-size: var(--estilo-bar-block-size);",
		"flex-wrap: nowrap;",
	} {
		if !strings.Contains(src, want) {
			t.Errorf("chrome.css lost %q", want)
		}
	}
	// Narrow: the title field may shrink to nothing and the Rename button
	// floats under it rather than taking room from Menu and the switcher.
	// The browser proof is polish-audit/r2-chrome-check.mjs's reach checks.
	narrow := src[strings.LastIndex(src, "@media (max-width: 799.98px)"):]
	for _, want := range []string{"[estilo-bar-title-input] { min-inline-size: 0; }", "[estilo-bar-title]:focus-within [estilo-bar-title-submit] {\n    position: absolute;"} {
		if !strings.Contains(narrow, want) {
			t.Errorf("the narrow title layout lost %q", want)
		}
	}
	if regexp.MustCompile(`\[estilo-bar\]\s*\{[^}]*min-block-size`).MatchString(src) {
		t.Error("the bar declares a min-block-size: it could grow")
	}
}

func parse(t *testing.T) *template.Template {
	t.Helper()
	view := template.New("").Funcs(ui.Funcs())
	view, err := view.ParseFS(ui.Templates(), "*.html")
	if err != nil {
		t.Fatal(err)
	}
	if view, err = view.ParseFS(menu.Templates(), "templates/*.html"); err != nil {
		t.Fatal(err)
	}
	if view, err = view.ParseFS(Templates(), "templates/*.html"); err != nil {
		t.Fatal(err)
	}
	return view
}

func render(t *testing.T, name string, data any) string {
	t.Helper()
	var out bytes.Buffer
	if err := parse(t).ExecuteTemplate(&out, name, data); err != nil {
		t.Fatal(err)
	}
	return out.String()
}

// One word per locale, used for every caller-supplied label, so a label
// the template dropped or hard-coded shows up as a missing string.
var locales = map[string]string{"en": "Account", "de": "Konto", "es": "Cuenta", "fr": "Compte", "it": "Account", "pt": "Conta", "nl": "Account", "pl": "Konto", "ar": "الحساب", "ja": "アカウント", "zh": "账户", "ko": "계정"}

func signedIn(label string) Bar {
	return Bar{
		App:         App{Name: label + "-app", Slug: "docs", Home: "/", Icon: "/static/estilo/brand/docs.svg"},
		ContextEdit: &TitleEdit{Action: "/d/abc/title", Name: "title", Value: label + "-title", Label: label + "-title-label", Submit: label + "-rename"},
		Nav:         []Link{{Href: "/", Label: label + "-nav", Current: true}},
		NavLabel:    label + "-navlabel",
		Actions: []Action{
			{Item: menu.Item{Href: "/d/abc/share", Label: label + "-share"}},
			{Item: menu.Item{Action: "/d/new", Label: label + "-create"}, Primary: true},
		},
		Switcher: &Switcher{Label: label + "-apps", AllApps: menu.Item{Href: "https://oficina.example/", Label: label + "-allapps"}},
		Account: &Account{
			TriggerLabel: label + "-trigger", Initials: "P", Address: "paul@example.test",
			Labels:     AccountLabels{SignedInAs: label + "-signedinas", Appearance: label + "-appearance", Help: label + "-help"},
			Items:      []menu.Item{{Href: "/account/home", Label: label + "-connect"}},
			Appearance: &AppearanceMenu{Action: "/appearance", Return: "/d/abc", Options: AppearanceOptions(Dark, label+"-light", label+"-dark", label+"-system")},
			Help:       []menu.Item{{Href: "/credits", Label: label + "-opensource"}},
			SignOut:    SignOut{Action: "/signout", Label: label + "-signout"},
		},
		Labels: BarLabels{Skip: label + "-skip", Menu: label + "-menu"},
	}
}

func TestBarRendersCallerLabelsInEveryLocale(t *testing.T) {
	for locale, label := range locales {
		t.Run(locale, func(t *testing.T) {
			html := render(t, "estilo-bar", signedIn(label))
			esc := template.HTMLEscapeString
			for _, want := range []string{
				`<a estilo-bar-brand href="/">`, esc(label) + "-app",
				`<form estilo-bar-title method="post" action="/d/abc/title">`, `value="` + esc(label) + `-title"`, `aria-label="` + esc(label) + `-title-label"`, esc(label) + "-rename",
				`aria-label="` + esc(label) + `-navlabel"`, `aria-current="page"`,
				esc(label) + "-share", esc(label) + "-create", esc(label) + "-menu",
				`aria-label="` + esc(label) + `-apps"`, esc(label) + "-allapps",
				`aria-label="` + esc(label) + `-trigger"`, esc(label) + "-signedinas", "paul@example.test",
				esc(label) + "-connect", esc(label) + "-appearance", esc(label) + "-light", esc(label) + "-dark", esc(label) + "-system",
				esc(label) + "-help", esc(label) + "-opensource", esc(label) + "-signout",
			} {
				if !strings.Contains(html, want) {
					t.Fatalf("missing %q", want)
				}
			}
			if strings.Contains(html, "<script") {
				t.Fatal("the bar requires no script")
			}
		})
	}
}

// The "same corner" rule: the account is the last element in the end
// group, after actions, Menu and the switcher, in that order.
func TestEndGroupOrderIsFixed(t *testing.T) {
	html := render(t, "estilo-bar", signedIn("x"))
	order := []string{"<div estilo-bar-actions>", "<details estilo-bar-more", "<details estilo-switcher", "<details estilo-account"}
	last := -1
	for _, marker := range order {
		i := strings.Index(html, marker)
		if i < 0 || i < last {
			t.Fatalf("%q is missing or out of order", marker)
		}
		last = i
	}
	tail := html[strings.LastIndex(html, "</details>"):]
	if strings.Count(tail, "<") != 3 { // </details> </div> </header>
		t.Fatalf("something follows the account in the end group: %q", tail)
	}
}

// Every top-level trigger shares one exclusivity group, so opening one
// closes the others; nothing nested inside a panel carries the name.
func TestEveryBarTriggerJoinsTheOneMenuGroup(t *testing.T) {
	html := render(t, "estilo-bar", signedIn("x"))
	details := regexp.MustCompile(`<details [^>]*>`).FindAllString(html, -1)
	if len(details) != 3 {
		t.Fatalf("want three bar disclosures, got %d", len(details))
	}
	for _, d := range details {
		if !strings.Contains(d, `name="estilo-menus"`) {
			t.Errorf("%s is not in the estilo-menus group", d)
		}
	}
}

func TestSignOutAppearsExactlyOnce(t *testing.T) {
	html := render(t, "estilo-bar", signedIn("x"))
	if n := strings.Count(html, "x-signout"); n != 1 {
		t.Fatalf("Sign out rendered %d times", n)
	}
}

func TestAppearancePressedStateOnEveryOption(t *testing.T) {
	html := render(t, "estilo-bar", signedIn("x"))
	pressed := regexp.MustCompile(`value="(light|dark|system)" aria-pressed="(true|false)"`).FindAllStringSubmatch(html, -1)
	if len(pressed) != 3 {
		t.Fatalf("want three appearance options with aria-pressed, got %v", pressed)
	}
	for _, p := range pressed {
		if (p[1] == "dark") != (p[2] == "true") {
			t.Errorf("%s pressed=%s, want only dark pressed", p[1], p[2])
		}
	}
	if !strings.Contains(html, `role="group" aria-labelledby="estilo-appearance"`) {
		t.Error("the appearance options are not a labelled group")
	}
}

func TestSignedOutCornerAndEmptyCorner(t *testing.T) {
	b := Bar{App: App{Name: "Docs", Home: "/", Icon: "/i.svg"}, SignIn: &Link{Href: "/signin?return_to=%2Fd%2Fabc", Label: "Sign in"}}
	html := render(t, "estilo-bar", b)
	if !strings.Contains(html, `<a rst-btn href="/signin?return_to=%2Fd%2Fabc" estilo-bar-signin>Sign in</a>`) {
		t.Fatal("signed-out corner missing", html)
	}
	if strings.Contains(html, "estilo-account") || strings.Contains(html, "estilo-bar-more") {
		t.Fatal("signed-out bar has an account or Menu", html)
	}
	b.SignIn = nil
	if html = render(t, "estilo-bar", b); strings.Contains(html, "estilo-bar-signin") {
		t.Fatal("sign-in page bar shows Sign in", html)
	}
}

func TestPublicBrandIsPlainText(t *testing.T) {
	html := render(t, "estilo-bar", Bar{App: App{Name: "Docs", Icon: "/i.svg"}, Context: "A document"})
	if strings.Contains(html, "<a estilo-bar-brand") || !strings.Contains(html, "<span estilo-bar-brand>") {
		t.Fatal("public brand is a link", html)
	}
	if !strings.Contains(html, `<span estilo-bar-context dir="auto" title="A document">A document</span>`) {
		t.Fatal("read-only context missing", html)
	}
}

func TestSwitcherWithoutTilesIsAllAppsOnly(t *testing.T) {
	b := signedIn("x")
	html := render(t, "estilo-bar", b)
	if strings.Contains(html, "estilo-switcher-grid") || strings.Contains(html, "estilo-switcher-app") {
		t.Fatal("a switcher with no tiles renders a grid")
	}
	b.Switcher.Apps = []SwitcherApp{{Name: "Docs", Href: "https://dir.example/apps/docs", Icon: "/d.svg", Current: true}, {Name: "Sheets", Href: "https://dir.example/apps/sheets", Icon: "/s.svg"}}
	b.Switcher.CurrentLabel = "(this app)"
	html = render(t, "estilo-bar", b)
	if !strings.Contains(html, `aria-current="true"`) || !strings.Contains(html, "(this app)") {
		t.Fatal("the current tile is not marked in words", html)
	}
	if strings.Count(html, "(this app)") != 1 {
		t.Fatal("more than one tile is current")
	}
}

func TestNoMenuTriggerWithoutNavOrActions(t *testing.T) {
	b := signedIn("x")
	b.Nav, b.Actions = nil, nil
	if html := render(t, "estilo-bar", b); strings.Contains(html, "estilo-bar-more") || strings.Contains(html, "estilo-bar-actions") {
		t.Fatal("an empty Menu is rendered", html)
	}
}

// An action is not always a link. Sheets' Create is a POST, and it must
// be one in both places the bar draws it: a primary button at wide widths
// and a row in the narrow Menu sheet. Drawn as a link in the sheet, it
// would be a GET to the list and create nothing.
func TestActionsCanPostInTheBarAndTheSheet(t *testing.T) {
	html := render(t, "estilo-bar", signedIn("x"))
	actions := html[strings.Index(html, "<div estilo-bar-actions>"):strings.Index(html, "<details estilo-bar-more")]
	for _, want := range []string{
		`<a rst-btn href="/d/abc/share">x-share</a>`,
		`<form method="post" action="/d/new"><button rst-btn="primary" type="submit">x-create</button></form>`,
	} {
		if !strings.Contains(actions, want) {
			t.Errorf("bar actions lack %q in %s", want, actions)
		}
	}
	sheet := html[strings.Index(html, `<div estilo-menu="sheet">`):strings.Index(html, "<details estilo-switcher")]
	for _, want := range []string{
		`<a estilo-menu-item href="/d/abc/share"><span estilo-menu-label>x-share</span></a>`,
		`<form method="post" action="/d/new"><button estilo-menu-item type="submit"><span estilo-menu-label>x-create</span></button></form>`,
	} {
		if !strings.Contains(sheet, want) {
			t.Errorf("the Menu sheet lacks %q in %s", want, sheet)
		}
	}
	b := signedIn("x")
	b.Actions = []Action{{Item: menu.Item{Dialog: "help", Label: "x-help"}}}
	html = render(t, "estilo-bar", b)
	if !strings.Contains(html, `<button rst-btn type="button" commandfor="help" command="show-modal">x-help</button>`) {
		t.Error("a dialog action is not an invoker button", html)
	}
}

// A full-height app (Sheets' grid) keys its layout on the shell. The rule
// is estilo's, not each app's: the working area is the viewport less the
// bar, and the bar must neither grow nor shrink inside it.
func TestTheFillShellGivesTheWorkingAreaTheRestOfTheViewport(t *testing.T) {
	src := string(CSS())
	for _, want := range []string{
		"[estilo-shell~=\"fill\"] {\n  display: flex;\n  flex-direction: column;\n  block-size: 100dvh;",
		"[estilo-shell~=\"fill\"] > [estilo-bar] { flex: none; }",
		"[estilo-shell~=\"fill\"] > main { flex: 1 1 auto; min-block-size: 0; }",
	} {
		if !strings.Contains(src, want) {
			t.Errorf("chrome.css lacks the fill shell rule %q", want)
		}
	}
}

func TestUntrustedValuesAreEscaped(t *testing.T) {
	b := signedIn("x")
	b.ContextEdit.Value = `"><script>bad()</script>`
	b.Account.Address = `<img src=x onerror=bad>`
	b.Actions[0].Href = "javascript:bad()"
	b.Actions[1].Action = "javascript:bad()"
	html := render(t, "estilo-bar", b)
	if strings.Contains(html, "<script>") || strings.Contains(html, "<img src=x") || !strings.Contains(html, "#ZgotmplZ") {
		t.Fatal("unsafe bar markup", html)
	}
}

func TestErrorPage(t *testing.T) {
	for locale, label := range locales {
		t.Run(locale, func(t *testing.T) {
			html := render(t, "estilo-error", ErrorPage{Status: 500, Title: label + "-t", Body: label + "-b", Home: Link{Href: "/", Label: label + "-home"}, Back: &Link{Href: "/d/x", Label: label + "-back"}, Ref: "k3f9tq", RefLabel: label + "-ref"})
			esc := template.HTMLEscapeString
			for _, want := range []string{"<p rst-error-status>500</p>", esc(label) + "-t", esc(label) + "-b", `<a rst-btn="primary" href="/">` + esc(label) + "-home", `<a rst-btn href="/d/x">` + esc(label) + "-back", esc(label) + "-ref k3f9tq"} {
				if !strings.Contains(html, want) {
					t.Fatalf("missing %q in %s", want, html)
				}
			}
		})
	}
	if html := render(t, "estilo-error", ErrorPage{Status: 404, Title: "t", Home: Link{Href: "/", Label: "h"}}); strings.Contains(html, "rst-error-ref") || strings.Contains(html, "rst-btn href") {
		t.Fatal("a 404 with no ref and no checked referer shows either", html)
	}
}

func TestSignInPages(t *testing.T) {
	for locale, label := range locales {
		t.Run(locale, func(t *testing.T) {
			esc := template.HTMLEscapeString
			html := render(t, "estilo-signin", SignIn{Icon: "/i.svg", Copy: &DoorCopy{Heading: label + "-h", AddressLabel: label + "-addr", Help: label + "-help", Submit: label + "-submit"}, Lede: label + "-lede", Error: label + "-err", Action: "/signin", Return: "/d/abc", Hidden: []Hidden{{"force", "1"}}, OpenSource: &Link{Href: "/credits", Label: label + "-os"}})
			for _, want := range []string{"<h1>" + esc(label) + "-h</h1>", esc(label) + "-lede", `rst-tone="negative" role="alert"`, esc(label) + "-err", `action="/signin" novalidate`, `name="return_to" value="/d/abc"`, `name="force" value="1"`, `type="email"`, `autocomplete="email"`, esc(label) + "-addr", esc(label) + "-help", esc(label) + "-submit", esc(label) + "-os"} {
				if !strings.Contains(html, want) {
					t.Fatalf("missing %q in %s", want, html)
				}
			}
			html = render(t, "estilo-signin-sent", SignInNotice{Icon: "/i.svg", Heading: label + "-sent", Body: label + "-body", Link: &Link{Href: "/signin", Label: label + "-again"}})
			if !strings.Contains(html, esc(label)+"-sent") || !strings.Contains(html, `<a href="/signin">`+esc(label)+"-again") {
				t.Fatal("sent page", html)
			}
			html = render(t, "estilo-signed-out", SignInNotice{Icon: "/i.svg", Heading: label + "-out", Body: label + "-body", Link: &Link{Href: "/signin", Label: label + "-in"}})
			if !strings.Contains(html, `<a rst-btn="primary" href="/signin">`+esc(label)+"-in") {
				t.Fatal("signed-out page", html)
			}
		})
	}
	// An address error belongs in the field, not a callout above it.
	html := render(t, "estilo-signin", SignIn{Icon: "/i.svg", Action: "/signin", AddressError: "bad address"})
	if strings.Contains(html, "rst-callout") || !strings.Contains(html, `rst-field-error id="estilo-signin-address-error" role="alert">bad address`) || !strings.Contains(html, `aria-invalid="true"`) {
		t.Fatal("address error not in the field slot", html)
	}
}

func TestInitials(t *testing.T) {
	cases := []struct{ name, address, want string }{
		{"Paul Campbell", "paul@tito.io", "P"},
		{"", "paul@tito.io", "P"},
		{"", "  émile@example.test", "É"},
		{"  ", "", ""},
		{"", "@example.test", ""},
		{"", "._@example.test", ""},
		{"李小龙", "", "李"},
	}
	for _, c := range cases {
		if got := Initials(c.name, c.address); got != c.want {
			t.Errorf("Initials(%q, %q) = %q, want %q", c.name, c.address, got, c.want)
		}
	}
}

func TestAppearanceAndThemeAttr(t *testing.T) {
	for value, want := range map[string]Mode{"light": Light, "dark": Dark, "system": System, "": System, "auto": System, "Dark": System, "<x>": System} {
		r := httptest.NewRequest("GET", "/", nil)
		r.AddCookie(&http.Cookie{Name: AppearanceCookie, Value: value})
		if got := Appearance(r); got != want {
			t.Errorf("cookie %q: Appearance = %q, want %q", value, got, want)
		}
	}
	if Appearance(httptest.NewRequest("GET", "/", nil)) != System {
		t.Error("no cookie is not System")
	}
	for m, want := range map[Mode]string{Light: "light", Dark: "dark", System: "", Mode("x"): ""} {
		if got := ThemeAttr(m); got != want {
			t.Errorf("ThemeAttr(%q) = %q, want %q", m, got, want)
		}
	}
}

func post(form url.Values) *httptest.ResponseRecorder {
	r := httptest.NewRequest("POST", "/appearance", strings.NewReader(form.Encode()))
	r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	w := httptest.NewRecorder()
	HandleAppearance(w, r)
	return w
}

func TestHandleAppearance(t *testing.T) {
	w := post(url.Values{"mode": {"dark"}, "return_to": {"/d/abc?x=1"}})
	if w.Code != http.StatusSeeOther || w.Header().Get("Location") != "/d/abc?x=1" {
		t.Fatalf("got %d %q", w.Code, w.Header().Get("Location"))
	}
	c := w.Result().Cookies()
	if len(c) != 1 || c[0].Name != AppearanceCookie || c[0].Value != "dark" || !c[0].Secure || !c[0].HttpOnly || c[0].SameSite != http.SameSiteLaxMode || c[0].Path != "/" || c[0].MaxAge < 364*24*3600 || c[0].Domain != "" {
		t.Fatalf("cookie %+v", c)
	}
	// return_to that leaves the site falls back to the root; SafeReturn's
	// control-character case is the one a prefix test misses.
	for _, bad := range []string{"https://evil.example/", "//evil.example/", "/\\evil.example", "/\t/evil.example", "evil", ""} {
		w := post(url.Values{"mode": {"light"}, "return_to": {bad}})
		if w.Code != http.StatusSeeOther || w.Header().Get("Location") != "/" {
			t.Errorf("return_to %q: got %d %q", bad, w.Code, w.Header().Get("Location"))
		}
	}
	for _, bad := range []string{"auto", "", "DARK", "sepia"} {
		if w := post(url.Values{"mode": {bad}, "return_to": {"/"}}); w.Code != http.StatusBadRequest || len(w.Result().Cookies()) != 0 {
			t.Errorf("mode %q: got %d with cookies %v", bad, w.Code, w.Result().Cookies())
		}
	}
	g := httptest.NewRecorder()
	HandleAppearance(g, httptest.NewRequest("GET", "/appearance?mode=dark", nil))
	if g.Code != http.StatusMethodNotAllowed || g.Header().Get("Allow") != "POST" || len(g.Result().Cookies()) != 0 {
		t.Fatalf("GET: %d", g.Code)
	}
}

// chrome.js must stay a classic, dependency-free script.
func TestScriptIsClassicAndSelfContained(t *testing.T) {
	src := string(JS())
	if strings.Contains(src, "import ") || strings.Contains(src, "export ") {
		t.Fatal("chrome.js must be a classic script")
	}
	// Escape and outside-click close every member of the one top-level
	// group, the menubar's menus included: Sheets' menubar lost both when
	// it left rastrillo's dropdown. And an invoker row closes the menu it
	// was in, with a fallback where the platform lacks invoker commands.
	for _, want := range []string{"Escape", "estilo-bar-title-input", "defaultValue", `details[name="estilo-menus"][open]`, "commandfor", "showModal"} {
		if !strings.Contains(src, want) {
			t.Errorf("chrome.js lost %q", want)
		}
	}
	// Escape is heard in the capture phase: an app that stops a key from
	// propagating out of its menus (Sheets, whose grid library listens on
	// document) would otherwise swallow it before a bubble listener ran.
	keydown := src[strings.Index(src, "addEventListener('keydown'"):]
	keydown = keydown[:strings.Index(keydown[1:], "document.addEventListener(")+1]
	if !strings.HasSuffix(strings.TrimSpace(keydown), "}, true)") {
		t.Error("chrome.js's Escape handler is not in the capture phase")
	}
}

// chrome.js's behaviour runs under Node against a minimal DOM
// (chrome.test.mjs), the way savestatus's does.
func TestScriptBehaviour(t *testing.T) {
	out, err := exec.Command("node", "--test", "chrome.test.mjs").CombinedOutput()
	if err != nil {
		t.Fatalf("node --test chrome.test.mjs: %v\n%s", err, out)
	}
}

// The door: the sign-in pages are one card on the suite's sky, headed by
// the app's mark and name. Its sky markup must be exactly the sky
// package's own, or the two would drift.
func TestSignInIsTheOficinaDoor(t *testing.T) {
	v := sky.For("calendar.oficina.works")
	html := render(t, "estilo-signin", SignIn{Icon: "/i.svg", App: "Calendar", Sky: v, Action: "/signin"})
	var want bytes.Buffer
	if err := template.Must(template.ParseFS(sky.Templates(), "templates/*.html")).ExecuteTemplate(&want, "estilo-sky", v); err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(html, strings.TrimSpace(want.String())) {
		t.Errorf("the door's sky differs from estilo-sky's:\n%s\nwant it to contain:\n%s", html, want.String())
	}
	for _, s := range []string{`<div estilo-door estilo-sky-host>`, `<section estilo-signin>`, `<span>Calendar</span>`, ` autofocus`, `</section>
</div>`} {
		if !strings.Contains(html, s) {
			t.Errorf("door lacks %q", s)
		}
	}
	for _, name := range []string{"estilo-signin-sent", "estilo-signed-out"} {
		if h := render(t, name, SignInNotice{Icon: "/i.svg", App: "Calendar", Sky: v, Heading: "h", Body: "b"}); !strings.Contains(h, `<div estilo-door estilo-sky-host>`) || !strings.Contains(h, "estilo-sky-layer") {
			t.Errorf("%s is not drawn as the door", name)
		}
	}
	// No sky given, no sky drawn: the card still stands.
	if h := render(t, "estilo-signin", SignIn{Icon: "/i.svg", Action: "/s"}); strings.Contains(h, "estilo-sky-layer") {
		t.Error("a sign-in with no Sky drew one")
	}
}

// The card styles its own links: an app that styles no bare <a> would
// otherwise show the browser's default blue on the door.
func TestTheDoorStylesItsLinks(t *testing.T) {
	src := string(CSS())
	for _, want := range []string{":where([estilo-signin]) a", "[estilo-signin-foot] a"} {
		if !strings.Contains(src, want) {
			t.Errorf("chrome.css does not style %q", want)
		}
	}
}

// iOS zooms the page into any text control under 16px. rastrillo's
// tokens.css brings controls up to 16px on a coarse pointer with a bare
// `input` selector, and the bar's title field outweighs that with
// `font: inherit` at 14px, so it zoomed on every tap in every app with a
// title (found in Sheets, 2026-10-01: its TestNoZoomOnTap). chrome.css
// restates rastrillo's rule for the field, at the field's own weight,
// after the field's own rule.
func TestTitleFieldDoesNotZoomOnTap(t *testing.T) {
	src := string(CSS())
	field := strings.Index(src, "[estilo-bar-title-input] {")
	if field < 0 {
		t.Fatal("chrome.css has no title field rule")
	}
	block := regexp.MustCompile(`@media \(pointer: coarse\) \{\s*\[estilo-bar-title-input\] \{\s*font-size: max\(1rem, 1em\);\s*\}\s*\}`)
	at := block.FindStringIndex(src)
	if at == nil {
		t.Fatal("chrome.css does not size the title field to max(1rem, 1em) under (pointer: coarse)")
	}
	if at[0] < field {
		t.Error("the coarse-pointer size comes before the title field's own rule, whose font: inherit then wins")
	}
}

// The account at a sidebar's foot (Account.Rail), for an app whose chrome
// is a rail, not the bar (Fichas, Paul 2026-10-01: "put any shared stuff in
// the bottom left and maybe roll it into a dropup"). The same menu, the
// same group and the same one Sign out; only where it sits changes.
func TestTheAccountCanSitAtARailsFoot(t *testing.T) {
	acc := signedIn("x").Account
	bar := render(t, "estilo-account", acc)
	if strings.Contains(bar, `estilo-account="rail"`) || strings.Contains(bar, "estilo-account-who") {
		t.Error("the bar's account changed: Rail is off by default")
	}
	acc.Rail = true
	html := render(t, "estilo-account", acc)
	if !strings.Contains(html, `<details estilo-account="rail" name="estilo-menus">`) {
		t.Errorf("a rail account is not marked, or left the one menu group:\n%s", html)
	}
	// In a rail the trigger is a row: who is signed in, beside the avatar.
	summary := html[strings.Index(html, "<summary"):strings.Index(html, "</summary>")]
	if !strings.Contains(summary, `<span estilo-account-who dir="auto">paul@example.test</span>`) {
		t.Errorf("the rail trigger does not say who is signed in:\n%s", summary)
	}
	if n := strings.Count(html, "x-signout"); n != 1 {
		t.Errorf("Sign out rendered %d times", n)
	}

	src := string(CSS())
	// It opens upward where the rail is the viewport's height, and it is
	// the foot's own width: hung from the inline end of a foot narrower
	// than the bar's panel it ran off the window's start edge, and from the
	// inline start it ran past the rail, which scrolls and so clips.
	wide := regexp.MustCompile(`@media \(min-width: 800px\) \{\s*\[estilo-account~="rail"\] > \[estilo-account-panel\] \{[^}]*inset-block-start: auto;[^}]*inset-block-end: calc\(100% \+ 4px\);`)
	if !wide.MatchString(src) {
		t.Error("chrome.css does not open the rail account upward from 800px")
	}
	if !regexp.MustCompile(`\[estilo-account~="rail"\] > \[estilo-account-panel\] \{[^}]*inset-inline: 0;[^}]*inline-size: auto;[^}]*min-inline-size: 0;`).MatchString(src) {
		t.Error("chrome.css does not size the rail account's panel to the rail's foot")
	}
	// The trigger is in the page flow: square, like every bar trigger.
	if regexp.MustCompile(`\[estilo-account~="rail"\] > \[estilo-bar-trigger\] \{[^}]*border-radius: (?:[1-9]|var)`).MatchString(src) {
		t.Error("the rail trigger is rounded; an in-flow highlight is square")
	}
}