package memoriatest

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

func TestStoreThenFind(t *testing.T) {
	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."); rec.Code != http.StatusSeeOther {
		t.Fatalf("store: status %d, want 303", rec.Code)
	}
	body := get(t, h, "/?q=june+revenue").Body.String()
	if !strings.Contains(body, "Q3 board pack") {
		t.Errorf("search does not show the document title:\n%s", body)
	}
	if !strings.Contains(body, "Revenue") {
		t.Error("search result carries no heading trail")
	}
	if !strings.Contains(body, "<mark>") {
		t.Error("search result carries no highlight")
	}
}

// The list must distinguish "nothing matched" from "nothing indexed".
// Conflating them is the plausible-empty-list failure.
func TestNoMatchSaysTheCorpusIsNotEmpty(t *testing.T) {
	h := newApp(t)
	store(t, h, "Notes", strings.Repeat("hosting migration notes. ", 20))
	body := get(t, h, "/?q=xylophone").Body.String()
	// One quiet line (shared chrome §4), not "0 results" over a callout.
	if !strings.Contains(body, "No matches for “xylophone”.") {
		t.Errorf("no-match page does not say nothing matched:\n%s", body)
	}
	// The count is on the same page, in the footer, and it is not zero —
	// so a reader can tell an absent answer from an empty index.
	if !regexp.MustCompile(`[1-9][0-9]* passages? indexed`).MatchString(body) {
		t.Error("no-match page does not say how much is indexed, so a reader " +
			"cannot tell an absent answer from an empty index")
	}
}

// Stored text is untrusted. A document containing markup must not
// execute in a search result or on the document page.
func TestStoredMarkupIsEscaped(t *testing.T) {
	h := newApp(t)
	const nasty = `<script>alert('xss')</script>`
	store(t, h, "Payload "+nasty, "## Heading "+nasty+"\n\nA passage containing "+nasty+" inline and revenue too.")

	for _, target := range []string{"/?q=revenue", "/documents/1"} {
		body := get(t, h, target).Body.String()
		if strings.Contains(body, "<script>") {
			t.Errorf("%s renders an unescaped <script>:\n%s", target, body)
		}
		if !strings.Contains(body, "&lt;script&gt;") {
			t.Errorf("%s does not show the escaped form, so the payload may have been dropped "+
				"rather than escaped — check the snippet path", target)
		}
	}
}

// Re-storing under the same key is idempotent. The key is the filename
// for an upload and the title for a paste, so pasting the same text twice
// under the same title updates one document.
func TestReStoringUnderTheSameKeyDoesNotDuplicate(t *testing.T) {
	h := newApp(t)
	const text = "## Revenue\n\nJune revenue was 1,350,000 across every region we serve."
	store(t, h, "Board pack", text)
	store(t, h, "Board pack", text)
	if body := get(t, h, "/").Body.String(); !strings.Contains(body, "1 document") {
		t.Errorf("re-storing under one key made more than one document:\n%s", body)
	}
}

// Two different documents that happen to share text are two documents.
// Under the old scheme — external_id as a hash of the body — they
// collided into one, and the second silently overwrote the first's title.
func TestSameTextUnderDifferentKeysIsTwoDocuments(t *testing.T) {
	h := newApp(t)
	const text = "## Revenue\n\nJune revenue was 1,350,000 across every region we serve."
	store(t, h, "Board pack", text)
	store(t, h, "Minutes", text)
	body := get(t, h, "/").Body.String()
	if !strings.Contains(body, "2 documents") {
		t.Errorf("two documents sharing text collapsed into one:\n%s", body)
	}
	for _, want := range []string{"Board pack", "Minutes"} {
		if !strings.Contains(body, want) {
			t.Errorf("%q is missing from the list", want)
		}
	}
}

// A changed document must not leave its old passages searchable: a
// citation to text that is no longer there is worse than a missing one.
func TestRevisingRemovesTheOldPassages(t *testing.T) {
	h := newApp(t)
	store(t, h, "Doc", "## Revenue\n\nThe zebrafinch figure was 100.")
	if !strings.Contains(get(t, h, "/?q=zebrafinch").Body.String(), "Doc") {
		t.Fatal("the first version was not indexed")
	}
	// Same title, different body: a new document under this design,
	// since the hash differs. Delete the first and confirm it is gone.
	if rec := post(t, h, "/documents/1/delete", nil); rec.Code != http.StatusSeeOther {
		t.Fatalf("delete: status %d, want 303", rec.Code)
	}
	body := get(t, h, "/?q=zebrafinch").Body.String()
	if strings.Contains(body, "<mark>") {
		t.Errorf("a deleted document is still searchable:\n%s", body)
	}
}

func TestMissingDocument404s(t *testing.T) {
	if rec := get(t, newApp(t), "/documents/999"); rec.Code != http.StatusNotFound {
		t.Errorf("GET /documents/999: status %d, want 404", rec.Code)
	}
}

func TestEmptySubmissionIsRefusedWithCopy(t *testing.T) {
	h := newApp(t)
	if rec := store(t, h, "", "   "); rec.Code != http.StatusSeeOther {
		t.Fatalf("empty store: status %d, want 303", rec.Code)
	}
	if !strings.Contains(get(t, h, "/add?err=empty").Body.String(), "nothing to store") {
		t.Error("the empty-submission page does not say what went wrong")
	}
}

