package calendartest

import (
	"net/http"
	"net/url"
	"regexp"
	"strings"
	"testing"
	"time"

	calendar "amadan.net/oficina/calendar/internal/calendar"
)

// createEvent posts the real form and returns the new event's path.
func createEvent(t *testing.T, h http.Handler, session *http.Cookie, form url.Values) string {
	t.Helper()
	// Read the SELECTED option, not the first one — that is what a
	// browser submits when nobody touches the dropdown, and it is the
	// personal calendar rather than the shared team one. An earlier
	// version of this helper took the first option, silently created
	// every test event on the team calendar, and made the isolation
	// test look like an app bug.
	if form.Get("calendar_id") == "" {
		page := getAs(t, h, session, "/events/new").Body.String()
		m := regexp.MustCompile(`<option value="(\d+)"[^>]*\bselected\b`).FindStringSubmatch(page)
		if m == nil {
			t.Fatalf("no calendar is selected by default on the create form:\n%s", page)
		}
		form.Set("calendar_id", m[1])
	}
	rec := postAs(t, h, session, "/events", form)
	if rec.Code != http.StatusSeeOther {
		t.Fatalf("POST /events: status %d, want 303\n%s", rec.Code, rec.Body.String())
	}
	return rec.Header().Get("Location")
}

// The whole stack, end to end: a form submission becomes a sealed row,
// and the day page renders it back in the viewer's own zone.
func TestCreateAnEventAndSeeItOnTheDay(t *testing.T) {
	app, session := signedIn(t, "someone@example.com")
	h := app.Handler()

	loc := createEvent(t, h, session, url.Values{
		"title":  {"Standup"},
		"start":  {"2026-09-02T09:30"},
		"end":    {"2026-09-02T09:45"},
		"kind":   {"meeting"},
		"status": {"confirmed"},
		"repeat": {"none"},
	})
	if !strings.HasPrefix(loc, "/events/") {
		t.Fatalf("created event redirected to %q", loc)
	}

	page := getAs(t, h, session, "/day/2026-09-02")
	if page.Code != http.StatusOK {
		t.Fatalf("GET the day: status %d", page.Code)
	}
	body := page.Body.String()
	if !strings.Contains(body, "Standup") {
		t.Errorf("the event is missing from its own day:\n%s", body)
	}
	if !strings.Contains(body, "09:30") {
		t.Errorf("the day page does not show the event's time:\n%s", body)
	}
	// The sentence is computed from real events, so it must have
	// noticed this one.
	if !strings.Contains(body, "One thing") {
		t.Errorf("the day's sentence did not count the event:\n%s", body)
	}
}

// A title is content, and content is sealed. The proof is the raw
// SQLite file: nothing readable may be in it.
//
// This is the one rule's own test, and it greps the bytes rather than
// trusting that the sealing code was called — a column that was never
// sealed looks identical from Go and completely different on disk.
func TestTheDatabaseNeverHoldsAPlaintextTitle(t *testing.T) {
	app, session := signedIn(t, "someone@example.com")
	const secret = "Quarterly board meeting about the acquisition"

	createEvent(t, app.Handler(), session, url.Values{
		"title":    {secret},
		"location": {"The unmarked room"},
		"notes":    {"Do not tell anybody"},
		"start":    {"2026-09-02T09:30"},
		"end":      {"2026-09-02T10:30"},
		"kind":     {"meeting"},
		"status":   {"confirmed"},
		"repeat":   {"none"},
	})

	// WAL mode keeps recent writes out of the main file, so the
	// checkpoint is not optional: without it this test passes by
	// looking at a file the data has not reached yet.
	if _, err := app.DBForTest().Exec("PRAGMA wal_checkpoint(TRUNCATE)"); err != nil {
		t.Fatalf("checkpoint: %v", err)
	}

	for _, needle := range []string{secret, "The unmarked room", "Do not tell anybody"} {
		if found, where := app.GrepDatabaseForTest(t, needle); found {
			t.Errorf("%q appears in plaintext in %s", needle, where)
		}
	}
}

// The same rule for a booking: the page's text, the booker's name,
// address and note, and the management token are all content (booking
// spec §2.4, §9). A stranger's identity is who this team MEETS WITH,
// which is exactly what the bucket must not give up.
func TestTheDatabaseNeverHoldsAPlaintextBooker(t *testing.T) {
	app, mailer, path, _ := publishedPageTitled(t, "Interrogation about the acquisition", "Bring nothing", "mondays 12-3, every day 9-5")
	h := app.Handler()
	_, starts := futureDaySlots(t, h, path)
	form := holdForm(starts[0], "Dermot Lacey", "dermot.lacey@elsewhere.example")
	form.Set("note", "The folder")
	if rec := strangerPost(t, h, path, form); rec.Code != 200 {
		t.Fatalf("hold: %d", rec.Code)
	}
	token := strings.TrimPrefix(reManage.FindString(mailer.body(0)), "/book/m/")
	if _, err := app.DBForTest().Exec("PRAGMA wal_checkpoint(TRUNCATE)"); err != nil {
		t.Fatalf("checkpoint: %v", err)
	}
	for _, needle := range []string{"Interrogation about the acquisition", "Bring nothing", "mondays 12-3",
		"Dermot Lacey", "dermot.lacey@elsewhere.example", "The folder", token} {
		if found, where := app.GrepDatabaseForTest(t, needle); found {
			t.Errorf("%q appears in plaintext in %s", needle, where)
		}
	}
}

