config

type AggregationConfiguration struct {
	ClickHouse ClickHouseAggregationConfiguration

	EventsTableName string

	// Set true for ClickHouse first store the incoming inserts into an in-memory buffer
	// before flushing them regularly to disk.
	// See https://clickhouse.com/docs/en/cloud/bestpractices/asynchronous-inserts
	AsyncInsert bool
	// Set true if you want an insert statement to return with an acknowledgment immediately
	// without waiting for the data got inserted into the buffer.
	// Setting true can cause silent errors that you need to monitor separately.
	AsyncInsertWait bool

	// See https://clickhouse.com/docs/en/operations/settings/settings
	// For example, you can set the `max_insert_threads` setting to control the number of threads
	// or the `parallel_view_processing` setting to enable pushing to attached views concurrently.
	InsertQuerySettings map[string]string
}

type AppStripeConfiguration struct {
	DisableWebhookRegistration bool `yaml:"disableWebhookRegistration"`
}

type AppsConfiguration struct {
	// BaseURL is the base URL for the Stripe webhook.
	BaseURL string `yaml:"baseURL"`

	Stripe AppStripeConfiguration `yaml:"stripe"`
}

type AutoMigrate string

type AutoProvisionConfiguration struct {
	Enabled      bool
	Partitions   int
	DLQRetention time.Duration
}

type BalanceWorkerConfiguration struct {
	ConsumerConfiguration `mapstructure:",squash"`
}

type BillingConfiguration struct {
	AdvancementStrategy billing.AdvancementStrategy
	Worker              BillingWorkerConfiguration
}

type BillingWorkerConfiguration struct {
	ConsumerConfiguration `mapstructure:",squash"`
}

type ClickHouseAggregationConfiguration struct {
	Address  string
	TLS      bool
	Username string
	Password string
	Database string

	// ClickHouse connection options
	DialTimeout     time.Duration
	MaxOpenConns    int
	MaxIdleConns    int
	ConnMaxLifetime time.Duration
	BlockBufferSize uint8
}

type Configuration struct {
	Address     string
	Environment string

	Telemetry TelemetryConfig

	Termination TerminationConfig

	Aggregation     AggregationConfiguration
	Entitlements    EntitlementsConfiguration
	Dedupe          DedupeConfiguration
	Events          EventsConfiguration
	Ingest          IngestConfiguration
	Meters          []*meter.Meter
	Namespace       NamespaceConfiguration
	Portal          PortalConfiguration
	Postgres        PostgresConfig
	Sink            SinkConfiguration
	BalanceWorker   BalanceWorkerConfiguration
	Notification    NotificationConfiguration
	ProductCatalog  ProductCatalogConfiguration
	ProgressManager ProgressManagerConfiguration
	Billing         BillingConfiguration
	Apps            AppsConfiguration
	Svix            SvixConfig
}

type ConsumerConfiguration struct {
	// ProcessingTimeout is the maximum time a message is allowed to be processed before it is considered failed. 0 disables the timeout.
	ProcessingTimeout time.Duration

	// Retry specifies how many times a message should be retried before it is sent to the DLQ.
	Retry RetryConfiguration

	// ConsumerGroupName is the name of the consumer group that the consumer belongs to.
	ConsumerGroupName string

	// DLQ specifies the configuration for the Dead Letter Queue.
	DLQ DLQConfiguration
}

type DLQAutoProvisionConfiguration struct {
	Enabled    bool
	Partitions int
	Retention  time.Duration
}

type DLQConfiguration struct {
	Enabled       bool
	Topic         string
	AutoProvision DLQAutoProvisionConfiguration
}

type DedupeConfiguration struct {
	Enabled bool

	DedupeDriverConfiguration
}

type DedupeDriverConfiguration interface {
	DriverName() string
	NewDeduplicator() (dedupe.Deduplicator, error)
	Validate() error
}

type DedupeDriverMemoryConfiguration struct {
	Enabled bool
	Size    int
}

type DedupeDriverRedisConfiguration struct {
	redis.Config `mapstructure:",squash"`

	Expiration time.Duration
}

type EntitlementsConfiguration struct {
	GracePeriod isodate.String
}

type EventSubsystemConfiguration struct {
	Enabled bool
	Topic   string

	AutoProvision AutoProvisionConfiguration
}

type EventsConfiguration struct {
	SystemEvents EventSubsystemConfiguration
	IngestEvents EventSubsystemConfiguration
}

type ExportersLogTelemetryConfig struct {
	OTLP   OTLPExportersLogTelemetryConfig
	Stdout StdoutExportersLogTelemetryConfig
	File   FileExportersLogTelemetryConfig
}

