errors.go

package mppx

import (
	"errors"
	"fmt"
	"net/http"
)

// ProblemDetails is an RFC 9457 Problem Details object returned in 402 response bodies.
type ProblemDetails struct {
	Type        string `json:"type"`
	Title       string `json:"title"`
	Status      int    `json:"status"`
	Detail      string `json:"detail"`
	ChallengeID string `json:"challengeId,omitempty"`
}

// PaymentError is the base type for all payment-related errors.
// It implements the error interface and serializes to RFC 9457 Problem Details.
type PaymentError struct {
	// ErrorType is the RFC 9457 problem type URI.
	ErrorType string
	// Title is a human-readable summary.
	Title string
	// HTTPStatus is the HTTP status code (default 402).
	HTTPStatus int
	// Detail is a human-readable explanation.
	Detail string
}

func (e *PaymentError) Error() string {
	return e.Detail
}

// ToProblemDetails converts the error to RFC 9457 Problem Details format.
func (e *PaymentError) ToProblemDetails(challengeID string) ProblemDetails {
	return ProblemDetails{
		Type:        e.ErrorType,
		Title:       e.Title,
		Status:      e.HTTPStatus,
		Detail:      e.Detail,
		ChallengeID: challengeID,
	}
}

// Status returns the HTTP status code for this error (defaults to 402).
func (e *PaymentError) Status() int {
	if e.HTTPStatus == 0 {
		return http.StatusPaymentRequired
	}
	return e.HTTPStatus
}

// IsPaymentError reports whether err is or wraps a *PaymentError.
func IsPaymentError(err error) bool {
	_, ok := AsPaymentError(err)
	return ok
}

// AsPaymentError returns the *PaymentError within err, or (nil, false).
func AsPaymentError(err error) (*PaymentError, bool) {
	var pe *PaymentError
	if errors.As(err, &pe) {
		return pe, true
	}
	return nil, false
}

// --- Error constructors ---

// ErrMalformedCredential creates a "malformed credential" error (402).
func ErrMalformedCredential(reason string) *PaymentError {
	detail := "Credential is malformed."
	if reason != "" {
		detail = fmt.Sprintf("Credential is malformed: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/malformed-credential",
		Title:      "Malformed Credential",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     detail,
	}
}

// ErrInvalidChallenge creates an "invalid challenge" error (402).
func ErrInvalidChallenge(id, reason string) *PaymentError {
	idPart := ""
	if id != "" {
		idPart = fmt.Sprintf(" %q", id)
	}
	reasonPart := ""
	if reason != "" {
		reasonPart = ": " + reason
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/invalid-challenge",
		Title:      "Invalid Challenge",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     fmt.Sprintf("Challenge%s is invalid%s.", idPart, reasonPart),
	}
}

// ErrVerificationFailed creates a "verification failed" error (402).
func ErrVerificationFailed(reason string) *PaymentError {
	detail := "Payment verification failed."
	if reason != "" {
		detail = fmt.Sprintf("Payment verification failed: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/verification-failed",
		Title:      "Verification Failed",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     detail,
	}
}

// ErrPaymentRequired creates a "payment required" error (402).
func ErrPaymentRequired(description string) *PaymentError {
	detail := "Payment is required."
	if description != "" {
		detail = fmt.Sprintf("Payment is required (%s).", description)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/payment-required",
		Title:      "Payment Required",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     detail,
	}
}

// ErrPaymentExpired creates a "payment expired" error (402).
func ErrPaymentExpired(expires string) *PaymentError {
	detail := "Payment has expired."
	if expires != "" {
		detail = fmt.Sprintf("Payment expired at %s.", expires)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/payment-expired",
		Title:      "Payment Expired",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     detail,
	}
}

// ErrInvalidPayload creates an "invalid payload" error (402).
func ErrInvalidPayload(reason string) *PaymentError {
	detail := "Credential payload is invalid."
	if reason != "" {
		detail = fmt.Sprintf("Credential payload is invalid: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/invalid-payload",
		Title:      "Invalid Payload",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     detail,
	}
}

// ErrBadRequest creates a "bad request" error (400).
func ErrBadRequest(reason string) *PaymentError {
	detail := "Bad request."
	if reason != "" {
		detail = fmt.Sprintf("Bad request: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/bad-request",
		Title:      "Bad Request",
		HTTPStatus: http.StatusBadRequest,
		Detail:     detail,
	}
}

// ErrPaymentInsufficient creates a "payment insufficient" error (402).
func ErrPaymentInsufficient(reason string) *PaymentError {
	detail := "Payment amount is insufficient."
	if reason != "" {
		detail = fmt.Sprintf("Payment insufficient: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/payment-insufficient",
		Title:      "Payment Insufficient",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     detail,
	}
}

// ErrMethodUnsupported creates a "method unsupported" error (400).
func ErrMethodUnsupported(method string) *PaymentError {
	detail := "Payment method is not supported."
	if method != "" {
		detail = fmt.Sprintf("Payment method %q is not supported.", method)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/method-unsupported",
		Title:      "Method Unsupported",
		HTTPStatus: http.StatusBadRequest,
		Detail:     detail,
	}
}

// ErrInsufficientBalance creates an "insufficient balance" error (402) for streaming sessions.
func ErrInsufficientBalance(reason string) *PaymentError {
	detail := "Insufficient balance."
	if reason != "" {
		detail = fmt.Sprintf("Insufficient balance: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/session/insufficient-balance",
		Title:      "Insufficient Balance",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     detail,
	}
}

// ErrInvalidSignature creates an "invalid signature" error (402) for session vouchers.
func ErrInvalidSignature(reason string) *PaymentError {
	detail := "Invalid signature."
	if reason != "" {
		detail = fmt.Sprintf("Invalid signature: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/session/invalid-signature",
		Title:      "Invalid Signature",
		HTTPStatus: http.StatusPaymentRequired,
		Detail:     detail,
	}
}

// ErrChannelNotFound creates a "channel not found" error (410).
func ErrChannelNotFound(reason string) *PaymentError {
	detail := "No channel with this ID exists."
	if reason != "" {
		detail = fmt.Sprintf("Channel not found: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/session/channel-not-found",
		Title:      "Channel Not Found",
		HTTPStatus: http.StatusGone,
		Detail:     detail,
	}
}

// ErrChannelClosed creates a "channel closed" error (410).
func ErrChannelClosed(reason string) *PaymentError {
	detail := "Channel is closed."
	if reason != "" {
		detail = fmt.Sprintf("Channel closed: %s.", reason)
	}
	return &PaymentError{
		ErrorType:  "https://paymentauth.org/problems/session/channel-finalized",
		Title:      "Channel Closed",
		HTTPStatus: http.StatusGone,
		Detail:     detail,
	}
}