bbq/handlers.go

package main

import (
	"bytes"
	"crypto/rand"
	"database/sql"
	"encoding/hex"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"strconv"
	"strings"

	"github.com/go-chi/chi/v5"
	"github.com/ryanchen/bbq/db"
)

const (
	maxFieldLen  = 200
	maxDescLen   = 5000
	maxNoteLen   = 500
	maxSlots     = 20
	maxRsvps     = 200
	maxClaims    = 50
	maxMaxClaims = 50

	maxAttendeeCap = 1000
	maxPlusOne     = 10
)

func plural(n int64) string {
	if n == 1 {
		return ""
	}
	return "s"
}

func sanitize(s string, maxLen int) string {
	s = strings.TrimSpace(s)
	if len(s) > maxLen {
		s = s[:maxLen]
	}
	return s
}

func randomToken() string {
	b := make([]byte, 16)
	rand.Read(b)
	return hex.EncodeToString(b)
}

func randomSlug() string {
	b := make([]byte, 4)
	rand.Read(b)
	return hex.EncodeToString(b)
}

// --- Home / Create Event ---

func (s *Server) handleHome(w http.ResponseWriter, r *http.Request) {
	if s.features.Auth && s.currentUser(r) == nil {
		http.Redirect(w, r, "/login", http.StatusSeeOther)
		return
	}
	pageTmpl["home"].ExecuteTemplate(w, "layout", map[string]any{
		"User":        s.currentUser(r),
		"AuthEnabled": s.features.Auth,
	})
}

func (s *Server) handleCreateEvent(w http.ResponseWriter, r *http.Request) {
	r.Body = http.MaxBytesReader(w, r.Body, 32*1024)
	r.ParseForm()
	title := sanitize(r.FormValue("title"), maxFieldLen)
	date := sanitize(r.FormValue("date"), maxFieldLen)
	time_ := sanitize(r.FormValue("time"), maxFieldLen)
	location := sanitize(r.FormValue("location"), maxFieldLen)
	description := sanitize(r.FormValue("description"), maxDescLen)

	if title == "" {
		http.Error(w, "Title is required", http.StatusBadRequest)
		return
	}

	// Capped events require login to RSVP, so the cap is only available when auth is on.
	var attendeeCap int64
	if s.features.Auth {
		if v, err := strconv.ParseInt(r.FormValue("attendee_cap"), 10, 64); err == nil && v > 0 {
			attendeeCap = v
		}
		if attendeeCap > maxAttendeeCap {
			attendeeCap = maxAttendeeCap
		}
	}

	slug := randomSlug()
	token := randomToken()
	event, err := s.q.CreateEvent(r.Context(), db.CreateEventParams{
		Slug: slug, Title: title, Date: date, Time: time_, Location: location, AdminToken: token, Description: description,
		AttendeeCap: attendeeCap,
	})
	if err != nil {
		log.Printf("create event: %v", err)
		http.Error(w, "Failed to create event", http.StatusInternalServerError)
		return
	}

	// Associate event with logged-in user
	if user := s.currentUser(r); user != nil {
		s.q.SetEventUser(r.Context(), db.SetEventUserParams{
			UserID: sql.NullInt64{Int64: user.ID, Valid: true},
			ID:     event.ID,
		})
	}

	slotNames := r.Form["slot_name"]
	slotEmojis := r.Form["slot_emoji"]
	slotMaxes := r.Form["slot_max"]
	created := 0
	for i, name := range slotNames {
		if created >= maxSlots {
			break
		}
		name = sanitize(name, maxFieldLen)
		if name == "" {
			continue
		}
		emoji := ""
		if i < len(slotEmojis) {
			emoji = sanitize(slotEmojis[i], 32)
		}
		mc := int64(1)
		if i < len(slotMaxes) {
			if v, err := strconv.ParseInt(slotMaxes[i], 10, 64); err == nil && v > 0 {
				mc = v
			}
		}
		if mc > maxMaxClaims {
			mc = maxMaxClaims
		}
		s.q.CreateSlot(r.Context(), db.CreateSlotParams{
			EventID: event.ID, Name: name, Emoji: emoji, MaxClaims: mc, SortOrder: int64(i),
		})
		created++
	}

	http.Redirect(w, r, fmt.Sprintf("/e/%s/admin/%s", event.Slug, event.AdminToken), http.StatusSeeOther)
}

