cache

type BackgroundConfig struct {
	WriteBackGoroutines int              `yaml:"writeback_goroutines"`
	WriteBackBuffer     int              `yaml:"writeback_buffer"`
	WriteBackSizeLimit  flagext.ByteSize `yaml:"writeback_size_limit"`
}

type Cache interface {
	Store(ctx context.Context, key []string, buf [][]byte) error
	Fetch(ctx context.Context, keys []string) (found []string, bufs [][]byte, missing []string, err error)
	Stop()
	// GetCacheType returns a string indicating the cache "type" for the purpose of grouping cache usage statistics
	GetCacheType() stats.CacheType
}

type Config struct {
	DefaultValidity time.Duration `yaml:"default_validity"`

	Background     BackgroundConfig      `yaml:"background"`
	Memcache       MemcachedConfig       `yaml:"memcached"`
	MemcacheClient MemcachedClientConfig `yaml:"memcached_client"`
	Redis          RedisConfig           `yaml:"redis"`
	EmbeddedCache  EmbeddedCacheConfig   `yaml:"embedded_cache"`

	// This is to name the cache metrics properly.
	Prefix string `yaml:"prefix" doc:"hidden"`

	// For tests to inject specific implementations.
	Cache Cache `yaml:"-"`
}

type EmbeddedCache[K comparable, V any] struct {
	// contains filtered or unexported fields
}

type EmbeddedCacheConfig struct {
	Enabled      bool          `yaml:"enabled,omitempty"`
	MaxSizeMB    int64         `yaml:"max_size_mb"`
	MaxSizeItems int           `yaml:"max_size_items"`
	TTL          time.Duration `yaml:"ttl"`

	// PurgeInterval tell how often should we remove keys that are expired.
	// by default it takes `defaultPurgeInterval`
	PurgeInterval time.Duration `yaml:"-"`
}

type Entry[K comparable, V any] struct {
	Key   K
	Value V
	// contains filtered or unexported fields
}

type GenNumMiddleware struct {
	// contains filtered or unexported fields
}

type Memcached struct {
	// contains filtered or unexported fields
}

type MemcachedClient interface {
	GetMulti(keys []string, opts ...memcache.Option) (map[string]*memcache.Item, error)
	Set(item *memcache.Item) error
}

type MemcachedClientConfig struct {
	Host           string        `yaml:"host"`
	Service        string        `yaml:"service"`
	Addresses      string        `yaml:"addresses"`
	Timeout        time.Duration `yaml:"timeout"`
	MaxIdleConns   int           `yaml:"max_idle_conns"`
	MaxItemSize    int           `yaml:"max_item_size"`
	UpdateInterval time.Duration `yaml:"update_interval"`
	ConsistentHash bool          `yaml:"consistent_hash"`
	CBFailures     uint          `yaml:"circuit_breaker_consecutive_failures"`
	CBTimeout      time.Duration `yaml:"circuit_breaker_timeout"`  // reset error count after this long
	CBInterval     time.Duration `yaml:"circuit_breaker_interval"` // remain closed for this long after CBFailures errors

	// TLSEnabled enables connecting to Memcached with TLS.
	TLSEnabled bool `yaml:"tls_enabled"`

	// TLS to use to connect to the Memcached server.
	TLS dstls.ClientConfig `yaml:",inline"`
}

type MemcachedConfig struct {
	Expiration time.Duration `yaml:"expiration"`

	BatchSize   int `yaml:"batch_size"`
	Parallelism int `yaml:"parallelism"`
}

type MockCache interface {
	Cache
	NumKeyUpdates() int
	GetInternal() map[string][]byte
	KeysRequested() int
	GetKeys() []string
}

type RedisCache struct {
	// contains filtered or unexported fields
}

type RedisClient struct {
	// contains filtered or unexported fields
}

type RedisConfig struct {
	Endpoint           string         `yaml:"endpoint"`
	MasterName         string         `yaml:"master_name"`
	Timeout            time.Duration  `yaml:"timeout"`
	Expiration         time.Duration  `yaml:"expiration"`
	DB                 int            `yaml:"db"`
	PoolSize           int            `yaml:"pool_size"`
	Username           string         `yaml:"username"`
	Password           flagext.Secret `yaml:"password"`
	EnableTLS          bool           `yaml:"tls_enabled"`
	InsecureSkipVerify bool           `yaml:"tls_insecure_skip_verify"`
	IdleTimeout        time.Duration  `yaml:"idle_timeout"`
	MaxConnAge         time.Duration  `yaml:"max_connection_age"`
	RouteRandomly      bool           `yaml:"route_randomly"`
}

type TypedCache[K comparable, V any] interface {
	Store(ctx context.Context, keys []K, values []V) error
	Fetch(ctx context.Context, keys []K) (found []K, values []V, missing []K, err error)
	Stop()
	// GetCacheType returns a string indicating the cache "type" for the purpose of grouping cache usage statistics
	GetCacheType() stats.CacheType
}