storage

type BackupInfo struct {
	Name       string    `json:"name"`
	Path       string    `json:"path"`
	Created    time.Time `json:"created"`
	Size       int64     `json:"size"`
	Compressed bool      `json:"compressed"`
	Checksum   string    `json:"checksum"`
	KeyCount   int64     `json:"key_count"`
}

type BackupStorage interface {
	Backup(ctx context.Context, destination string) error
	Restore(ctx context.Context, source string) error
	ListBackups() ([]BackupInfo, error)
}

type CacheStats struct {
	Hits        int64   `json:"hits"`
	Misses      int64   `json:"misses"`
	Entries     int64   `json:"entries"`
	Size        int64   `json:"size"`
	Evictions   int64   `json:"evictions"`
	HitRate     float64 `json:"hit_rate"`
	MemoryUsage int64   `json:"memory_usage"`
}

type CacheStorage interface {
	Get(key string) ([]byte, error)
	Set(key string, value []byte, ttl time.Duration) error
	Delete(key string) error
	Clear() error
	Stats() CacheStats
}

type CompressionStorage interface {
	SetCompressionLevel(level int) error
	GetCompressionLevel() int
	CompressedSize() (int64, error)
	UncompressedSize() (int64, error)
	CompressionRatio() (float64, error)
}

type ConcurrentStorage interface {
	Storage
	ReadLock() error
	ReadUnlock() error
	WriteLock() error
	WriteUnlock() error
	TryReadLock() bool
	TryWriteLock() bool
}

type Config struct {
	Driver   string                 `toml:"driver"`
	Database string                 `toml:"database"`
	Host     string                 `toml:"host"`
	Port     int                    `toml:"port"`
	Username string                 `toml:"username"`
	Password string                 `toml:"password"`
	SSLMode  string                 `toml:"sslmode"`
	Options  map[string]interface{} `toml:"options"`
}

type Event struct {
	Type      EventType              `json:"type"`
	Timestamp time.Time              `json:"timestamp"`
	KeyID     string                 `json:"key_id,omitempty"`
	Data      map[string]interface{} `json:"data,omitempty"`
}

type EventHandler func(Event) error

type EventType string

type EventfulStorage interface {
	Storage
	Subscribe(EventType, EventHandler) error
	Unsubscribe(EventType, EventHandler) error
	PublishEvent(Event) error
}

type Factory interface {
	Create(config Config) (Storage, error)
	DriverName() string
	ConfigSchema() map[string]interface{}
}

type HealthChecker interface {
	HealthCheck(ctx context.Context) error
	HealthStatus() HealthStatus
}

type HealthStatus struct {
	Healthy      bool                   `json:"healthy"`
	LastCheck    time.Time              `json:"last_check"`
	Details      map[string]interface{} `json:"details,omitempty"`
	Errors       []string               `json:"errors,omitempty"`
	ResponseTime time.Duration          `json:"response_time"`
}

type Identity struct {
	ScopedDigest string     `json:"scoped_digest"`
	Packet       []byte     `json:"packet"`
	Creation     time.Time  `json:"creation"`
	Expiration   *time.Time `json:"expiration,omitempty"`
	State        int        `json:"state"`
	Ctime        time.Time  `json:"ctime"`
	Mtime        time.Time  `json:"mtime"`
	Keywords     []string   `json:"keywords,omitempty"`
}

type IndexInfo struct {
	Name     string    `json:"name"`
	Fields   []string  `json:"fields"`
	Unique   bool      `json:"unique"`
	Created  time.Time `json:"created"`
	Size     int64     `json:"size"`
	KeyCount int64     `json:"key_count"`
}

type IndexStorage interface {
	CreateIndex(name string, fields []string) error
	DropIndex(name string) error
	ListIndexes() ([]IndexInfo, error)
	ReindexAll() error
}

type KeyReader interface {
	io.Reader
	Next() (*Pubkey, error)
	Close() error
}

type KeyWriter interface {
	io.Writer
	WriteKey(*Pubkey) error
	Close() error
}

