package slidestest

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

// bundleLink finds the editor bundle's script tag on a page: the one
// committed file under internal/slides/static, served through the
// fingerprinted asset handler.
var bundleLink = regexp.MustCompile(`/static/editor\.[0-9a-f]{16}(\.[0-9a-f]{16})?\.js`)

// TestEditorPageLinksTheCommittedBundle: GET /d/{sqid}/edit is the one
// screen that needs the bundle (spec §8), and the page carries
// everything the bundle reads back — the deck, the seq, the current
// slide, the person — as data rather than as script. The strip and the
// stage are server-rendered too, so the first paint is right before a
// byte of JS has run.
func TestEditorPageLinksTheCommittedBundle(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	sqid := strings.TrimPrefix(path, "/d/")

	page := mustGet(t, a, path+"/edit", http.StatusOK, cookies).Body.String()

	src := bundleLink.FindString(page)
	if src == "" {
		t.Fatalf("the editor page links no committed bundle:\n%s", page)
	}
	if !strings.Contains(page, `type="module"`) {
		t.Errorf("the bundle is an ES module and must be loaded as one:\n%s", page)
	}
	js := mustGet(t, a, src, http.StatusOK, nil)
	if ct := js.Header().Get("Content-Type"); !strings.HasPrefix(ct, "text/javascript") {
		t.Errorf("GET %s: Content-Type = %q, want text/javascript", src, ct)
	}
	if !strings.Contains(js.Header().Get("Cache-Control"), "immutable") {
		t.Errorf("GET %s: Cache-Control = %q, want immutable", src, js.Header().Get("Cache-Control"))
	}
	for _, css := range []string{"editor", "slides"} {
		if !regexp.MustCompile(`/static/` + css + `\.[0-9a-f]{16}\.css`).MatchString(page) {
			t.Errorf("the editor page links no fingerprinted %s.css:\n%s", css, page)
		}
	}

	for _, attr := range []string{
		`data-deck="` + sqid + `"`,
		`data-seq="`,
		`data-slide="`,
		`data-client-name="`,
		`data-client-colour="`,
	} {
		if !strings.Contains(page, attr) {
			t.Errorf("the editor page carries no %s:\n%s", attr, page)
		}
	}
	if strings.Contains(page, `data-slide=""`) {
		t.Errorf("the sample deck has slides, so data-slide must name the first one:\n%s", page)
	}

	// The strip: one <li> per slide, each an <img> of the server's SVG
	// of it (thumbs.go), the current one saying so in words.
	// The <template> the bundle clones for a new slide is an item too,
	// with no slide id; the eight with one are the deck's.
	if n := strings.Count(page, `<li slides-strip-item draggable="true" data-slide-id="`); n != 8 {
		t.Errorf("the strip lists %d slides, want the sample deck's 8:\n%s", n, page)
	}
	// One section on the page, and it is the stage. The strip used to
	// carry eight more — a whole live copy of every slide, scaled down
	// by CSS — and each is now one picture.
	if n := strings.Count(page, "<section slides-slide"); n != 1 {
		t.Errorf("the page renders %d sections, want only the stage:\n%s", n, page)
	}
	if n := strings.Count(page, `<img slides-thumb-img src="`); n != 8 {
		t.Errorf("the strip has %d thumbnails with a picture, want the sample deck's 8:\n%s", n, page)
	}
	if !strings.Contains(page, `.svg?seq=`) {
		t.Errorf("a strip thumbnail does not point at the SVG route:\n%s", page)
	}
	if !strings.Contains(page, `aria-current="true"`) {
		t.Errorf("no strip item is marked current:\n%s", page)
	}
	if !strings.Contains(page, "Current slide") {
		t.Errorf("the current slide is not said in words:\n%s", page)
	}
	if !strings.Contains(page, sampleSlide2Heading) {
		t.Errorf("the strip does not label slide 2 by its heading:\n%s", page)
	}

	// The status line, with every state's text server-rendered from the
	// catalog so the bundle never carries English.
	for _, want := range []string{`data-text-saved="Saved"`, `data-text-saving="Saving…"`, `data-text-retrying="Offline, retrying"`, `data-text-failed="Some changes could not be saved. Reload to continue."`, "<noscript>"} {
		if !strings.Contains(page, want) {
			t.Errorf("the editor page lacks %s:\n%s", want, page)
		}
	}
	if !strings.Contains(page, `href="`+path+`"`) {
		t.Errorf("the noscript fallback does not link the viewer:\n%s", page)
	}
	// Every shortcut has a visible menu equivalent.
	for _, want := range []string{"New slide", "Duplicate slide", `action="` + path + `/present"`} {
		if !strings.Contains(page, want) {
			t.Errorf("the editor's menu lacks %s:\n%s", want, page)
		}
	}
}