// --- Guest Event View ---

type SlotView struct {
	Slot       db.Slot
	Claims     []db.Claim
	ClaimCount int64
	IsFull     bool
	Pct        int64
}

type GoingPerson struct {
	Name    string
	Note    string
	RsvpID  int64
	PlusOne int64
}

type EventPageData struct {
	Event           db.Event
	Slots           []SlotView
	Rsvps           []db.Rsvp
	GoingList       []GoingPerson
	NotGoingList    []GoingPerson
	TotalGoing      int64
	IsAdmin         bool
	BaseURL         string
	DescriptionHTML template.HTML
	User            *db.User
	AuthEnabled     bool
	CanEditRsvps    bool
	Capped          bool
	SpotsLeft       int64
	CapFull         bool
	PlusOneMax      int64
}

func (s *Server) loadEventPage(r *http.Request, slug string, isAdmin bool) (*EventPageData, error) {
	event, err := s.q.GetEventBySlug(r.Context(), slug)
	if err != nil {
		return nil, err
	}

	slots, err := s.q.ListSlots(r.Context(), event.ID)
	if err != nil {
		return nil, err
	}

	claims, err := s.q.ListClaimsByEvent(r.Context(), event.ID)
	if err != nil {
		return nil, err
	}

	claimsBySlot := make(map[int64][]db.Claim)
	for _, c := range claims {
		claimsBySlot[c.SlotID] = append(claimsBySlot[c.SlotID], c)
	}

	var slotViews []SlotView
	for _, slot := range slots {
		sc := claimsBySlot[slot.ID]
		count := int64(len(sc))
		pct := int64(0)
		if slot.MaxClaims > 0 {
			pct = (count * 100) / slot.MaxClaims
			if pct > 100 {
				pct = 100
			}
		}
		slotViews = append(slotViews, SlotView{
			Slot:       slot,
			Claims:     sc,
			ClaimCount: count,
			IsFull:     count >= slot.MaxClaims,
			Pct:        pct,
		})
	}

	rsvps, err := s.q.ListRsvps(r.Context(), event.ID)
	if err != nil {
		return nil, err
	}
	var totalGoing int64
	var goingList, notGoingList []GoingPerson
	for _, r := range rsvps {
		p := GoingPerson{Name: r.Name, Note: r.Note, RsvpID: r.ID, PlusOne: r.PlusOne}
		if r.Status == "no" {
			notGoingList = append(notGoingList, p)
			continue
		}
		totalGoing += 1 + r.PlusOne
		goingList = append(goingList, p)
	}

	var descHTML template.HTML
	if event.Description != "" {
		descHTML = RenderMarkdown(event.Description)
	}

	capped := s.features.Auth && event.AttendeeCap > 0
	var spotsLeft int64
	plusOneMax := int64(maxPlusOne)
	if capped {
		spotsLeft = event.AttendeeCap - totalGoing
		if spotsLeft < 0 {
			spotsLeft = 0
		}
		if spotsLeft-1 < plusOneMax {
			plusOneMax = spotsLeft - 1
		}
		if plusOneMax < 0 {
			plusOneMax = 0
		}
	}

	user := s.currentUser(r)
	return &EventPageData{
		Event:           event,
		Slots:           slotViews,
		Rsvps:           rsvps,
		GoingList:       goingList,
		NotGoingList:    notGoingList,
		TotalGoing:      totalGoing,
		IsAdmin:         isAdmin,
		BaseURL:         s.baseURL,
		DescriptionHTML: descHTML,
		User:            user,
		AuthEnabled:     s.features.Auth,
		CanEditRsvps:    isAdmin || !s.features.Auth || user != nil,
		Capped:          capped,
		SpotsLeft:       spotsLeft,
		CapFull:         capped && totalGoing >= event.AttendeeCap,
		PlusOneMax:      plusOneMax,
	}, nil
}