type MetricsCollector interface {
	CollectMetrics() (map[string]interface{}, error)
	RegisterMetric(name string, collector func() interface{}) error
}

type NoOpStorage struct{}

type PartitionCriteria struct {
	Type        PartitionType          `json:"type"`
	Field       string                 `json:"field"`
	Values      []interface{}          `json:"values,omitempty"`
	Ranges      []PartitionRange       `json:"ranges,omitempty"`
	HashBuckets int                    `json:"hash_buckets,omitempty"`
	Config      map[string]interface{} `json:"config,omitempty"`
}

type PartitionInfo struct {
	Name      string            `json:"name"`
	Criteria  PartitionCriteria `json:"criteria"`
	KeyCount  int64             `json:"key_count"`
	Size      int64             `json:"size"`
	Created   time.Time         `json:"created"`
	LastWrite time.Time         `json:"last_write"`
}

type PartitionRange struct {
	Start interface{} `json:"start"`
	End   interface{} `json:"end"`
	Name  string      `json:"name"`
}

type PartitionType string

type PartitionedStorage interface {
	Storage
	CreatePartition(name string, criteria PartitionCriteria) error
	DropPartition(name string) error
	ListPartitions() ([]PartitionInfo, error)
	GetPartition(keyID string) (string, error)
}

type Pubkey struct {
	RFingerprint string     `json:"rfingerprint"`
	Creation     time.Time  `json:"creation"`
	Expiration   *time.Time `json:"expiration,omitempty"`
	State        int        `json:"state"`
	Packet       []byte     `json:"packet"`
	Ctime        time.Time  `json:"ctime"`
	Mtime        time.Time  `json:"mtime"`
	MD5          string     `json:"md5"`
	SHA256       string     `json:"sha256"`
	Size         int        `json:"size"`

	// Associated data
	Identities []*Identity  `json:"identities,omitempty"`
	SubKeys    []*SubKey    `json:"subkeys,omitempty"`
	Signatures []*Signature `json:"signatures,omitempty"`
}

type ReadOnlyStorage interface {
	// Read operations only
	MatchMD5([]string) ([]string, error)
	ModifiedSince(time.Time) ([]string, error)
	FetchKeys([]string) ([]*Pubkey, error)
	FetchKeysPrefix(string) ([]*Pubkey, error)
	Stats() (*Stats, error)
	Healthy() error
	ReconStats() (*ReconStats, error)
	ReconState() (ReconState, error)
	Close() error
}

type ReconState struct {
	Version   int                    `json:"version"`
	HTTPAddr  string                 `json:"http_addr"`
	ReconAddr string                 `json:"recon_addr"`
	Filters   []string               `json:"filters"`
	Stats     *ReconStats            `json:"stats"`
	Settings  map[string]interface{} `json:"settings"`
}

type ReconStats struct {
	Total       int64     `json:"total"`
	LastUpdate  time.Time `json:"last_update"`
	SyncStarted time.Time `json:"sync_started,omitempty"`
	SyncStatus  string    `json:"sync_status"`
}

type ReplicationError struct {
	Timestamp time.Time `json:"timestamp"`
	PeerID    string    `json:"peer_id"`
	Error     string    `json:"error"`
	KeyID     string    `json:"key_id,omitempty"`
}

type ReplicationPeer struct {
	ID       string `json:"id"`
	Address  string `json:"address"`
	Priority int    `json:"priority"`
	ReadOnly bool   `json:"read_only"`
}

type ReplicationPeerStatus struct {
	ID         string        `json:"id"`
	Address    string        `json:"address"`
	Connected  bool          `json:"connected"`
	LastSync   time.Time     `json:"last_sync"`
	Lag        time.Duration `json:"lag"`
	ErrorCount int           `json:"error_count"`
	LastError  string        `json:"last_error,omitempty"`
}

type ReplicationStatus struct {
	Active     bool                    `json:"active"`
	Peers      []ReplicationPeerStatus `json:"peers"`
	LastSync   time.Time               `json:"last_sync"`
	SyncErrors []ReplicationError      `json:"sync_errors,omitempty"`
	Stats      map[string]interface{}  `json:"stats"`
}

