compaction

type BaseTier struct {
	StorageBackend storage.Backend
	MinAgeHours    int
	MinFiles       int
	TargetSizeMB   int
	Enabled        bool

	// Metrics
	TotalCompactions    int
	TotalFilesCompacted int
	TotalBytesSaved     int64

	Logger zerolog.Logger
	// contains filtered or unexported fields
}

type BaseTierConfig struct {
	StorageBackend storage.Backend
	MinAgeHours    int
	MinFiles       int
	TargetSizeMB   int
	Enabled        bool
	Logger         zerolog.Logger
}

type Candidate struct {
	Database      string
	Measurement   string
	PartitionPath string
	Files         []string
	FileCount     int
	Tier          string
	PartitionTime time.Time
	BatchNumber   int // Batch number when candidate is split (0 = not batched or first batch)
	TotalBatches  int // Total number of batches for this partition (0 = not batched)
}

type ClusterGate interface {
	// CanCompact reports whether the local node may run compaction. When
	// the scheduler sees false, it logs a clear "gated" message and stays
	// idle (NOT running, NOT an error).
	CanCompact() bool
	// Role returns the current node's role string for log messages. The
	// scheduler only uses this for human-readable output, never for
	// decision-making — CanCompact is authoritative.
	Role() string
}

type CompactedFile struct {
	Path          string // storage-relative path
	SHA256        string // hex-encoded 64 chars
	SizeBytes     int64
	Database      string
	Measurement   string
	PartitionTime time.Time
	Tier          string
	CreatedAt     time.Time
}

type CompactedOutput struct {
	Path          string    `json:"path"`           // storage-relative path (e.g. "mydb/cpu/2026/04/11/14/compacted_....parquet")
	SHA256        string    `json:"sha256"`         // hex-encoded 64 chars; bridged into raft.FileEntry.SHA256
	SizeBytes     int64     `json:"size_bytes"`     // authoritative size after upload
	Database      string    `json:"database"`       // bridged into raft.FileEntry.Database
	Measurement   string    `json:"measurement"`    // bridged into raft.FileEntry.Measurement
	PartitionTime time.Time `json:"partition_time"` // bridged into raft.FileEntry.PartitionTime
	Tier          string    `json:"tier"`           // "hot", "cold", etc.
	CreatedAt     time.Time `json:"created_at"`     // bridged into raft.FileEntry.CreatedAt
}

type CompletionManifest struct {
	JobID          string            `json:"job_id"`          // matches Job.JobID; unique per attempt
	Database       string            `json:"database"`        // for operator debugging; Outputs[].Database is authoritative
	Measurement    string            `json:"measurement"`     // for operator debugging
	PartitionPath  string            `json:"partition_path"`  // for operator debugging
	Tier           string            `json:"tier"`            // for operator debugging
	State          CompletionState   `json:"state"`           // lifecycle phase; drives watcher behavior
	Outputs        []CompactedOutput `json:"outputs"`         // set when State >= output_written
	DeletedSources []string          `json:"deleted_sources"` // set when State == sources_deleted; storage-relative paths
	CreatedAt      time.Time         `json:"created_at"`      // when the manifest was first written
	UpdatedAt      time.Time         `json:"updated_at"`      // bumped on every state transition
}

type CompletionState string

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

type CompletionWatcherConfig struct {
	// Dir is the local-disk directory scanned for pending completion manifests.
	// Matches the compaction Manager's CompletionDir field. Must not be empty.
	Dir string

	// Bridge is the cluster-side manifest appender. Required.
	Bridge ManifestBridge

	// PollInterval is the time between scan cycles. Default: 1s. Smaller
	// values catch up faster but add load; larger values delay visibility
	// of compacted files in the cluster manifest.
	PollInterval time.Duration

	// ApplyTimeout bounds a single bridge call. Default: 5s. The watcher
	// derives a fresh context from its own context with this deadline for
	// each Register/Delete call so a stuck bridge call doesn't pin the
	// poll loop.
	ApplyTimeout time.Duration

	// Logger receives structured log output. Defaults to Nop if zero.
	Logger zerolog.Logger
}

type DailyTier struct {
	*BaseTier
	SkipFileAgeCheckDays int // Skip file creation time check for partitions older than this
}

type DailyTierConfig struct {
	StorageBackend       storage.Backend
	MinAgeHours          int  // Don't compact days younger than this (default: 24)
	MinFiles             int  // Only compact days with at least this many files (default: 12)
	SkipFileAgeCheckDays int  // Skip file creation time check for partitions older than this (default: 7)
	TargetSizeMB         int  // Target size for compacted files (default: 2048)
	Enabled              bool // Enable daily compaction (default: true)
	Logger               zerolog.Logger
}

