Add daily render context

internal/generatedtext/render_context.go

@@ -52,6 +52,14 @@ type TomorrowRenderContext struct {
 	Derived       facts.DerivedFacts
 }
 
+type DailyRenderContext struct {
+	Report        DailyReportContext
+	GeneratedText Daily
+	Modules       DailyTemplateModules
+	Collected     facts.CollectedFacts
+	Derived       facts.DerivedFacts
+}
+
 type TodayRenderContext struct {
 	Report        TodayReportContext
 	GeneratedText Today
@@ -124,6 +132,39 @@ type TomorrowDaypartContext struct {
 	Summary briefing.DerivedDaypartSummaryModule
 }
 
+type DailyReportContext struct {
+	Title             string
+	ForecastDate      time.Time
+	ForecastDateLabel string
+	ForecastDayName   string
+	GeneratedAt       time.Time
+	GeneratedAtLabel  string
+	ValidPeriod       timeutil.Period
+	Timezone          string
+}
+
+type DailyTemplateModules struct {
+	Metadata                *briefing.MetadataModule
+	CurrentConditions       *briefing.CurrentConditionsModule
+	HourlyForecast          *briefing.HourlyForecastModule
+	DerivedDailySummary     *briefing.DerivedDailySummaryModule
+	DerivedDaypartSummaries *map[string]briefing.DerivedDaypartSummaryModule
+	Dayparts                []DailyDaypartContext
+	PrecipTiming            *briefing.PrecipTimingModule
+	AlertDigest             *briefing.AlertDigestModule
+	SPCConvectiveOutlooks   *briefing.SPCConvectiveOutlooksModule
+	AreaForecastDiscussion  *briefing.AreaForecastDiscussionModule
+	SPCConvectiveDiscussion *briefing.SPCConvectiveDiscussionModule
+	WeatherStory            *briefing.WeatherStoryModule
+	OutdoorWindows          *briefing.OutdoorWindowsModule
+	DailyPlanning           *briefing.DailyPlanningModule
+}
+
+type DailyDaypartContext struct {
+	Key     string
+	Summary briefing.DerivedDaypartSummaryModule
+}
+
 func BuildHourlyRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, generated Hourly, collected facts.CollectedFacts, derived facts.DerivedFacts) (HourlyRenderContext, error) {
 	location, err := timeutil.LoadLocation(metadata.Timezone)
 	if err != nil {
@@ -156,6 +197,41 @@ func BuildHourlyRenderContext(metadata briefing.Metadata, snapshot module.Snapsh
 	}, nil
 }
 
+func BuildDailyRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, generated Daily, collected facts.CollectedFacts, derived facts.DerivedFacts) (DailyRenderContext, error) {
+	location, err := timeutil.LoadLocation(metadata.Timezone)
+	if err != nil {
+		return DailyRenderContext{}, fmt.Errorf("build daily render context: %w", err)
+	}
+	if metadata.GeneratedAt.IsZero() {
+		return DailyRenderContext{}, fmt.Errorf("build daily render context: generatedAt is required")
+	}
+	if !metadata.ValidPeriod.IsValid() {
+		return DailyRenderContext{}, fmt.Errorf("build daily render context: valid period is required")
+	}
+	modules, err := dailyTemplateModules(snapshot, derived)
+	if err != nil {
+		return DailyRenderContext{}, err
+	}
+	forecastDate := metadata.ValidPeriod.Start.In(location)
+	forecastDayName := forecastDate.Format("Monday")
+	return DailyRenderContext{
+		Report: DailyReportContext{
+			Title:             forecastDayName + "'s Weather",
+			ForecastDate:      forecastDate,
+			ForecastDateLabel: forecastDate.Format("Monday, January 2, 2006"),
+			ForecastDayName:   forecastDayName,
+			GeneratedAt:       metadata.GeneratedAt,
+			GeneratedAtLabel:  generatedAtLabel(metadata.GeneratedAt, location),
+			ValidPeriod:       metadata.ValidPeriod,
+			Timezone:          metadata.Timezone,
+		},
+		GeneratedText: generated,
+		Modules:       modules,
+		Collected:     collected,
+		Derived:       derived,
+	}, nil
+}
+
 func BuildTodayRenderContext(metadata briefing.Metadata, snapshot module.Snapshot, generated Today, collected facts.CollectedFacts, derived facts.DerivedFacts) (TodayRenderContext, error) {
 	location, err := timeutil.LoadLocation(metadata.Timezone)
 	if err != nil {
@@ -225,6 +301,78 @@ func BuildTomorrowRenderContext(metadata briefing.Metadata, snapshot module.Snap
 	}, nil
 }
 
+func dailyTemplateModules(snapshot module.Snapshot, derived facts.DerivedFacts) (DailyTemplateModules, error) {
+	lookup := newModuleSnapshotLookup(snapshot)
+	metadata, err := lookup.metadata()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	current, err := lookup.currentConditions()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	hourly, err := lookup.hourlyForecast()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	daily, err := lookup.derivedDailySummary()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	dayparts, err := lookup.derivedDaypartSummaries()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	precip, err := lookup.precipTiming()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	alerts, err := lookup.alertDigest()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	outlooks, err := lookup.spcConvectiveOutlooks()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	discussion, err := lookup.areaForecastDiscussion()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	spcDiscussion, err := lookup.spcConvectiveDiscussion()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	story, err := lookup.weatherStory()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	outdoor, err := lookup.outdoorWindows()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	planning, err := lookup.dailyPlanning()
+	if err != nil {
+		return DailyTemplateModules{}, err
+	}
+	return DailyTemplateModules{
+		Metadata:                metadata,
+		CurrentConditions:       current,
+		HourlyForecast:          hourly,
+		DerivedDailySummary:     daily,
+		DerivedDaypartSummaries: dayparts,
+		Dayparts:                orderedDailyDayparts(dayparts, derived.DaypartSummaries),
+		PrecipTiming:            precip,
+		AlertDigest:             alerts,
+		SPCConvectiveOutlooks:   outlooks,
+		AreaForecastDiscussion:  discussion,
+		SPCConvectiveDiscussion: spcDiscussion,
+		WeatherStory:            story,
+		OutdoorWindows:          outdoor,
+		DailyPlanning:           planning,
+	}, nil
+}
+
 func todayTemplateModules(snapshot module.Snapshot, derived facts.DerivedFacts) (TodayTemplateModules, error) {
 	lookup := newModuleSnapshotLookup(snapshot)
 	metadata, err := lookup.metadata()
@@ -470,6 +618,14 @@ func (lookup moduleSnapshotLookup) weatherStory() (*briefing.WeatherStoryModule,
 	return optionalStanza[briefing.WeatherStoryModule](lookup, module.WeatherStory)
 }
 
+func (lookup moduleSnapshotLookup) outdoorWindows() (*briefing.OutdoorWindowsModule, error) {
+	return optionalStanza[briefing.OutdoorWindowsModule](lookup, module.OutdoorWindows)
+}
+
+func (lookup moduleSnapshotLookup) dailyPlanning() (*briefing.DailyPlanningModule, error) {
+	return optionalStanza[briefing.DailyPlanningModule](lookup, module.DailyPlanning)
+}
+
 func (lookup moduleSnapshotLookup) todayPlanning() (*briefing.TodayPlanningModule, error) {
 	return optionalStanza[briefing.TodayPlanningModule](lookup, module.TodayPlanning)
 }
@@ -500,6 +656,15 @@ func orderedTodayDayparts(dayparts *map[string]briefing.DerivedDaypartSummaryMod
 	return out
 }
 
+func orderedDailyDayparts(dayparts *map[string]briefing.DerivedDaypartSummaryModule, ordered []forecast.DaypartSummary) []DailyDaypartContext {
+	orderedRows := orderedDaypartRows(dayparts, ordered)
+	out := make([]DailyDaypartContext, 0, len(orderedRows))
+	for _, row := range orderedRows {
+		out = append(out, DailyDaypartContext{Key: row.Key, Summary: row.Summary})
+	}
+	return out
+}
+
 func orderedTomorrowDayparts(dayparts *map[string]briefing.DerivedDaypartSummaryModule, ordered []forecast.DaypartSummary) []TomorrowDaypartContext {
 	orderedRows := orderedDaypartRows(dayparts, ordered)
 	out := make([]TomorrowDaypartContext, 0, len(orderedRows))