nidus/internal/web/calendar.go

package web

import (
	"bytes"
	"context"
	"crypto/rand"
	"encoding/hex"
	"errors"
	"fmt"
	"io"
	"net/http"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"time"

	ical "github.com/emersion/go-ical"
	"github.com/yourusername/caldav-server/internal/db"
	"github.com/yourusername/caldav-server/internal/web/templates"
)

// eventIDRe validates an event's object ID as it appears in a URL path
// segment: a filename like "3f9a2b8c1d4e5f60ab12cd34ef56ab78.ics".
var eventIDRe = regexp.MustCompile(`^[a-zA-Z0-9_-]{1,128}\.ics$`)

// dateLayout/timeLayout are the HTML date/time input formats used
// throughout the event form.
const dateLayout = "2006-01-02"
const timeLayout = "15:04"

// calRefSep separates the owner and calendar name in a shared calendar's
// reference string (e.g. "alice~vacations"), mirroring (but independent
// from) internal/caldav's sharedNameSep convention for its own URL
// namespace.
const calRefSep = "~"

// errCalendarNotFound/errCalendarReadOnly are sentinel errors returned by
// resolveCalRef, translated by callers into 404/403 responses.
var (
	errCalendarNotFound = errors.New("calendar not found")
	errCalendarReadOnly = errors.New("calendar is read-only")
)

// newEventID generates a random filename for a new event object,
// mirroring the "<id>.ics" convention used by the CalDAV backend
// (internal/caldav).
func newEventID() (string, error) {
	buf := make([]byte, 16)
	if _, err := rand.Read(buf); err != nil {
		return "", err
	}
	return hex.EncodeToString(buf) + ".ics", nil
}

// sharedCalRef builds the reference string used in URLs for a calendar
// shared with the requesting user by owner.
func sharedCalRef(owner, name string) string {
	return owner + calRefSep + name
}

// ownsCalendar reports whether cal is one of username's own calendars.
func (s *Server) ownsCalendar(username, cal string) (bool, error) {
	if !resourceNameRe.MatchString(cal) {
		return false, nil
	}
	cals, err := s.dbase.ListCalendars(username)
	if err != nil {
		return false, err
	}
	for _, c := range cals {
		if c.Name == cal {
			return true, nil
		}
	}
	return false, nil
}

// resolveCalRef resolves a calendar reference (either a bare name for
// username's own calendar, or "<owner>~<name>" for a calendar shared with
// username) into the concrete (owner, name) pair to use when addressing
// store.Store/db.DB. If requireWrite is true, a read-only share is
// rejected with errCalendarReadOnly.
func (s *Server) resolveCalRef(username, ref string, requireWrite bool) (owner, name string, err error) {
	if owner, name, ok := strings.Cut(ref, calRefSep); ok {
		if !resourceNameRe.MatchString(owner) || !resourceNameRe.MatchString(name) {
			return "", "", errCalendarNotFound
		}
		share, err := s.dbase.CalendarShareFor(owner, name, username)
		if err != nil {
			if errors.Is(err, db.ErrShareNotFound) {
				return "", "", errCalendarNotFound
			}
			return "", "", err
		}
		if requireWrite && share.Permission != db.PermWrite {
			return "", "", errCalendarReadOnly
		}
		return owner, name, nil
	}

	ok, err := s.ownsCalendar(username, ref)
	if err != nil {
		return "", "", err
	}
	if !ok {
		return "", "", errCalendarNotFound
	}
	return username, ref, nil
}

// calendarEntry is one calendar (own or shared) visible to a user in the
// combined month view.
type calendarEntry struct {
	Ref      string // path-safe reference: "name" or "owner~name"
	Owner    string // owner's username
	Name     string // calendar's own name (unqualified)
	Color    string
	Writable bool
}