type DeleteSourceOp struct {
	Path   string
	Reason string
}

type HourlyTier struct {
	*BaseTier
}

type HourlyTierConfig struct {
	StorageBackend storage.Backend
	MinAgeHours    int  // Don't compact partitions younger than this (default: 1)
	MinFiles       int  // Only compact partitions with at least this many files (default: 10)
	TargetSizeMB   int  // Target size for compacted files (default: 512)
	Enabled        bool // Enable hourly compaction (default: true)
	Logger         zerolog.Logger
}

type Job struct {
	// Configuration
	Measurement    string
	PartitionPath  string
	Files          []string // Original files to be compacted
	StorageBackend storage.Backend
	Database       string
	TargetSizeMB   int
	Tier           string
	TempDirectory  string   // Base temp directory for compaction files
	SortKeys       []string // Sort keys for this measurement (for ORDER BY in compaction)

	// Job metadata
	JobID       string
	StartedAt   *time.Time
	CompletedAt *time.Time
	Status      JobStatus
	Error       error

	// Metrics
	FilesCompacted  int
	BytesBefore     int64
	BytesAfter      int64
	DurationSeconds float64

	// Phase 4: cluster-mode completion manifest. When CompletionDir is
	// non-empty, the job writes a local-disk CompletionManifest at each
	// state transition so the parent-side CompletionWatcher can apply
	// RegisterFile/DeleteFile commands to the Raft manifest. Empty means
	// OSS / standalone mode — no manifest is written and behavior is
	// byte-identical to pre-Phase-4.
	//
	// PartitionTime is the tier-scanner's authoritative timestamp for the
	// partition (see Candidate.PartitionTime in tier.go). Surfaced in the
	// completion manifest so the bridge can set raft.FileEntry.PartitionTime.
	// Only meaningful when clusterMode() is true; zero value in OSS.
	CompletionDir string
	PartitionTime time.Time
	// contains filtered or unexported fields
}

type JobConfig struct {
	Measurement     string
	PartitionPath   string
	Files           []string
	StorageBackend  storage.Backend
	Database        string
	TargetSizeMB    int
	Tier            string
	TempDirectory   string   // Base temp directory for compaction files (default: ./data/compaction)
	SortKeys        []string // Sort keys for this measurement (for ORDER BY in compaction)
	Logger          zerolog.Logger
	DB              *sql.DB          // Shared DuckDB connection (avoids memory retention from temp connections)
	ManifestManager *ManifestManager // Manifest manager for crash recovery (optional, recommended)

	// CompletionDir is the Phase 4 cluster-mode completion-manifest directory.
	// When non-empty, the job writes a local-disk CompletionManifest at each
	// state transition. Empty means OSS / standalone — no completion manifest
	// is written and the job is byte-compatible with pre-Phase-4 behavior.
	CompletionDir string

	// JobID, if set, overrides the auto-generated JobID. Phase 4 uses this
	// so the parent (which spawns the subprocess) and the subprocess agree
	// on the completion-manifest filename. Empty means auto-generate.
	JobID string

	// PartitionTime is the authoritative partition timestamp from the tier
	// scanner. Threaded through so the completion manifest includes it for
	// the Raft FileEntry. Zero value in OSS.
	PartitionTime time.Time
}

type JobStatus string

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

type Manager struct {
	StorageBackend  storage.Backend
	LockManager     *LockManager
	ManifestManager *ManifestManager

	// Configuration
	MinAgeHours   int
	MinFiles      int
	TargetSizeMB  int
	MaxConcurrent int
	TempDirectory string // Temp directory for compaction files
	MemoryLimit   string // DuckDB memory limit for subprocess (e.g., "8GB")
	// Phase 4: local-disk directory where compaction subprocesses write
	// completion manifests for the parent-side CompletionWatcher to pick
	// up. Empty means "OSS mode, no completion-manifest handoff". Set by
	// the main wiring to filepath.Join(TempDirectory, ".completion", "pending")
	// when clustering + replication are enabled.
	CompletionDir string

	// Sort key configuration (from ingest config)
	SortKeysConfig  map[string][]string // measurement -> sort keys
	DefaultSortKeys []string            // default sort keys

	// Tiers
	Tiers []Tier

	// Metrics
	TotalJobsCompleted  int
	TotalJobsFailed     int
	TotalFilesCompacted int
	TotalBytesSaved     int64
	TotalManifestsRecov int // Number of manifests recovered
	// contains filtered or unexported fields
}

