cache

type BlobCache interface {
	// GetBlob retrieves a blob by its digest.
	// Returns a ReadCloser that the caller must close.
	GetBlob(ctx context.Context, digest string) (io.ReadCloser, error)

	// PutBlob stores a blob with the given digest.
	// The reader content is consumed and stored.
	PutBlob(ctx context.Context, digest string, reader io.Reader) error

	// HasBlob checks if a blob exists in the cache.
	// This is more efficient than GetBlob when only existence matters.
	HasBlob(ctx context.Context, digest string) (bool, error)

	// DeleteBlob removes a blob from the cache.
	// Returns nil if the blob doesn't exist (idempotent operation).
	DeleteBlob(ctx context.Context, digest string) error
}

type Cache interface {
	// Get retrieves a cache entry by key.
	// Returns ErrCacheExpired if the entry exists but has expired.
	// Returns an error if the key is not found or if retrieval fails.
	Get(ctx context.Context, key string) (*Entry, error)

	// Put stores a cache entry with the given key.
	// Returns ErrCacheFull if the cache cannot accommodate the entry.
	// Overwrites existing entries with the same key.
	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 operation).
	Delete(ctx context.Context, key string) error

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

	// Size returns the total size of all cache entries in bytes.
	Size(ctx context.Context) (int64, error)
}

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

type Config struct {
	// MaxSizeBytes is the maximum size of the cache in bytes.
	MaxSizeBytes int64
	// DefaultTTL is the default time-to-live for cache entries.
	DefaultTTL time.Duration
}

type ConfigProvider interface {
	Config() Config
}

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

type DebugInfo struct {
	Timestamp   time.Time        `json:"timestamp"`
	Config      Config           `json:"config"`
	Metrics     MetricsSnapshot  `json:"metrics"`
	IndexStats  IndexStats       `json:"index_stats"`
	CacheStats  Stats            `json:"cache_stats"`
	TopEntries  []EntryInfo      `json:"top_entries"`
	Integrity   IntegrityReport  `json:"integrity"`
	StorageInfo StorageDebugInfo `json:"storage_info"`
}

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

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

type DirInfo struct {
	Path      string `json:"path"`
	FileCount int    `json:"file_count"`
	TotalSize int64  `json:"total_size"`
}

type Entry struct {
	// Key is the unique identifier for this cache entry.
	Key string
	// Data contains the cached data.
	Data []byte
	// Metadata contains additional metadata about the entry.
	Metadata map[string]string
	// CreatedAt is when this entry was first created.
	CreatedAt time.Time
	// AccessedAt is when this entry was last accessed.
	AccessedAt time.Time
	// TTL is the time-to-live for this entry. Zero means no expiration.
	TTL time.Duration
	// AccessCount tracks how many times this entry has been accessed.
	AccessCount int64
}

type EntryInfo struct {
	Key         string        `json:"key"`
	Size        int64         `json:"size"`
	CreatedAt   time.Time     `json:"created_at"`
	AccessedAt  time.Time     `json:"accessed_at"`
	TTL         time.Duration `json:"ttl"`
	AccessCount int64         `json:"access_count"`
	FilePath    string        `json:"file_path"`
	IsExpired   bool          `json:"is_expired"`
	Type        string        `json:"type"` // "manifest" or "blob"
}

type EvictionStrategy interface {
	// SelectForEviction chooses which cache entries should be evicted.
	// Returns a slice of keys to evict, ordered by eviction priority.
	// The entries map provides access to all current cache entries for decision making.
	SelectForEviction(entries map[string]*Entry) []string

	// OnAccess is called when a cache entry is accessed (read).
	// Implementations can update access patterns or priorities.
	OnAccess(entry *Entry)

	// OnAdd is called when a new entry is added to the cache.
	// Implementations can initialize eviction metadata.
	OnAdd(entry *Entry)

	// OnRemove is called when an entry is removed from the cache.
	// Implementations can clean up eviction metadata.
	OnRemove(entry *Entry)
}

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

type IndexEntry struct {
	Key         string            `json:"key"`
	Size        int64             `json:"size"`
	CreatedAt   time.Time         `json:"created_at"`
	AccessedAt  time.Time         `json:"accessed_at"`
	TTL         time.Duration     `json:"ttl"`
	AccessCount int64             `json:"access_count"`
	Metadata    map[string]string `json:"metadata,omitempty"`
	FilePath    string            `json:"file_path"` // Relative path to the data file
}

type IndexStats struct {
	TotalEntries       int
	ExpiredEntries     int
	TotalSize          int64
	LastCompaction     time.Time
	AverageAccessCount float64
}

type IntegrityReport struct {
	TotalEntries     int           `json:"total_entries"`
	CorruptedEntries []string      `json:"corrupted_entries"`
	MissingFiles     []string      `json:"missing_files"`
	InvalidDigests   []string      `json:"invalid_digests"`
	IsHealthy        bool          `json:"is_healthy"`
	CheckDuration    time.Duration `json:"check_duration"`
}

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

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

type LogConfig struct {
	// Level sets the minimum log level (debug, info, warn, error)
	Level LogLevel
	// EnableCallerInfo includes file and line number in logs
	EnableCallerInfo bool
	// EnablePerformanceLogging enables detailed performance metrics logging
	EnablePerformanceLogging bool
	// EnableCacheOperations enables logging of individual cache operations
	EnableCacheOperations bool
}

type LogLevel int

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

