package gallery

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

	xhtml "golang.org/x/net/html"

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

// The frame document: what every frame carries in its head, the stage
// under the sign-in card, the links a shell demo needs to work as the
// app it stands for, and the attribute that lets a document opened in
// a tab of its own remember the reader's scheme.

// The rules every frame's style carries, as written: a component
// sample gets breathing room, a whole-page sample fills the frame, by
// its markup or by the manifest's word.
const (
	paddingRule  = `body { padding: 1rem; }`
	fillRule     = `body:is([rst-stage], [rst-shell-topbar], [rst-shell-sidebar], [rst-shell-console]), body:has(> [rst-shell-topbar], > [rst-shell-sidebar], > [rst-shell-console], > [rst-backdrop], > [rst-stage]) { padding: 0; }`
	documentRule = `body[data-gallery-document] { padding: 0; }`
)

// frameDocs is every frame document of the tree, by path.
func frameDocs(t *testing.T, files map[string][]byte) map[string][]byte {
	t.Helper()
	out := map[string][]byte{}
	for name, body := range files {
		if isFrame(name) {
			out[name] = body
		}
	}
	if len(out) == 0 {
		t.Fatal("the render wrote no frame document; the check that follows would read nothing")
	}
	return out
}

// elementChildren is the element children of n, in order.
func elementChildren(n node) []node {
	var out []node
	for c := n.n.FirstChild; c != nil; c = c.NextSibling {
		if c.Type == xhtml.ElementNode {
			out = append(out, node{c})
		}
	}
	return out
}

// TestEveryFrameDocumentCarriesNoindexAndItsPaddingRule: every frame
// document has one robots meta saying noindex, right after the
// viewport meta, and one style, the last element of its head, with the
// padding rule, the fill rule and the document rule each exactly once,
// every selector present as written.
func TestEveryFrameDocumentCarriesNoindexAndItsPaddingRule(t *testing.T) {
	frames := frameDocs(t, render(t, ""))
	for name, body := range frames {
		doc := parse(t, body)
		head, ok := doc.first(func(n node) bool { return n.n.Data == "head" })
		if !ok {
			t.Errorf("%s has no <head>", name)
			continue
		}
		kids := elementChildren(head)
		robots := -1
		for i, k := range kids {
			if k.n.Data != "meta" {
				continue
			}
			if v, _ := k.attr("name"); v == "robots" {
				if robots >= 0 {
					t.Errorf("%s carries two robots metas", name)
				}
				robots = i
				if c, _ := k.attr("content"); c != "noindex" {
					t.Errorf("%s says robots %q, want noindex", name, c)
				}
			}
		}
		if robots < 0 {
			t.Errorf("%s carries no robots meta", name)
		} else if robots == 0 {
			t.Errorf("%s: the robots meta is the head's first element; it follows the viewport meta", name)
		} else if prev := kids[robots-1]; prev.n.Data != "meta" || func() bool { v, _ := prev.attr("name"); return v != "viewport" }() {
			t.Errorf("%s: the robots meta does not follow the viewport meta", name)
		}
		if last := kids[len(kids)-1]; last.n.Data != "style" {
			t.Errorf("%s: the last element of the head is <%s>, want the frame's <style>", name, last.n.Data)
		}
		s := string(body)
		if n := strings.Count(s, paddingRule); n != 1 {
			t.Errorf("%s carries the padding rule %d times, want once", name, n)
		}
		if n := strings.Count(s, fillRule); n != 1 {
			t.Errorf("%s carries the fill rule %d times, want once", name, n)
		}
		if n := strings.Count(s, documentRule); n != 1 {
			t.Errorf("%s carries the document rule %d times, want once", name, n)
		}
	}
	t.Logf("%d frame documents checked", len(frames))
}