func (s *Server) handleEvent(w http.ResponseWriter, r *http.Request) {
	slug := chi.URLParam(r, "slug")
	data, err := s.loadEventPage(r, slug, false)
	if err != nil {
		if err == sql.ErrNoRows {
			http.NotFound(w, r)
			return
		}
		log.Printf("load event: %v", err)
		http.Error(w, "Internal error", http.StatusInternalServerError)
		return
	}
	pageTmpl["event"].ExecuteTemplate(w, "layout", data)
}

func (s *Server) handleSlotsPartial(w http.ResponseWriter, r *http.Request) {
	slug := chi.URLParam(r, "slug")
	data, err := s.loadEventPage(r, slug, false)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}
	pageTmpl["slots"].ExecuteTemplate(w, "slots-inner", data)
}

// --- Unclaim ---

func (s *Server) handleUnclaim(w http.ResponseWriter, r *http.Request) {
	slug := chi.URLParam(r, "slug")
	claimID, err := strconv.ParseInt(chi.URLParam(r, "claimID"), 10, 64)
	if err != nil {
		http.Error(w, "Invalid claim", http.StatusBadRequest)
		return
	}

	// Look up the claim to get the name, then delete the auto-created RSVP
	claim, err := s.q.GetClaimByID(r.Context(), claimID)
	if err == nil {
		event, err := s.q.GetEventBySlug(r.Context(), slug)
		if err == nil {
			rsvp, err := s.q.GetRsvpByName(r.Context(), db.GetRsvpByNameParams{
				EventID: event.ID,
				Name:    claim.Name,
			})
			if err == nil {
				s.q.DeleteRsvp(r.Context(), rsvp.ID)
			}
		}
	}

	err = s.q.DeleteClaim(r.Context(), claimID)
	if err != nil {
		http.Error(w, "Failed to remove", http.StatusInternalServerError)
		return
	}

	s.notify(slug)

	data, err := s.loadEventPage(r, slug, false)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}
	pageTmpl["slots"].ExecuteTemplate(w, "slots-inner", data)
}

// --- RSVP (+ optional claim) ---

