retry

type BackoffConfig struct {
	// Strategy is the backoff strategy to use.
	// Default is BackoffExponential.
	Strategy BackoffStrategy

	// BaseInterval is the base interval for backoff calculation.
	// Default is DefaultRetryInterval (5 minutes).
	BaseInterval time.Duration

	// MaxInterval is the maximum interval between retries.
	// Default is 48 hours.
	MaxInterval time.Duration

	// Jitter adds randomness to prevent thundering herd.
	// Value between 0.0 (no jitter) and 1.0 (full jitter).
	// Default is 0.1 (10% jitter).
	Jitter float64
}

type BackoffStrategy int

type FileQueueConfig struct {
	// Dir is the directory to store queue files.
	// Default: ~/.openctem/retry-queue
	Dir string

	// MaxSize is the maximum number of items in the queue.
	// Default: 1000
	MaxSize int

	// Deduplication enables fingerprint-based deduplication.
	// Default: true
	Deduplication bool

	// Backoff configures the retry backoff behavior.
	// Default: exponential backoff with 5-minute base
	Backoff *BackoffConfig

	// Verbose enables verbose logging.
	Verbose bool
}

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

type FingerprintCheckResult struct {
	Existing []string // Fingerprints that already exist on the server
	Missing  []string // Fingerprints that don't exist on the server
}

type FingerprintChecker interface {
	// CheckFingerprints checks which fingerprints already exist on the server.
	// Returns two slices: existing fingerprints and missing fingerprints.
	CheckFingerprints(ctx context.Context, fingerprints []string) (*FingerprintCheckResult, error)
}

type ItemStatus string

type ItemType string

type ListFilter struct {
	// Status filters by item status. Empty means all statuses.
	Status ItemStatus

	// Type filters by item type. Empty means all types.
	Type ItemType

	// Limit is the maximum number of items to return. 0 means no limit.
	Limit int

	// Offset is the number of items to skip. Used for pagination.
	Offset int

	// ReadyOnly if true, only returns items ready for retry (NextRetry <= now).
	ReadyOnly bool

	// OrderBy specifies the field to order by. Default is "created_at".
	OrderBy string

	// OrderDesc if true, orders in descending order.
	OrderDesc bool
}

type Pusher interface {
	// PushReport pushes a report to the server.
	// Returns nil on success.
	PushReport(ctx context.Context, report any) error
}

type QueueConfig struct {
	// MaxSize is the maximum number of items allowed in the queue.
	// Default is DefaultMaxQueueSize (1000).
	MaxSize int

	// Deduplication enables fingerprint-based deduplication.
	// Default is true.
	Deduplication bool

	// Verbose enables verbose logging.
	Verbose bool
}

type QueueItem struct {
	// Identification
	ID          string     `json:"id"`          // Unique identifier (UUID)
	Type        ItemType   `json:"type"`        // Type of item (findings, assets, heartbeat)
	Fingerprint string     `json:"fingerprint"` // Content fingerprint for deduplication
	Status      ItemStatus `json:"status"`      // Current status

	// Payload
	Report *ctis.Report `json:"report"` // The CTIS report to push

	// Retry tracking
	Attempts    int       `json:"attempts"`     // Number of retry attempts made
	MaxAttempts int       `json:"max_attempts"` // Maximum retry attempts allowed
	LastError   string    `json:"last_error"`   // Last error message
	LastAttempt time.Time `json:"last_attempt"` // Timestamp of last attempt
	NextRetry   time.Time `json:"next_retry"`   // Scheduled next retry time

	// Metadata
	CreatedAt   time.Time `json:"created_at"`   // When item was first queued
	UpdatedAt   time.Time `json:"updated_at"`   // Last update timestamp
	AgentID     string    `json:"agent_id"`     // Source agent ID
	ScannerName string    `json:"scanner_name"` // Source scanner name
	TargetPath  string    `json:"target_path"`  // Scan target path
}

type QueueStats struct {
	TotalItems      int       `json:"total_items"`       // Total items in queue
	PendingItems    int       `json:"pending_items"`     // Items waiting for retry
	ProcessingItems int       `json:"processing_items"`  // Items currently being processed
	FailedItems     int       `json:"failed_items"`      // Items that exhausted retries
	OldestItem      time.Time `json:"oldest_item"`       // Creation time of oldest item
	NewestItem      time.Time `json:"newest_item"`       // Creation time of newest item
	LastRetry       time.Time `json:"last_retry"`        // Last retry attempt time
	TotalRetries    int64     `json:"total_retries"`     // Total retry attempts made
	SuccessfulPush  int64     `json:"successful_pushes"` // Successful pushes from retry
}