// listCalendarEntries returns every calendar visible to username: their
// own calendars (always writable) plus any calendars shared with them
// (writable only if the share grants write permission).
func (s *Server) listCalendarEntries(username string) ([]calendarEntry, error) {
	var entries []calendarEntry

	own, err := s.dbase.ListCalendars(username)
	if err != nil {
		return nil, err
	}
	for _, c := range own {
		entries = append(entries, calendarEntry{
			Ref: c.Name, Owner: username, Name: c.Name, Color: c.Color, Writable: true,
		})
	}

	shared, err := s.dbase.CalendarsSharedWith(username)
	if err != nil {
		return nil, err
	}
	for _, sh := range shared {
		color, err := s.dbase.GetCalendarColor(sh.Owner, sh.CalendarName)
		if err != nil {
			color = ""
		}
		entries = append(entries, calendarEntry{
			Ref:      sharedCalRef(sh.Owner, sh.CalendarName),
			Owner:    sh.Owner,
			Name:     sh.CalendarName,
			Color:    color,
			Writable: sh.Permission == db.PermWrite,
		})
	}

	sort.Slice(entries, func(i, j int) bool {
		if entries[i].Owner != entries[j].Owner {
			return entries[i].Owner < entries[j].Owner
		}
		return entries[i].Name < entries[j].Name
	})
	return entries, nil
}