// TestEditorRequiresMembership: the editor is deckFor's audience — the
// owner and, on a team deck, every member — and 404 to anybody else, so
// the sqid of a private deck stays unconfirmed. The viewer offers the
// Edit button to exactly the people the editor lets in.
func TestEditorRequiresMembership(t *testing.T) {
	a := newSharedApp(t)
	mine := signedIn(t, a, allowedAddress)
	theirs := signedIn(t, a, otherAddress)

	path := createDeck(t, a, mine, "Board update")
	mustGet(t, a, path+"/edit", http.StatusNotFound, theirs)
	mustGet(t, a, path+"/edit", http.StatusOK, mine)

	owner := mustGet(t, a, path, http.StatusOK, mine).Body.String()
	if !strings.Contains(owner, `href="`+path+`/edit"`) {
		t.Errorf("the owner's viewer offers no Edit:\n%s", owner)
	}

	if rec := post(t, a, path+"/settings", url.Values{
		"title": {"Board update"}, "theme": {"ink"}, "rung": {"team"},
	}, mine...); rec.Code != http.StatusSeeOther {
		t.Fatalf("raising the rung: status %d\n%s", rec.Code, rec.Body)
	}
	mustGet(t, a, path+"/edit", http.StatusOK, theirs)
	member := mustGet(t, a, path, http.StatusOK, theirs).Body.String()
	if !strings.Contains(member, `href="`+path+`/edit"`) {
		t.Errorf("a member's viewer offers no Edit:\n%s", member)
	}

	// Signed out, the editor is behind the gate like every other
	// signed-in screen: a redirect to sign in, never the page.
	if rec := get(t, a, path+"/edit"); rec.Code != http.StatusSeeOther && rec.Code != http.StatusFound {
		t.Errorf("GET %s/edit signed out: status %d, want a redirect to /signin", path, rec.Code)
	}
}

// TestEditorOfAnEmptyDeck: a deck with no slides is a real state (the
// viewer's own rule), so the editor opens on it with no current slide
// and a way to make the first one, rather than a 404 or a 500.
func TestEditorOfAnEmptyDeck(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := createDeck(t, a, cookies, "Blank")
	sqid := strings.TrimPrefix(path, "/d/")

	// A new deck opens with one slide; an agent takes it away, which
	// is the only way a deck ends up with none.
	token := mintAgent(t, a, cookies, "claude")
	before := mustGet(t, a, path+"/edit", http.StatusOK, cookies).Body.String()
	m := regexp.MustCompile(`data-slide="([a-z2-7]{12})"`).FindStringSubmatch(before)
	if m == nil {
		t.Fatalf("a new deck's editor names no current slide:\n%s", before)
	}
	apiJSON(t, a, http.MethodPost, "/api/v1/decks/"+sqid+"/ops", token,
		`{"ops":[{"op":"remove_slide","id":"`+m[1]+`"}]}`, http.StatusOK)

	page := mustGet(t, a, path+"/edit", http.StatusOK, cookies).Body.String()
	if !strings.Contains(page, `data-slide=""`) {
		t.Errorf("an empty deck's editor names a current slide:\n%s", page)
	}
	if !strings.Contains(page, "No slides yet") {
		t.Errorf("an empty deck's editor does not say so:\n%s", page)
	}
	if !strings.Contains(page, "New slide") {
		t.Errorf("an empty deck's editor offers no way to add a slide:\n%s", page)
	}
}

