configuration

type Clock struct {
	// The first label of the clock is a human readable label for the clock. For example, use "UTC" for a clock that displays the UTC time.
	Label string `hcl:"label,label"`
	// The location attribute is a name corresponding to a well known location on earth, for example "Europe/Paris".
	// You can also use the special values "UTC" and "Local" for the UTC timezone and the configured local one respectively.
	// See [time.LoadLocation].
	//
	// [time.LoadLocation]: https://pkgo.dev/time#LoadLocation
	Location string `hcl:"location"`
	// The format attribute is the display format of the clock. Use the [time.Format] reference time to describe the expected format, ie "2006-01-02 15:04:05"
	Format string `hcl:"format,optional"`
	// The status_format attribute is the display format for the Update and Change columns of a status row when the display_time_for_statuses attribute of the preferences block is set to true.
	StatusFormat string `hcl:"status_format,optional"`
	// The status_day_format attribute is the same as above, but used when the change or update happened a different day than today.
	StatusDayFormat string `hcl:"status_day_format,optional"`
}

type ClockConfig struct {
	Label           string
	Location        *time.Location
	Format          string
	StatusFormat    string
	StatusDayFormat string
}

type ControllerConfig struct {
	Refresh                time.Duration
	RefreshOnUpdate        bool
	Expiration             time.Duration
	DefaultSeverityFilter  model.Severity
	DefaultLayerFilter     model.Layer
	DefaultSort            model.StatusField
	MinimumErrorSeverity   model.Severity
	DisplayTimeForStatuses bool
	Clocks                 []ClockConfig
	LogFile                string
}

type File struct {
	// A preferences block sets general preferences such as default severity filter, ordering and user interface refresh interval.
	// Only one preferences block is allowed per configuration.
	Preferences []Preferences `hcl:"preferences,block"`
	// A theme block customizes Kee's appearence.
	// Only one theme block is allowed per configuration.
	Theme []Theme `hcl:"theme,block"`
	// A probe block configures a probe provider to watch a system or resource and reports its status(es)/conditions.
	// The first label of the block is the provider type; the second is a human readable label for it.
	// The tuple (provider type, label) must be unique within the configuration.
	// You can define multiple probe blocks per configuration.
	Probes []Probe `hcl:"probe,block"`
}

type HeaderConfig struct {
	BgColor          tcell.Color
	FgColor          tcell.Color
	StatusCountRules []ThemeRuleConfig
	ErrorCountRules  []ThemeRuleConfig
	BorderColor      tcell.Color
	LayerMenu        ThemeMenuConfig
	SeverityMenu     ThemeMenuConfig
	SortMenu         ThemeMenuConfig
}

type HeaderTheme struct {
	BgColor         string      `hcl:"bg_color,optional"`
	FgColor         string      `hcl:"fg_color,optional"`
	StatusCountRule []ThemeRule `hcl:"status_count_rule,block"`
	ErrorCountRule  []ThemeRule `hcl:"error_count_rule,block"`
	BorderColor     string      `hcl:"border_color,optional"`
	LayerMenu       []ThemeMenu `hcl:"layer_menu,block"`
	SeverityMenu    []ThemeMenu `hcl:"severity_menu,block"`
	SortMenu        []ThemeMenu `hcl:"sort_menu,block"`
}

type InternalConfig struct {
	Controller  *ControllerConfig
	View        *ViewConfig
	ProbeRunner ProbeRunnerConfigs
}