type ExportersMetricsTelemetryConfig struct {
	Prometheus PrometheusExportersMetricsTelemetryConfig
	OTLP       OTLPExportersMetricsTelemetryConfig
}

type ExportersTraceTelemetryConfig struct {
	OTLP OTLPExportersTraceTelemetryConfig
}

type FileExportersLogTelemetryConfig struct {
	Enabled     bool
	FilePath    string
	PrettyPrint bool
}

type IngestConfiguration struct {
	Kafka KafkaIngestConfiguration
}

type IngestNotificationsConfiguration struct {
	MaxEventsInBatch int
}

type KafkaConfig struct {
	pkgkafka.CommonConfigParams   `mapstructure:",squash"`
	pkgkafka.ConsumerConfigParams `mapstructure:",squash"`
	pkgkafka.ProducerConfigParams `mapstructure:",squash"`
}

type KafkaConfiguration struct {
	Broker           string
	SecurityProtocol string
	SaslMechanisms   string
	SaslUsername     string
	SaslPassword     string

	StatsInterval pkgkafka.TimeDurationMilliSeconds

	// BrokerAddressFamily defines the IP address family to be used for network communication with Kafka cluster
	BrokerAddressFamily pkgkafka.BrokerAddressFamily
	// SocketKeepAliveEnable defines if TCP socket keep-alive is enabled to prevent closing idle connections
	// by Kafka brokers.
	SocketKeepAliveEnabled bool
	// TopicMetadataRefreshInterval defines how frequently the Kafka client needs to fetch metadata information
	// (brokers, topic, partitions, etc) from the Kafka cluster.
	// The 5 minutes default value is appropriate for mostly static Kafka clusters, but needs to be lowered
	// in case of large clusters where changes are more frequent.
	// This value must not be set to value lower than 10s.
	TopicMetadataRefreshInterval pkgkafka.TimeDurationMilliSeconds

	// Enable contexts for extensive debugging of librdkafka.
	// See: https://github.com/confluentinc/librdkafka/blob/master/INTRODUCTION.md#debug-contexts
	DebugContexts pkgkafka.DebugContexts
}

type KafkaIngestConfiguration struct {
	KafkaConfiguration `mapstructure:",squash"`

	TopicProvisionerConfig `mapstructure:",squash"`

	Partitions          int
	EventsTopicTemplate string

	// NamespaceDeletionEnabled defines whether deleting namespaces are allowed or not.
	NamespaceDeletionEnabled bool
}

type LogTelemetryConfig struct {
	// Format specifies the output log format.
	// Accepted values are: json, text
	Format string

	// Level is the minimum log level that should appear on the output.
	//
	// Requires [mapstructure.TextUnmarshallerHookFunc] to be high up in the decode hook chain.
	Level slog.Level

	Exporters ExportersLogTelemetryConfig
}

type MetricsTelemetryConfig struct {
	Exporters ExportersMetricsTelemetryConfig
}

type NamespaceConfiguration struct {
	Default           string
	DisableManagement bool
}

type NotificationConfiguration struct {
	Consumer ConsumerConfiguration

	Webhook WebhookConfiguration
}

type OTLPExporterTelemetryConfig struct {
	Address string
}

type OTLPExportersLogTelemetryConfig struct {
	Enabled bool

	OTLPExporterTelemetryConfig `mapstructure:",squash"`
}

type OTLPExportersMetricsTelemetryConfig struct {
	Enabled bool

	OTLPExporterTelemetryConfig `mapstructure:",squash"`
}

type OTLPExportersTraceTelemetryConfig struct {
	Enabled bool

	OTLPExporterTelemetryConfig `mapstructure:",squash"`
}

type PortalCORSConfiguration struct {
	Enabled bool `mapstructure:"enabled"`
}

type PortalConfiguration struct {
	Enabled         bool                    `mapstructure:"enabled"`
	CORS            PortalCORSConfiguration `mapstructure:"cors"`
	TokenSecret     string                  `mapstructure:"tokenSecret"`
	TokenExpiration time.Duration           `mapstructure:"tokenExpiration"`
}

type PostgresConfig struct {
	// URL is the PostgreSQL database connection URL.
	URL string `yaml:"url"`
	// AutoMigrate is a flag that indicates whether the database should be automatically migrated.
	// Supported values are:
	// - "false" to disable auto-migration at startup
	// - "ent" to use ent Schema Upserts (the default value)
	// - "migration" to use the migrations directory
	AutoMigrate AutoMigrate `yaml:"autoMigrate"`
}

