model

type BuildableConfig interface {
	ReaderWriter
	Setup
	Compound
}

type Compound interface {
	ReadInConfig() error
	ReadConfig(in io.Reader) error
	MergeConfig(in io.Reader) error
	MergeFleetPolicy(configPath string) error

	// Revert a finished configuration so that more can be build on top of it.
	// When building is completed, the caller should call BuildSchema.
	// NOTE: This method should not be used by any new callsites, it is needed
	// currently because of the unique requirements of OTel's configuration.
	RevertFinishedBackToBuilder() BuildableConfig
}

type Config interface {
	ReaderWriter
	Compound
}

type DirectSetting struct {
	Key    string
	Value  interface{}
	Source Source
}

type NotificationReceiver func(setting string, source Source, oldValue, newValue any, sequenceID uint64, unsetSource Source)

type Proxy struct {
	HTTP    string   `mapstructure:"http"`
	HTTPS   string   `mapstructure:"https"`
	NoProxy []string `mapstructure:"no_proxy"`
}

type Reader interface {
	Get(key string) interface{}
	GetString(key string) string
	GetBool(key string) bool
	GetInt(key string) int
	GetInt32(key string) int32
	GetInt64(key string) int64
	GetFloat64(key string) float64
	GetDuration(key string) time.Duration
	GetStringSlice(key string) []string
	GetFloat64Slice(key string) []float64
	GetStringMap(key string) map[string]interface{}
	GetStringMapString(key string) map[string]string
	GetStringMapStringSlice(key string) map[string][]string
	GetSizeInBytes(key string) uint
	GetProxies() *Proxy
	GetSequenceID() uint64

	GetSource(key string) Source
	GetAllSources(key string) []ValueWithSource

	ConfigFileUsed() string
	ExtraConfigFilesUsed() []string

	AllSettings() map[string]interface{}
	AllSettingsWithoutDefault() map[string]interface{}
	// AllSettingsWithoutSecrets returns all settings excluding the secrets layer.
	AllSettingsWithoutSecrets() map[string]interface{}
	// AllSettingsWithoutDefaultOrSecrets returns settings excluding both defaults and the secrets layer.
	AllSettingsWithoutDefaultOrSecrets() map[string]interface{}
	AllSettingsBySource() map[Source]interface{}
	// AllKeysLowercased returns all config keys in the config, no matter how they are set.
	// Note that it returns the keys lowercased.
	AllKeysLowercased() []string
	// AllFlattenedSettingsWithSequenceID returns all settings as a flattened map of schema leaf keys
	// (for example, "logs_config.enabled" instead of nested {"logs_config": {"enabled": ...}})
	// along with the current sequence ID.
	// This provides atomic access to flattened keys, values, and sequence ID under a single lock.
	AllFlattenedSettingsWithSequenceID() (map[string]interface{}, uint64)

	// SetTestOnlyDynamicSchema is used by tests to disable validation of the config schema
	// This lets tests use the config is more flexible ways (can add to the schema at any point,
	// can modify env vars and the config will rebuild itself, etc)
	SetTestOnlyDynamicSchema(allow bool)

	// IsConfigured returns true if a setting is configured by the user. This means that either:
	//  1. The key is for a leaf, and the setting has a non-nil value on a non-default source OR
	//  2. The key is for an inner node, and one of its children IsConfigured
	IsConfigured(key string) bool
	// HasSection returns true if the key is for a non-leaf setting that is defined by the user
	HasSection(key string) bool

	// IsKnown returns whether this key is known
	IsKnown(key string) bool
	// IsSetting returns whether the key identifies a setting (and not a section)
	IsSetting(key string) bool

	// GetEnvVars returns a list of the env vars that the config supports.
	// These have had the EnvPrefix applied, as well as the EnvKeyReplacer.
	GetEnvVars() []string

	// Warnings returns pointer to a list of warnings (completes config.Component interface)
	Warnings() []string

	// StartTime returns the time at which the agent process started (completes config.Component interface)
	StartTime() time.Time

	// Object returns Reader to config (completes config.Component interface)
	Object() Reader

	// OnUpdate adds a callback to the list receivers to be called each time a value is change in the configuration
	// by a call to the 'Set' method. The configuration will sequentially call each receiver.
	OnUpdate(callback NotificationReceiver)

	// Stringify stringifies the config, only available if "test" build tag is enabled
	Stringify(source Source, opts ...StringifyOption) string
}

type ReaderWriter interface {
	Reader
	Writer
}

type Setup interface {

	// BuildSchema should be called when Setup is done, it builds the schema making the config ready for use
	BuildSchema()

	SetDefault(key string, value interface{})

	SetEnvPrefix(in string)

	// ParseEnvSplitComma registers a transformer to parse the env var for key as a comma-separated list.
	ParseEnvSplitComma(key string)
	// ParseEnvSplitSpace registers a transformer to parse the env var for key as a space-separated list.
	ParseEnvSplitSpace(key string)
	// ParseEnvJSON registers a transformer to parse the env var for key as a JSON payload into varType.
	// varType must be a zero value of the target type (e.g. []string{}, []map[string]string{}).
	ParseEnvJSON(key string, varType any)

	// The following helpers are legacy and should no longer be used. Instead leverage the one above
	ParseEnvAsStringSlice(key string, fx func(string) []string)
	ParseEnvAsMapStringInterface(key string, fx func(string) map[string]interface{})

	// BindEnvAndSetDefault sets the default value for a config parameter and adds an env binding
	// in one call, used for most config options.
	//
	// If env is provided, it will override the name of the environment variable used for this
	// config key
	BindEnvAndSetDefault(key string, val interface{}, env ...string)

	// BindEnvAndSetDefaultWithDeprecation fully declares a setting with a default value, a list of deprecated names and
	// optional env var overrides.
	// If no env vars are declared, one will be derived from the key name.
	// Settings in the deprecated names list take precedence over the official and will automatically generate a warning.
	// Name in the list must be sorted by priority (oldest name first).
	BindEnvAndSetDefaultWithDeprecation(key string, defaultVal interface{}, deprecatedNames []string, envvars ...string)

	AddConfigPath(in string)
	AddExtraConfigPaths(in []string) error
	SetConfigName(in string)
	SetConfigFile(in string)
	SetConfigType(in string)
}

type Source string

type StringifyConfig struct {
	DedupPointerAddr bool
	OmitPointerAddr  bool
	SettingFilters   []string
}

type StringifyOption func(*StringifyConfig)

type ValueWithSource struct {
	Source Source
	Value  interface{}
}

type Writer interface {
	Set(key string, value interface{}, source Source)
	SetInTest(key string, value interface{})
	UnsetForSource(key string, source Source)
	// DirectBulkSet writes settings already resolved by another config, keeping each one in the
	// source layer it came from so the result mirrors the sender. It exists for config streaming
	// and nothing else should call it: unlike Set it accepts SourceEnvVar, which makes it unfit
	// for applying a live change. shouldNotify notifies receivers for every setting whose resolved
	// value changed, which a snapshot replacing a config the process already runs on requires.
	DirectBulkSet(settings []DirectSetting, shouldNotify bool)
}