package memoriatest

import (
	"net/http"
	"strings"
	"testing"
)

// The corpus every test in this file searches.
//
// Two passages match "june revenue", and that is the point rather than
// an incidental. The first version of this file used a corpus where
// every query returned exactly ONE result, which made "the primed one is
// the first one" unfalsifiable: with a single list item, priming the
// first, priming all and priming the last are the same markup. Fable's
// review caught it by mutating the template to `{{if $.Primed}}` and
// watching the suite stay green. Any test below that asserts a POSITION
// must therefore check it has more than one result to be wrong about.
func withCorpus(t *testing.T) http.Handler {
	t.Helper()
	h := newApp(t)
	if rec := store(t, h, "Q3 board pack",
		"## Revenue\n\nJune revenue was 1,350,000 across all regions.\n\n"+
			"## Costs\n\nHosting fell after the migration.\n\n"+
			"## Risks\n\nOne customer is 22% of June revenue, and that has not improved.",
	); rec.Code != http.StatusSeeOther {
		t.Fatalf("store: status %d, want 303", rec.Code)
	}
	return h
}

// results counts the rendered result items, so a positional assertion
// can refuse to run against a list too short to hold a wrong answer.
func results(body string) int {
	return strings.Count(body, "<li rst-result")
}

// A lookup primes the first result, which is what makes Enter go
// somewhere. The attribute is the whole contract between the server's
// heuristic and search.js: the script never re-derives the rule.
//
// Broken by hard-coding p.Primed to false — red, then reverted.
// 2026-09-05.
func TestALookupPrimesTheFirstResult(t *testing.T) {
	h := withCorpus(t)
	body := get(t, h, "/?q=june+revenue").Body.String()
	// Without at least two results this test cannot tell prime-first
	// from prime-anything, so it refuses to pretend it did.
	if n := results(body); n < 2 {
		t.Fatalf("corpus returned %d results; a positional assertion needs at least 2:\n%s", n, body)
	}
	if !strings.Contains(body, "rst-result-primed") {
		t.Errorf("a lookup did not prime a result, so Enter goes nowhere:\n%s", body)
	}
	if n := strings.Count(body, "rst-result-primed"); n != 1 {
		t.Errorf("primed %d results, want exactly 1", n)
	}
	// The prime must be on the FIRST result, not merely somewhere.
	// Split on the <li> opener rather than comparing indexes, because
	// "rst-result" is a prefix of "rst-result-primed" and an index
	// comparison would be measuring the same attribute twice.
	items := strings.Split(body, "<li rst-result")
	if !strings.Contains(items[1], "rst-result-primed") {
		t.Errorf("the primed result is not the first one:\n%s", body)
	}
	for i := 2; i < len(items); i++ {
		if strings.Contains(items[i], "rst-result-primed") {
			t.Errorf("result %d is primed as well as the first", i)
		}
	}
}

// Broken by priming on `len(results) > 0` alone, dropping the question
// term — red, then reverted. 2026-09-05.
func TestAQuestionPrimesNothing(t *testing.T) {
	h := withCorpus(t)
	body := get(t, h, "/?q=what+was+june+revenue").Body.String()
	if !strings.Contains(body, "Q3 board pack") {
		t.Fatalf("the question found nothing, so this test proves nothing:\n%s", body)
	}
	if strings.Contains(body, "rst-result-primed") {
		t.Error("a question primed a result; Enter would navigate away from " +
			"a page the reader was still reading")
	}
}

// There is deliberately no test here for "a page with no results primes
// nothing". It was written, and it could not fail: with no results the
// template renders no list items, so priming nothing and priming a
// result that does not exist are the same bytes. The invariant is real
// and is guarded where it is visible — query.TestPrimesFirstResult.

