package calendartest

import (
	"context"
	"net/http"
	"net/url"
	"regexp"
	"strconv"
	"strings"
	"testing"
	"time"
)

// The host's side of booking, through the router (booking spec §2.1,
// §3.4, §7.4, B18, B25).

func settingsForm(handle string) url.Values {
	return url.Values{"zone": {"Europe/Dublin"}, "week_start": {"1"},
		"default_reminder_min": {"10"}, "default_all_day_min": {"360"}, "handle": {handle}}
}

func pageForm() url.Values {
	return url.Values{"title": {"Quick chat"}, "description": {"Fifteen minutes."},
		"availability": {"mondays 12-3, tuesdays 12-2, 5-7"}, "duration_min": {"15"},
		"buffer_min": {"10"}, "notice_min": {"120"}, "horizon_days": {"30"}}
}

var rePublicURL = regexp.MustCompile(`/book/paul/([a-z0-9]{8})`)

func TestAHostMakesAPageAndSeesItsLinkOnlyOncePublished(t *testing.T) {
	app, session := signedIn(t, "host@example.com")
	h := app.Handler()
	if rec := postAs(t, h, session, "/settings", settingsForm("paul")); rec.Code != http.StatusSeeOther {
		t.Fatalf("settings: %d\n%s", rec.Code, rec.Body.String())
	}
	if rec := postAs(t, h, session, "/settings/booking", pageForm()); rec.Code != http.StatusSeeOther {
		t.Fatalf("create: %d\n%s", rec.Code, rec.Body.String())
	}
	body := getAs(t, h, session, "/settings/booking").Body.String()
	for _, want := range []string{"Quick chat", "Not published", "Tuesday 12:00–14:00, 17:00–19:00", "Anyone with this link can see when you are free"} {
		if !strings.Contains(body, want) {
			t.Errorf("list lacks %q", want)
		}
	}
	if rePublicURL.MatchString(body) {
		t.Error("an unpublished page shows a public URL")
	}
	if rec := postAs(t, h, session, "/settings/booking/1/publish", url.Values{"publish": {"1"}}); rec.Code != http.StatusSeeOther {
		t.Fatalf("publish: %d", rec.Code)
	}
	body = getAs(t, h, session, "/settings/booking").Body.String()
	if !rePublicURL.MatchString(body) || !strings.Contains(body, "Published") {
		t.Errorf("a published page shows no public URL:\n%s", body)
	}
}

func TestAPageWithAnUnreadableSentenceIsNotSaved(t *testing.T) {
	app, session := signedIn(t, "host@example.com")
	h := app.Handler()
	postAs(t, h, session, "/settings", settingsForm("paul"))
	form := pageForm()
	form.Set("availability", "mondays whenever")
	rec := postAs(t, h, session, "/settings/booking", form)
	if rec.Code != http.StatusUnprocessableEntity {
		t.Fatalf("status %d, want 422", rec.Code)
	}
	if !strings.Contains(rec.Body.String(), "whenever") {
		t.Error("the refusal does not quote the clause")
	}
	if strings.Contains(getAs(t, h, session, "/settings/booking").Body.String(), "Quick chat") {
		t.Error("the page was saved anyway")
	}
}

func TestThePaneFragmentDescribesTheWindows(t *testing.T) {
	app, session := signedIn(t, "host@example.com")
	rec := postAs(t, app.Handler(), session, "/settings/booking/parse", url.Values{"text": {"fri 9-5"}})
	body := rec.Body.String()
	if !strings.Contains(body, "Friday 09:00–17:00") || strings.Contains(strings.ToLower(body), "<html") {
		t.Errorf("pane:\n%s", body)
	}
}

func TestAnotherPersonsBookingPageIs404(t *testing.T) {
	app, mine := signedIn(t, "me@example.com")
	h := app.Handler()
	postAs(t, h, mine, "/settings", settingsForm("me"))
	postAs(t, h, mine, "/settings/booking", pageForm())
	theirs := app.SignInForTest(t, "them@example.com")
	for _, c := range []struct {
		method, path string
	}{{"GET", "/settings/booking/1"}, {"POST", "/settings/booking/1"}, {"POST", "/settings/booking/1/publish"}} {
		var rec = getAs(t, h, theirs, c.path)
		if c.method == "POST" {
			rec = postAs(t, h, theirs, c.path, pageForm())
		}
		if rec.Code != http.StatusNotFound {
			t.Errorf("%s %s as another person: %d, want 404", c.method, c.path, rec.Code)
		}
	}
}

func TestATakenHandleIsRefusedOnSettings(t *testing.T) {
	app, a := signedIn(t, "a@example.com")
	h := app.Handler()
	postAs(t, h, a, "/settings", settingsForm("paul"))
	b := app.SignInForTest(t, "b@example.com")
	rec := postAs(t, h, b, "/settings", settingsForm("paul"))
	if rec.Code != http.StatusUnprocessableEntity || !strings.Contains(rec.Body.String(), "taken") {
		t.Errorf("second claim: %d\n%s", rec.Code, rec.Body.String())
	}
}