// TestALayoutDocumentIsMarkedAWholePage: the body of every layout
// example's frame carries data-gallery-document, which the document
// rule fills to the frame's edge, and no other frame's body does. The
// column shell is the case the markup rules cannot reach: its body has
// no wrapper, so without the mark it would sit in a component's padding.
func TestALayoutDocumentIsMarkedAWholePage(t *testing.T) {
	frames := frameDocs(t, render(t, ""))
	m := manifest(t)
	marked, layouts := 0, 0
	for name, body := range frames {
		parts := strings.Split(name, "/")
		e, ok := m.Entry(parts[len(parts)-2])
		if !ok {
			t.Fatalf("%s is no example's frame", name)
		}
		bodyEl, ok := parse(t, body).first(func(n node) bool { return n.n.Data == "body" })
		if !ok {
			t.Errorf("%s has no <body>", name)
			continue
		}
		has := hasAttr(bodyEl, "data-gallery-document")
		if e.Document {
			layouts++
			if has {
				marked++
			} else {
				t.Errorf("%s is a layout document whose body is not marked data-gallery-document", name)
			}
		} else if has {
			t.Errorf("%s is not a layout document and its body is marked data-gallery-document", name)
		}
	}
	if layouts == 0 {
		t.Fatal("no frame belongs to a layout example; the check above read nothing")
	}
	column := "day/en/frames/layout-column/" + mustEntry(t, "layout-column").Default + ".html"
	if _, ok := frames[column]; !ok {
		t.Fatalf("no %s", column)
	}
	t.Logf("%d of %d layout frames marked", marked, layouts)
}

// sceneOf lifts the stage's scene from the layout-stage example's own
// document, independently of the render, so the test and the code
// cannot agree on a wrong scene.
func sceneOf(t *testing.T) string {
	t.Helper()
	doc, err := example.Document(fiesta.FS(), "layout-stage", mustEntry(t, "layout-stage").Default)
	if err != nil {
		t.Fatal(err)
	}
	scene := regexp.MustCompile(`(?s)<div rst-stage-scene aria-hidden="true">.*?</div>`).FindString(doc)
	if scene == "" {
		t.Fatal("the layout-stage example carries no scene to lift")
	}
	return scene
}

// hasAttr says whether the element carries the attribute, whatever its
// value.
func hasAttr(n node, name string) bool {
	_, ok := n.attr(name)
	return ok
}

// TestTheSigninScreensAreOnTheStage: the ten sign-in states whose body
// opens with the card are framed on the stage, the scene first and the
// card inside the page column; the two bare rst-box screens are not;
// every scene is the layout-stage example's own; and the signin page's
// HTML tab shows the bare card, never the stage. Read in every theme
// and locale, the structure parsed in day/en.
func TestTheSigninScreensAreOnTheStage(t *testing.T) {
	files := render(t, "")
	e := mustEntry(t, "signin")
	scene := sceneOf(t)
	bare := map[string]bool{"email-and-password": true, "google-apple-and-the-rest": true}

	staged := 0
	for _, dir := range dirs() {
		for _, st := range e.States {
			name := dir + "frames/signin/" + st.ID + ".html"
			body, ok := files[name]
			if !ok {
				t.Fatalf("no %s", name)
			}
			// The body alone: the frame style's selectors name the
			// stage in every frame's head.
			s := string(body)
			s = s[strings.Index(s, "<body"):]
			if bare[st.ID] {
				if strings.Contains(s, "rst-stage") {
					t.Errorf("%s is staged; the rst-box screens stay bare", name)
				}
				continue
			}
			if dir == "day/en/" {
				staged++
			}
			if !strings.Contains(s, `<div rst-stage><div rst-stage-scene aria-hidden="true">`) {
				t.Errorf("%s does not open its stage with the scene", name)
			}
			if n := strings.Count(s, scene); n != 1 {
				t.Errorf("%s carries the layout-stage scene %d times, want once", name, n)
			}
		}
	}
	if staged != 10 {
		t.Errorf("%d signin states are staged in day/en, want 10", staged)
	}

	for _, st := range e.States {
		if bare[st.ID] {
			continue
		}
		name := "day/en/frames/signin/" + st.ID + ".html"
		doc := parse(t, files[name])
		body, _ := doc.first(func(n node) bool { return n.n.Data == "body" })
		kids := elementChildren(body)
		if len(kids) != 1 || kids[0].n.Data != "div" || !hasAttr(kids[0], "rst-stage") {
			t.Errorf("%s: the body's one child is not <div rst-stage>", name)
			continue
		}
		parts := elementChildren(kids[0])
		if len(parts) != 2 || !hasAttr(parts[0], "rst-stage-scene") || !hasAttr(parts[1], "rst-page") {
			t.Errorf("%s: the stage holds %d parts, want the scene then the page column", name, len(parts))
			continue
		}
		if v, _ := parts[0].attr("aria-hidden"); v != "true" {
			t.Errorf("%s: the scene is not aria-hidden", name)
		}
		card := elementChildren(parts[1])
		if len(card) != 1 || !hasAttr(card[0], "rst-signin") {
			t.Errorf("%s: the page column holds %d elements, want the one [rst-signin] card", name, len(card))
		}
	}

	page := files["day/en/signin.html"]
	for _, st := range e.States {
		if tab := htmlTab(t, page, "signin", st.ID); strings.Contains(tab, "rst-stage") {
			t.Errorf("signin/%s: the HTML tab shows the stage; it shows the card a reader copies", st.ID)
		}
	}
}