type Preferences struct {
	// The refresh_interval attribute sets how often the interface will be refreshed. Use duration values.
	// It defaults to 1 second.
	RefreshInterval string `hcl:"refresh_interval,optional"`
	// The refresh_on_update attribute will refresh the interface everytime new information is gathered by a probe, in addition to the refresh_interval, when set to true.
	RefreshOnUpdate bool `hcl:"refresh_on_update,optional"`
	// The expiration attribute will hide statuses that haven't been updated within the specified duration.
	// This is useful to clear some errors due to loosing network, or to "forget" statuses about resources that were deleted while kee is running, such as pods or CloudWatch alarms.
	Expiration string `hcl:"expiration,optional"`
	// The default_filter attribute is a severity that will filter status rows on launch. This is merely a convenience and you can always update the filter while the app is running.
	DefaultFilter int `hcl:"default_filter,optional"`
	// The default_sort attribute is a field that will sort status rows on launch. Only fields currently accepted are severity, label and change. You can change ordering while the app is running.
	DefaultSort int `hcl:"default_sort,optional"`
	// The minimum_error_severity attribute determines which severities count as errors (in summaries, like the count presented in the interface header or the JSON output from -t mode)
	MinErrorSeverity int `hcl:"minimum_error_severity,optional"`
	// The display_time_for_statuses attribute, when set to true, display the time and (if needed) the date of changes and updates rather than a duration.
	DisplayTimeForStatuses bool `hcl:"display_time_for_statuses,optional"`
	// The log_file attributes will enable a JSON log file reporting all changes. This is intended for incident post-mortems.
	LogFile string `hcl:"log_file,optional"`
	// A clock block configures a timezone location and display format for the clock in the header and for the Update and Change columns when display_time_for_statuses is set to true.
	Clocks []Clock `hcl:"clock,block"`
}

type Probe struct {
	// The first label is the type of probe to use.
	Type string `hcl:"type,label"`
	// The second label is the human-readable label for the probe.
	Label string `hcl:"label,label"`
	// The minimum_severity attribute is a severity that will replace the probe's reported severity when the condition reported is not OK.
	// Use this if a probe doesn't present a condition as severe enough for critical resources in your system.
	MinSeverity int `hcl:"minimum_severity,optional"`
	// The interval attribute is a duration that define how often the probe will check for a system or resources conditions.
	// It defaults to 1 minute.
	Interval string `hcl:"interval,optional"`
	// The layer attribute assigns a static system layer to all Statuses returned by this probe.
	Layer int `hcl:"layer,optional"`
	// The remainder of the probe block depends on the type of the probe selected with the first label.
	ProbeConfig hcl.Body `hcl:"probe_configuration,remain"`
}

type ProbeRunnerConfig struct {
	ID          string
	Probe       model.Prober
	MinSeverity model.Severity
	Label       string
	Interval    time.Duration
	Layer       model.Layer
}

type ProbeRunnerConfigs []ProbeRunnerConfig

type StatusTableConfig struct {
	BgColor       tcell.Color
	BorderColor   tcell.Color
	HeaderBgColor tcell.Color
	HeaderFgColor tcell.Color
	Columns       []model.StatusField
	Rules         []ThemeRuleConfig
}

type StatusTableTheme struct {
	BgColor       string      `hcl:"bg_color,optional"`
	BorderColor   string      `hcl:"border_color,optional"`
	HeaderBgColor string      `hcl:"header_bg_color,optional"`
	HeaderFgColor string      `hcl:"header_fg_color,optional"`
	Columns       []int       `hcl:"columns,optional"`
	Rules         []ThemeRule `hcl:"rule,block"`
}

type Theme struct {
	// The title attribute sets what is display on top of the header of the interface.
	// You may use it to distinguish between a prod and a dev Kee configuration for example, or to indicate which system or app is being monitored by the configuration.
	Title       string             `hcl:"title,optional"`
	Header      []HeaderTheme      `hcl:"header,block"`
	StatusTable []StatusTableTheme `hcl:"status_table,block"`
}

type ThemeMenu struct {
	FgColor         string `hcl:"fg_color,optional"`
	SelectedFgColor string `hcl:"selected_fg_color,optional"`
	TitleFgColor    string `hcl:"title_fg_color,optional"`
}

type ThemeMenuConfig struct {
	FgColor         tcell.Color
	SelectedFgColor tcell.Color
	TitleFgColor    tcell.Color
}

type ThemeRule struct {
	Condition hcl.Expression `hcl:"condition,optional"`
	BgColor   string         `hcl:"bg_color,optional"`
	FgColor   string         `hcl:"fg_color,optional"`
}

type ThemeRuleConfig struct {
	Condition hcl.Expression
	BgColor   tcell.Color
	FgColor   tcell.Color
}

type Variables map[string]cty.Value

type ViewConfig struct {
	Title       string
	Header      HeaderConfig
	StatusTable StatusTableConfig
	Context     *hcl.EvalContext
}