package memoriatest

import (
	"context"
	"io"
	"log/slog"
	"net/http"
	"path/filepath"
	"strconv"
	"strings"
	"testing"

	"amadan.net/rastrillo/rastrillo/db"

	"amadan.net/oficina/memoria/internal/memoria"
	"amadan.net/oficina/memoria/internal/memoria/provider"
)

// noLayoutHere is every declared GET route that renders no page layout
// under this harness, and why. A route missing from here that renders no
// footer fails the walk.
var noLayoutHere = map[string]string{
	// Each reason is VERIFIED, not assumed — a review found two of the
	// first set were guesses stated as facts: "/native/*: not wired by
	// AppForTest" (it is wired) and "/auth/*: sign-in redirect" (with Home
	// configured, four of them render the footer on failure).
	"GET /search":              "the results fragment search.js swaps into a page; renders the results define alone, no layout",
	"GET /api/native/session":  "JSON for the native client",
	"GET /native/start":        "wired by AppForTest, but 404 without a pending native request id; with one it redirects (303)",
	"GET /native/authorize":    "wired by AppForTest, but 404 without a pending id; with one it serves the native library's standalone consent template, which has no layout footer",
	"GET /auth/local/complete": "a redirect on every GET path — the Home navigation guard either passes and redirects, or redirects; it renders nothing (read in home/connect navigation.go)",
	// The sign-in pages carry no footer at all: the count and the egress
	// claim are said only to somebody signed in (layout.html; shared chrome
	// §9.2 retires the claim there). memoria.TestHomePagesStateTheModelSwitch
	// asserts the absence with Home configured.
	"GET /signed-out":   "a sign-in page: no footer by design (layout.html's .Frame.Signed)",
	"GET /signin/local": "Home-only, and a sign-in page: no footer by design — memoria.TestHomePagesStateTheModelSwitch",
	// AppForTest is signed in, and a signed-in GET /signin skips the form.
	"GET /signin":      "signed in under this harness, so it answers 303 to the index (localSignin's shortcut) and renders nothing",
	"GET /auth/landed": "a redirect: where a verified link lands, and on to the remembered page (return.go)",
	// These render the footer when Home is configured, which this harness
	// does not do. They are checked there, by name, including their
	// failure pages at 400.
	"GET /account/home":         "Home-only — memoria.TestHomePagesStateTheModelSwitch",
	"GET /account/home/confirm": "Home-only — memoria.TestHomePagesStateTheModelSwitch",
	"GET /auth/start":           "Home-only; its failure page renders the footer — memoria.TestHomePagesStateTheModelSwitch",
	"GET /auth/finish":          "Home-only; its failure page renders the footer — memoria.TestHomePagesStateTheModelSwitch",
	"GET /auth/callback":        "no sign-in wired here; with Home its LocalGuard failure renders the footer — memoria.TestHomePagesStateTheModelSwitch",
	"GET /auth/verify":          "no sign-in wired here; with Home its LocalGuard failure renders the footer — memoria.TestHomePagesStateTheModelSwitch",
}

// countingModel is a stand-in model that counts calls and points at any
// "address: " line, as a compliant model would.
type countingModel struct{ calls int }

func (m *countingModel) ExtractAddresses(_ context.Context, passages []string) ([]provider.Pointer, error) {
	m.calls++
	var out []provider.Pointer
	for i, p := range passages {
		if j := strings.Index(p, "address: "); j >= 0 {
			line := p[j+len("address: "):]
			if k := strings.IndexByte(line, '\n'); k >= 0 {
				line = line[:k]
			}
			out = append(out, provider.Pointer{Passage: i, Text: line})
		}
	}
	return out, nil
}

// appWithModel is newApp with the model layer switched on by a stand-in,
// and a document stored so every page has something to show.
func appWithModel(t *testing.T, m memoria.Extractor) (http.Handler, int64) {
	t.Helper()
	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
	d, err := db.Open(filepath.Join(t.TempDir(), "app.db"), logger)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { d.Close() })
	mux, a, err := memoria.AppForTest(d, testOrigin, testDEK(t), logger)
	if err != nil {
		t.Fatal(err)
	}
	if m != nil {
		a.UseFakeModel(m)
	}
	id, err := a.Store().Ingest(context.Background(), memoria.IngestSpec{
		Source: "upload", Key: "office", Title: "Tito office",
		Body: "## Contact\n\nOffice address: 12 Main Street, Dublin 2",
	})
	if err != nil {
		t.Fatal(err)
	}
	return mux, id
}

