cache

type ByteRange struct {
	Start int64
	End   int64
}

type ByteSize int64

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

type CacheControl struct {
	// MaxAge specifies the maximum age in seconds.
	MaxAge int `json:"max_age,omitempty"`

	// SMaxAge specifies the shared cache maximum age.
	SMaxAge int `json:"s_maxage,omitempty"`

	// NoCache indicates the response must be revalidated.
	NoCache bool `json:"no_cache,omitempty"`

	// NoStore indicates the response must not be stored.
	NoStore bool `json:"no_store,omitempty"`

	// MustRevalidate indicates stale responses must be revalidated.
	MustRevalidate bool `json:"must_revalidate,omitempty"`

	// Public indicates the response may be cached by any cache.
	Public bool `json:"public,omitempty"`

	// Private indicates the response is for a single user.
	Private bool `json:"private,omitempty"`

	// Immutable indicates the response will not change.
	Immutable bool `json:"immutable,omitempty"`
}

type CacheStats struct {
	Enabled          bool    `json:"enabled"`
	StorageType      string  `json:"storage_type"`
	Entries          int64   `json:"entries"`
	TotalSize        int64   `json:"total_size_bytes"`
	MaxSize          int64   `json:"max_size_bytes"`
	UsedPercent      float64 `json:"used_percent"`
	HitCount         int64   `json:"hit_count"`
	MissCount        int64   `json:"miss_count"`
	HitRate          float64 `json:"hit_rate"`
	EvictionCount    int64   `json:"eviction_count"`
	RulesCount       int     `json:"rules_count"`
	PresetsCount     int     `json:"presets_count"`
	CustomRulesCount int     `json:"custom_rules_count"`
}

type Config struct {
	// Enabled enables or disables caching.
	Enabled bool `yaml:"enabled" json:"enabled"`

	// DefaultTTL is the default time-to-live for cached entries.
	DefaultTTL Duration `yaml:"default_ttl" json:"default_ttl"`

	// MaxFileSize is the maximum size of a single cached file.
	MaxFileSize ByteSize `yaml:"max_file_size" json:"max_file_size"`

	// Storage configures the storage backend.
	Storage StorageConfig `yaml:"storage" json:"storage"`

	// Presets are built-in cache rules for common CDNs.
	Presets []string `yaml:"presets,omitempty" json:"presets,omitempty"`

	// Rules are custom caching rules.
	Rules []RuleConfig `yaml:"rules,omitempty" json:"rules,omitempty"`
}

type DiskConfig struct {
	// Path is the directory for storing cached files.
	Path string `yaml:"path" json:"path"`

	// MaxSize is the maximum total size of the disk cache.
	MaxSize ByteSize `yaml:"max_size" json:"max_size"`

	// CleanupInterval is how often to run cleanup of expired entries.
	CleanupInterval Duration `yaml:"cleanup_interval" json:"cleanup_interval"`

	// ShardCount is the number of subdirectories for sharding (default: 256).
	ShardCount int `yaml:"shard_count,omitempty" json:"shard_count,omitempty"`
}

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

type Duration time.Duration

type Entry struct {
	// Metadata contains cache entry metadata.
	Metadata *Metadata

	// Body is the response body. For streaming large files, this is a reader
	// that streams from storage rather than loading into memory.
	Body io.ReadCloser
}

type EvictionPolicy string

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

type KeyGenerator struct {
	// IgnoreQuery ignores query string in key generation (useful for CDNs).
	IgnoreQuery bool

	// IgnoreScheme ignores the scheme (http/https) in key generation.
	IgnoreScheme bool

	// SortQueryParams sorts query parameters for consistent keys.
	SortQueryParams bool

	// IncludeHeaders includes specific headers in key generation (for Vary support).
	IncludeHeaders []string
}

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

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

type MemoryConfig struct {
	// MaxSize is the maximum total size of the memory cache.
	MaxSize ByteSize `yaml:"max_size" json:"max_size"`

	// MaxEntries is the maximum number of entries in memory.
	MaxEntries int `yaml:"max_entries" json:"max_entries"`

	// EvictPolicy is the eviction policy: lru, lfu, or fifo.
	EvictPolicy string `yaml:"evict_policy" json:"evict_policy"`
}

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