// A booked event's form: the scheduling controls are disabled and their
// stored values ride along hidden, so a scriptless title-only save
// works — and still works after the host changes their profile zone,
// because the hidden tz is the event's own (B25).
func TestABookedEventsFormLocksItsTimeButSavesItsTitle(t *testing.T) {
	// Keep this scenario independent of the machine's wall clock.  With
	// time.Now() it failed only when run between 14:00 and 15:00 UTC in
	// summer time, on any date (a sweep of every hour, 20-30 September,
	// failed at 14:17 and nowhere else): the stale-host bug the reread below
	// fixes. The first case is that hour, and fails without the reread;
	// the other two are either side of Dublin's DST boundaries.
	for _, now := range []struct {
		name string
		now  time.Time
	}{
		{"ci-failure-2026-09-24-1417Z", time.Date(2026, time.September, 24, 14, 17, 0, 0, time.UTC)},
		{"dublin-dst-start", time.Date(2026, time.March, 29, 13, 0, 0, 0, time.UTC)},
		{"dublin-dst-end", time.Date(2026, time.October, 25, 13, 0, 0, 0, time.UTC)},
	} {
		t.Run(now.name, func(t *testing.T) {
			testABookedEventsFormLocksItsTimeButSavesItsTitle(t, now.now)
		})
	}
}

func testABookedEventsFormLocksItsTimeButSavesItsTitle(t *testing.T, now time.Time) {
	app, host, page := hostWithPage(t)
	h := app.Handler()
	session := app.SignInForTest(t, host.Address)
	st := app.StoreForTest()
	slot := slotsFor(t, app, page, host, now, 3)[0]
	b, err := st.HoldBooking(context.Background(), holdInput(page, host, slot, "doc@tito.io", "ip"), now)
	if err != nil {
		t.Fatal(err)
	}
	st.ConfirmBooking(context.Background(), b.ID, now)

	edit := "/events/" + strconv.FormatInt(b.EventID, 10) + "/edit"
	body := getAs(t, h, session, edit).Body.String()
	for _, want := range []string{`name="tz" value="UTC"`, `name="start" value="`, "This is a booked meeting", "Doc"} {
		if !strings.Contains(body, want) {
			t.Errorf("the booked form lacks %q", want)
		}
	}
	// The host moves zone; a title-only save still passes.
	postAs(t, h, session, "/settings", settingsForm("paul"))
	form := formValuesFrom(body)
	form.Set("title", "Renamed by the host")
	rec := postAs(t, h, session, "/events/"+strconv.FormatInt(b.EventID, 10), form)
	if rec.Code != http.StatusSeeOther {
		t.Fatalf("title-only save: %d\n%s", rec.Code, rec.Body.String())
	}
	// And a stale form with the old time after a public reschedule is refused.
	// Settings above changed the host's zone.  Read the booking again before
	// selecting the new public slot, so FreeSlots and RescheduleBooking use
	// the same host-zone record.
	v, err := st.BookingByID(context.Background(), b.ID, false)
	if err != nil {
		t.Fatal(err)
	}
	slots := slotsFor(t, app, v.Page, v.Host, now, 3)
	if changed, err := st.RescheduleBooking(context.Background(), b.ID, slots[3].StartUTC, slots[3].EndUTC, v.Event.Sequence, now); err != nil || !changed {
		t.Fatalf("reschedule: changed=%v err=%v", changed, err)
	}
	rec = postAs(t, h, session, "/events/"+strconv.FormatInt(b.EventID, 10), form)
	if rec.Code != http.StatusUnprocessableEntity || !strings.Contains(rec.Body.String(), "booked meeting") {
		t.Errorf("stale form after a public reschedule: %d", rec.Code)
	}
	// The event page says how to move it.
	if page := getAs(t, h, session, "/events/"+strconv.FormatInt(b.EventID, 10)).Body.String(); !strings.Contains(page, "cancel it and let Doc rebook") {
		t.Error("the event page does not say how a booked meeting is moved")
	}
}

// formValuesFrom pulls every hidden input off a rendered form, plus the
// fields a title-only save needs, the way a browser would submit them.
func formValuesFrom(body string) url.Values {
	form := url.Values{}
	for _, m := range regexp.MustCompile(`name="([a-z_]+)" value="([^"]*)"`).FindAllStringSubmatch(body, -1) {
		if form.Get(m[1]) == "" {
			form.Set(m[1], m[2])
		}
	}
	// The status select's selected option.
	if m := regexp.MustCompile(`<option value="(confirmed|tentative|cancelled)" selected`).FindStringSubmatch(body); m != nil {
		form.Set("status", m[1])
	}
	if m := regexp.MustCompile(`name="calendar_id"[^>]*>[\s\S]*?<option value="(\d+)" selected`).FindStringSubmatch(body); m != nil {
		form.Set("calendar_id", m[1])
	}
	form.Set("title", "Renamed")
	form.Del("all_day")
	return form
}