// bodyLinks is every <a> in the document's body, in order.
func bodyLinks(t *testing.T, doc node) []node {
	t.Helper()
	body, ok := doc.first(func(n node) bool { return n.n.Data == "body" })
	if !ok {
		t.Fatal("the document has no <body>")
	}
	return body.find(func(n node) bool { return n.n.Data == "a" })
}

// within says whether n has an ancestor pred accepts.
func within(n node, pred func(node) bool) bool {
	for p := n.n.Parent; p != nil; p = p.Parent {
		if p.Type == xhtml.ElementNode && pred(node{p}) {
			return true
		}
	}
	return false
}

// TestAShellDemosLinksAreLive: in the sidebar shell's frame document
// the back link, the nav links, the brand and the twelve language links
// point where the interface says, each marked as the gallery's own and
// the current language marked; in the sidebar's page document the way
// up is the sidebar's index with its first nav id; in the stage shell
// the foot link is the Overview; and every other href in a layout's
// body is a fragment. Rendered at a mount, so a link written for the
// root could not pass.
func TestAShellDemosLinksAreLive(t *testing.T) {
	const mount = "/x"
	files := render(t, mount)
	s := newTestSite(t, fiesta.FS(), mount)
	overview := s.href("day", "en", "index.html")
	frameOf := func(theme, locale, name string) string {
		return s.href(theme, locale, "frames/"+name+"/"+mustEntry(t, name).Default+".html")
	}
	nav := func(t *testing.T, n node, where string) {
		t.Helper()
		if !hasAttr(n, "data-gallery-nav") {
			t.Errorf("%s is not marked data-gallery-nav", where)
		}
	}
	attr := func(n node, name string) string { v, _ := n.attr(name); return v }
	hrefOf := func(n node) string { return attr(n, "href") }

	// The sidebar's index document, in English and in Arabic for the
	// language mark.
	for _, locale := range []string{"en", "ar"} {
		name := "day/" + locale + "/frames/layout-sidebar/default.html"
		doc := parse(t, files[name])
		live := map[*xhtml.Node]bool{}
		links := bodyLinks(t, doc)
		mark := func(n node) { live[n.n] = true }

		back := doc.find(func(n node) bool {
			return n.n.Data == "a" && attr(n, "rel") == "up" && within(n, func(p node) bool { return hasAttr(p, "rst-shell-back") })
		})
		if len(back) != 1 {
			t.Fatalf("%s has %d back links, want 1", name, len(back))
		}
		if want := frameOf("day", locale, "layout-sidebar") + "#nav-posts"; hrefOf(back[0]) != want {
			t.Errorf("%s: the back link goes to %q, want %q", name, hrefOf(back[0]), want)
		}
		nav(t, back[0], name+": the back link")
		mark(back[0])

		navLinks := doc.find(func(n node) bool {
			return n.n.Data == "a" && within(n, func(p node) bool { return hasAttr(p, "rst-shell-nav") })
		})
		if len(navLinks) != 3 {
			t.Fatalf("%s has %d nav links, want 3", name, len(navLinks))
		}
		for _, a := range navLinks {
			if want := frameOf("day", locale, "layout-sidebar-page"); hrefOf(a) != want {
				t.Errorf("%s: nav link %q goes to %q, want %q", name, a.text(), hrefOf(a), want)
			}
			nav(t, a, name+": nav link "+a.text())
			mark(a)
		}

		brands := doc.find(func(n node) bool { return n.n.Data == "a" && hasAttr(n, "rst-shell-brand") })
		if len(brands) != 2 {
			t.Fatalf("%s has %d brand links, want 2", name, len(brands))
		}
		for _, a := range brands {
			if want := s.href("day", locale, "index.html"); hrefOf(a) != want {
				t.Errorf("%s: the brand goes to %q, want the Overview %q", name, hrefOf(a), want)
			}
			nav(t, a, name+": the brand")
			mark(a)
		}

		langs := doc.find(func(n node) bool {
			return n.n.Data == "a" && within(n, func(p node) bool { return hasAttr(p, "rst-locale") })
		})
		if len(langs) != len(Locales) {
			t.Fatalf("%s has %d language links, want %d", name, len(langs), len(Locales))
		}
		current := 0
		seen := map[string]bool{}
		for _, a := range langs {
			l := attr(a, "lang")
			seen[l] = true
			if want := frameOf("day", l, "layout-sidebar"); hrefOf(a) != want {
				t.Errorf("%s: the %s link goes to %q, want %q", name, l, hrefOf(a), want)
			}
			if d := attr(a, "dir"); d != Dir(l) {
				t.Errorf("%s: the %s link says dir=%q, want %q", name, l, d, Dir(l))
			}
			cur, _ := a.attr("aria-current")
			if cur == "true" {
				current++
				if l != locale {
					t.Errorf("%s marks %s current, want %s", name, l, locale)
				}
			}
			nav(t, a, name+": the "+l+" link")
			mark(a)
		}
		for _, l := range Locales {
			if !seen[l] {
				t.Errorf("%s: the language menu has no %s", name, l)
			}
		}
		if current != 1 {
			t.Errorf("%s marks %d languages current, want 1", name, current)
		}

		// The foot link is the layout's own sample text, so it is in
		// the page's language.
		backWords := html.UnescapeString(localMarkup(locale, "", footWords))
		backs := doc.find(func(n node) bool {
			return n.n.Data == "a" && strings.TrimSpace(n.text()) == backWords
		})
		if len(backs) == 0 {
			t.Fatalf("%s has no link back to the design system", name)
		}
		for _, a := range backs {
			if want := s.href("day", locale, "index.html"); hrefOf(a) != want {
				t.Errorf("%s: the way back to the design system goes to %q, want %q", name, hrefOf(a), want)
			}
			nav(t, a, name+": the way back to the design system")
			mark(a)
		}

		rest := 0
		for _, a := range links {
			if live[a.n] {
				continue
			}
			rest++
			if h := hrefOf(a); !strings.HasPrefix(h, "#") {
				t.Errorf("%s: <a href=%q>%s</a> is neither the gallery's nor a fragment", name, h, a.text())
			}
			if hasAttr(a, "data-gallery-nav") {
				t.Errorf("%s: <a href=%q> is marked the gallery's and points nowhere the interface says", name, hrefOf(a))
			}
		}
		if rest == 0 {
			t.Errorf("%s: every body link was rewritten; the sample's own links should stay fragments", name)
		}
	}

	// The sidebar's page document: the way up is the index and its
	// first nav id.
	pageDoc := parse(t, files["day/en/frames/layout-sidebar-page/default.html"])
	up := pageDoc.find(func(n node) bool { return n.n.Data == "a" && attr(n, "rel") == "up" })
	if len(up) != 1 {
		t.Fatalf("the sidebar's page document has %d up links, want 1", len(up))
	}
	if want := frameOf("day", "en", "layout-sidebar") + "#nav-posts"; hrefOf(up[0]) != want {
		t.Errorf("the sidebar's page document goes up to %q, want %q", hrefOf(up[0]), want)
	}
	nav(t, up[0], "the sidebar page's way up")

	// The stage: its foot link is the Overview.
	stageDoc := parse(t, files["day/en/frames/layout-stage/default.html"])
	foot := stageDoc.find(func(n node) bool {
		return n.n.Data == "a" && within(n, func(p node) bool { return hasAttr(p, "rst-stage-foot") })
	})
	if len(foot) != 1 {
		t.Fatalf("the stage shell has %d foot links, want 1", len(foot))
	}
	if hrefOf(foot[0]) != overview {
		t.Errorf("the stage's foot link goes to %q, want %q", hrefOf(foot[0]), overview)
	}
	nav(t, foot[0], "the stage's foot link")

	// A shell with no page document: its nav links stay fragments.
	topbar := parse(t, files["day/en/frames/layout-topbar/default.html"])
	for _, a := range topbar.find(func(n node) bool {
		return n.n.Data == "a" && within(n, func(p node) bool { return hasAttr(p, "rst-shell-nav") })
	}) {
		if h := hrefOf(a); h != "#" {
			t.Errorf("the topbar, which has no page document, links its nav to %q, want #", h)
		}
	}

	// A component's frame has no gallery link at all: the rewrite is
	// the layouts' alone.
	for _, a := range bodyLinks(t, parse(t, files["day/en/frames/button/"+mustEntry(t, "button").Default+".html"])) {
		if hasAttr(a, "data-gallery-nav") {
			t.Errorf("the button frame carries a gallery link to %q", hrefOf(a))
		}
	}
}

