cfgmodel

type Config struct {
	// Version if a compatibility number for the config. It is always 1 for now.
	Version int `koanf:"version"`

	Groups []GroupConfig `koanf:"groups"`

	Server ServerConfig `koanf:"server"`

	Telemetry TelemetryConfig `koanf:"telemetry"`

	Heartbeat HeartbeatConfig `koanf:"heartbeat"`

	Service ServiceConfig `koanf:"service"`

	Notifications NotificationsConfig `koanf:"notifications"`
}

type GroupConfig struct {
	// A unique ID for the group. It will be used in metrics and logs.
	ID          string `koanf:"id"`
	DisplayName string `koanf:"display_name"`

	// ReadOnly is a flag that indicates that the group should not perform any actions.
	// This is useful for testing or for monitoring-only setups.
	ReadOnly bool `koanf:"readonly"`

	// PollInterval is the interval at which to poll the Hetzner API for changes.
	// This defaults to 1 minute.
	PollInterval time.Duration `koanf:"poll_interval"`

	// PollTimeout is the maximum time to wait for the Hetzner API to respond.
	// This defaults to 20 seconds.
	PollTimeout time.Duration `koanf:"poll_timeout"`

	// PlanApplyTimeout is the maximum time to wait for a plan to be applied.
	// This defaults to 30 seconds.
	PlanApplyTimeout time.Duration `koanf:"plan_apply_timeout"`

	// PostPlanDelay is the time to wait after a plan is applied before allowing another plan.
	// This is useful to prevent plans happening too quickly in succession.
	// This defaults to 0 (disabled).
	PostPlanDelay time.Duration `koanf:"post_plan_delay"`

	// PlanApplyWithUnknownStatus is a flag that indicates that the group should apply plans
	// even if the status of one or more servers is unknown.
	PlanApplyWithUnkownStatus bool `koanf:"plan_apply_with_unknown_status"`

	// Provider is the name of the cloud provider that the group is using.
	// Supported values: "hetzner", "mock".
	Provider string `koanf:"provider"`

	// Hetzner is the Hetzner-specific configuration.
	// nil when using a different provider.
	Hetzner *HetznerProviderConfig `koanf:"hetzner"`

	// Mock is the mock provider configuration.
	// nil when using a different provider.
	Mock *MockProviderConfig `koanf:"mock"`

	// Checks is a list of health checks to perform on the servers.
	Checks []HealthCheckConfig `koanf:"checks"`
}

type HealthCheckConfig struct {
	ID string `koanf:"id"`

	DisplayName string `koanf:"display_name"`

	// Type of check, currently only "http" or "https" is supported.
	Type string `koanf:"type"`

	// Interval for the check. Must be a `time.Duration` string like "5s" or "1m".
	// Defaults to 1 minute.
	Interval time.Duration `koanf:"interval"`
	// Timeout for waiting for a successful answer. Must be a `time.Duration` string like "5s" or "1m".
	// Defaults to 10 seconds.
	Timeout time.Duration `koanf:"timeout"`

	// Fall is the number of consecutive failures required to mark the check as down.
	// This is useful to avoid flapping. Defaults to 1.
	Fall uint64 `koanf:"fall"`

	// Rise is the number of consecutive successes required to mark the check as up.
	// This is useful to avoid flapping. Defaults to 1.
	Rise uint64 `koanf:"rise"`

	// Method is the HTTP method to use for the check. Defaults to "GET".
	Method string `koanf:"method"`

	// Host is the value of the host header to set. If empty, IP address is used.
	// For HTTPS checks, this is used for SNI: the host must match the certificate.
	Host string `koanf:"host"`

	// Port is the port to check. Must be between 1 and 65535.
	// Defaults to 80 for HTTP and 443 for HTTPS.
	Port int `koanf:"port"`

	// Path is the URL path to check. Should start with a forward slash "/".
	Path string `koanf:"path"`

	// IPVersion is the IP version to use for the check. Must be either "ipv4", "ipv6" or "both".
	// Defaults to "both".
	IPVersion string `koanf:"ip_version"`
}

