weatherreporter/internal/report/registry.go

package report

import (
	"fmt"

	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
)

type Registry struct {
	definitions map[ID]Definition
}

func DefaultRegistry() Registry {
	definitions := []Definition{
		{
			ID:                 DailyToday,
			Name:               "Daily Report",
			PromptID:           "weather.daily_report",
			ComparisonStrategy: CompareSameValidDate,
			ArtifactGroup:      "daily",
			BatchOutputName:    "daily.md",
			Generated:          true,
			CompatiblePriorIDs: []ID{DailyToday, DailyTomorrow},
			Modules:            dailyTodayModules(),
			Morning:            true,
			resolve:            resolveDailyToday,
		},
		{
			ID:                 DailyTomorrow,
			Name:               "Tomorrow Planning Brief",
			PromptID:           "weather.daily_report",
			ComparisonStrategy: CompareSameValidDate,
			ArtifactGroup:      "daily",
			BatchOutputName:    "tomorrow.md",
			Generated:          true,
			CompatiblePriorIDs: []ID{DailyToday, DailyTomorrow},
			Modules:            dailyTomorrowModules(),
			Evening:            true,
			resolve:            resolveDailyTomorrow,
		},
		{
			ID:                 ThreeDay,
			Name:               "3-Day Outlook",
			PromptID:           "weather.three_day_outlook",
			ComparisonStrategy: CompareSameValidDate,
			ArtifactGroup:      "three-day",
			BatchOutputName:    "three-day.md",
			Generated:          true,
			CompatiblePriorIDs: []ID{ThreeDay},
			Modules:            threeDayModules(),
			Morning:            true,
			resolve:            resolveThreeDay,
		},
		{
			ID:                 Weekend,
			Name:               "Weekend Outlook",
			PromptID:           "weather.weekend_outlook",
			ComparisonStrategy: CompareWeekendWindow,
			ArtifactGroup:      "weekend",
			BatchOutputName:    "weekend.md",
			Generated:          true,
			CompatiblePriorIDs: []ID{Weekend},
			Modules:            weekendModules(),
			Morning:            true,
			resolve:            resolveWeekend,
		},
		{
			ID:                 Storm,
			Name:               "Storm Report",
			PromptID:           "weather.storm_report",
			ComparisonStrategy: CompareExplicitWindow,
			ArtifactGroup:      "storm",
			BatchOutputName:    "storm.md",
			Generated:          true,
			CompatiblePriorIDs: []ID{Storm},
			Modules:            stormModules(),
			resolve:            resolveStorm,
		},
	}
	registry := Registry{definitions: map[ID]Definition{}}
	for _, definition := range definitions {
		registry.definitions[definition.ID] = definition
	}
	return registry
}

func (r Registry) WithModuleOverrides(overrides map[ID][]module.ConfigItem) (Registry, error) {
	next := Registry{definitions: map[ID]Definition{}}
	for id, definition := range r.definitions {
		definition.Modules = append([]module.ConfigItem(nil), definition.Modules...)
		next.definitions[id] = definition
	}
	for id, items := range overrides {
		definition, ok := next.definitions[id]
		if !ok {
			return Registry{}, fmt.Errorf("unknown report %q", id)
		}
		definition.Modules = cloneModuleItems(items)
		next.definitions[id] = definition
	}
	return next, nil
}

func dailyTodayModules() []module.ConfigItem {
	return moduleItems(
		module.Metadata,
		module.CurrentConditions,
		module.DerivedDailySummary,
		module.DerivedDaypartSummaries,
		module.PrecipTiming,
		module.AlertDigest,
		module.ForecastDelta,
		module.AreaForecastDiscussion,
		module.WeatherStory,
		module.OutdoorWindows,
	)
}

func dailyTomorrowModules() []module.ConfigItem {
	items := dailyTodayModules()
	items = append(items, module.ConfigItem{ID: module.TomorrowPlanning})
	return items
}

func threeDayModules() []module.ConfigItem {
	return moduleItems(
		module.Metadata,
		module.CurrentConditions,
		module.DerivedDaypartSummaries,
		module.PrecipTiming,
		module.AlertDigest,
		module.ForecastDelta,
		module.AreaForecastDiscussion,
		module.WeatherStory,
		module.OutdoorWindows,
	)
}

func weekendModules() []module.ConfigItem {
	return moduleItems(
		module.Metadata,
		module.CurrentConditions,
		module.DerivedDaypartSummaries,
		module.PrecipTiming,
		module.AlertDigest,
		module.AreaForecastDiscussion,
		module.WeatherStory,
		module.OutdoorWindows,
		module.WeekendPlanning,
	)
}

func stormModules() []module.ConfigItem {
	return moduleItems(
		module.Metadata,
		module.CurrentConditions,
		module.HourlyTable,
		module.PrecipTiming,
		module.AlertDigest,
		module.AreaForecastDiscussion,
		module.WeatherStory,
		module.StormWindowSummary,
	)
}

func moduleItems(ids ...module.ID) []module.ConfigItem {
	items := make([]module.ConfigItem, 0, len(ids))
	for _, id := range ids {
		items = append(items, module.ConfigItem{ID: id})
	}
	return items
}

func cloneModuleItems(items []module.ConfigItem) []module.ConfigItem {
	cloned := make([]module.ConfigItem, len(items))
	copy(cloned, items)
	return cloned
}

func (r Registry) Lookup(id ID) (Definition, error) {
	definition, ok := r.definitions[id]
	if !ok {
		return Definition{}, fmt.Errorf("unknown report %q", id)
	}
	return definition, nil
}

func (r Registry) MustLookup(id ID) Definition {
	definition, err := r.Lookup(id)
	if err != nil {
		panic(err)
	}
	return definition
}

func (r Registry) All() []Definition {
	ids := []ID{DailyToday, DailyTomorrow, ThreeDay, Weekend, Storm}
	out := make([]Definition, 0, len(ids))
	for _, id := range ids {
		if definition, ok := r.definitions[id]; ok {
			out = append(out, definition)
		}
	}
	return out
}