func (s *Server) handleRsvp(w http.ResponseWriter, r *http.Request) {
	slug := chi.URLParam(r, "slug")
	r.Body = http.MaxBytesReader(w, r.Body, 8*1024)
	r.ParseForm()

	name := sanitize(r.FormValue("name"), maxFieldLen)
	if name == "" {
		http.Error(w, "Name is required", http.StatusBadRequest)
		return
	}
	note := sanitize(r.FormValue("note"), maxNoteLen)
	status := "yes"
	if r.FormValue("status") == "no" {
		status = "no"
	}
	plusOne := int64(0)
	if v, err := strconv.ParseInt(r.FormValue("plus_one"), 10, 64); err == nil && v > 0 {
		plusOne = v
	}
	if plusOne > maxPlusOne {
		plusOne = maxPlusOne
	}
	if status == "no" {
		plusOne = 0
	}

	event, err := s.q.GetEventBySlug(r.Context(), slug)
	if err != nil {
		http.Error(w, "Event not found", http.StatusNotFound)
		return
	}

	// Answering — yes or no — requires login when auth is enabled.
	user := s.currentUser(r)
	if s.features.Auth && user == nil {
		http.Error(w, "You must be logged in to RSVP", http.StatusUnauthorized)
		return
	}

	// One answer per person: find an existing RSVP by user, falling back to name.
	var existing *db.Rsvp
	if user != nil {
		if rv, err := s.q.GetRsvpByUser(r.Context(), db.GetRsvpByUserParams{
			EventID: event.ID,
			UserID:  sql.NullInt64{Int64: user.ID, Valid: true},
		}); err == nil {
			existing = &rv
		}
	}
	if existing == nil {
		if rv, err := s.q.GetRsvpByName(r.Context(), db.GetRsvpByNameParams{
			EventID: event.ID, Name: name,
		}); err == nil {
			existing = &rv
		}
	}

	// Capped events enforce the cap on total people going.
	capped := s.features.Auth && event.AttendeeCap > 0
	if capped && status == "yes" {
		going, err := s.q.CountGoing(r.Context(), event.ID)
		if err != nil {
			http.Error(w, "error", http.StatusInternalServerError)
			return
		}
		var current int64
		if existing != nil && existing.Status == "yes" {
			current = 1 + existing.PlusOne
		}
		if going-current+1+plusOne > event.AttendeeCap {
			left := event.AttendeeCap - (going - current)
			if left <= 0 {
				http.Error(w, "Event is full", http.StatusConflict)
			} else {
				http.Error(w, fmt.Sprintf("Only %d spot%s left", left, plural(left)), http.StatusConflict)
			}
			return
		}
	}

	// Optional slot claim (only when going)
	if slotIDStr := r.FormValue("slot_id"); slotIDStr != "" && status == "yes" {
		slotID, err := strconv.ParseInt(slotIDStr, 10, 64)
		if err != nil {
			http.Error(w, "Invalid slot", http.StatusBadRequest)
			return
		}

		slot, err := s.q.GetSlot(r.Context(), slotID)
		if err != nil {
			http.Error(w, "Slot not found", http.StatusNotFound)
			return
		}
		if slot.EventID != event.ID {
			http.Error(w, "Invalid slot", http.StatusBadRequest)
			return
		}

		count, err := s.q.CountClaimsBySlot(r.Context(), slotID)
		if err != nil {
			http.Error(w, "error", http.StatusInternalServerError)
			return
		}
		if count >= slot.MaxClaims {
			http.Error(w, "Slot is full", http.StatusConflict)
			return
		}

		_, err = s.q.CreateClaim(r.Context(), db.CreateClaimParams{
			SlotID: slotID, Name: name, Note: note,
		})
		if err != nil {
			log.Printf("create claim: %v", err)
			http.Error(w, "Failed to claim", http.StatusInternalServerError)
			return
		}
	}

	// Record the answer: update the existing RSVP or create a new one.
	if existing != nil {
		err = s.q.UpdateRsvp(r.Context(), db.UpdateRsvpParams{
			Name: name, Note: note, PlusOne: plusOne, Status: status, ID: existing.ID,
		})
		if err != nil {
			log.Printf("update rsvp: %v", err)
			http.Error(w, "Failed", http.StatusInternalServerError)
			return
		}
	} else {
		count, err := s.q.CountRsvps(r.Context(), event.ID)
		if err != nil {
			http.Error(w, "error", http.StatusInternalServerError)
			return
		}
		if count >= maxRsvps {
			http.Error(w, "RSVP list is full", http.StatusConflict)
			return
		}

		var userID sql.NullInt64
		if user != nil {
			userID = sql.NullInt64{Int64: user.ID, Valid: true}
		}
		_, err = s.q.CreateRsvp(r.Context(), db.CreateRsvpParams{
			EventID: event.ID, Name: name, Note: note, PlusOne: plusOne, Status: status, UserID: userID,
		})
		if err != nil {
			log.Printf("create rsvp: %v", err)
			http.Error(w, "Failed", http.StatusInternalServerError)
			return
		}
	}

	// Not coming — free any slots claimed under their name.
	if status == "no" {
		s.q.DeleteClaimsByEventAndName(r.Context(), db.DeleteClaimsByEventAndNameParams{
			EventID: event.ID, Name: name,
		})
		if existing != nil && !strings.EqualFold(existing.Name, name) {
			s.q.DeleteClaimsByEventAndName(r.Context(), db.DeleteClaimsByEventAndNameParams{
				EventID: event.ID, Name: existing.Name,
			})
		}
	}

	s.notify(slug)

	data, err := s.loadEventPage(r, slug, false)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}
	pageTmpl["slots"].ExecuteTemplate(w, "slots-inner", data)
}