type Metadata struct {
	// Key is the unique cache key (SHA256 hash).
	Key string `json:"key"`

	// URL is the original request URL.
	URL string `json:"url"`

	// Host is the request host.
	Host string `json:"host"`

	// Method is the HTTP method (typically GET).
	Method string `json:"method"`

	// StatusCode is the HTTP response status code.
	StatusCode int `json:"status_code"`

	// Headers are the response headers to preserve.
	Headers http.Header `json:"headers"`

	// ContentLength is the total content length in bytes.
	ContentLength int64 `json:"content_length"`

	// ContentType is the MIME type of the content.
	ContentType string `json:"content_type"`

	// ETag is the entity tag for cache validation.
	ETag string `json:"etag,omitempty"`

	// LastModified is the last modification time from the origin.
	LastModified time.Time `json:"last_modified,omitempty"`

	// CacheControl contains parsed Cache-Control directives.
	CacheControl *CacheControl `json:"cache_control,omitempty"`

	// CreatedAt is when the entry was cached.
	CreatedAt time.Time `json:"created_at"`

	// ExpiresAt is when the entry should be considered stale.
	ExpiresAt time.Time `json:"expires_at"`

	// AccessedAt is the last access time (for LRU eviction).
	AccessedAt time.Time `json:"accessed_at"`

	// AccessCount is the number of times this entry was served.
	AccessCount int64 `json:"access_count"`

	// Size is the actual stored size in bytes.
	Size int64 `json:"size_bytes"`

	// Tier indicates which storage tier holds this entry (memory/disk).
	Tier string `json:"tier"`
}

type Metrics struct {
	// Hits tracks cache hits by domain.
	Hits *prometheus.CounterVec

	// Misses tracks cache misses by domain and reason.
	Misses *prometheus.CounterVec

	// BytesServed tracks bytes served from cache vs origin.
	BytesServed *prometheus.CounterVec

	// BytesCached tracks total bytes stored in cache.
	BytesCached prometheus.Counter

	// StorageSize tracks current storage size by tier.
	StorageSize *prometheus.GaugeVec

	// StorageEntries tracks current entry count by tier.
	StorageEntries *prometheus.GaugeVec

	// StorageUsage tracks storage usage percentage by tier.
	StorageUsage *prometheus.GaugeVec

	// Evictions tracks evictions by tier and reason.
	Evictions *prometheus.CounterVec

	// OperationLatency tracks latency of cache operations.
	OperationLatency *prometheus.HistogramVec

	// ActiveRules tracks number of active cache rules.
	ActiveRules prometheus.Gauge

	// ActivePresets tracks number of enabled presets.
	ActivePresets prometheus.Gauge
}

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

type NopCloser struct {
	io.Reader
}

type Preset struct {
	Name        PresetName
	Description string
	Domains     []string
	TTL         time.Duration
	Priority    int
}

type PresetInfo struct {
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Domains     []string `json:"domains"`
	TTL         string   `json:"ttl"`
	Priority    int      `json:"priority"`
}

type PresetName string

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

type RangeSpec struct {
	Ranges []ByteRange
}

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

type Rule struct {
	// Name is the unique identifier for this rule.
	Name string

	// Domains are the original domain patterns (for API display).
	Domains []string

	// Matcher matches domains against this rule's patterns.
	Matcher *matcher.Matcher

	// Enabled indicates if this rule is active.
	Enabled bool

	// TTL is the time-to-live for cached entries.
	TTL time.Duration

	// MaxSize is the maximum file size to cache (0 = unlimited).
	MaxSize int64

	// Priority determines which rule applies when multiple match.
	// Higher priority rules take precedence.
	Priority int

	// Methods are HTTP methods to cache (empty = GET only).
	Methods []string

	// ContentTypes are MIME types to cache (empty = all).
	ContentTypes []string

	// IgnoreQuery ignores query string in cache key.
	IgnoreQuery bool

	// RespectCacheControl honors Cache-Control headers from origin.
	RespectCacheControl bool

	// StripHeaders are headers to remove before caching.
	StripHeaders []string

	// Preset is the preset name if this rule was created from a preset.
	Preset string
}