type ManifestCache interface {
	// GetManifest retrieves a manifest by its digest.
	// Returns the manifest content or an error if not found.
	GetManifest(ctx context.Context, digest string) (*ocispec.Manifest, error)

	// PutManifest stores a manifest with the given digest.
	// The digest should be validated before storage.
	PutManifest(ctx context.Context, digest string, manifest *ocispec.Manifest) error

	// HasManifest checks if a manifest exists in the cache.
	// This is more efficient than GetManifest when only existence matters.
	HasManifest(ctx context.Context, digest string) (bool, error)

	// ValidateManifest performs validation of a manifest against a reference.
	// This may involve checking the manifest digest against a registry.
	ValidateManifest(ctx context.Context, reference, digest string) (bool, error)
}

type MetricsSnapshot struct {
	// Core hit/miss statistics
	Hits    int64   `json:"hits"`
	Misses  int64   `json:"misses"`
	HitRate float64 `json:"hit_rate"`

	// Eviction and error tracking
	Evictions int64 `json:"evictions"`
	Errors    int64 `json:"errors"`

	// Size and entry tracking
	BytesStored    int64 `json:"bytes_stored"`
	EntriesStored  int64 `json:"entries_stored"`
	BytesRetrieved int64 `json:"bytes_retrieved"`

	// Bandwidth metrics
	NetworkRequests int64 `json:"network_requests"`
	BytesDownloaded int64 `json:"bytes_downloaded"`
	BytesServed     int64 `json:"bytes_served"`
	BandwidthSaved  int64 `json:"bandwidth_saved"`

	// Operation counts by type
	ManifestGets   int64 `json:"manifest_gets"`
	ManifestPuts   int64 `json:"manifest_puts"`
	BlobGets       int64 `json:"blob_gets"`
	BlobPuts       int64 `json:"blob_puts"`
	TagResolutions int64 `json:"tag_resolutions"`

	// Latency metrics (in nanoseconds)
	AverageGetLatency    time.Duration `json:"avg_get_latency_ns"`
	AveragePutLatency    time.Duration `json:"avg_put_latency_ns"`
	AverageDeleteLatency time.Duration `json:"avg_delete_latency_ns"`

	// Time-based metrics
	Uptime                time.Duration `json:"uptime"`
	TimeSinceLastHit      time.Duration `json:"time_since_last_hit"`
	TimeSinceLastMiss     time.Duration `json:"time_since_last_miss"`
	TimeSinceLastEviction time.Duration `json:"time_since_last_eviction"`
	TimeSinceLastError    time.Duration `json:"time_since_last_error"`

	// Peak usage tracking
	PeakBytesStored   int64   `json:"peak_bytes_stored"`
	PeakEntriesStored int64   `json:"peak_entries_stored"`
	PeakHitRate       float64 `json:"peak_hit_rate"`

	// Sample counts for latency calculations
	GetLatencySamples    int `json:"get_latency_samples"`
	PutLatencySamples    int `json:"put_latency_samples"`
	DeleteLatencySamples int `json:"delete_latency_samples"`
}

type Operation string

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

type Stats struct {
	TotalEntries       int       `json:"total_entries"`
	ExpiredEntries     int       `json:"expired_entries"`
	TotalSize          int64     `json:"total_size_bytes"`
	MaxSize            int64     `json:"max_size_bytes"`
	HitRate            float64   `json:"hit_rate"`
	Evictions          int64     `json:"total_evictions"`
	Errors             int64     `json:"total_errors"`
	LastCompaction     time.Time `json:"last_compaction"`
	AverageAccessCount float64   `json:"average_access_count"`
}

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

type StorageDebugInfo struct {
	TotalFiles     int       `json:"total_files"`
	TotalSize      int64     `json:"total_size"`
	CachePath      string    `json:"cache_path"`
	Subdirectories []DirInfo `json:"subdirectories"`
}

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

type TTLEviction struct{}

type TagCache interface {
	// GetTagMapping retrieves the current digest for a tag reference.
	// Returns the tag mapping or an error if not found or expired.
	GetTagMapping(ctx context.Context, reference string) (*TagMapping, error)

	// PutTagMapping stores or updates a tag-to-digest mapping.
	// Creates history entries when updating existing mappings.
	PutTagMapping(ctx context.Context, reference, digest string) error

	// HasTagMapping checks if a tag mapping exists and is not expired.
	// This is more efficient than GetTagMapping when only existence matters.
	HasTagMapping(ctx context.Context, reference string) (bool, error)

	// DeleteTagMapping removes a tag mapping from the cache.
	// Returns nil if the mapping doesn't exist (idempotent operation).
	DeleteTagMapping(ctx context.Context, reference string) error

	// GetTagHistory retrieves the history of digests for a tag reference.
	// Returns a slice of historical entries in chronological order (oldest first).
	GetTagHistory(ctx context.Context, reference string) ([]TagHistoryEntry, error)
}

type TagHistoryEntry struct {
	// Digest the tag previously pointed to
	Digest string `json:"digest"`
	// ChangedAt when this change occurred
	ChangedAt time.Time `json:"changed_at"`
}

type TagMapping struct {
	// Reference is the tag reference (e.g., "myregistry.com/myimage:latest")
	Reference string `json:"reference"`
	// Digest is the content digest this tag currently points to
	Digest string `json:"digest"`
	// CreatedAt is when this mapping was first created
	CreatedAt time.Time `json:"created_at"`
	// UpdatedAt is when this mapping was last updated
	UpdatedAt time.Time `json:"updated_at"`
	// AccessCount tracks how many times this mapping has been accessed
	AccessCount int64 `json:"access_count"`
	// History contains previous digests this tag has pointed to
	History []TagHistoryEntry `json:"history,omitempty"`
}

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

type TagResolverConfig struct {
	// DefaultTTL is the default TTL for tag mappings
	DefaultTTL time.Duration
	// MaxHistorySize is the maximum number of historical entries to keep per tag
	MaxHistorySize int
	// EnableHistory enables tracking of tag history (defaults to true)
	EnableHistory bool
}