// TestEveryFrameCarriesTheSchemeStore: every frame document's <html>
// says data-rst-scheme-store="local", so fiesta.js in a document
// opened in a tab of its own remembers the reader's choice where the
// gallery's pages do; the one example that already says so says it
// once.
func TestEveryFrameCarriesTheSchemeStore(t *testing.T) {
	frames := frameDocs(t, render(t, ""))
	for name, body := range frames {
		html, ok := parse(t, body).first(func(n node) bool { return n.n.Data == "html" })
		if !ok {
			t.Errorf("%s has no <html>", name)
			continue
		}
		if v, _ := html.attr("data-rst-scheme-store"); v != "local" {
			t.Errorf("%s says data-rst-scheme-store=%q, want local", name, v)
		}
		if n := strings.Count(string(body), "data-rst-scheme-store="); n != 1 {
			t.Errorf("%s carries data-rst-scheme-store %d times, want once", name, n)
		}
	}
}

// countingFS counts the opens of one file in the source it serves, so
// a test can say how often a render read it.
type countingFS struct {
	fs.FS
	name  string
	opens *int
}

func (c countingFS) Open(name string) (fs.File, error) {
	if name == c.name {
		*c.opens++
	}
	return c.FS.Open(name)
}

// TestTheStageSceneIsLiftedOncePerRender: the scene the ten staged
// sign-in frames share is read from the layout-stage example once, when
// the site is set up, not once per staged frame: a whole theme and
// locale rendered after the setup reads that document once more, for
// the layout-stage example's own page, and no more.
func TestTheStageSceneIsLiftedOncePerRender(t *testing.T) {
	opens := 0
	src := countingFS{FS: fiesta.FS(), name: "examples/layout-stage/" + mustEntry(t, "layout-stage").Default + ".html", opens: &opens}
	s := newTestSite(t, src, "")
	setup := opens
	if err := s.theme("day", "en"); err != nil {
		t.Fatal(err)
	}
	if staged := strings.Count(string(s.out["day/en/frames/signin/asking-for-an-address.html"]), "<div rst-stage-scene"); staged != 1 {
		t.Fatalf("the staged sign-in frame carries %d scenes, so the count below measures nothing", staged)
	}
	if setup != 1 {
		t.Errorf("the setup read the layout-stage document %d times, want once", setup)
	}
	if during := opens - setup; during != 1 {
		t.Errorf("rendering day/en read the layout-stage document %d times, want once (its own page); the scene is lifted per frame", during)
	}
}

