backup

type ArchiveWALOptions struct {
	WALFile       string // path to local WAL file
	Remote        string // rclone remote path
	AgeRecipient  string // age public key for encryption
	Timeline      string // PG timeline ID
	MaxRetries    int    // max upload retries (default: 3)
	RetryInterval time.Duration
}

type BackupEntry struct {
	ID        string    `json:"id"`
	Date      time.Time `json:"date"`
	Size      int64     `json:"size"`
	Type      string    `json:"type"`      // full, metadata, minio, wal
	Tag       string    `json:"tag"`       // user tag if present
	Encrypted bool      `json:"encrypted"` // .age suffix
}

type BackupType string

type Container struct {
	Name, User, DB, Volume string
	// contains filtered or unexported fields
}

type ContainerSpec struct {
	Name     string // "" = throwaway; otherwise must end in _pg_restore_test
	Volume   string // named data volume ("" = anonymous, removed with the container)
	User     string
	DB       string
	Password string // "" = random
	Image    string
	Keep     bool          // leave the container for inspection
	Ready    time.Duration // wait for postgres; default 60s
}

type CreateOptions struct {
	Type      BackupType // full, wal, metadata, minio, all
	Remote    string     // remote name override
	Encrypt   bool       // force encryption on
	NoEncrypt bool       // force encryption off
	Tag       string     // human label for this backup
	DryRun    bool       // preview only
}

type DrillRemoteOptions struct {
	Project     string
	From        string // destination holding <project>_stream_* objects
	Key         string // object to restore; "" = newest
	Identity    string // age identity file; "" = default locations
	HeartbeatTo string // heartbeat remote; "" = drill.json is not written
}

type DrillRemoteResult struct {
	Heartbeat        Heartbeat
	Tables           []string // restored tables, sorted
	Estimated        bool     // row estimates from the backup heartbeat were used
	HeartbeatWritten bool
	Warnings         []string // why source counts were not used, key mismatches
	Duration         time.Duration
}

type EmbeddedBackupResult struct {
	// ArtifactPath is the absolute path of the produced backup file.
	ArtifactPath string
	// Format is "pgdump-custom" when pg_dump was used, or "sql-plain" when
	// the wire-protocol COPY fallback was used.
	Format string
}

type HasuraMetadataOptions struct {
	// HasuraURL is the base URL of the Hasura instance, e.g.
	// "http://localhost:8080". Defaults to "http://localhost:8080".
	HasuraURL string
	// AdminSecret is the Hasura admin secret used for authentication.
	AdminSecret string
	// BackupDir is the directory where the JSON file will be written.
	// Defaults to "./backups".
	BackupDir string
}

type Heartbeat struct {
	ApproxRows    map[string]int64 `json:"approx_rows"` // backup: estimates, null when unreadable
	At            string           `json:"at"`          // RFC 3339 UTC, upload finish time
	BackupKey     string           `json:"backup_key"`  // object key, never the remote
	Bytes         int64            `json:"bytes"`       // size of the (encrypted) object
	CLIVersion    string           `json:"cli_version"`
	Encrypted     bool             `json:"encrypted"`
	Kind          string           `json:"kind"`
	Mismatches    []string         `json:"mismatches"` // drill only; [] for a backup
	Project       string           `json:"project"`
	RestoredRows  map[string]int64 `json:"restored_rows"` // drill only; null for a backup
	Result        string           `json:"result"`
	SchemaVersion string           `json:"schema_version"`
}

type Identity struct {
	Path      string
	Recipient string // public key, safe to print
	Created   bool   // true when this call created the file
}

type ListOptions struct {
	Remote string        // filter by remote name
	Env    string        // filter by environment
	Since  time.Duration // only show backups newer than this
	Format string        // table or json
}

type OffboxOptions struct {
	MaxAge      time.Duration
	MaxDrillAge time.Duration
}

type OffboxStatus struct {
	Source              string     `json:"source"` // "heartbeat" or "none"
	LastBackup          *Heartbeat `json:"last_backup"`
	LastDrill           *Heartbeat `json:"last_drill"`
	BackupAgeSeconds    *int64     `json:"backup_age_seconds"`
	DrillAgeSeconds     *int64     `json:"drill_age_seconds"`
	MaxAgeExceeded      bool       `json:"max_age_exceeded"`
	MaxDrillAgeExceeded bool       `json:"max_drill_age_exceeded"`
	// Problems lists the reason of every missing, stale, failed or unreadable
	// heartbeat ("[E219] ..."); an empty array when none. Additive in v1.
	Problems []string `json:"problems"`
}

type PruneJSONEntry struct {
	Path    string `json:"path"`
	AgeDays int    `json:"age_days"`
}

type PruneJSONReport struct {
	DryRun      bool             `json:"dry_run"`
	KeepDaily   int              `json:"keep_daily"`
	WouldDelete []PruneJSONEntry `json:"would_delete"`
	Kept        []PruneJSONEntry `json:"kept"`
}