type ManagerConfig struct {
	StorageBackend  storage.Backend
	LockManager     *LockManager
	MinAgeHours     int
	MinFiles        int
	TargetSizeMB    int
	MaxConcurrent   int
	TempDirectory   string              // Temp directory for compaction files
	MemoryLimit     string              // DuckDB memory limit for subprocess (e.g., "8GB")
	CompletionDir   string              // Phase 4: local-disk completion-manifest dir (empty = OSS mode)
	SortKeysConfig  map[string][]string // Per-measurement sort keys from ingest config
	DefaultSortKeys []string            // Default sort keys from ingest config
	Tiers           []Tier
	Logger          zerolog.Logger
}

type Manifest struct {
	// Output file information
	OutputPath string `json:"output_path"` // Full storage path of compacted file
	OutputSize int64  `json:"output_size"` // Expected size of output file (for validation)

	// Input files that were compacted
	InputFiles []string `json:"input_files"`

	// Metadata
	Database      string         `json:"database"`
	Measurement   string         `json:"measurement"`
	PartitionPath string         `json:"partition_path"`
	Tier          string         `json:"tier"`
	Status        ManifestStatus `json:"status"`
	CreatedAt     time.Time      `json:"created_at"`
	JobID         string         `json:"job_id"`
}

type ManifestBridge interface {
	RegisterCompactedFile(ctx context.Context, file CompactedFile) error
	DeleteCompactedSource(ctx context.Context, path, reason string) error
	// BatchFileOps groups all register and delete operations for one manifest
	// into a single Raft log entry. The watcher always calls this in applyOne
	// instead of the individual methods — O(1) Raft applies per manifest
	// regardless of file count.
	BatchFileOps(ctx context.Context, registers []CompactedFile, deletes []DeleteSourceOp) error
}

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

type ManifestStatus string

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

type SchedulerConfig struct {
	Manager     *Manager
	Schedule    string      // Cron schedule string (e.g., "5 * * * *" for every hour at :05)
	TierNames   []string    // Specific tiers to process (must be non-empty and enabled)
	Enabled     bool        // Enable automatic scheduling
	ClusterGate ClusterGate // Optional Phase 4 role check; nil means "no gate, allow"
	Logger      zerolog.Logger
}

type SubprocessJobConfig struct {
	Database      string   `json:"database"`
	Measurement   string   `json:"measurement"`
	PartitionPath string   `json:"partition_path"`
	Files         []string `json:"files"`
	Tier          string   `json:"tier"`
	TargetSizeMB  int      `json:"target_size_mb"`
	TempDirectory string   `json:"temp_directory"`
	SortKeys      []string `json:"sort_keys"`    // Sort keys for ORDER BY in compaction
	MemoryLimit   string   `json:"memory_limit"` // DuckDB memory limit (e.g., "8GB")

	// Storage configuration
	StorageType   string `json:"storage_type"`   // "local" or "s3"
	StorageConfig string `json:"storage_config"` // JSON-encoded storage-specific config

	// Phase 4: cluster-mode completion-manifest handoff. When CompletionDir
	// is non-empty, the job writes a local-disk CompletionManifest that the
	// parent-side CompletionWatcher picks up and applies to the Raft manifest.
	// PartitionTime is the tier-scanner's authoritative timestamp for the
	// partition — bridged into raft.FileEntry.PartitionTime so peers know
	// which hour/day this compacted file belongs to.
	// JobID is generated by the parent (not NewJob) so both sides agree on
	// the completion-manifest filename. Empty values disable the feature.
	JobID         string    `json:"job_id,omitempty"`
	CompletionDir string    `json:"completion_dir,omitempty"`
	PartitionTime time.Time `json:"partition_time,omitempty"`
}

type SubprocessJobResult struct {
	Success        bool   `json:"success"`
	Error          string `json:"error,omitempty"`
	FilesCompacted int    `json:"files_compacted"`
	BytesBefore    int64  `json:"bytes_before"`
	BytesAfter     int64  `json:"bytes_after"`
	OutputFile     string `json:"output_file,omitempty"`
}

type Tier interface {
	// GetTierName returns the human-readable tier name (e.g., 'daily', 'weekly', 'monthly')
	GetTierName() string

	// GetPartitionLevel returns the partition level for this tier (e.g., 'day', 'week', 'month')
	GetPartitionLevel() string

	// FindCandidates finds partitions that are candidates for compaction at this tier level
	FindCandidates(ctx context.Context, database, measurement string) ([]Candidate, error)

	// ShouldCompact determines if a partition should be compacted based on tier-specific criteria
	ShouldCompact(files []string, partitionTime time.Time) bool

	// IsCompactedFile checks if a file is already a compacted file from this tier
	IsCompactedFile(filename string) bool

	// IsEnabled returns whether this tier is enabled
	IsEnabled() bool

	// GetStats returns tier statistics
	GetStats() map[string]interface{}
}