type HeartbeatConfig struct {
	// Enabled is a flag that enables or disables the heartbeat.
	Enabled bool `koanf:"enabled"`

	// URL is the URL to send the heartbeat to.
	URL string `koanf:"url"`

	// Interval is the interval at which the heartbeat should be sent.
	Interval time.Duration `koanf:"interval"`

	// Timeout is the maximum time to wait for the heartbeat to be sent.
	Timeout time.Duration `koanf:"timeout"`
}

type HetznerProviderConfig struct {
	// API token to use to authenticate with Hetzner
	APIToken string `koanf:"api_token"`

	// ProjectID is the ID of the project to use, you can find this in the URL of the Hetzner Cloud Console.
	// For example, if the URL is https://console.hetzner.cloud/projects/123456, the project ID is 123456.
	//
	// Hetzner does not provide a way to list projects or check the ID, so you will need to know this in advance,
	// see https://github.com/hetznercloud/hcloud-go/issues/451.
	ProjectID string `koanf:"project_id"`

	FloatingIPs HetznerSelector `koanf:"floating_ips"`
	Servers     HetznerSelector `koanf:"servers"`
}

type HetznerSelector struct {
	LabelSelector string `koanf:"label_selector"`
}

type LoggingConfig struct {
	// Level is the log level to use. Valid values are: "debug", "info", "warn", "error".
	// Default is "info".
	Level string `koanf:"level"`
	// Format is the log format to use. Valid values are: "json", "text". Default is "json".
	Format string `koanf:"format"`
}

type MockFloatingIPConfig struct {
	ID            int64  `koanf:"id"`
	Name          string `koanf:"name"`
	Location      string `koanf:"location"`
	NetworkZone   string `koanf:"network_zone"`
	ResourceIndex int    `koanf:"resource_index"`
	IP            string `koanf:"ip"`
	// CurrentTarget is the ID of the server this floating IP is assigned to.
	// Use 0 or omit for unassigned.
	CurrentTarget int64 `koanf:"current_target"`
}

type MockProviderConfig struct {
	// Servers is a list of mock servers to create.
	Servers []MockServerConfig `koanf:"servers"`
	// FloatingIPs is a list of mock floating IPs to create.
	FloatingIPs []MockFloatingIPConfig `koanf:"floating_ips"`
}

type MockServerConfig struct {
	ID            int64  `koanf:"id"`
	Name          string `koanf:"name"`
	Location      string `koanf:"location"`
	NetworkZone   string `koanf:"network_zone"`
	ResourceIndex int    `koanf:"resource_index"`
	PublicIPv4    string `koanf:"public_ipv4"`
	PublicIPv6    string `koanf:"public_ipv6"`
}

type NotificationTargetConfig struct {
	// Type of notification target, currently only "mattermost" is supported (which may be compatible with Slack).
	Type string `json:"type"`

	// URL of the Mattermost webhook.
	URL string `json:"url"`

	// Username to use when sending the notification.
	Username string `json:"username"`

	// Channel to send the notification to.
	// Note that in Mattermost this should be the channel slug, not the display name.
	Channel string `json:"channel"`

	// IconEmoji to use when sending the notification.
	// Defaults to ":dolphin:".
	IconEmoji string `json:"icon_url"`
}

type NotificationsConfig struct {
	Enabled bool                       `json:"enabled"`
	Targets []NotificationTargetConfig `json:"targets"`
}

type ServerConfig struct {
	Enabled bool `koanf:"enabled"`
	// Host to bind to.
	Host string `koanf:"host"`
	// Port to bind to.
	Port int `koanf:"port"`

	// Timeout for graceful shutdown.
	ShutdownTimeout time.Duration `koanf:"shutdown_timeout"`

	// Assets is the path to serve assets from. If empty, the server will use the embedded files.
	// Generally you will only need to specify this during development for quick iteration.
	Assets string `koanf:"assets"`
	// Templates is the path to serve templates from. If empty, the server will use the embedded files.
	// Generally you will only need to specify this during development for quick iteration.
	Templates string `koanf:"templates"`
}

type ServiceConfig struct {
	Name string `koanf:"name"`
}

type TelemetryConfig struct {
	Logging LoggingConfig `koanf:"logging"`
}