// TestEditorSlideHTMLServesTheThumbnailViewport: ?vp=thumb is the strip's
// rendering and is the desktop one — a thumbnail is a desktop slide
// scaled by CSS, never a third rendering.
func TestEditorSlideHTMLServesTheThumbnailViewport(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)

	page := mustGet(t, a, path+"/edit", http.StatusOK, cookies).Body.String()
	m := regexp.MustCompile(`data-slide="([a-z2-7]{12})"`).FindStringSubmatch(page)
	if m == nil {
		t.Fatalf("no current slide id on the editor page:\n%s", page)
	}
	thumb := mustGet(t, a, path+"/slides/"+m[1]+".html?vp=thumb", http.StatusOK, cookies).Body.String()
	if !strings.HasPrefix(thumb, "<section slides-slide") {
		t.Errorf("the thumbnail is not a bare section:\n%s", thumb)
	}
	if strings.Contains(thumb, `data-vp="phone"`) {
		t.Errorf("the thumbnail rendered as a phone:\n%s", thumb)
	}
}

// TestEditorInspectorMarkupIsFormsWithLabels: every control in the
// inspector is a real form control with a name — a <label for> that
// names its id, or a wrapping <label> (the switch's shape) — whether or
// not the bundle has it on screen. The scan is a walk of the tags in
// [slides-inspector]: a control inside a <label> passes, a control with
// an id that some <label for> names passes, anything else fails by
// name. It also checks the three sections are forms and the eleven
// block types are in the add menu, the way a keyboard reaches them.
func TestEditorInspectorMarkupIsFormsWithLabels(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	page := mustGet(t, a, path+"/edit", http.StatusOK, cookies).Body.String()

	start := strings.Index(page, "<details slides-inspector")
	end := strings.Index(page, "<dialog slides-link-dialog")
	if start < 0 || end < start {
		t.Fatalf("no inspector on the page:\n%s", page)
	}
	inspector := page[start:end]

	labelFor := map[string]bool{}
	for _, m := range regexp.MustCompile(`<label[^>]*\sfor="([^"]+)"`).FindAllStringSubmatch(inspector, -1) {
		labelFor[m[1]] = true
	}
	tag := regexp.MustCompile(`<(/?)(label|input|select|textarea)\b([^>]*)>`)
	idAttr := regexp.MustCompile(`\sid="([^"]+)"`)
	nameAttr := regexp.MustCompile(`\sname="([^"]+)"`)
	depth, controls := 0, 0
	for _, m := range tag.FindAllStringSubmatch(inspector, -1) {
		closing, name, attrs := m[1] == "/", m[2], m[3]
		if name == "label" {
			if closing {
				depth--
			} else {
				depth++
			}
			continue
		}
		if closing {
			continue
		}
		controls++
		if depth > 0 {
			continue
		}
		id := idAttr.FindStringSubmatch(attrs)
		if id == nil {
			t.Errorf("an inspector <%s> has no label and no id: <%s%s>", name, name, attrs)
			continue
		}
		if !labelFor[id[1]] {
			t.Errorf("no <label for=%q> names the inspector's <%s%s>", id[1], name, attrs)
		}
		if n := nameAttr.FindStringSubmatch(attrs); n == nil {
			t.Errorf("the inspector's %s has no name", id[1])
		}
	}
	if controls < 30 {
		t.Errorf("the inspector holds %d controls, want the deck, slide and block sections' worth", controls)
	}
	for _, section := range []string{"deck", "slide", "block"} {
		if !strings.Contains(inspector, `data-section="`+section+`"`) {
			t.Errorf("the inspector has no form for the %s section", section)
		}
	}
	if n := strings.Count(inspector, "<form "); n != 3 {
		t.Errorf("the inspector holds %d forms, want 3", n)
	}
	for _, kind := range []string{"heading", "text", "list", "quote", "image", "columns", "code", "shape", "table", "divider", "spacer"} {
		if !strings.Contains(inspector, `data-add-block="`+kind+`"`) {
			t.Errorf("the add menu lists no %s", kind)
		}
	}
	// The strip's menu, the switcher and the canvas overlay carry their
	// words from the catalog too.
	for _, want := range []string{
		`data-slide-command="move-up"`, `name="slides-view" value="phone"`, `data-text-phone-override="Phone override"`,
		`data-type-heading="Heading"`, `<template slides-strip-item-template>`,
	} {
		if !strings.Contains(page, want) {
			t.Errorf("the editor page lacks %s:\n%s", want, page)
		}
	}
}

