package slidestest

import (
	"bytes"
	"encoding/xml"
	"errors"
	"io"
	"net/http"
	"net/http/httptest"
	"regexp"
	"strings"
	"testing"
)

// slideIDOn finds the slide the editor page opened on — the id every
// thumbnail route in this file then asks for.
var slideIDOn = regexp.MustCompile(`data-slide="([a-z2-7]{12})"`)

func currentSlideID(t *testing.T, a *testApp, deckPath string, cookies []*http.Cookie) string {
	t.Helper()
	page := mustGet(t, a, deckPath+"/edit", http.StatusOK, cookies).Body.String()
	m := slideIDOn.FindStringSubmatch(page)
	if m == nil {
		t.Fatalf("no current slide id on the editor page:\n%s", page)
	}
	return m[1]
}

// wellFormed insists the body parses as XML and is rooted at an <svg>.
// Every assertion in this file about a thumbnail leans on it: a picture
// that will not parse is not a picture, and a browser shows nothing at
// all for one rather than saying why.
func wellFormed(t *testing.T, body []byte) {
	t.Helper()
	dec := xml.NewDecoder(bytes.NewReader(body))
	root := ""
	for {
		tok, err := dec.Token()
		if errors.Is(err, io.EOF) {
			break
		}
		if err != nil {
			t.Fatalf("the thumbnail is not well-formed XML: %v\n%s", err, body)
		}
		if s, ok := tok.(xml.StartElement); ok && root == "" {
			root = s.Name.Local
		}
	}
	if root != "svg" {
		t.Fatalf("the thumbnail is rooted at <%s>, want <svg>:\n%s", root, body)
	}
}

// thumbHeaders is the header set every surface's thumbnail carries.
func checkThumbHeaders(t *testing.T, rec *httptest.ResponseRecorder, where string) {
	t.Helper()
	for _, c := range []struct{ header, want string }{
		{"Content-Type", "image/svg+xml; charset=utf-8"},
		{"X-Content-Type-Options", "nosniff"},
		{"Cache-Control", "private, max-age=0, must-revalidate"},
		{"Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:"},
	} {
		if got := rec.Header().Get(c.header); got != c.want {
			t.Errorf("%s: %s = %q, want %q", where, c.header, got, c.want)
		}
	}
	if rec.Header().Get("ETag") == "" {
		t.Errorf("%s: no ETag, so every keystroke refetches every thumbnail", where)
	}
}

// TestSlideThumbnailIsAnSVGOfTheSlide: the signed-in route answers a
// picture, headed as one, with the slide's own label as its accessible
// name.
func TestSlideThumbnailIsAnSVGOfTheSlide(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	id := currentSlideID(t, a, path, cookies)

	rec := mustGet(t, a, path+"/slides/"+id+".svg", http.StatusOK, cookies)
	checkThumbHeaders(t, rec, "the signed-in route")
	body := rec.Body.Bytes()
	wellFormed(t, body)

	if !bytes.Contains(body, []byte(`role="img"`)) {
		t.Errorf("the thumbnail is not announced as a picture:\n%s", body)
	}
	if !bytes.Contains(body, []byte(`viewBox="0 0 1920 1080"`)) {
		t.Errorf("the thumbnail is not the 16:9 frame:\n%s", body)
	}
	if !bytes.Contains(body, []byte("<title>Welcome to Slides</title>")) {
		t.Errorf("the thumbnail is not named after the slide:\n%s", body)
	}
	// The words of the slide are IN the picture, as text and not as a
	// bitmap: a thumbnail is searchable, selectable and readable by a
	// screen reader that opens it, and it is the same file the export
	// is made of.
	if !bytes.Contains(body, []byte("<text")) {
		t.Errorf("the thumbnail has no text in it:\n%s", body)
	}
}

// The tag is the deck's seq and the slide: an unchanged deck answers
// 304 with no body, which is what makes a strip that refetches nine
// thumbnails after every save cheap.
func TestSlideThumbnailRevalidatesOnItsTag(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	id := currentSlideID(t, a, path, cookies)
	target := path + "/slides/" + id + ".svg"

	first := mustGet(t, a, target, http.StatusOK, cookies)
	etag := first.Header().Get("ETag")

	req := httptest.NewRequest(http.MethodGet, target, nil)
	for _, c := range cookies {
		req.AddCookie(c)
	}
	req.Header.Set("If-None-Match", etag)
	rec := httptest.NewRecorder()
	a.ServeHTTP(rec, req)
	if rec.Code != http.StatusNotModified {
		t.Fatalf("a matching tag answered %d, want 304\n%s", rec.Code, rec.Body)
	}
	if rec.Body.Len() != 0 {
		t.Errorf("the 304 carried %d bytes", rec.Body.Len())
	}
	if got := rec.Header().Get("ETag"); got != etag {
		t.Errorf("the 304's ETag is %q, want %q", got, etag)
	}
}

// ?w= is accepted and changes nothing about the bytes — an SVG scales
// — but it IS in the tag, so a raster twin can land later without a
// cache in between already holding one size for every width.
func TestThumbnailWidthIsAcceptedAndIsInTheTag(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	id := currentSlideID(t, a, path, cookies)

	plain := mustGet(t, a, path+"/slides/"+id+".svg", http.StatusOK, cookies)
	narrow := mustGet(t, a, path+"/slides/"+id+".svg?w=180", http.StatusOK, cookies)
	if !bytes.Equal(plain.Body.Bytes(), narrow.Body.Bytes()) {
		t.Error("?w= changed the bytes; an SVG scales, so it should not have")
	}
	if plain.Header().Get("ETag") == narrow.Header().Get("ETag") {
		t.Errorf("both widths share the tag %q", plain.Header().Get("ETag"))
	}
}