func (s *Server) handleEditRsvpForm(w http.ResponseWriter, r *http.Request) {
	slug := chi.URLParam(r, "slug")
	rsvpID, err := strconv.ParseInt(chi.URLParam(r, "rsvpID"), 10, 64)
	if err != nil {
		http.Error(w, "Invalid RSVP", http.StatusBadRequest)
		return
	}

	rsvp, err := s.q.GetRsvp(r.Context(), rsvpID)
	if err != nil {
		http.Error(w, "RSVP not found", http.StatusNotFound)
		return
	}

	pageTmpl["edit-rsvp"].ExecuteTemplate(w, "edit-rsvp", map[string]any{
		"Slug": slug,
		"Rsvp": rsvp,
	})
}

func (s *Server) handleUpdateRsvp(w http.ResponseWriter, r *http.Request) {
	slug := chi.URLParam(r, "slug")
	rsvpID, err := strconv.ParseInt(chi.URLParam(r, "rsvpID"), 10, 64)
	if err != nil {
		http.Error(w, "Invalid RSVP", http.StatusBadRequest)
		return
	}

	if s.features.Auth && s.currentUser(r) == nil {
		http.Error(w, "You must be logged in to RSVP", http.StatusUnauthorized)
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, 8*1024)
	r.ParseForm()

	name := sanitize(r.FormValue("name"), maxFieldLen)
	if name == "" {
		http.Error(w, "Name is required", http.StatusBadRequest)
		return
	}
	note := sanitize(r.FormValue("note"), maxNoteLen)
	status := "yes"
	if r.FormValue("status") == "no" {
		status = "no"
	}
	plusOne := int64(0)
	if v, err := strconv.ParseInt(r.FormValue("plus_one"), 10, 64); err == nil && v > 0 {
		plusOne = v
	}
	if plusOne > maxPlusOne {
		plusOne = maxPlusOne
	}
	if status == "no" {
		plusOne = 0
	}

	event, err := s.q.GetEventBySlug(r.Context(), slug)
	if err != nil {
		http.Error(w, "Event not found", http.StatusNotFound)
		return
	}
	old, err := s.q.GetRsvp(r.Context(), rsvpID)
	if err != nil {
		http.Error(w, "RSVP not found", http.StatusNotFound)
		return
	}
	// Raising plus_one (or flipping back to yes) can't exceed the attendee cap.
	if s.features.Auth && event.AttendeeCap > 0 && status == "yes" {
		going, err := s.q.CountGoing(r.Context(), event.ID)
		if err != nil {
			http.Error(w, "error", http.StatusInternalServerError)
			return
		}
		var current int64
		if old.Status == "yes" {
			current = 1 + old.PlusOne
		}
		if going-current+1+plusOne > event.AttendeeCap {
			http.Error(w, "Not enough spots left", http.StatusConflict)
			return
		}
	}

	err = s.q.UpdateRsvp(r.Context(), db.UpdateRsvpParams{
		Name: name, Note: note, PlusOne: plusOne, Status: status, ID: rsvpID,
	})
	if err != nil {
		http.Error(w, "Failed to update", http.StatusInternalServerError)
		return
	}

	// Not coming — free any slots claimed under their name.
	if status == "no" {
		s.q.DeleteClaimsByEventAndName(r.Context(), db.DeleteClaimsByEventAndNameParams{
			EventID: event.ID, Name: name,
		})
		if !strings.EqualFold(old.Name, name) {
			s.q.DeleteClaimsByEventAndName(r.Context(), db.DeleteClaimsByEventAndNameParams{
				EventID: event.ID, Name: old.Name,
			})
		}
	}

	s.notify(slug)

	w.Header().Set("HX-Trigger", "closeModal")
	data, err := s.loadEventPage(r, slug, false)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}
	pageTmpl["slots"].ExecuteTemplate(w, "slots-inner", data)
}

