config

type ChatRouletteConfig struct {
	// Interval is the interval or frequency that matches will be made.
	// Valid values are "weekly", "biweekly", "triweekly", or "monthly".
	//
	// Optional
	Interval string `mapstructure:"interval"`

	// Weekday is the day of the week that matches will be made.
	// eg, Monday
	//
	// Optional
	Weekday string `mapstructure:"weekday"`

	// Hour is the hour (in UTC) that matches will be made.
	//
	// Optional
	Hour int `mapstructure:"hour"`
}

type Config struct {
	Bot          SlackBotConfig
	ChatRoulette ChatRouletteConfig
	Database     DatabaseConfig
	Server       ServerConfig
	Worker       WorkerConfig
	Tracing      TracingConfig
	Dev          bool
}

type DBConnectionsConfig struct {
	// MaxOpen is the maximum number of open connections.
	//
	// Optional
	MaxOpen int `mapstructure:"max_open"`

	// MaxIdle is the maximum number of idle connections.
	//
	// Optional
	MaxIdle int `mapstructure:"max_idle"`

	// MaxLifeTime is the maximum lifetime of connections.
	//
	// Optional
	MaxLifetime time.Duration `mapstructure:"max_lifetime"`

	// MaxIdleTime is the maximum amount of time a connection can be idle.
	//
	// Optional
	MaxIdletime time.Duration `mapstructure:"max_idletime"`
}

type DBEncryptionConfig struct {
	// Key is the current data encryption key (DEK) used to encrypt and decrypt data.
	// This must be a 32-byte hex-encoded key.
	//
	// Required
	Key string

	// PreviousKey is the key used to decrypt old data. This should
	// only be set if the data encryption key is being rotated.
	// If set, this must be a 32-byte hex-encoded key.
	//
	// Optional
	PreviousKey string `mapstructure:"previous_key"`
}

type DatabaseConfig struct {
	// URL is the PostgreSQL connection URL
	//
	// Required
	URL string

	// Connections is the database connections configuration
	//
	// Optional
	Connections DBConnectionsConfig

	// Encryption is the database encryption configuration
	//
	// Required
	Encryption DBEncryptionConfig
}

type HoneycombTracing struct {
	// Team is the Honeycomb API key to use
	//
	// Required
	Team string `mapstructure:"team"`

	// Dataset is the destination dataset to send traces to
	//
	// Required
	Dataset string `mapstructure:"dataset"`
}

type JaegerTracing struct {
	// Endpoint is the URL of the Jaeger collector.
	// This is typically "http://localhost:14268/api/traces"
	//
	// Required
	Endpoint string `mapstructure:"endpoint"`
}

type ServerConfig struct {
	// Address is the address that the server binds on.
	//
	// Optional, defaults to 0.0.0.0
	Address string

	// Port is the TCP port that the server binds on.
	//
	// Optional, defaults to 8080
	Port int

	// ClientID is the Slack OpenID Connect (OIDC) client ID.
	//
	// Required
	ClientID string `mapstructure:"client_id"`

	// Client Secret is Slack OpenID Connect (OIDC) client secret.
	//
	// Required
	ClientSecret string `mapstructure:"client_secret"`

	// RedirectURL is the Slack OpenID Connect (OIDC) redirect URL.
	//
	// Required
	RedirectURL string `mapstructure:"redirect_url"`

	// SecretKey is the 32-byte hex-encoded secret key used to authenticate cookies.
	//
	// Required
	SecretKey string `mapstructure:"secret_key"`

	// SigningSecret is the secret used to authenticate requests received from Slack.
	//
	// Required
	SigningSecret string `mapstructure:"signing_secret"`
}

type SlackBotConfig struct {
	// AuthToken is the Slack OAuth2 bot token
	//
	// Required
	AuthToken string `mapstructure:"auth_token"`
}

type TracingConfig struct {
	// Enabled turns on OpenTelemetry tracing.
	//
	// Optional
	Enabled bool `mapstructure:"enabled"`

	// Exporter sets the tracing exporter to use.
	// The only options currently supported are: jaeger or honeycomb.
	//
	// Optional
	Exporter TracingExporter `mapstructure:"exporter"`

	// Jaeger stores the configuration for the Jaeger exporter
	//
	// Optional, required if Exporter=jaeger
	Jaeger JaegerTracing `mapstructure:"jaeger"`

	// Honeycomb stores the configuration for the Honeycomb exporter
	//
	// Optional, required if Exporter=honeycomb
	Honeycomb HoneycombTracing `mapstructure:"honeycomb"`
}

type TracingExporter string

type WorkerConfig struct {
	// Concurrency is the number of concurrent workers to run
	//
	// Optional, defaults to the number of CPU cores
	Concurrency int
}