// A slide this deck does not have is a 404 with no tag on it: a tag on
// "there is no such slide" invites a cache to treat the absence as the
// thing.
func TestAMissingSlideHasNoThumbnail(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)

	rec := mustGet(t, a, path+"/slides/aaaaaaaaaaaa.svg", http.StatusNotFound, cookies)
	if got := rec.Header().Get("ETag"); got != "" {
		t.Errorf("the 404 carries ETag %q", got)
	}
}

// The `.html` twin still works: the stage swaps real markup in, and
// ?vp=thumb is still a desktop rendering (editor.go's rule). The strip
// no longer asks for it; the Both view still can.
func TestTheSlideHTMLRouteStillServesTheSameSlide(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	id := currentSlideID(t, a, path, cookies)

	html := mustGet(t, a, path+"/slides/"+id+".html?vp=thumb", http.StatusOK, cookies)
	if ct := html.Header().Get("Content-Type"); !strings.HasPrefix(ct, "text/html") {
		t.Errorf("the .html route answers %q", ct)
	}
	if !strings.HasPrefix(strings.TrimSpace(html.Body.String()), "<section slides-slide") {
		t.Errorf("the .html route is not a bare section:\n%s", html.Body)
	}
}

// ── The other three surfaces ─────────────────────────────────────────

// A share link reaches the thumbnails, because the presenter view and
// the strip are not the only things that show a slide small — and
// because the token is the whole capability, exactly as it is for the
// page and for the pictures on it.
func TestShareLinkReachesTheThumbnails(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	id := currentSlideID(t, a, path, cookies)
	token := mintShareLink(t, a, path, cookies)

	rec := get(t, a, "/s/"+token+"/slides/"+id+".svg")
	if rec.Code != http.StatusOK {
		t.Fatalf("GET /s/{token}/slides/{id}.svg: status %d, want 200\n%s", rec.Code, rec.Body)
	}
	checkThumbHeaders(t, rec, "the share route")
	wellFormed(t, rec.Body.Bytes())

	// Revoking the link closes the thumbnails with the page.
	page := mustGet(t, a, path+"/share", http.StatusOK, cookies).Body.String()
	m := revokeAction.FindStringSubmatch(page)
	if m == nil {
		t.Fatalf("no revoke form on the share page:\n%s", page)
	}
	if rec := post(t, a, path+"/share/"+m[1]+"/revoke", nil, cookies...); rec.Code != http.StatusSeeOther {
		t.Fatalf("revoke: status %d", rec.Code)
	}
	if rec := get(t, a, "/s/"+token+"/slides/"+id+".svg"); rec.Code != http.StatusNotFound {
		t.Errorf("a revoked link still draws thumbnails: status %d", rec.Code)
	}
}

// The presentation surface serves them too: the presenter's notes
// window and the remote both show the current slide and the next one
// small, and neither has a session.
func TestPresentationReachesTheThumbnails(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	id := currentSlideID(t, a, path, cookies)
	session, _ := startPresenting(t, a, path, cookies)

	rec := get(t, a, "/p/"+session+"/slides/"+id+".svg")
	if rec.Code != http.StatusOK {
		t.Fatalf("GET /p/{session}/slides/{id}.svg: status %d, want 200\n%s", rec.Code, rec.Body)
	}
	checkThumbHeaders(t, rec, "the presentation route")
	wellFormed(t, rec.Body.Bytes())
}

// The API twin, for an agent that wants to LOOK at what it made
// (§7.2). Same bytes, same tag, the API's own 404 shape.
func TestAgentCanFetchASlideAsAPicture(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	id := currentSlideID(t, a, path, cookies)
	sqid := strings.TrimPrefix(path, "/d/")
	token := mintAgent(t, a, cookies, "claude")

	rec := send(t, a, bearerRequest(t, http.MethodGet,
		"/api/v1/decks/"+sqid+"/slides/"+id+".svg", token, ""))
	if rec.Code != http.StatusOK {
		t.Fatalf("GET the API thumbnail: status %d, want 200\n%s", rec.Code, rec.Body)
	}
	checkThumbHeaders(t, rec, "the API route")
	wellFormed(t, rec.Body.Bytes())

	// A slide that is not there answers the API's JSON, not a page.
	apiJSON(t, a, http.MethodGet, "/api/v1/decks/"+sqid+"/slides/aaaaaaaaaaaa.svg",
		token, "", http.StatusNotFound)

	// And without a token, nothing.
	anon := send(t, a, bearerRequest(t, http.MethodGet,
		"/api/v1/decks/"+sqid+"/slides/"+id+".svg", "", ""))
	if anon.Code != http.StatusUnauthorized {
		t.Errorf("an unauthenticated API thumbnail answered %d, want 401", anon.Code)
	}
}

// A stranger with a session of their own cannot draw somebody else's
// deck: the thumbnail goes through deckFor like every other read.
func TestAThumbnailIsBehindTheDecksOwnGate(t *testing.T) {
	a := newSharedApp(t)
	owner := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, owner)
	id := currentSlideID(t, a, path, owner)

	stranger := signedIn(t, a, otherAddress)
	if rec := get(t, a, path+"/slides/"+id+".svg", stranger...); rec.Code != http.StatusNotFound {
		t.Errorf("a stranger drew somebody else's slide: status %d", rec.Code)
	}
	if rec := get(t, a, path+"/slides/"+id+".svg"); rec.Code == http.StatusOK {
		t.Error("a signed-out request drew a private slide")
	}
}