type ReportPusher interface {
	// PushReport pushes a CTIS report to the server.
	PushReport(ctx context.Context, report *ctis.Report) error
}

type RetryCallback func(result *RetryResult)

type RetryQueue interface {
	// Enqueue adds an item to the queue.
	// Returns the item ID on success.
	// Returns ErrQueueFull if the queue has reached its maximum capacity.
	// Returns ErrDuplicateItem if an item with the same fingerprint exists.
	Enqueue(ctx context.Context, item *QueueItem) (string, error)

	// Dequeue removes and returns the next item ready for retry.
	// Returns nil, nil if no items are ready for retry.
	// The item's status should be set to ItemStatusProcessing.
	Dequeue(ctx context.Context) (*QueueItem, error)

	// Peek returns items ready for retry without removing them.
	// Items are returned in order of priority (oldest NextRetry first).
	Peek(ctx context.Context, limit int) ([]*QueueItem, error)

	// Get retrieves an item by ID without removing it.
	// Returns ErrItemNotFound if the item doesn't exist.
	Get(ctx context.Context, id string) (*QueueItem, error)

	// Update updates an existing item in the queue.
	// Typically called after a retry attempt to update attempt count, error, etc.
	// Returns ErrItemNotFound if the item doesn't exist.
	Update(ctx context.Context, item *QueueItem) error

	// Delete removes an item from the queue.
	// Typically called after successful push or when item should be discarded.
	// Returns ErrItemNotFound if the item doesn't exist.
	Delete(ctx context.Context, id string) error

	// MarkFailed marks an item as permanently failed.
	// Called when an item has exhausted all retry attempts.
	MarkFailed(ctx context.Context, id string, lastError string) error

	// Requeue moves an item back to pending status for retry.
	// Called when a processing item needs to be retried.
	Requeue(ctx context.Context, id string, nextRetry time.Time) error

	// Size returns the total number of items in the queue.
	Size(ctx context.Context) (int, error)

	// Stats returns detailed statistics about the queue.
	Stats(ctx context.Context) (*QueueStats, error)

	// Cleanup removes expired items (older than TTL) and permanently failed items.
	// Returns the number of items removed.
	Cleanup(ctx context.Context, ttl time.Duration) (int, error)

	// List returns items matching the given filter.
	List(ctx context.Context, filter ListFilter) ([]*QueueItem, error)

	// Close closes the queue and releases any resources.
	// After Close is called, all other methods should return ErrQueueClosed.
	Close() error
}

type RetryResult struct {
	ItemID    string        `json:"item_id"`
	Success   bool          `json:"success"`
	Error     string        `json:"error,omitempty"`
	Duration  time.Duration `json:"duration"`
	Attempt   int           `json:"attempt"`
	Timestamp time.Time     `json:"timestamp"`
}

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

type RetryWorkerConfig struct {
	// Interval is how often to check the queue for items to retry.
	// Default: 5 minutes
	Interval time.Duration `yaml:"interval" json:"interval"`

	// BatchSize is the maximum number of items to process per check.
	// Default: 10
	BatchSize int `yaml:"batch_size" json:"batch_size"`

	// MaxAttempts is the maximum number of retry attempts per item.
	// Default: 10
	MaxAttempts int `yaml:"max_attempts" json:"max_attempts"`

	// TTL is how long to keep items in the queue before expiring.
	// Default: 7 days
	TTL time.Duration `yaml:"ttl" json:"ttl"`

	// Backoff configures the retry backoff behavior.
	// Default: exponential backoff with 5-minute base
	Backoff *BackoffConfig `yaml:"backoff" json:"backoff"`

	// Verbose enables verbose logging.
	Verbose bool `yaml:"verbose" json:"verbose"`
}

type SmartPusher interface {
	ReportPusher
	FingerprintChecker
}

type WorkerStats struct {
	// Lifetime statistics
	TotalAttempts   int64         `json:"total_attempts"`
	SuccessfulPush  int64         `json:"successful_pushes"`
	FailedAttempts  int64         `json:"failed_attempts"`
	ExhaustedItems  int64         `json:"exhausted_items"`
	TotalDuration   time.Duration `json:"total_duration"`
	LastProcessedAt time.Time     `json:"last_processed_at"`

	// Current state
	IsRunning   bool      `json:"is_running"`
	StartedAt   time.Time `json:"started_at"`
	LastCheckAt time.Time `json:"last_check_at"`
}