// TestALayoutsLanguageLinksNameTheStateItFrames: the language menu of a
// layout's frame document goes to the same state's document in each
// locale, the state being the one framed, so a layout with a second
// state would not send a reader of that state to the first. Driven
// through frame() with a state the layout does not have, since every
// layout has one state today.
func TestALayoutsLanguageLinksNameTheStateItFrames(t *testing.T) {
	s := newTestSite(t, fiesta.FS(), "")
	e := mustEntry(t, "layout-sidebar")
	doc, err := example.Document(fiesta.FS(), e.Name, e.Default)
	if err != nil {
		t.Fatal(err)
	}
	framed, err := s.frame(doc, "day", "ga", e, "second")
	if err != nil {
		t.Fatal(err)
	}
	langs := parse(t, []byte(framed)).find(func(n node) bool {
		return n.n.Data == "a" && within(n, func(p node) bool { return hasAttr(p, "rst-locale") })
	})
	if len(langs) != len(Locales) {
		t.Fatalf("%d language links, want %d", len(langs), len(Locales))
	}
	for _, a := range langs {
		lang, _ := a.attr("lang")
		href, _ := a.attr("href")
		if want := s.href("day", lang, "frames/layout-sidebar/second.html"); href != want {
			t.Errorf("the %s link goes to %q, want %q", lang, href, want)
		}
	}
}