// The live-search endpoint returns the results region and nothing else.
// A fragment that shipped a whole page would nest <html> inside the list
// on every keystroke.
//
// Broken by pointing searchResults at render instead of renderFragment —
// red, then reverted. 2026-09-05.
func TestSearchFragmentIsResultsOnly(t *testing.T) {
	h := withCorpus(t)
	rec := get(t, h, "/search?q=june+revenue")
	if rec.Code != http.StatusOK {
		t.Fatalf("status %d, want 200", rec.Code)
	}
	body := rec.Body.String()
	if !strings.Contains(body, "Q3 board pack") {
		t.Errorf("the fragment carries no result:\n%s", body)
	}
	if !strings.Contains(body, "rst-result-primed") {
		t.Error("the fragment does not prime, so live search and a form " +
			"submit would disagree about where Enter goes")
	}
	// rst-refresh is on the list because a fragment that ever grew the
	// wrapper would nest a refreshable region inside one, and drop.js
	// would then find two regions with the same name.
	for _, chrome := range []string{"<html", "<body", "rst-page-header", "Add something", "rst-refresh"} {
		if strings.Contains(body, chrome) {
			t.Errorf("the fragment carries page chrome (%q); it would nest a "+
				"whole page inside the results list", chrome)
		}
	}
}

// The empty query is the state the box starts in and returns to when it
// is cleared. It must render an empty region, not an error and not the
// whole corpus.
func TestSearchFragmentOfAnEmptyQueryIsEmpty(t *testing.T) {
	rec := get(t, withCorpus(t), "/search?q=")
	if rec.Code != http.StatusOK {
		t.Fatalf("status %d, want 200", rec.Code)
	}
	if body := strings.TrimSpace(rec.Body.String()); body != "" {
		t.Errorf("an empty query rendered %q, want nothing", body)
	}
}

// The fragment and the full page must agree, because Enter can land on
// either: live search fills the region, and a scriptless submit renders
// the page. If they disagreed, priming would depend on whether JS had
// loaded yet.
func TestFragmentAndPageAgreeOnPriming(t *testing.T) {
	h := withCorpus(t)
	// Two queries, not three: the no-match case was here and could not
	// disagree, because with nothing to render both sides emit the same
	// empty region whatever they decided. A case that cannot fail on a
	// list of cases that can reads as coverage it is not.
	for _, q := range []string{"june+revenue", "what+was+june+revenue"} {
		page := strings.Contains(get(t, h, "/?q="+q).Body.String(), "rst-result-primed")
		frag := strings.Contains(get(t, h, "/search?q="+q).Body.String(), "rst-result-primed")
		if page != frag {
			t.Errorf("q=%q: page primed=%v but fragment primed=%v", q, page, frag)
		}
	}
}