type RuleConfig struct {
	// Name is the unique name for this rule.
	Name string `yaml:"name" json:"name"`

	// Domains are the domain patterns to match.
	Domains []string `yaml:"domains" json:"domains"`

	// Enabled enables or disables this rule.
	Enabled bool `yaml:"enabled" json:"enabled"`

	// TTL is the time-to-live for entries matching this rule.
	TTL Duration `yaml:"ttl" json:"ttl"`

	// MaxSize is the maximum file size to cache for this rule.
	MaxSize ByteSize `yaml:"max_size,omitempty" json:"max_size,omitempty"`

	// Priority determines which rule applies when multiple match.
	// Higher priority rules take precedence.
	Priority int `yaml:"priority" json:"priority"`

	// Methods are HTTP methods to cache (default: GET only).
	Methods []string `yaml:"methods,omitempty" json:"methods,omitempty"`

	// ContentTypes are MIME types to cache (empty = all).
	ContentTypes []string `yaml:"content_types,omitempty" json:"content_types,omitempty"`

	// IgnoreQuery ignores query string in cache key generation.
	IgnoreQuery bool `yaml:"ignore_query,omitempty" json:"ignore_query,omitempty"`

	// RespectCacheControl honors Cache-Control headers from origin.
	RespectCacheControl bool `yaml:"respect_cache_control,omitempty" json:"respect_cache_control,omitempty"`

	// StripHeaders removes these headers before caching.
	StripHeaders []string `yaml:"strip_headers,omitempty" json:"strip_headers,omitempty"`
}

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

type SizeReader struct {
	Reader io.Reader
	Size   int64
}

type Storage interface {
	// Get retrieves a cache entry by key.
	// Returns ErrNotFound if the key doesn't exist.
	Get(ctx context.Context, key string) (*Entry, error)

	// Put stores a cache entry.
	// The entry's Body will be fully consumed and the reader closed.
	// Returns ErrEntrySizeExceeded if the content is too large.
	// Returns ErrStorageFull if there's no space and eviction fails.
	Put(ctx context.Context, key string, entry *Entry) error

	// Delete removes a cache entry by key.
	// Returns nil if the key doesn't exist (idempotent).
	Delete(ctx context.Context, key string) error

	// Exists checks if a key exists in the cache.
	// This is a fast check that doesn't load the content.
	Exists(ctx context.Context, key string) bool

	// GetMetadata returns only the metadata for a key (fast lookup).
	// Returns ErrNotFound if the key doesn't exist.
	GetMetadata(ctx context.Context, key string) (*Metadata, error)

	// GetRange retrieves a byte range from a cached entry.
	// Returns ErrNotFound if the key doesn't exist.
	// The returned reader must be closed by the caller.
	GetRange(ctx context.Context, key string, start, end int64) (io.ReadCloser, error)

	// List returns all metadata entries, optionally filtered by domain.
	// If domain is empty, returns all entries.
	// Results are paginated using offset and limit.
	List(ctx context.Context, domain string, offset, limit int) ([]*Metadata, int64, error)

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

	// Stats returns storage statistics.
	Stats() StorageStats

	// Start initializes the storage backend.
	// Must be called before any other operations.
	Start(ctx context.Context) error

	// Stop gracefully shuts down the storage backend.
	// Flushes pending writes and releases resources.
	Stop(ctx context.Context) error
}

type StorageConfig struct {
	// Type is the storage type: memory, disk, or tiered.
	Type string `yaml:"type" json:"type"`

	// Tiered contains tiered storage settings.
	Tiered *TieredConfig `yaml:"tiered,omitempty" json:"tiered,omitempty"`

	// Memory contains memory storage settings.
	Memory *MemoryConfig `yaml:"memory,omitempty" json:"memory,omitempty"`

	// Disk contains disk storage settings.
	Disk *DiskConfig `yaml:"disk,omitempty" json:"disk,omitempty"`
}

type StorageStats struct {
	// Entries is the number of cached entries.
	Entries int64 `json:"entries"`

	// TotalSize is the total size of all cached content in bytes.
	TotalSize int64 `json:"total_size_bytes"`

	// MaxSize is the maximum allowed size in bytes.
	MaxSize int64 `json:"max_size_bytes"`

	// UsedPercent is the percentage of storage used.
	UsedPercent float64 `json:"used_percent"`

	// HitCount is the total number of cache hits.
	HitCount int64 `json:"hit_count"`

	// MissCount is the total number of cache misses.
	MissCount int64 `json:"miss_count"`

	// EvictionCount is the total number of evictions.
	EvictionCount int64 `json:"eviction_count"`
}

type StorageType string

type TieredConfig struct {
	// MemoryThreshold is the size threshold for memory vs disk storage.
	// Files smaller than this are stored in memory, larger in disk.
	MemoryThreshold ByteSize `yaml:"memory_threshold" json:"memory_threshold"`
}

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

type UnsatisfiableRangeError struct {
	Size int64
}

type Validator struct{}