storage

type Cache interface {
	Get(key EntryKey) Sizable
	Put(key EntryKey, value Sizable)
	Close()
	Requests() uint64
	Misses() uint64
	Entries() uint64
	Size() uint64
}

type CacheConfig struct {
	MaxCacheSize    run.Bytes
	CleanupInterval time.Duration
	IdleTimeout     time.Duration
}

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

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

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

type FieldResult map[string][]byte

type FieldResultList []FieldResult

type IndexDB interface {
	Insert(docs index.Documents) error
	Update(docs index.Documents) error
	Search(ctx context.Context, series []*pbv1.Series, opts IndexSearchOpts) (SeriesData, [][]byte, error)
	SearchWithoutSeries(ctx context.Context, opts IndexSearchOpts) (sd SeriesData, sortedValues [][]byte, err error)
	EnableExternalSegments() (index.ExternalSegmentStreamer, error)
}

type IndexGranularity int

type IndexSearchOpts struct {
	Query       index.Query
	Order       *index.OrderBy
	TimeRange   *timestamp.TimeRange
	Projection  []index.FieldKey
	PreloadSize int
}

type IntervalRule struct {
	Unit IntervalUnit
	Num  int
}

type IntervalUnit int

type Metrics interface {
	// DeleteAll deletes all metrics.
	DeleteAll()
}

type PartInfo struct {
	SourcePath string
	PartType   string
	PartID     uint64
}

type RetentionConfig struct {
	// HighWatermark is the disk usage percentage that triggers forced cleanup (0-100)
	HighWatermark float64
	// LowWatermark is the disk usage percentage where cleanup stops (0-100)
	LowWatermark float64
	// CheckInterval is how often to check disk usage
	CheckInterval time.Duration
	// Cooldown is the sleep duration between segment deletions
	Cooldown time.Duration
	// ForceCleanupEnabled determines whether forced cleanup is enabled
	ForceCleanupEnabled bool
}

type RetentionService interface {
	// GetDataPath returns the service's data directory path
	GetDataPath() string
	// GetSnapshotDir returns the service's snapshot directory path
	GetSnapshotDir() string
	// LoadAllGroups returns all groups managed by this service
	LoadAllGroups() []resourceSchema.Group
	// PeekOldestSegmentEndTimeInGroup returns the end time of the oldest segment in the specified group
	// Returns zero time and false if no segments exist or group not found
	PeekOldestSegmentEndTimeInGroup(group string) (time.Time, bool)
	// DeleteOldestSegmentInGroup deletes the oldest segment in the specified group
	// Returns true if a segment was deleted, false if no segments to delete
	DeleteOldestSegmentInGroup(group string) (bool, error)
	// CleanupOldSnapshots removes snapshots older than the specified duration
	CleanupOldSnapshots(maxAge time.Duration) error
	// GetServiceName returns the service name for metrics and logging
	GetServiceName() string
}

type Segment[T TSTable, O any] interface {
	DecRef()
	GetTimeRange() timestamp.TimeRange
	CreateTSTableIfNotExist(shardID common.ShardID) (T, error)
	Tables() ([]T, []Cache)
	Lookup(ctx context.Context, series []*pbv1.Series) (pbv1.SeriesList, error)
	IndexDB() IndexDB
}

type SegmentVisitor interface {
	// VisitSeries visits the series index directory for a segment.
	VisitSeries(segmentTR *timestamp.TimeRange, seriesIndexPath string, shardIDs []common.ShardID) error
	// VisitShard visits a shard directory within a segment.
	VisitShard(segmentTR *timestamp.TimeRange, shardID common.ShardID, shardPath string) error
}

type SeriesData struct {
	SeriesList pbv1.SeriesList
	Fields     FieldResultList
	Timestamps []int64
	Versions   []int64
}

type Sizable interface {
	Size() uint64
}

type SupplyTSDB[T TSTable] func() T

type TSDB[T TSTable, O any] interface {
	io.Closer
	CreateSegmentIfNotExist(ts time.Time) (Segment[T, O], error)
	SelectSegments(timeRange timestamp.TimeRange) ([]Segment[T, O], error)
	Tick(ts int64)
	UpdateOptions(opts *commonv1.ResourceOpts)
	TakeFileSnapshot(dst string) error
	GetExpiredSegmentsTimeRange() *timestamp.TimeRange
	DeleteExpiredSegments(segmentSuffixes []string) int64
	// PeekOldestSegmentEndTime returns the end time of the oldest segment.
	// Returns the zero time and false if no segments exist or retention gate cannot be acquired.
	PeekOldestSegmentEndTime() (time.Time, bool)
	// DeleteOldestSegment deletes exactly one oldest segment if it exists and meets safety rules.
	// Returns true if a segment was deleted, false otherwise.
	DeleteOldestSegment() (bool, error)
}

type TSDBOpts[T TSTable, O any] struct {
	Option                         O
	TableMetrics                   Metrics
	TSTableCreator                 TSTableCreator[T, O]
	StorageMetricsFactory          *observability.Factory
	Location                       string
	SegmentInterval                IntervalRule
	TTL                            IntervalRule
	SeriesIndexFlushTimeoutSeconds int64
	SeriesIndexCacheMaxBytes       int
	ShardNum                       uint32
	DisableRetention               bool
	SegmentIdleTimeout             time.Duration
	MemoryLimit                    uint64
}

type TSTable interface {
	io.Closer
	Collect(Metrics)
	TakeFileSnapshot(dst string) error
}

type TSTableCreator[T TSTable, O any] func(fileSystem fs.FileSystem, root string, position common.Position,
	l *logger.Logger, timeRange timestamp.TimeRange, option O, metrics any) (T, error)