func (s *Server) handleUnrsvp(w http.ResponseWriter, r *http.Request) {
	slug := chi.URLParam(r, "slug")
	rsvpID, err := strconv.ParseInt(chi.URLParam(r, "rsvpID"), 10, 64)
	if err != nil {
		http.Error(w, "Invalid RSVP", http.StatusBadRequest)
		return
	}

	if s.features.Auth && s.currentUser(r) == nil {
		http.Error(w, "You must be logged in to RSVP", http.StatusUnauthorized)
		return
	}

	s.q.DeleteRsvp(r.Context(), rsvpID)
	s.notify(slug)

	data, err := s.loadEventPage(r, slug, false)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}
	pageTmpl["slots"].ExecuteTemplate(w, "slots-inner", data)
}

// --- SSE ---

func (s *Server) handleSSE(w http.ResponseWriter, r *http.Request) {
	slug := chi.URLParam(r, "slug")
	flusher, ok := w.(http.Flusher)
	if !ok {
		http.Error(w, "SSE not supported", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "text/event-stream")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")

	ch := s.subscribe(slug)
	defer s.unsubscribe(slug, ch)

	for {
		select {
		case <-ch:
			data, err := s.loadEventPage(r, slug, false)
			if err != nil {
				return
			}
			var buf bytes.Buffer
			pageTmpl["slots"].ExecuteTemplate(&buf, "slots-inner", data)
			// SSE format: replace newlines for event stream
			lines := strings.Split(buf.String(), "\n")
			for _, line := range lines {
				fmt.Fprintf(w, "data: %s\n", line)
			}
			fmt.Fprintf(w, "\n")
			flusher.Flush()
		case <-r.Context().Done():
			return
		}
	}
}

// --- Admin ---

// authorizeAdmin checks the admin token and (when auth is enabled) that the
// logged-in user owns the event. Returns the event on success, nil on failure.
// For page loads (isPage=true) it redirects to the guest view; for actions it
// returns 403.
func (s *Server) authorizeAdmin(w http.ResponseWriter, r *http.Request, isPage bool) *db.Event {
	slug := chi.URLParam(r, "slug")
	token := chi.URLParam(r, "token")

	event, err := s.q.GetEventBySlug(r.Context(), slug)
	if err != nil || event.AdminToken != token {
		http.NotFound(w, r)
		return nil
	}

	if s.features.Auth && event.UserID.Valid {
		user := s.currentUser(r)
		if user == nil || user.ID != event.UserID.Int64 {
			if isPage {
				http.Redirect(w, r, "/e/"+slug, http.StatusSeeOther)
			} else {
				http.Error(w, "Forbidden", http.StatusForbidden)
			}
			return nil
		}
	}

	return &event
}

func (s *Server) handleAdmin(w http.ResponseWriter, r *http.Request) {
	event := s.authorizeAdmin(w, r, true)
	if event == nil {
		return
	}

	data, err := s.loadEventPage(r, event.Slug, true)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}
	pageTmpl["event"].ExecuteTemplate(w, "layout", data)
}

func (s *Server) handleUpdateDescription(w http.ResponseWriter, r *http.Request) {
	event := s.authorizeAdmin(w, r, false)
	if event == nil {
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, 32*1024)
	r.ParseForm()
	description := sanitize(r.FormValue("description"), maxDescLen)

	s.q.UpdateEventDescription(r.Context(), db.UpdateEventDescriptionParams{
		Description: description,
		ID:          event.ID,
	})

	http.Redirect(w, r, fmt.Sprintf("/e/%s/admin/%s", event.Slug, event.AdminToken), http.StatusSeeOther)
}