// When search.js's own fetch fails there is no server response to render
// a callout from, so the page must arrive already carrying the sentence.
// Without it the script has nothing to say and nothing to show, and the
// older results stand on screen as though they were current — which is
// this codebase's worst failure shape, reached by deleting one attribute.
//
// The sentence must be the SAME one the server's callout uses. Two
// wordings for "the search did not run" is a page arguing with itself.
//
// Broken by deleting rst-search-stale-note from index.html — red, then
// reverted. Broken again by changing its wording so the two disagree —
// red, then reverted. 2026-09-05.
func TestThePageCarriesTheFailureSentenceItMayNeed(t *testing.T) {
	h, _, d := newAppWithLog(t)
	store(t, h, "Q3 board pack", "June revenue was 1,350,000 across all regions.")

	// The sentence the page hands to search.js, for a fetch that never
	// answers and so has no callout of its own to render.
	carried := attr(t, get(t, h, "/").Body.String(), "rst-search-stale-note")
	if carried == "" {
		t.Fatal("the page carries no failure sentence, so a failed live search has nothing to show")
	}

	// The sentence the SERVER renders when the search itself fails.
	// Taking the database away is how that path is reached; nothing a
	// well-formed request can carry makes store.Search fail.
	d.Close()
	broken := get(t, h, "/?q=june+revenue").Body.String()
	// **The ATTRIBUTE tone is `rst-tone`**, and this assertion has now
	// been wrong twice. tokens.css pairs every kind: the class spelling
	// takes `data-tone`, the attribute spelling takes `rst-tone`, and the
	// header says so — "rst-tone carries the four tones that data-tone
	// carries today". `[rst-callout]` is the attribute spelling, so it
	// wants `rst-tone`.
	//
	// Attempt one asserted `rst-callout="danger"`, a value on the kind
	// attribute that nothing selects. Attempt two asserted `data-tone`,
	// which is a real string in the stylesheet — inside the CLASS
	// selector next to the one needed here — so it confirmed a spelling
	// the markup could not use. Both times the callout rendered untoned
	// and both times a test said it was fine.
	if !strings.Contains(broken, `rst-tone="negative"`) {
		t.Fatalf("a failed search did not render its callout, so there is nothing to compare:\n%s", broken)
	}
	// Compare the callout's OWN words to the carried ones. Searching the
	// whole page for the carried sentence is what this gate did first,
	// and it could not fail: that page also carries the attribute, so
	// the sentence always found itself and a drifted callout went
	// unnoticed. Caught by mutating the attribute's wording.
	spoken := calloutBody(broken)
	if spoken == "" {
		t.Fatalf("could not read the failure callout's own words:\n%s", broken)
	}
	if spoken != carried {
		t.Errorf("the sentence search.js would show and the one the server shows disagree:\n"+
			"  server:  %q\n  carried: %q", spoken, carried)
	}
	if strings.Contains(broken, "rst-result-primed") {
		t.Error("a search that broke primed a result")
	}
}

// calloutBody is the text of the first danger callout's body, trimmed.
func calloutBody(body string) string {
	i := strings.Index(body, `rst-tone="negative"`)
	if i < 0 {
		return ""
	}
	rest := body[i:]
	open := strings.Index(rest, "<div rst-callout-body><p>")
	if open < 0 {
		return ""
	}
	rest = rest[open+len("<div rst-callout-body><p>"):]
	shut := strings.Index(rest, "</p>")
	if shut < 0 {
		return ""
	}
	return strings.TrimSpace(rest[:shut])
}

// attr pulls one attribute's value out of rendered markup. Small enough
// to be obvious, and obvious beats a parser for one attribute.
func attr(t *testing.T, body, name string) string {
	t.Helper()
	i := strings.Index(body, name+`="`)
	if i < 0 {
		return ""
	}
	rest := body[i+len(name)+2:]
	j := strings.Index(rest, `"`)
	if j < 0 {
		return ""
	}
	return rest[:j]
}

// The stamp is what search.js reads to decide whether the results on
// screen still describe what is in the box. Reading the input instead
// was the bug Fable found: after a Back, a browser restores the field on
// a schedule of its own, and a script that trusted it would treat a
// stale screen as current and send Enter to the wrong document.
//
// Broken by deleting rst-search-results-for from index.html — red, then
// reverted. 2026-09-05.
func TestThePageStampsTheQueryItRendered(t *testing.T) {
	h := withCorpus(t)
	for _, c := range []struct{ url, want string }{
		{"/?q=june+revenue", `rst-search-results-for="june revenue"`},
		{"/", `rst-search-results-for=""`},
	} {
		if body := get(t, h, c.url).Body.String(); !strings.Contains(body, c.want) {
			t.Errorf("GET %s does not stamp the query it rendered (want %s):\n%s", c.url, c.want, body)
		}
	}
}

// search.js is an enhancement. The page it enhances must work with it
// deleted, which means the form is a real GET form to a real route and
// the script is not what makes results appear.
func TestSearchWorksWithoutTheScript(t *testing.T) {
	h := withCorpus(t)
	body := get(t, h, "/").Body.String()
	if !strings.Contains(body, `action="/"`) || !strings.Contains(body, `method="get"`) {
		t.Errorf("the search form is not a plain GET form:\n%s", body)
	}
	if !strings.Contains(get(t, h, "/?q=june+revenue").Body.String(), "Q3 board pack") {
		t.Error("a plain form submit does not produce results")
	}
}