cache

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

type Cache interface {
	// Get retrieves a value from the cache and deserializes it into the provided destination
	Get(ctx context.Context, key string, dest interface{}) (bool, error)

	// Set stores a value in the cache with the specified TTL
	Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error

	// Delete removes a value from the cache
	Delete(ctx context.Context, key string) error

	// Exists checks if a key exists in the cache
	Exists(ctx context.Context, key string) (bool, error)

	// Clear removes all entries from the cache
	Clear(ctx context.Context) error

	// GetMulti retrieves multiple values from the cache
	GetMulti(ctx context.Context, keys []string) (map[string]interface{}, error)

	// SetMulti stores multiple values in the cache
	SetMulti(ctx context.Context, items map[string]interface{}, ttl time.Duration) error

	// DeleteMulti removes multiple values from the cache
	DeleteMulti(ctx context.Context, keys []string) error

	// GetTTL returns the remaining TTL for a key
	GetTTL(ctx context.Context, key string) (time.Duration, error)

	// SetTTL updates the TTL for an existing key
	SetTTL(ctx context.Context, key string, ttl time.Duration) error

	// GetStats returns cache statistics
	GetStats() Stats

	// Close closes the cache and releases resources
	Close() error
}

type Config struct {
	MaxSize         int64         `json:"max_size"`
	DefaultTTL      time.Duration `json:"default_ttl"`
	CleanupInterval time.Duration `json:"cleanup_interval"`
	EnableLRU       bool          `json:"enable_lru"`
	EnableStats     bool          `json:"enable_stats"`
	EnableEvents    bool          `json:"enable_events"`
	Namespace       string        `json:"namespace"`
	// Shards splits a MemoryCache into this many parts with their own locks. 0 or 1 keeps one
	// part, which is an exact LRU; more parts let concurrent writers run in parallel but make
	// eviction approximate: MaxSize is divided exactly between the parts (so the cache never holds
	// more than MaxSize items) and a full part evicts its own least recently used item. With a
	// MaxSize below Shards, some parts hold nothing.
	Shards       int          `json:"shards,omitempty"`
	Serializer   Serializer   `json:"-"`
	EventHandler EventHandler `json:"-"`
}

type Error struct {
	Op  string
	Key string
	Err error
}

type Event struct {
	Type      EventType   `json:"type"`
	Key       string      `json:"key"`
	Value     interface{} `json:"value,omitempty"`
	Timestamp time.Time   `json:"timestamp"`
	Namespace string      `json:"namespace,omitempty"`
	Error     error       `json:"error,omitempty"`
}

type EventHandler func(event Event)

type EventType int

type InMemorySerializer interface {
	Serializer
	// Keep returns what the cache stores for the value
	Keep(value interface{}) (interface{}, error)
	// Restore copies a stored value into dest, which is a pointer
	Restore(kept interface{}, dest interface{}) error
}

type Item struct {
	Key       string        `json:"key"`
	Value     interface{}   `json:"value"`
	ExpiresAt time.Time     `json:"expires_at"`
	CreatedAt time.Time     `json:"created_at"`
	UpdatedAt time.Time     `json:"updated_at"`
	AccessAt  time.Time     `json:"access_at"`
	TTL       time.Duration `json:"ttl"`
	Size      int64         `json:"size"`
	Namespace string        `json:"namespace,omitempty"`
}

type JSONSerializer struct{}

type MemoryCache struct {
	*BaseCache
	// contains filtered or unexported fields
}

type NativeSerializer struct{ JSONSerializer }

type NoOpSerializer struct{}

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

type RedisConfig struct {
	Addr         string        `json:"addr"`
	Password     string        `json:"password"`
	DB           int           `json:"db"`
	PoolSize     int           `json:"pool_size"`
	MinIdleConns int           `json:"min_idle_conns"`
	MaxRetries   int           `json:"max_retries"`
	DialTimeout  time.Duration `json:"dial_timeout"`
	ReadTimeout  time.Duration `json:"read_timeout"`
	WriteTimeout time.Duration `json:"write_timeout"`
	IdleTimeout  time.Duration `json:"idle_timeout"`
}

type Serializer interface {
	Serialize(value interface{}) ([]byte, error)
	Deserialize(data []byte, dest interface{}) error
}

type Stats struct {
	Hits        int64     `json:"hits"`
	Misses      int64     `json:"misses"`
	Sets        int64     `json:"sets"`
	Deletes     int64     `json:"deletes"`
	Evictions   int64     `json:"evictions"`
	Size        int64     `json:"size"`
	MaxSize     int64     `json:"max_size"`
	HitRatio    float64   `json:"hit_ratio"`
	Memory      int64     `json:"memory_bytes"`
	Errors      int64     `json:"errors"`
	LastError   string    `json:"last_error,omitempty"`
	LastErrorAt time.Time `json:"last_error_at,omitempty"`
}

type TieredCache struct {
	*BaseCache
	// contains filtered or unexported fields
}