1 files changed, 92 insertions, 0 deletions
diff --git a/internal/api/ics_client.go b/internal/api/ics_client.go
new file mode 100644
index 0000000..857fa8f
--- /dev/null
+++ b/internal/api/ics_client.go
@@ -0,0 +1,92 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"task-dashboard/internal/models"
+)
+
+// ICSFetcher retrieves and parses a remote iCalendar feed.
+type ICSFetcher struct {
+	client *http.Client
+}
+
+// NewICSFetcher builds a fetcher with a bounded timeout.
+func NewICSFetcher(timeout time.Duration) *ICSFetcher {
+	return &ICSFetcher{client: &http.Client{Timeout: timeout}}
+}
+
+// maxICSBytes caps how much of a feed is read. A calendar is small; anything
+// enormous is a misconfigured URL pointing at something else, and reading it
+// all into memory would be the only harm it does.
+const maxICSBytes = 8 << 20 // 8 MiB
+
+// Fetch downloads the feed at url and returns its events.
+//
+// The context is threaded into the request, so a hung feed cannot outlive the
+// refresh that started it — see internal/api/context_audit_test.go for why that
+// matters here.
+func (f *ICSFetcher) Fetch(ctx context.Context, url string) ([]ICSEvent, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("building request: %w", err)
+	}
+	// Some publishers serve HTML to unknown agents and the calendar only to
+	// something that looks like a calendar client.
+	req.Header.Set("Accept", "text/calendar, text/plain;q=0.9, */*;q=0.8")
+	req.Header.Set("User-Agent", "doot/1.0 (+https://doot.terst.org)")
+
+	resp, err := f.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("fetching feed: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("feed returned HTTP %d", resp.StatusCode)
+	}
+
+	events, err := ParseICS(io.LimitReader(resp.Body, maxICSBytes))
+	if err != nil {
+		return nil, fmt.Errorf("parsing feed: %w", err)
+	}
+	return events, nil
+}
+
+// ToCalendarEvents converts parsed ICS events into the model the timeline
+// already renders, so feed events need no special handling downstream.
+//
+// feedID scopes the generated ids; feedName is prefixed to each title so a
+// bare fixture like "Seahawks at 49ers" is identifiable on a mixed timeline.
+func ToCalendarEvents(feedID, feedName string, events []ICSEvent) []models.CalendarEvent {
+	out := make([]models.CalendarEvent, 0, len(events))
+	for _, e := range events {
+		summary := e.Summary
+		if summary == "" {
+			summary = feedName
+		}
+		out = append(out, models.CalendarEvent{
+			ID:          e.StableID(feedID),
+			Summary:     summary,
+			Description: descriptionWithLocation(e),
+			Start:       e.Start,
+			End:         e.End,
+		})
+	}
+	return out
+}
+
+func descriptionWithLocation(e ICSEvent) string {
+	switch {
+	case e.Location == "":
+		return e.Description
+	case e.Description == "":
+		return e.Location
+	default:
+		return e.Description + "\n" + e.Location
+	}
+}