func (s *Server) handleUpdateLocation(w http.ResponseWriter, r *http.Request) {
	event := s.authorizeAdmin(w, r, false)
	if event == nil {
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, 8*1024)
	r.ParseForm()
	location := sanitize(r.FormValue("location"), maxFieldLen)

	s.q.UpdateEventLocation(r.Context(), db.UpdateEventLocationParams{
		Location: location,
		ID:       event.ID,
	})

	http.Redirect(w, r, fmt.Sprintf("/e/%s/admin/%s", event.Slug, event.AdminToken), http.StatusSeeOther)
}

func (s *Server) handleUpdateDateTime(w http.ResponseWriter, r *http.Request) {
	event := s.authorizeAdmin(w, r, false)
	if event == nil {
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, 8*1024)
	r.ParseForm()
	date := sanitize(r.FormValue("date"), maxFieldLen)
	time_ := sanitize(r.FormValue("time"), maxFieldLen)

	s.q.UpdateEventDateTime(r.Context(), db.UpdateEventDateTimeParams{
		Date: date,
		Time: time_,
		ID:   event.ID,
	})

	http.Redirect(w, r, fmt.Sprintf("/e/%s/admin/%s", event.Slug, event.AdminToken), http.StatusSeeOther)
}

func (s *Server) handleCreateSlot(w http.ResponseWriter, r *http.Request) {
	event := s.authorizeAdmin(w, r, false)
	if event == nil {
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, 8*1024)
	r.ParseForm()
	name := sanitize(r.FormValue("name"), maxFieldLen)
	emoji := sanitize(r.FormValue("emoji"), 32)
	mc := int64(1)
	if v, err := strconv.ParseInt(r.FormValue("max_claims"), 10, 64); err == nil && v > 0 {
		mc = v
	}
	if mc > maxMaxClaims {
		mc = maxMaxClaims
	}

	if name == "" {
		http.Error(w, "Name required", http.StatusBadRequest)
		return
	}

	slots, _ := s.q.ListSlots(r.Context(), event.ID)
	if len(slots) >= maxSlots {
		http.Error(w, "Too many slots", http.StatusConflict)
		return
	}

	_, err := s.q.CreateSlot(r.Context(), db.CreateSlotParams{
		EventID: event.ID, Name: name, Emoji: emoji, MaxClaims: mc, SortOrder: 999,
	})
	if err != nil {
		http.Error(w, "Failed", http.StatusInternalServerError)
		return
	}

	s.notify(event.Slug)

	data, err := s.loadEventPage(r, event.Slug, true)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}
	pageTmpl["slots"].ExecuteTemplate(w, "slots-inner", data)
}

func (s *Server) handleDeleteSlot(w http.ResponseWriter, r *http.Request) {
	event := s.authorizeAdmin(w, r, false)
	if event == nil {
		return
	}

	slotID, err := strconv.ParseInt(chi.URLParam(r, "slotID"), 10, 64)
	if err != nil {
		http.Error(w, "Invalid slot", http.StatusBadRequest)
		return
	}

	s.q.DeleteSlot(r.Context(), slotID)
	s.notify(event.Slug)

	data, err := s.loadEventPage(r, event.Slug, true)
	if err != nil {
		http.Error(w, "error", http.StatusInternalServerError)
		return
	}
	pageTmpl["slots"].ExecuteTemplate(w, "slots-inner", data)
}

func (s *Server) handlePrivacy(w http.ResponseWriter, r *http.Request) {
	pageTmpl["privacy"].ExecuteTemplate(w, "layout", nil)
}

func (s *Server) handleTerms(w http.ResponseWriter, r *http.Request) {
	pageTmpl["terms"].ExecuteTemplate(w, "layout", nil)
}