errors

type AuditLogger struct {
	// Writer is the writer for audit logs
	Writer io.Writer
	// User is the user performing the operation
	User string
}

type BackupRecoveryStrategy struct {
	// Logger is the logger for recovery events
	Logger io.Writer
	// BackupDir is the directory for backups
	BackupDir string
}

type BundleError struct {
	// Original is the original error
	Original error
	// Message is a human-readable error message
	Message string
	// Category is the category of the error
	Category ErrorCategory
	// Severity is the severity of the error
	Severity ErrorSeverity
	// Recoverability indicates whether the error is recoverable
	Recoverability ErrorRecoverability
	// Context contains additional context about the error
	Context map[string]interface{}
	// ErrorID is a unique identifier for the error
	ErrorID string
	// Timestamp is the time the error occurred
	Timestamp time.Time
	// RetryAttempt is the current retry attempt
	RetryAttempt int
	// MaxRetries is the maximum number of retries
	MaxRetries int
}

type ConflictRecoveryStrategy struct {
	// Logger is the logger for recovery events
	Logger io.Writer
	// Force indicates whether to force resolution
	Force bool
}

type DefaultErrorCategorizer struct {
	// Logger is the logger for categorization events
	Logger io.Writer
}

type DefaultErrorHandler struct {
	// Logger is the logger for error handling
	Logger ErrorLogger
	// AdminNotificationEnabled indicates whether admin notifications are enabled
	AdminNotificationEnabled bool
	// AdminEmail is the email address for admin notifications
	AdminEmail string
}

type DefaultErrorReporter struct {
	// Logger is the logger for error reporting
	Logger io.Writer
	// ReportsDir is the directory for error reports
	ReportsDir string
	// NotificationService is the service for sending notifications
	NotificationService NotificationService
	// IncludeSystemInfo indicates whether to include system information in reports
	IncludeSystemInfo bool
}

type EmailNotificationService struct {
	// Recipients is the list of email recipients
	Recipients []string
	// SenderEmail is the sender email address
	SenderEmail string
	// SMTPServer is the SMTP server
	SMTPServer string
	// SMTPPort is the SMTP port
	SMTPPort int
	// SMTPUsername is the SMTP username
	SMTPUsername string
	// SMTPPassword is the SMTP password
	SMTPPassword string
	// Logger is the logger for notification events
	Logger io.Writer
}

type EnhancedErrorHandler struct {
	DefaultErrorHandler
	// MaxRetries is the maximum number of retries for recoverable errors
	MaxRetries int
	// RetryableCategories is a list of error categories that are retryable
	RetryableCategories map[ErrorCategory]bool
	// BackoffBaseSeconds is the base time in seconds for exponential backoff
	BackoffBaseSeconds float64
	// BackoffMaxSeconds is the maximum backoff time in seconds
	BackoffMaxSeconds float64
	// BackoffJitterFactor is the jitter factor for backoff (0-1)
	BackoffJitterFactor float64
	// NotificationThreshold is the severity threshold for admin notifications
	NotificationThreshold ErrorSeverity
	// ErrorMetrics tracks error metrics for reporting
	ErrorMetrics *ErrorMetrics
}

type ErrorCategorizer interface {
	// CategorizeError categorizes an error
	CategorizeError(err error) (ErrorCategory, ErrorSeverity, ErrorRecoverability)
}

type ErrorCategory string

type ErrorHandler interface {
	// HandleError handles an error
	HandleError(ctx context.Context, err error) (*BundleError, error)
	// ShouldRetry determines whether an error should be retried
	ShouldRetry(ctx context.Context, err *BundleError) bool
	// GetBackoffDuration returns the backoff duration for a retry
	GetBackoffDuration(ctx context.Context, err *BundleError) time.Duration
	// LogError logs an error
	LogError(ctx context.Context, err *BundleError)
	// NotifyAdmin notifies an administrator about a critical error
	NotifyAdmin(ctx context.Context, err *BundleError) error
}

type ErrorLogger interface {
	// LogEvent logs an event
	LogEvent(event, component, id string, details map[string]interface{})
	// LogEventWithStatus logs an event with a status
	LogEventWithStatus(event, component, id, status string, details map[string]interface{})
}

type ErrorMetrics struct {
	// TotalErrors is the total number of errors
	TotalErrors int
	// ErrorsByCategory tracks errors by category
	ErrorsByCategory map[ErrorCategory]int
	// ErrorsBySeverity tracks errors by severity
	ErrorsBySeverity map[ErrorSeverity]int
	// RecoveredErrors is the number of errors that were recovered from
	RecoveredErrors int
	// UnrecoveredErrors is the number of errors that were not recovered from
	UnrecoveredErrors int
	// RetryAttempts is the total number of retry attempts
	RetryAttempts int
	// SuccessfulRetries is the number of successful retries
	SuccessfulRetries int
}

type ErrorRecoverability string

type ErrorReport struct {
	// ReportID is the unique identifier for the report
	ReportID string `json:"report_id"`
	// Timestamp is the time the report was generated
	Timestamp time.Time `json:"timestamp"`
	// Errors is the list of errors in the report
	Errors []*BundleError `json:"errors"`
	// Statistics is the error statistics
	Statistics map[string]interface{} `json:"statistics"`
	// SystemInfo is information about the system
	SystemInfo map[string]interface{} `json:"system_info"`
}

type ErrorReporter interface {
	// ReportError reports an error
	ReportError(ctx context.Context, err *BundleError) error
	// GenerateErrorReport generates an error report for a list of errors
	GenerateErrorReport(ctx context.Context, errors []*BundleError, outputPath string) error
	// GetErrorStatistics returns statistics about errors
	GetErrorStatistics(errors []*BundleError) map[string]interface{}
}

type ErrorSeverity string

type FileSystemRecoveryStrategy struct {
	// Logger is the logger for recovery events
	Logger io.Writer
}

type NetworkRecoveryStrategy struct {
	// Logger is the logger for recovery events
	Logger io.Writer
	// MaxRetries is the maximum number of retries
	MaxRetries int
}

type NotificationService interface {
	// SendNotification sends a notification
	SendNotification(ctx context.Context, subject, message string) error
}

type RecoveryManager struct {
	// Strategies is a list of recovery strategies
	Strategies []RecoveryStrategy
	// Logger is the logger for recovery events
	Logger io.Writer
	// AuditLogger is the logger for audit events
	AuditLogger *AuditLogger
}

type RecoveryStrategy interface {
	// Recover attempts to recover from an error
	Recover(ctx context.Context, err *BundleError) (bool, error)
	// CanRecover determines if the strategy can recover from an error
	CanRecover(err *BundleError) bool
}

type SlackNotificationService struct {
	// WebhookURL is the Slack webhook URL
	WebhookURL string
	// Channel is the Slack channel
	Channel string
	// Username is the username to use for notifications
	Username string
	// Logger is the logger for notification events
	Logger io.Writer
}