type PruneOptions struct {
	DryRun      bool
	KeepDaily   int
	KeepWeekly  int
	KeepMonthly int
}

type PruneResult struct {
	Kept   []string
	Pruned []string
	DryRun bool
}

type RestoreOptions struct {
	BackupID   string   // backup ID or "latest"
	ToDir      string   // restore to alternate directory
	Only       []string // pg, minio, metadata — subset to restore
	DecryptKey string   // path to age identity file
	Yes        bool     // skip confirmation
}

type ResumeOptions struct {
	BackupID string
}

type ResumeState struct {
	BackupID    string    `json:"backup_id"`
	Destination string    `json:"destination"`
	Key         string    `json:"key"`
	Recipients  []string  `json:"recipients"`
	StartedAt   time.Time `json:"started_at"`
	// For rclone-based multipart, we store the partial object key prefix.
	// rclone handles actual part tracking internally; we record enough to
	// invoke rclone copyto from a local temp file on resume.
	PartialPath string `json:"partial_path,omitempty"`
}

type ScheduleOptions struct {
	Cron        string
	To          string   // rclone destination; falls back to cfg.Backup.Remote
	Recipients  []string // repeatable --recipient, written as repeated flags
	HeartbeatTo string   // --heartbeat-to, written into the unit when given
	EnvFile     string   // --env-file; no EnvironmentFile line when empty
	UnitDir     string   // default /etc/systemd/system
	DryRun      bool
	Out         io.Writer // dry-run output; default os.Stdout

	BinaryPath string
	ProjectDir string
}

type StatusInfo struct {
	LastRun          string `json:"last_run"`
	NextRun          string `json:"next_run"`
	Health           string `json:"health"` // healthy, warning, error
	TotalSize        string `json:"total_size"`
	BackupCount      int    `json:"backup_count"`
	RetentionDaily   int    `json:"retention_daily"`
	RetentionWeekly  int    `json:"retention_weekly"`
	RetentionMonthly int    `json:"retention_monthly"`
}

type StreamConfig struct {
	// PgURL is the postgres DSN used by pg_dump. If empty, derived from cfg.
	PgURL string

	// Destination is the rclone remote path, e.g. "s3:bucket/prefix/".
	Destination string

	// Recipients holds age/SSH public keys (one per entry). May also be
	// "github:<username>" to fetch the user's SSH public keys from GitHub.
	Recipients []string

	// Key is the object name appended to Destination. Auto-generated if empty.
	Key string

	// ChunkMB is the multipart chunk size. Defaults to 64.
	ChunkMB int
}

type StreamOptions struct {
	To         string   // destination URL (rclone remote path)
	Recipients []string // --recipient flags (may be specified multiple times)
	DryRun     bool
	// AllowUnencrypted permits streaming in the clear when no recipient
	// resolves. Off by default: without it, a missing recipient is an error
	// rather than a silent plaintext upload. See the check in Stream.
	AllowUnencrypted bool

	// HeartbeatTo is the rclone remote that receives <project>/backup.json
	// after a successful upload (--heartbeat-to). Empty falls back to
	// NSELF_BACKUP_HEARTBEAT_REMOTE; with neither, no heartbeat is written.
	HeartbeatTo string

	// HeartbeatRequired makes Stream return an error when the heartbeat cannot
	// be written (--heartbeat-required). Off by default: a heartbeat outage
	// must never lose or fail the backup itself.
	HeartbeatRequired bool
}

type StreamResult struct {
	BackupID    string    `json:"backup_id"`
	Destination string    `json:"destination"`
	StartedAt   time.Time `json:"started_at"`
	Duration    string    `json:"duration"`
	Encrypted   bool      `json:"encrypted"`
	// Bytes is the size of the uploaded (encrypted) object.
	Bytes int64 `json:"bytes,omitempty"`
}

type SystemdInstallOptions struct {
	FullAt      string // "HH:MM" UTC, e.g. "02:00"
	WALEvery    string // e.g. "15m"
	PruneAt     string // "HH:MM" UTC, default "04:30"
	VerifyOnDay string // systemd OnCalendar day name (Sun..Sat), default "Sun"
	VerifyAt    string // "HH:MM", default "05:00"
	UnitDir     string // default /etc/systemd/system
	EnvFile     string // default /etc/nself/backup.env
	BinaryPath  string // default /usr/local/bin/nself
	ProjectDir  string // working directory for nself commands
	Remote      string // e.g. b2-nclaw
	DryRun      bool
}

type SystemdUnitFiles map[string]string

type VerifyOptions struct {
	BackupID    string // backup ID or "latest"
	RestoreTest bool   // spin up test container and restore
	Cleanup     bool   // remove test container after verify
	Keep        bool   // keep test container for inspection
}

type VerifyResult struct {
	BackupID  string    `json:"backup_id"`
	Verified  bool      `json:"verified"`
	StartedAt time.Time `json:"started_at"`
	Duration  string    `json:"duration"`
	Method    string    `json:"method"` // checksum, restore-test
	Details   string    `json:"details"`
}