// TestTheColumnDemosMenusAreInItsFooter: the column demo, opened from
// the Demos list in a tab of its own, shows its menus where the column
// shell now puts them, in the footer row under the page, and its
// language menu still works there: each of the twelve links opens the
// column demo in its locale, and the page's own language is the one
// marked. Nothing that drops down comes before the page header.
func TestTheColumnDemosMenusAreInItsFooter(t *testing.T) {
	files := render(t, "")
	s := newTestSite(t, fiesta.FS(), "")
	state := mustEntry(t, "layout-column").Default
	for _, locale := range []string{"en", "ar"} {
		name := "day/" + locale + "/frames/layout-column/" + state + ".html"
		body, ok := files[name]
		if !ok {
			t.Fatalf("the render wrote no %s", name)
		}
		head := strings.Index(string(body), "<header rst-page-header")
		if head < 0 {
			t.Fatalf("%s has no page header", name)
		}
		if strings.Contains(string(body[:head]), "<details") {
			t.Errorf("%s: a <details> comes before the page header; the title must be the first thing on the page", name)
		}
		doc := parse(t, body)
		inFoot := func(n node) bool { return within(n, func(p node) bool { return hasAttr(p, "rst-page-foot") }) }
		for _, menu := range []string{"rst-locale", "rst-scheme"} {
			found := doc.find(func(n node) bool { return n.n.Data == "details" && hasAttr(n, menu) })
			if len(found) != 1 || !inFoot(found[0]) {
				t.Errorf("%s: %d %s menus, want one, inside rst-page-foot", name, len(found), menu)
			}
		}
		langs := doc.find(func(n node) bool {
			return n.n.Data == "a" && within(n, func(p node) bool { return hasAttr(p, "rst-locale") })
		})
		if len(langs) != len(Locales) {
			t.Fatalf("%s: %d language links, want %d", name, len(langs), len(Locales))
		}
		for _, a := range langs {
			lang, _ := a.attr("lang")
			href, _ := a.attr("href")
			if !inFoot(a) {
				t.Errorf("%s: the %s link is not in the footer row", name, lang)
			}
			if want := s.href("day", lang, "frames/layout-column/"+state+".html"); href != want {
				t.Errorf("%s: the %s link goes to %q, want %q", name, lang, href, want)
			}
			current, _ := a.attr("aria-current")
			if want := map[bool]string{true: "true"}[lang == locale]; current != want {
				t.Errorf("%s: the %s link has aria-current=%q, want %q", name, lang, current, want)
			}
		}
	}
}