type ReplicationStorage interface {
	Storage
	StartReplication(peers []ReplicationPeer) error
	StopReplication() error
	ReplicationStatus() ReplicationStatus
}

type SearchCriteria struct {
	KeyIDs       []string   `json:"key_ids,omitempty"`
	Fingerprints []string   `json:"fingerprints,omitempty"`
	UserIDs      []string   `json:"user_ids,omitempty"`
	Emails       []string   `json:"emails,omitempty"`
	Keywords     []string   `json:"keywords,omitempty"`
	After        *time.Time `json:"after,omitempty"`
	Before       *time.Time `json:"before,omitempty"`
	Limit        int        `json:"limit,omitempty"`
	Offset       int        `json:"offset,omitempty"`
}

type SearchResult struct {
	Keys       []*Pubkey     `json:"keys"`
	Total      int64         `json:"total"`
	Offset     int           `json:"offset"`
	Limit      int           `json:"limit"`
	HasMore    bool          `json:"has_more"`
	SearchTime time.Duration `json:"search_time"`
}

type Signature struct {
	ScopedDigest string     `json:"scoped_digest"`
	Packet       []byte     `json:"packet"`
	Creation     time.Time  `json:"creation"`
	Expiration   *time.Time `json:"expiration,omitempty"`
	State        int        `json:"state"`
	Ctime        time.Time  `json:"ctime"`
	Mtime        time.Time  `json:"mtime"`
}

type Stats struct {
	Total      int64     `json:"total"`
	Inserted   int64     `json:"inserted"`
	Updated    int64     `json:"updated"`
	Ignored    int64     `json:"ignored"`
	Duplicates int64     `json:"duplicates"`
	LastUpdate time.Time `json:"last_update"`
}

type Storage interface {
	// Key operations
	MatchMD5([]string) ([]string, error)
	ModifiedSince(time.Time) ([]string, error)
	FetchKeys([]string) ([]*Pubkey, error)
	FetchKeysPrefix(string) ([]*Pubkey, error)
	Insert([]*Pubkey) error
	Update(*Pubkey, *Pubkey) error
	Delete([]string) error

	// Statistics
	Stats() (*Stats, error)

	// Health check
	Healthy() error

	// Recon operations
	ReconStats() (*ReconStats, error)
	ReconState() (ReconState, error)

	// Close
	Close() error
}

type StreamingStorage interface {
	StreamKeys(criteria SearchCriteria) (KeyReader, error)
	ImportKeys(reader KeyReader) error
	ExportKeys(criteria SearchCriteria, writer KeyWriter) error
}

type SubKey struct {
	RFingerprint string     `json:"rfingerprint"`
	Creation     time.Time  `json:"creation"`
	Expiration   *time.Time `json:"expiration,omitempty"`
	State        int        `json:"state"`
	Packet       []byte     `json:"packet"`
	Ctime        time.Time  `json:"ctime"`
	Mtime        time.Time  `json:"mtime"`
}

type Transaction interface {
	// Key operations within transaction
	Insert([]*Pubkey) error
	Update(*Pubkey, *Pubkey) error
	Delete([]string) error

	// Transaction control
	Commit() error
	Rollback() error
}

type TransactionalStorage interface {
	Storage
	Begin() (Transaction, error)
}

type VersionInfo struct {
	Version   int64     `json:"version"`
	Timestamp time.Time `json:"timestamp"`
	KeyID     string    `json:"key_id,omitempty"`
	Operation string    `json:"operation"`
	Size      int64     `json:"size"`
	Checksum  string    `json:"checksum"`
}

type VersionedStorage interface {
	Storage
	GetVersion() int64
	ListVersions() ([]VersionInfo, error)
	GetKeyVersion(keyID string, version int64) (*Pubkey, error)
	GetKeyHistory(keyID string) ([]VersionInfo, error)
}

type WriteOnlyStorage interface {
	// Write operations only
	Insert([]*Pubkey) error
	Update(*Pubkey, *Pubkey) error
	Delete([]string) error
	Close() error
}