// footers requests every declared GET route and returns the footer of
// each page that has one, keyed by route. Walking declaredChiRoutes rather
// than a hand-written list is the point: the first build of §8.9 updated
// the README and missed the footer on every page, and a list of pages
// written by the same hand misses a page the same way.
func footers(t *testing.T, h http.Handler, docID int64) map[string]string {
	t.Helper()
	out := map[string]string{}
	for route := range declaredChiRoutes {
		method, path, _ := strings.Cut(route, " ")
		if method != "GET" {
			continue
		}
		path = strings.ReplaceAll(path, "{id}", strconv.FormatInt(docID, 10))
		rec := get(t, h, path)
		body := rec.Body.String()
		i := strings.Index(body, "<footer")
		// A footer is checked at WHATEVER status it renders with: an error
		// page carries the same footer and the same claim. The first
		// version checked 200s only.
		if i < 0 {
			// **A skip has to be explained**, or the walk proves less than
			// it says. Every route below renders no layout under this
			// harness, for the reason given; anything else that fails to
			// render a footer is a page this gate cannot see, and it fails
			// rather than passing quietly. (The first version skipped
			// silently, and seven routes went unchecked.)
			if why, ok := noLayoutHere[route]; !ok {
				t.Errorf("%s returned %d with no footer, and is not a known non-page route; "+
					"the footer check cannot see it", route, rec.Code)
			} else if why == "" {
				t.Errorf("%s: skipped without a reason", route)
			}
			continue
		}
		// Whitespace collapsed, as a browser renders it: the template wraps
		// its sentences across source lines, and a substring search over
		// the raw bytes misses "leaves this\n    instance".
		out[route] = strings.Join(strings.Fields(body[i:]), " ")
	}
	return out
}

// **The footer's egress claim is right on every page, with AI on and off.**
//
// With AI on, "no document ever leaves this instance" is FALSE — a search
// that asks for a postal address has just sent passages to TensorX — and
// the first build of §8.9 printed it on every page anyway, including the
// response to the search that sent them. Found by review, reproduced by
// sending a passage and reading this footer back.
func TestTheFooterStatesTheModelSwitch(t *testing.T) {
	m := &countingModel{}
	on, id := appWithModel(t, m)

	// Presence: the model really is reached. Without this, every "the
	// footer names TensorX" below is a statement about an app that never
	// sends anything.
	if body := get(t, on, "/?q=office+address").Body.String(); !strings.Contains(body, "12 Main Street, Dublin 2") {
		t.Fatal("the address search did not render a model row")
	}
	if m.calls == 0 {
		t.Fatal("the model was never called; the footers below prove nothing")
	}

	withAI := footers(t, on, id)
	// A page may make NO egress claim — /help/open-source deliberately
	// renders an empty footer — and that is fine: an absent claim is not a
	// false one. What is checked is every page that makes a claim, and
	// there must be enough of those to mean something.
	claims := 0
	for route, f := range withAI {
		// Never the zero-egress claim while AI is on, on any page.
		if strings.Contains(f, "no document ever") {
			t.Errorf("%s: with AI on the footer still says no document ever leaves", route)
		}
		if strings.Contains(f, "leaves this instance") {
			claims++
			if !strings.Contains(f, "TensorX") {
				t.Errorf("%s: with AI on the footer makes an egress claim without naming TensorX", route)
			}
		}
	}
	// Index, a document, sign-in, the connectors: fewer means the walk
	// stopped finding pages, and the loop above proved nothing.
	if claims < 4 {
		t.Fatalf("only %d pages made an egress claim with AI on: %v", claims, keys(withAI))
	}

	// And the strong claim still appears when it is TRUE.
	off, id2 := appWithModel(t, nil)
	offClaims := 0
	for route, f := range footers(t, off, id2) {
		if strings.Contains(f, "TensorX") {
			t.Errorf("%s: with AI off the footer names a provider nothing is sent to", route)
		}
		if strings.Contains(f, "leaves this instance") {
			offClaims++
			if !strings.Contains(f, "no document ever") {
				t.Errorf("%s: with AI off the footer does not make the true, strong claim", route)
			}
		}
	}
	if offClaims != claims {
		t.Errorf("%d pages make a claim with AI off against %d with it on", offClaims, claims)
	}
}

func keys(m map[string]string) []string {
	var out []string
	for k := range m {
		out = append(out, k)
	}
	return out
}