// A row that isn't yours doesn't exist — 404, never 403, so no id can
// be enumerated by watching which ones answer differently.
func TestAnotherPersonsEventIsNotFound(t *testing.T) {
	app, mine := signedIn(t, "me@example.com")
	h := app.Handler()

	loc := createEvent(t, h, mine, url.Values{
		"title":  {"Mine"},
		"start":  {"2026-09-02T09:30"},
		"end":    {"2026-09-02T10:00"},
		"kind":   {"meeting"},
		"status": {"confirmed"},
		"repeat": {"none"},
	})

	// A second person on the same instance. They share the team
	// calendar, so this event must be on a personal one to be hidden —
	// which is exactly why a new event defaults to the personal
	// calendar rather than the shared one.
	theirs := app.SignInForTest(t, "someone-else@example.com")
	rec := getAs(t, h, theirs, loc)
	if rec.Code != http.StatusNotFound {
		t.Errorf("GET %s as another person: status %d, want 404", loc, rec.Code)
	}
}

// A recurring event appears on every day the rule names, without any
// of those occurrences existing as rows.
func TestARecurringEventAppearsOnEveryDayItNames(t *testing.T) {
	app, session := signedIn(t, "someone@example.com")
	h := app.Handler()

	createEvent(t, h, session, url.Values{
		"title":  {"Daily standup"},
		"start":  {"2026-09-02T09:30"},
		"end":    {"2026-09-02T09:45"},
		"kind":   {"meeting"},
		"status": {"confirmed"},
		"repeat": {"daily"},
	})

	for _, day := range []string{"2026-09-02", "2026-09-03", "2026-09-10"} {
		body := getAs(t, h, session, "/day/"+day).Body.String()
		if !strings.Contains(body, "Daily standup") {
			t.Errorf("the series is missing from %s", day)
		}
	}
}

// A form that fails validation must give back what was typed. Losing
// it is the single most common way a form wastes somebody's time.
func TestARejectedFormKeepsWhatWasTyped(t *testing.T) {
	app, session := signedIn(t, "someone@example.com")

	rec := postAs(t, app.Handler(), session, "/events", url.Values{
		"title":       {"A meeting that ends before it starts"},
		"calendar_id": {"1"},
		"start":       {"2026-09-02T10:00"},
		"end":         {"2026-09-02T09:00"},
		"kind":        {"meeting"},
		"status":      {"confirmed"},
		"repeat":      {"none"},
	})
	if rec.Code != http.StatusUnprocessableEntity {
		t.Fatalf("status %d, want 422", rec.Code)
	}
	body := rec.Body.String()
	if !strings.Contains(body, "A meeting that ends before it starts") {
		t.Error("the rejected form lost the title that was typed")
	}
	if !strings.Contains(body, "It cannot end before it starts.") {
		t.Errorf("the rejected form does not say what was wrong:\n%s", body)
	}
}

// Every page must work with scripts off. The floor is that no page
// depends on one to be usable, so nothing here may carry an affordance
// that only a script can reach.
func TestEveryPageWorksWithoutScript(t *testing.T) {
	app, session := signedIn(t, "someone@example.com")
	h := app.Handler()
	today := time.Now().Format("2006-01-02")

	for _, target := range []string{
		"/today", "/day/" + today, "/week/" + today,
		"/month/" + today[:7], "/agenda", "/calendars",
		"/events/new", "/settings", "/import",
	} {
		rec := follow(t, h, session, target)
		if rec.Code != http.StatusOK {
			t.Errorf("GET %s: status %d, want 200", target, rec.Code)
			continue
		}
		body := rec.Body.String()
		// An onclick is the tell that an affordance was built as a
		// script hook rather than as a link or a form.
		if strings.Contains(body, "onclick=") {
			t.Errorf("GET %s carries an onclick handler; the scriptless floor is the product", target)
		}
	}
}

// The half-hour slots are what make "click a time to create an event"
// work with no JavaScript. They are ordinary links, and each one is
// named for a screen reader.
func TestTheDayOffersScriptlessSlotLinks(t *testing.T) {
	app, session := signedIn(t, "someone@example.com")
	body := getAs(t, app.Handler(), session, "/day/2026-09-02").Body.String()

	if n := strings.Count(body, "cal-slot"); n < 40 {
		t.Errorf("the day offers %d slot links, want one per half hour", n)
	}
	if !strings.Contains(body, "Create an event at 09:30") {
		t.Errorf("slot links carry no accessible name:\n%s", body[:min(2000, len(body))])
	}
	if !strings.Contains(body, "/events/new?start=2026-09-02T09%3A30") &&
		!strings.Contains(body, "/events/new?start=2026-09-02T09:30") {
		t.Error("a slot link does not prefill the form with its own time")
	}
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

var _ = calendar.MaxOccurrencesPerSeries