func (s *Server) handleCalendarMonth(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		w.Header().Set("Allow", "GET")
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	username := userFromContext(r.Context())

	year, month := parseYearMonth(r)

	data, err := s.buildMonthView(username, year, month)
	if err != nil {
		s.logger.Error("building month view", "error", err)
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	_ = templates.MonthView(username, data).Render(context.Background(), w)
}

// parseYearMonth reads ?year=&month= query params, defaulting to the
// current month if absent or invalid.
func parseYearMonth(r *http.Request) (year int, month time.Month) {
	now := time.Now()
	year, month = now.Year(), now.Month()
	if y, err := strconv.Atoi(r.URL.Query().Get("year")); err == nil && y >= 1 && y <= 9999 {
		year = y
	}
	if m, err := strconv.Atoi(r.URL.Query().Get("month")); err == nil && m >= 1 && m <= 12 {
		month = time.Month(m)
	}
	return year, month
}

// buildMonthView loads every event from every calendar visible to
// username (own + shared), then places each occurrence's days onto a
// 6-week grid covering the requested month (plus enough leading/trailing
// days of neighboring months to fill full weeks). Recurring events
// (RRULE) are not expanded — only an event's own DTSTART/DTEND span is
// considered.
func (s *Server) buildMonthView(username string, year int, month time.Month) (templates.MonthViewData, error) {
	entries, err := s.listCalendarEntries(username)
	if err != nil {
		return templates.MonthViewData{}, err
	}

	loc := time.Local
	first := time.Date(year, month, 1, 0, 0, 0, 0, loc)
	// Monday-first offset: time.Weekday has Sunday=0..Saturday=6.
	offset := (int(first.Weekday()) + 6) % 7
	gridStart := first.AddDate(0, 0, -offset)
	const totalDays = 42 // 6 weeks

	today := time.Now().In(loc).Format(dateLayout)

	days := make([]templates.MonthDay, totalDays)
	dayIndex := make(map[string]int, totalDays)
	for i := 0; i < totalDays; i++ {
		d := gridStart.AddDate(0, 0, i)
		dateStr := d.Format(dateLayout)
		days[i] = templates.MonthDay{
			Date:    dateStr,
			Day:     d.Day(),
			InMonth: d.Month() == month,
			IsToday: dateStr == today,
		}
		dayIndex[dateStr] = i
	}
	gridEnd := gridStart.AddDate(0, 0, totalDays-1)

	hasWritable := false
	var calSummaries []templates.CalendarSummary
	for _, entry := range entries {
		if entry.Writable {
			hasWritable = true
		}
		calSummaries = append(calSummaries, templates.CalendarSummary{
			Ref: entry.Ref, Name: entry.Name, Owner: entry.Owner, Color: entry.Color,
			Shared: entry.Owner != username, Writable: entry.Writable,
		})

		ids, err := s.store.ListObjects(entry.Owner, "cal-"+entry.Name)
		if err != nil {
			continue
		}
		for _, id := range ids {
			data, err := s.store.GetObject(entry.Owner, "cal-"+entry.Name, id)
			if err != nil {
				continue
			}
			form, err := eventFormFromICS(id, data)
			if err != nil {
				s.logger.Warn("decoding calendar object", "calendar", entry.Name, "id", id, "error", err)
				continue
			}
			startDay, endDay, err := eventDayRange(form, loc)
			if err != nil {
				continue
			}
			if endDay.Before(gridStart) || startDay.After(gridEnd) {
				continue
			}
			if startDay.Before(gridStart) {
				startDay = gridStart
			}
			if endDay.After(gridEnd) {
				endDay = gridEnd
			}
			// Cap the number of days a single event can add to the grid,
			// in case of malformed data with a wildly distant DTEND.
			for d, n := startDay, 0; !d.After(endDay) && n < totalDays; d, n = d.AddDate(0, 0, 1), n+1 {
				idx, ok := dayIndex[d.Format(dateLayout)]
				if !ok {
					continue
				}
				timeText := ""
				if !form.AllDay {
					timeText = form.StartTime
				}
				days[idx].Events = append(days[idx].Events, templates.EventSummary{
					ID:       id,
					CalRef:   entry.Ref,
					Color:    entry.Color,
					Summary:  form.Summary,
					TimeText: timeText,
					AllDay:   form.AllDay,
				})
			}
		}
	}

	// Keep each day's events in a stable, readable order: all-day events
	// first, then timed events sorted by start time.
	for i := range days {
		evs := days[i].Events
		sort.SliceStable(evs, func(a, b int) bool {
			if evs[a].AllDay != evs[b].AllDay {
				return evs[a].AllDay
			}
			return evs[a].TimeText < evs[b].TimeText
		})
	}

	weeks := make([][]templates.MonthDay, 0, 6)
	for i := 0; i < totalDays; i += 7 {
		weeks = append(weeks, days[i:i+7])
	}

	prevMonth := first.AddDate(0, -1, 0)
	nextMonth := first.AddDate(0, 1, 0)
	monthURL := func(y int, m time.Month) string {
		return fmt.Sprintf("/web/calendar?year=%d&month=%d", y, int(m))
	}

	return templates.MonthViewData{
		Calendars:    calSummaries,
		HasWritable:  hasWritable,
		MonthLabel:   first.Format("January 2006"),
		Weeks:        weeks,
		PrevMonthURL: monthURL(prevMonth.Year(), prevMonth.Month()),
		NextMonthURL: monthURL(nextMonth.Year(), nextMonth.Month()),
		TodayURL:     "/web/calendar",
	}, nil
}

// eventDayRange returns the inclusive [start, end] calendar-day span an
// event occupies, in loc, for placing it on the month grid.
func eventDayRange(form templates.EventFormData, loc *time.Location) (start, end time.Time, err error) {
	start, err = time.ParseInLocation(dateLayout, form.StartDate, loc)
	if err != nil {
		return time.Time{}, time.Time{}, err
	}
	endDate := form.EndDate
	if endDate == "" {
		endDate = form.StartDate
	}
	end, err = time.ParseInLocation(dateLayout, endDate, loc)
	if err != nil {
		return time.Time{}, time.Time{}, err
	}
	if end.Before(start) {
		end = start
	}
	return start, end, nil
}

func (s *Server) handleEventNew(w http.ResponseWriter, r *http.Request) {
	username := userFromContext(r.Context())

	entries, err := s.listCalendarEntries(username)
	if err != nil {
		s.logger.Error("listing calendars", "error", err)
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}
	var options []templates.CalendarOption
	for _, e := range entries {
		if !e.Writable {
			continue
		}
		label := e.Name
		if e.Owner != username {
			label = e.Name + " (" + e.Owner + ")"
		}
		options = append(options, templates.CalendarOption{Ref: e.Ref, Label: label})
	}
	if len(options) == 0 {
		http.Error(w, "you don't have any calendar you can add events to", http.StatusConflict)
		return
	}

	switch r.Method {
	case http.MethodGet:
		selected := r.URL.Query().Get("calendar")
		if selected == "" {
			selected = options[0].Ref
		}
		form := newEventFormDefaults(selected, r.URL.Query().Get("date"))
		form.Calendars = options
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		_ = templates.EventForm(username, form, "").Render(context.Background(), w)
	case http.MethodPost:
		if err := r.ParseForm(); err != nil {
			http.Error(w, "invalid form", http.StatusBadRequest)
			return
		}
		ref := strings.TrimSpace(r.PostForm.Get("calendar"))
		owner, name, err := s.resolveCalRef(username, ref, true)
		if err != nil {
			s.handleCalRefError(w, r, err)
			return
		}
		s.saveEventFromForm(w, r, owner, name, ref, "", options)
	default:
		w.Header().Set("Allow", "GET, POST")
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
	}
}

// handleCalRefError translates a resolveCalRef error into the
// appropriate HTTP response.
func (s *Server) handleCalRefError(w http.ResponseWriter, r *http.Request, err error) {
	switch {
	case errors.Is(err, errCalendarNotFound):
		http.NotFound(w, r)
	case errors.Is(err, errCalendarReadOnly):
		http.Error(w, "this calendar is shared read-only", http.StatusForbidden)
	default:
		s.logger.Error("resolving calendar reference", "error", err)
		http.Error(w, "internal error", http.StatusInternalServerError)
	}
}

// newEventFormDefaults builds the initial form values for a brand new
// event. If dateParam is a valid "YYYY-MM-DD" (e.g. from clicking a day
// cell in the month grid), the event defaults to an all-day event on that
// date; otherwise it defaults to a one-hour timed event starting at the
// next full hour today.
func newEventFormDefaults(calRef, dateParam string) templates.EventFormData {
	if _, err := time.Parse(dateLayout, dateParam); err == nil {
		return templates.EventFormData{CalRef: calRef, AllDay: true, StartDate: dateParam, EndDate: dateParam}
	}
	now := time.Now()
	start := now.Truncate(time.Hour).Add(time.Hour)
	end := start.Add(time.Hour)
	return templates.EventFormData{
		CalRef:    calRef,
		StartDate: start.Format(dateLayout),
		StartTime: start.Format(timeLayout),
		EndDate:   end.Format(dateLayout),
		EndTime:   end.Format(timeLayout),
	}
}

func (s *Server) handleEventEdit(w http.ResponseWriter, r *http.Request) {
	username := userFromContext(r.Context())
	ref := r.PathValue("ref")
	id := r.PathValue("id")

	owner, name, err := s.resolveCalRef(username, ref, false)
	if err != nil {
		s.handleCalRefError(w, r, err)
		return
	}
	if !eventIDRe.MatchString(id) {
		http.NotFound(w, r)
		return
	}

	switch r.Method {
	case http.MethodGet:
		data, err := s.store.GetObject(owner, "cal-"+name, id)
		if err != nil {
			http.NotFound(w, r)
			return
		}
		form, err := eventFormFromICS(id, data)
		if err != nil {
			s.logger.Error("decoding event", "error", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}
		form.CalRef = ref
		label := name
		if owner != username {
			label = name + " (" + owner + ")"
		}
		form.CalendarLabel = label
		form.Writable = owner == username
		if !form.Writable {
			if share, err := s.dbase.CalendarShareFor(owner, name, username); err == nil {
				form.Writable = share.Permission == db.PermWrite
			}
		}
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		_ = templates.EventForm(username, form, "").Render(context.Background(), w)
	case http.MethodPost:
		if owner2, _, err := s.resolveCalRef(username, ref, true); err != nil {
			s.handleCalRefError(w, r, err)
			return
		} else {
			owner = owner2
		}
		s.saveEventFromForm(w, r, owner, name, ref, id, nil)
	default:
		w.Header().Set("Allow", "GET, POST")
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
	}
}

func (s *Server) handleEventDelete(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		w.Header().Set("Allow", "POST")
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	username := userFromContext(r.Context())
	ref := r.PathValue("ref")
	id := r.PathValue("id")

	owner, name, err := s.resolveCalRef(username, ref, true)
	if err != nil {
		s.handleCalRefError(w, r, err)
		return
	}
	if !eventIDRe.MatchString(id) {
		http.NotFound(w, r)
		return
	}
	if err := s.store.DeleteObject(owner, "cal-"+name, id); err != nil {
		http.NotFound(w, r)
		return
	}
	http.Redirect(w, r, "/web/calendar", http.StatusSeeOther)
}

// eventFormInput holds the parsed, not-yet-validated values submitted by
// the event form.
type eventFormInput struct {
	Summary     string
	Description string
	Location    string
	AllDay      bool
	StartDate   string
	StartTime   string
	EndDate     string
	EndTime     string
}

func parseEventForm(r *http.Request) eventFormInput {
	return eventFormInput{
		Summary:     strings.TrimSpace(r.PostForm.Get("summary")),
		Description: strings.TrimSpace(r.PostForm.Get("description")),
		Location:    strings.TrimSpace(r.PostForm.Get("location")),
		AllDay:      r.PostForm.Get("all_day") != "",
		StartDate:   strings.TrimSpace(r.PostForm.Get("start_date")),
		StartTime:   strings.TrimSpace(r.PostForm.Get("start_time")),
		EndDate:     strings.TrimSpace(r.PostForm.Get("end_date")),
		EndTime:     strings.TrimSpace(r.PostForm.Get("end_time")),
	}
}

// saveEventFromForm handles both event creation (id == "") and editing
// (id preserves the existing event's UID). owner/name identify the
// resolved (and already permission-checked) storage location; ref is the
// calendar reference used for redirect/re-render URLs; options is only
// non-nil when creating a new event (to re-render the calendar <select>
// on a validation error).
func (s *Server) saveEventFromForm(w http.ResponseWriter, r *http.Request, owner, name, ref, id string, options []templates.CalendarOption) {
	username := userFromContext(r.Context())
	if err := r.ParseForm(); err != nil {
		http.Error(w, "invalid form", http.StatusBadRequest)
		return
	}
	in := parseEventForm(r)

	reRender := func(errMsg string) {
		form := templates.EventFormData{
			CalRef: ref, ID: id, Summary: in.Summary, Description: in.Description, Location: in.Location,
			AllDay: in.AllDay, StartDate: in.StartDate, StartTime: in.StartTime, EndDate: in.EndDate, EndTime: in.EndTime,
			Calendars: options,
		}
		if id != "" {
			label := name
			if owner != username {
				label = name + " (" + owner + ")"
			}
			form.CalendarLabel = label
		}
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		_ = templates.EventForm(username, form, errMsg).Render(context.Background(), w)
	}

	if in.Summary == "" {
		reRender("Title is required")
		return
	}

	start, end, err := computeEventTimes(in)
	if err != nil {
		reRender(err.Error())
		return
	}

	var uid string
	if id == "" {
		newID, err := newEventID()
		if err != nil {
			s.logger.Error("generating event id", "error", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}
		id = newID
		uid = strings.TrimSuffix(id, ".ics")
	} else {
		data, err := s.store.GetObject(owner, "cal-"+name, id)
		if err != nil {
			http.NotFound(w, r)
			return
		}
		existing, err := ical.NewDecoder(strings.NewReader(string(data))).Decode()
		if err != nil {
			s.logger.Error("decoding existing event", "error", err)
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}
		if events := existing.Events(); len(events) > 0 {
			if uidProp := events[0].Props.Get(ical.PropUID); uidProp != nil {
				uid = uidProp.Value
			}
		}
		if uid == "" {
			uid = strings.TrimSuffix(id, ".ics")
		}
	}

	newCal := buildEventCalendar(uid, in, start, end)
	if err := s.saveEvent(owner, name, id, newCal); err != nil {
		s.logger.Error("saving event", "error", err)
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/web/calendar", http.StatusSeeOther)
}

// computeEventTimes validates and converts the submitted form fields into
// concrete start/end instants (for timed events) or dates (for all-day
// events, where end is returned as the exclusive DTEND day).
func computeEventTimes(in eventFormInput) (start, end time.Time, err error) {
	if in.StartDate == "" {
		return time.Time{}, time.Time{}, fmt.Errorf("start date is required")
	}
	endDate := in.EndDate
	if endDate == "" {
		endDate = in.StartDate
	}

	if in.AllDay {
		start, err = time.ParseInLocation(dateLayout, in.StartDate, time.Local)
		if err != nil {
			return time.Time{}, time.Time{}, fmt.Errorf("invalid start date")
		}
		end, err = time.ParseInLocation(dateLayout, endDate, time.Local)
		if err != nil {
			return time.Time{}, time.Time{}, fmt.Errorf("invalid end date")
		}
		if end.Before(start) {
			return time.Time{}, time.Time{}, fmt.Errorf("end date must not be before start date")
		}
		// DTEND for all-day events is exclusive: the end date the user
		// picks is the last day the event covers, so add one day.
		end = end.AddDate(0, 0, 1)
		return start, end, nil
	}

	if in.StartTime == "" || in.EndTime == "" {
		return time.Time{}, time.Time{}, fmt.Errorf("start and end time are required for timed events")
	}
	start, err = time.ParseInLocation(dateLayout+"T"+timeLayout, in.StartDate+"T"+in.StartTime, time.Local)
	if err != nil {
		return time.Time{}, time.Time{}, fmt.Errorf("invalid start date/time")
	}
	end, err = time.ParseInLocation(dateLayout+"T"+timeLayout, endDate+"T"+in.EndTime, time.Local)
	if err != nil {
		return time.Time{}, time.Time{}, fmt.Errorf("invalid end date/time")
	}
	if !end.After(start) {
		return time.Time{}, time.Time{}, fmt.Errorf("end must be after start")
	}
	return start, end, nil
}

// buildEventCalendar builds a fresh VCALENDAR/VEVENT from the submitted
// form input and resolved start/end instants.
func buildEventCalendar(uid string, in eventFormInput, start, end time.Time) *ical.Calendar {
	cal := ical.NewCalendar()
	cal.Props.SetText(ical.PropVersion, "2.0")
	cal.Props.SetText(ical.PropProductID, "-//nidus//web calendar//EN")

	ev := ical.NewEvent()
	ev.Props.SetText(ical.PropUID, uid)
	ev.Props.SetDateTime(ical.PropDateTimeStamp, time.Now().UTC())
	ev.Props.SetText(ical.PropSummary, in.Summary)
	if in.Description != "" {
		ev.Props.SetText(ical.PropDescription, in.Description)
	}
	if in.Location != "" {
		ev.Props.SetText(ical.PropLocation, in.Location)
	}

	if in.AllDay {
		ev.Props.SetDate(ical.PropDateTimeStart, start)
		ev.Props.SetDate(ical.PropDateTimeEnd, end)
	} else {
		ev.Props.SetDateTime(ical.PropDateTimeStart, start.UTC())
		ev.Props.SetDateTime(ical.PropDateTimeEnd, end.UTC())
	}

	cal.Children = append(cal.Children, ev.Component)
	return cal
}

func (s *Server) saveEvent(owner, cal, id string, calendar *ical.Calendar) error {
	var buf strings.Builder
	enc := ical.NewEncoder(&buf)
	if err := enc.Encode(calendar); err != nil {
		return fmt.Errorf("encoding ical: %w", err)
	}
	return s.store.PutObject(owner, "cal-"+cal, id, []byte(buf.String()))
}

// eventFormFromICS decodes a single-VEVENT .ics object into the shared
// EventFormData shape used both for pre-filling the edit form and for
// placing the event on the month grid.
func eventFormFromICS(id string, data []byte) (templates.EventFormData, error) {
	calendar, err := ical.NewDecoder(strings.NewReader(string(data))).Decode()
	if err != nil {
		return templates.EventFormData{}, err
	}
	events := calendar.Events()
	if len(events) == 0 {
		return templates.EventFormData{}, fmt.Errorf("no VEVENT in %s", id)
	}
	ev := events[0]

	form := templates.EventFormData{ID: id}
	if p := ev.Props.Get(ical.PropSummary); p != nil {
		form.Summary = p.Value
	}
	if p := ev.Props.Get(ical.PropDescription); p != nil {
		form.Description = p.Value
	}
	if p := ev.Props.Get(ical.PropLocation); p != nil {
		form.Location = p.Value
	}

	startProp := ev.Props.Get(ical.PropDateTimeStart)
	endProp := ev.Props.Get(ical.PropDateTimeEnd)
	if startProp == nil {
		return templates.EventFormData{}, fmt.Errorf("missing DTSTART in %s", id)
	}

	allDay := startProp.ValueType() == ical.ValueDate || len(startProp.Value) == 8 // RFC 5545 DATE value, e.g. "20060102"
	form.AllDay = allDay

	if allDay {
		start, err := startProp.DateTime(time.Local)
		if err != nil {
			return templates.EventFormData{}, err
		}
		form.StartDate = start.Format(dateLayout)
		end := start.AddDate(0, 0, 1)
		if endProp != nil {
			if e, err := endProp.DateTime(time.Local); err == nil {
				end = e
			}
		}
		// Displayed end date is the last inclusive day (DTEND is exclusive).
		form.EndDate = end.AddDate(0, 0, -1).Format(dateLayout)
	} else {
		// go-ical's Prop.DateTime always parses a "Z"-suffixed UTC value
		// as UTC regardless of the loc argument passed in, so the
		// returned time must be explicitly converted to the local zone
		// before formatting for display.
		start, err := startProp.DateTime(time.Local)
		if err != nil {
			return templates.EventFormData{}, err
		}
		start = start.In(time.Local)
		form.StartDate = start.Format(dateLayout)
		form.StartTime = start.Format(timeLayout)
		end := start.Add(time.Hour)
		if endProp != nil {
			if e, err := endProp.DateTime(time.Local); err == nil {
				end = e.In(time.Local)
			}
		}
		form.EndDate = end.Format(dateLayout)
		form.EndTime = end.Format(timeLayout)
	}

	return form, nil
}

// handleCalendarExportOne exports a single event as a standalone .ics
// file.
func (s *Server) handleEventExportOne(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		w.Header().Set("Allow", "GET")
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	username := userFromContext(r.Context())
	ref := r.PathValue("ref")
	id := r.PathValue("id")

	owner, name, err := s.resolveCalRef(username, ref, false)
	if err != nil {
		s.handleCalRefError(w, r, err)
		return
	}
	if !eventIDRe.MatchString(id) {
		http.NotFound(w, r)
		return
	}
	data, err := s.store.GetObject(owner, "cal-"+name, id)
	if err != nil {
		http.NotFound(w, r)
		return
	}
	w.Header().Set("Content-Type", "text/calendar; charset=utf-8")
	w.Header().Set("Content-Disposition", `attachment; filename="`+id+`"`)
	_, _ = w.Write(data)
}

// handleCalendarExportAll exports every event in a calendar as one
// concatenated .ics file.
func (s *Server) handleCalendarExportAll(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		w.Header().Set("Allow", "GET")
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	username := userFromContext(r.Context())
	ref := r.PathValue("ref")

	owner, name, err := s.resolveCalRef(username, ref, false)
	if err != nil {
		s.handleCalRefError(w, r, err)
		return
	}

	ids, err := s.store.ListObjects(owner, "cal-"+name)
	if err != nil {
		s.logger.Error("listing calendar objects", "calendar", name, "error", err)
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "text/calendar; charset=utf-8")
	w.Header().Set("Content-Disposition", `attachment; filename="`+name+`.ics"`)
	for _, id := range ids {
		data, err := s.store.GetObject(owner, "cal-"+name, id)
		if err != nil {
			continue
		}
		// Each stored object is already a complete, self-contained
		// VCALENDAR document, so concatenating their raw bytes produces a
		// file most clients will happily re-import (though it is not a
		// single strictly-valid multi-event VCALENDAR document).
		_, _ = w.Write(data)
	}
}

// handleCalendarImport accepts an uploaded .ics file that may contain one
// or more VCALENDAR blocks, each possibly holding multiple VEVENTs, and
// stores each VEVENT as its own object (mirroring how the CalDAV backend
// stores one event per object).
func (s *Server) handleCalendarImport(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		w.Header().Set("Allow", "POST")
		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	username := userFromContext(r.Context())
	ref := r.PathValue("ref")

	owner, name, err := s.resolveCalRef(username, ref, true)
	if err != nil {
		s.handleCalRefError(w, r, err)
		return
	}

	if err := r.ParseMultipartForm(maxUploadMemory); err != nil {
		http.Error(w, "invalid upload", http.StatusBadRequest)
		return
	}
	file, _, err := r.FormFile("file")
	if err != nil {
		http.Error(w, "no file provided", http.StatusBadRequest)
		return
	}
	defer file.Close()

	body, err := io.ReadAll(file)
	if err != nil {
		s.logger.Error("reading import file", "error", err)
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}

	imported := 0
	dec := ical.NewDecoder(bytes.NewReader(body))
	for {
		srcCal, err := dec.Decode()
		if errors.Is(err, io.EOF) {
			break
		}
		if err != nil {
			s.logger.Warn("stopping ics import on parse error", "calendar", name, "error", err)
			break
		}

		version := "2.0"
		if p := srcCal.Props.Get(ical.PropVersion); p != nil && p.Value != "" {
			version = p.Value
		}
		prodID := "-//nidus//web calendar//EN"
		if p := srcCal.Props.Get(ical.PropProductID); p != nil && p.Value != "" {
			prodID = p.Value
		}
		var timezones []*ical.Component
		for _, child := range srcCal.Children {
			if child.Name == ical.CompTimezone {
				timezones = append(timezones, child)
			}
		}

		for _, ev := range srcCal.Events() {
			id, err := newEventID()
			if err != nil {
				s.logger.Error("generating event id", "error", err)
				continue
			}
			out := ical.NewCalendar()
			out.Props.SetText(ical.PropVersion, version)
			out.Props.SetText(ical.PropProductID, prodID)
			out.Children = append(out.Children, timezones...)
			out.Children = append(out.Children, ev.Component)

			if err := s.saveEvent(owner, name, id, out); err != nil {
				s.logger.Warn("saving imported event", "error", err)
				continue
			}
			imported++
		}
	}

	http.Redirect(w, r, "/web/calendar?imported="+strconv.Itoa(imported), http.StatusSeeOther)
}