// The footer states slice 0's honest claim on every screen.
//
// This test used to assert "nothing leaves this instance", which is how a
// false claim stayed put: the copy was wrong and the test held it there.
// Sign-in fetches https://<the address's domain>/.well-known/keymail
// before anyone is admitted, so something does leave. What is true, and
// what the product can support, is that no *document* does.
func TestFooterStatesTheClaimItCanSupport(t *testing.T) {
	body := get(t, newApp(t), "/").Body.String()
	if !strings.Contains(body, "no document ever") {
		t.Errorf("the page does not state the document-egress property:\n%s", body)
	}
	if strings.Contains(body, "nothing leaves this instance") {
		t.Error("the page overclaims: sign-in dials the address's domain")
	}
}

// The heading has its own indexed column, so it must not also be inside
// the body column: it would count twice in BM25 and appear at the front
// of every snippet. Caught by reading a rendered page, not by a test —
// hence this one.
func TestSnippetDoesNotRepeatTheHeading(t *testing.T) {
	h := newApp(t)
	store(t, h, "Board pack", "## Revenue\n\nJune revenue was 1,350,000 across all regions and every product line we sell today.")
	body := get(t, h, "/?q=june+revenue").Body.String()

	// Find the snippet paragraph and check it does not open with the
	// heading text.
	i := strings.Index(body, "rst-result-snippet")
	if i < 0 {
		t.Fatalf("no snippet rendered:\n%s", body)
	}
	snippet := body[i:min(i+300, len(body))]
	// The heading is "Revenue"; the passage itself begins "June revenue".
	if strings.Contains(snippet, "Revenue</mark> <mark>June") || strings.Contains(snippet, "Revenue June revenue") {
		t.Errorf("the snippet repeats the heading before the body:\n%s", snippet)
	}
}

// A search result links to "#p{n}" using the ordinal stored at ingest.
// The document page used to re-run the chunker at view time, so any
// change to chunking silently misaligned every citation on every existing
// document — and this branch changed the chunker twice.
func TestCitedAnchorExistsOnTheDocumentPage(t *testing.T) {
	h := newApp(t)
	store(t, h, "Board pack",
		"## Revenue\nJune revenue was 1,350,000 across all regions.\n\n"+
			"## Costs\nHosting fell after the migration and support was flat.\n\n"+
			"## Risks\nOne customer is 22% of recurring revenue, which is the concentration risk.")

	results := get(t, h, "/?q=concentration").Body.String()
	m := regexp.MustCompile(`/documents/(\d+)#p(\d+)`).FindStringSubmatch(results)
	if m == nil {
		t.Fatalf("no citation anchor in the results:\n%s", results)
	}
	page := get(t, h, "/documents/"+m[1]).Body.String()
	anchor := `id="p` + m[2] + `"`
	if !strings.Contains(page, anchor) {
		t.Errorf("the search cited %s but the document page has no %s — "+
			"the citation points at nothing", m[0], anchor)
	}
}

// A document edited and re-ingested under the same key must UPDATE, not
// accumulate. external_id used to be a hash of the body, so every edit
// produced a second document with the first still indexed under the same
// title — and Revision, which the design leans on for staleness, could
// only ever move for a byte-identical re-upload. Found by a code review.
func TestEditingUnderTheSameKeyUpdatesOneDocument(t *testing.T) {
	h := newApp(t)
	const key = "board-pack.md"
	upload(t, h, key, "## Revenue\nThe zebrafinch figure was 100 for the quarter just gone.")
	upload(t, h, key, "## Revenue\nThe wildebeest figure was 200 for the quarter just gone.")

	list := get(t, h, "/").Body.String()
	if !strings.Contains(list, "1 document") {
		t.Errorf("editing under the same key made more than one document:\n%s", list)
	}
	// The old passage must be gone, not merely outranked.
	if got := get(t, h, "/?q=zebrafinch").Body.String(); strings.Contains(got, "<mark>") {
		t.Error("the superseded passage is still searchable; a citation would point at text that is no longer there")
	}
	if got := get(t, h, "/?q=wildebeest").Body.String(); !strings.Contains(got, "<mark>") {
		t.Error("the new passage was not indexed")
	}
}

// A term that appears only in the document's title must find the
// document. Reported from the live instance: a paste titled "Passport
// numbers" whose body was numbers could not be found by "passport", and
// the page said so confidently — "1 passage indexed, so this is a real
// absence". It was not an absence. The index held two columns, heading
// and body, and neither is the title: a chunk's heading trail comes from
// Markdown headings *inside* the body, so a plain paste has none at all.
// The title was sealed, shown on every result, and never indexed.
func TestATermOnlyInTheTitleIsFound(t *testing.T) {
	h := newApp(t)
	store(t, h, "Passport numbers", "L898902C3\n\n7727833B1\n\n3041005D9")
	body := get(t, h, "/?q=passport").Body.String()
	// Count the result rows, not the title text. The same page lists
	// every document below the results, so asserting on the title alone
	// passes on a 0-result page — which is how the first draft of this
	// test passed against the very bug it was written for.
	if n := strings.Count(body, "rst-result-title"); n != 1 {
		t.Errorf("a term that appears only in the title returns %d results, want 1:\n%s", n, body)
	}
}

// The title must not drown the body. Indexing the title into every chunk
// makes it a term in each one; this checks a body match still ranks and
// that the title has not become the only thing that matches.
func TestBodyStillMatchesWhenTitleIsIndexed(t *testing.T) {
	h := newApp(t)
	store(t, h, "Passport numbers", "The renewal fee rose in June.")
	body := get(t, h, "/?q=renewal").Body.String()
	if n := strings.Count(body, "rst-result-title"); n != 1 {
		t.Errorf("body term returns %d results, want 1:\n%s", n, body)
	}
}