errors.go

package avp

import (
	"errors"
	"fmt"
)

// Error codes
const (
	ErrCodeAuthenticationFailed = "AUTHENTICATION_FAILED"
	ErrCodeSessionError         = "SESSION_ERROR"
	ErrCodeSessionExpired       = "SESSION_EXPIRED"
	ErrCodeSessionTerminated    = "SESSION_TERMINATED"
	ErrCodeSessionNotFound      = "SESSION_NOT_FOUND"
	ErrCodeSecretNotFound       = "SECRET_NOT_FOUND"
	ErrCodeInvalidName          = "INVALID_NAME"
	ErrCodeInvalidWorkspace     = "INVALID_WORKSPACE"
	ErrCodeCapacityExceeded     = "CAPACITY_EXCEEDED"
	ErrCodeBackendError         = "BACKEND_ERROR"
	ErrCodeBackendUnavailable   = "BACKEND_UNAVAILABLE"
	ErrCodeRateLimitExceeded    = "RATE_LIMIT_EXCEEDED"
	ErrCodeValueTooLarge        = "VALUE_TOO_LARGE"
	ErrCodeEncryptionError      = "ENCRYPTION_ERROR"
	ErrCodeIntegrityError       = "INTEGRITY_ERROR"
)

// AVPError represents an AVP protocol error.
type AVPError struct {
	Code    string
	Message string
	Detail  map[string]interface{}
}

func (e *AVPError) Error() string {
	return fmt.Sprintf("%s: %s", e.Code, e.Message)
}

// Is implements error comparison.
func (e *AVPError) Is(target error) bool {
	t, ok := target.(*AVPError)
	if !ok {
		return false
	}
	return e.Code == t.Code
}

// Common errors
var (
	ErrAuthenticationFailed = &AVPError{Code: ErrCodeAuthenticationFailed, Message: "Authentication failed"}
	ErrSessionExpired       = &AVPError{Code: ErrCodeSessionExpired, Message: "Session has expired"}
	ErrSessionTerminated    = &AVPError{Code: ErrCodeSessionTerminated, Message: "Session was terminated"}
	ErrRateLimitExceeded    = &AVPError{Code: ErrCodeRateLimitExceeded, Message: "Rate limit exceeded"}
)

// NewSessionNotFoundError creates a new session not found error.
func NewSessionNotFoundError(sessionID string) *AVPError {
	return &AVPError{
		Code:    ErrCodeSessionNotFound,
		Message: fmt.Sprintf("Session not found: %s", sessionID),
	}
}

// NewSecretNotFoundError creates a new secret not found error.
func NewSecretNotFoundError(name string) *AVPError {
	return &AVPError{
		Code:    ErrCodeSecretNotFound,
		Message: fmt.Sprintf("Secret '%s' not found", name),
	}
}

// NewInvalidNameError creates a new invalid name error.
func NewInvalidNameError(name string) *AVPError {
	return &AVPError{
		Code:    ErrCodeInvalidName,
		Message: fmt.Sprintf("Invalid name: %s", name),
	}
}

// NewInvalidWorkspaceError creates a new invalid workspace error.
func NewInvalidWorkspaceError(workspace string) *AVPError {
	return &AVPError{
		Code:    ErrCodeInvalidWorkspace,
		Message: fmt.Sprintf("Invalid workspace: %s", workspace),
	}
}

// NewCapacityExceededError creates a new capacity exceeded error.
func NewCapacityExceededError(message string) *AVPError {
	return &AVPError{
		Code:    ErrCodeCapacityExceeded,
		Message: message,
	}
}

// NewBackendError creates a new backend error.
func NewBackendError(message string) *AVPError {
	return &AVPError{
		Code:    ErrCodeBackendError,
		Message: message,
	}
}

// NewValueTooLargeError creates a new value too large error.
func NewValueTooLargeError(maxSize int) *AVPError {
	return &AVPError{
		Code:    ErrCodeValueTooLarge,
		Message: fmt.Sprintf("Value exceeds maximum size of %d bytes", maxSize),
	}
}

// NewEncryptionError creates a new encryption error.
func NewEncryptionError(message string) *AVPError {
	return &AVPError{
		Code:    ErrCodeEncryptionError,
		Message: message,
	}
}

// IsSecretNotFound checks if the error is a secret not found error.
func IsSecretNotFound(err error) bool {
	var avpErr *AVPError
	if errors.As(err, &avpErr) {
		return avpErr.Code == ErrCodeSecretNotFound
	}
	return false
}

// IsSessionExpired checks if the error is a session expired error.
func IsSessionExpired(err error) bool {
	var avpErr *AVPError
	if errors.As(err, &avpErr) {
		return avpErr.Code == ErrCodeSessionExpired
	}
	return false
}

// IsSessionNotFound checks if the error is a session not found error.
func IsSessionNotFound(err error) bool {
	var avpErr *AVPError
	if errors.As(err, &avpErr) {
		return avpErr.Code == ErrCodeSessionNotFound
	}
	return false
}