type ProductCatalogConfiguration struct{}

type ProgressManagerConfiguration struct {
	Enabled    bool
	Expiration time.Duration
	Redis      redis.Config
}

type PrometheusExportersMetricsTelemetryConfig struct {
	Enabled bool
}

type RetryConfiguration struct {
	// MaxRetries is maximum number of times a retry will be attempted. Disabled if 0
	MaxRetries int
	// InitialInterval is the first interval between retries. Subsequent intervals will be scaled by Multiplier.
	InitialInterval time.Duration
	// MaxInterval sets the limit for the exponential backoff of retries. The interval will not be increased beyond MaxInterval.
	MaxInterval time.Duration
	// MaxElapsedTime sets the time limit of how long retries will be attempted. Disabled if 0.
	MaxElapsedTime time.Duration
}

type SinkConfiguration struct {
	// FIXME(chrisgacsal): remove as it is deprecated by moving Kafka specific configuration to dedicated config params.
	GroupId             string
	Dedupe              DedupeConfiguration
	MinCommitCount      int
	MaxCommitWait       time.Duration
	MaxPollTimeout      time.Duration
	NamespaceRefetch    time.Duration
	FlushSuccessTimeout time.Duration
	DrainTimeout        time.Duration
	IngestNotifications IngestNotificationsConfiguration
	// Kafka client/Consumer configuration
	Kafka KafkaConfig
	// TODO: remove, config moved to aggregation config
	// Storage configuration
	Storage StorageConfiguration

	// NamespaceRefetchTimeout is the timeout for updating namespaces and consumer subscription.
	// It must be less than NamespaceRefetch interval.
	NamespaceRefetchTimeout time.Duration

	// NamespaceTopicRegexp defines the regular expression to match/validate topic names the sink-worker needs to subscribe to.
	NamespaceTopicRegexp string

	// MeterRefetchInterval is the interval to refetch meters from the database
	MeterRefetchInterval time.Duration
}

type StdoutExportersLogTelemetryConfig struct {
	Enabled     bool
	PrettyPrint bool
}

type StorageConfiguration struct {
	// Set true for ClickHouse first store the incoming inserts into an in-memory buffer
	// before flushing them regularly to disk.
	// See https://clickhouse.com/docs/en/cloud/bestpractices/asynchronous-inserts
	AsyncInsert bool
	// Set true if you want an insert statement to return with an acknowledgment immediately
	// without waiting for the data got inserted into the buffer.
	// Setting true can cause silent errors that you need to monitor separately.
	AsyncInsertWait bool

	// See https://clickhouse.com/docs/en/operations/settings/settings
	// For example, you can set the `max_insert_threads` setting to control the number of threads
	// or the `parallel_view_processing` setting to enable pushing to attached views concurrently.
	QuerySettings map[string]string
}

type SvixConfig = notificationwebhook.SvixConfig

type TelemetryConfig struct {
	// Telemetry HTTP server address
	Address string

	Trace TraceTelemetryConfig

	Metrics MetricsTelemetryConfig

	Log LogTelemetryConfig
}

type TerminationConfig struct {
	// CheckInterval defines the time period used for updating the readiness check based on the termination status
	CheckInterval time.Duration

	// GracefulShutdownTimeout defines the maximum time for the process to gracefully stop on receiving stop signal.
	GracefulShutdownTimeout time.Duration

	// PropagationTimeout defines how long to block the termination process in order
	// to allow the termination event to be propagated to other systems. e.g. reverse proxy.
	// Its value should be set higher than the failure threshold for readiness probe.
	// In Kubernetes it should be: readiness.periodSeconds * (readiness.failureThreshold + 1) + CheckInterval
	// PropagationTimeout must always less than GracefulShutdownTimeout.
	PropagationTimeout time.Duration
}

type TopicProvisionerConfig struct {
	// The maximum number of entries stored in topic cache at a time which after the least recently used is evicted.
	// Setting size to 0 makes it unlimited
	CacheSize int

	// The maximum time an entries is kept in cache before being evicted
	CacheTTL time.Duration

	// ProtectedTopics defines a list of topics which are protected from deletion.
	ProtectedTopics []string
}

type TraceTelemetryConfig struct {
	Sampler   string
	Exporters ExportersTraceTelemetryConfig
}

type ViperKeyPrefixer func(s string) string

type WebhookConfiguration struct {
	// Timeout for registering event types in webhook provider
	EventTypeRegistrationTimeout time.Duration
	// Skip registering event types on unsuccessful attempt instead of returning with error
	SkipEventTypeRegistrationOnError bool
}