// TestEditorSlideHTMLAnswers304ToItsOwnETag: the stage sends the tag
// back on its next fetch, and an unchanged slide costs the server no
// document open. A different seq is a different tag.
func TestEditorSlideHTMLAnswers304ToItsOwnETag(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := sampleDeck(t, a, cookies)
	page := mustGet(t, a, path+"/edit", http.StatusOK, cookies).Body.String()
	m := regexp.MustCompile(`data-slide="([a-z2-7]{12})"`).FindStringSubmatch(page)
	if m == nil {
		t.Fatalf("no current slide id on the editor page:\n%s", page)
	}
	target := path + "/slides/" + m[1] + ".html?vp=desktop"
	first := mustGet(t, a, target, http.StatusOK, cookies)
	etag := first.Header().Get("ETag")
	if etag == "" {
		t.Fatalf("the slide HTML carries no 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.Errorf("GET with the slide's own ETag: status %d, want 304", rec.Code)
	}
	if rec.Body.Len() != 0 {
		t.Errorf("a 304 carried a body:\n%s", rec.Body)
	}
	// The phone rendering of the same slide at the same seq is other
	// bytes, and says so.
	phone := mustGet(t, a, path+"/slides/"+m[1]+".html?vp=phone", http.StatusOK, cookies)
	if phone.Header().Get("ETag") == etag {
		t.Errorf("the phone rendering shares the desktop's ETag %s", etag)
	}
}

// TestEditorOfAnEmptyDeckHasAStage: the stage and the notes pane are on
// the page whether or not there is a slide, because New slide loads
// the first slide INTO the stage; the empty state sits inside it until
// then (task 3 review round 1, finding 1).
func TestEditorOfAnEmptyDeckHasAStage(t *testing.T) {
	a := newApp(t)
	cookies := signedIn(t, a, allowedAddress)
	path := createDeck(t, a, cookies, "Blank")
	sqid := strings.TrimPrefix(path, "/d/")
	token := mintAgent(t, a, cookies, "claude")
	before := mustGet(t, a, path+"/edit", http.StatusOK, cookies).Body.String()
	m := regexp.MustCompile(`data-slide="([a-z2-7]{12})"`).FindStringSubmatch(before)
	if m == nil {
		t.Fatalf("a new deck's editor names no current slide:\n%s", before)
	}
	apiJSON(t, a, http.MethodPost, "/api/v1/decks/"+sqid+"/ops", token,
		`{"ops":[{"op":"remove_slide","id":"`+m[1]+`"}]}`, http.StatusOK)

	page := mustGet(t, a, path+"/edit", http.StatusOK, cookies).Body.String()
	stage := regexp.MustCompile(`(?s)<div slides-stage data-vp="desktop">(.*?)</div>\s*<div slides-stage-phone`).FindStringSubmatch(page)
	if stage == nil {
		t.Fatalf("an empty deck's editor has no [slides-stage]:\n%s", page)
	}
	if !strings.Contains(stage[1], "No slides yet") {
		t.Errorf("the empty state is not inside the stage:\n%s", stage[1])
	}
	if !strings.Contains(page, "<div slides-notes>") {
		t.Errorf("an empty deck's editor has no notes element:\n%s", page)
	}
}