processor

type Balance struct {
	Available currency.Cents `json:"available"`
	Pending   currency.Cents `json:"pending"`
	Currency  currency.Type  `json:"currency"`
}

type BaseProcessor struct {
	// contains filtered or unexported fields
}

type CryptoProcessor interface {
	PaymentProcessor

	// GenerateAddress creates a new payment address for a customer
	GenerateAddress(ctx context.Context, customerID string, chain string) (string, error)

	// GetBalance returns the balance for an address
	GetBalance(ctx context.Context, address string, chain string) (*Balance, error)

	// EstimateFee estimates transaction fees for a payment
	EstimateFee(ctx context.Context, req PaymentRequest) (currency.Cents, error)

	// SupportedChains returns the list of supported blockchain networks
	SupportedChains() []string
}

type CustomerProcessor interface {
	PaymentProcessor

	// CreateCustomer creates a customer in the processor
	CreateCustomer(ctx context.Context, email, name string, metadata map[string]interface{}) (string, error)

	// GetCustomer retrieves customer details
	GetCustomer(ctx context.Context, customerID string) (map[string]interface{}, error)

	// UpdateCustomer updates customer details
	UpdateCustomer(ctx context.Context, customerID string, updates map[string]interface{}) error

	// DeleteCustomer removes a customer
	DeleteCustomer(ctx context.Context, customerID string) error

	// AddPaymentMethod adds a payment method to a customer
	AddPaymentMethod(ctx context.Context, customerID, token string) (string, error)

	// RemovePaymentMethod removes a payment method
	RemovePaymentMethod(ctx context.Context, customerID, paymentMethodID string) error
}

type PaymentError struct {
	Processor ProcessorType
	Code      string
	Message   string
	Err       error
}

type PaymentProcessor interface {
	// Type returns the processor type
	Type() ProcessorType

	// Charge processes a payment
	Charge(ctx context.Context, req PaymentRequest) (*PaymentResult, error)

	// Authorize authorizes a payment without capturing
	Authorize(ctx context.Context, req PaymentRequest) (*PaymentResult, error)

	// Capture captures a previously authorized payment
	Capture(ctx context.Context, transactionID string, amount currency.Cents) (*PaymentResult, error)

	// Refund processes a refund
	Refund(ctx context.Context, req RefundRequest) (*RefundResult, error)

	// GetTransaction retrieves transaction details
	GetTransaction(ctx context.Context, txID string) (*Transaction, error)

	// ValidateWebhook validates an incoming webhook
	ValidateWebhook(ctx context.Context, payload []byte, signature string) (*WebhookEvent, error)

	// SupportedCurrencies returns currencies this processor supports
	SupportedCurrencies() []currency.Type

	// IsAvailable checks if processor is configured and available
	IsAvailable(ctx context.Context) bool
}

type PaymentRequest struct {
	Amount      currency.Cents         `json:"amount"`
	Currency    currency.Type          `json:"currency"`
	Description string                 `json:"description,omitempty"`
	CustomerID  string                 `json:"customerId,omitempty"`
	OrderID     string                 `json:"orderId,omitempty"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`

	// Processor-specific options
	Options map[string]interface{} `json:"options,omitempty"`

	// For card payments
	Token string `json:"token,omitempty"`

	// For crypto payments
	Address string `json:"address,omitempty"`
	Chain   string `json:"chain,omitempty"`
}

type PaymentResult struct {
	Success       bool                   `json:"success"`
	TransactionID string                 `json:"transactionId"`
	ProcessorRef  string                 `json:"processorRef"`
	Fee           currency.Cents         `json:"fee"`
	Error         error                  `json:"-"`
	ErrorMessage  string                 `json:"error,omitempty"`
	Metadata      map[string]interface{} `json:"metadata,omitempty"`
	Status        string                 `json:"status"`
}

type ProcessorType string

type RefundRequest struct {
	TransactionID string                 `json:"transactionId"`
	Amount        currency.Cents         `json:"amount"`
	Reason        string                 `json:"reason,omitempty"`
	Metadata      map[string]interface{} `json:"metadata,omitempty"`
}

type RefundResult struct {
	Success      bool   `json:"success"`
	RefundID     string `json:"refundId"`
	ProcessorRef string `json:"processorRef"`
	Error        error  `json:"-"`
	ErrorMessage string `json:"error,omitempty"`
}

type Registry struct {
	// contains filtered or unexported fields
}

type RegistryConfig struct {
	// DefaultFiatProcessor is the default for fiat currencies
	DefaultFiatProcessor ProcessorType

	// DefaultCryptoProcessor is the default for crypto currencies
	DefaultCryptoProcessor ProcessorType

	// ProcessorPriority defines the order to try processors
	ProcessorPriority []ProcessorType

	// DisabledProcessors lists processors that should not be used
	DisabledProcessors map[ProcessorType]bool
}

type Subscription struct {
	ID                 string                 `json:"id"`
	CustomerID         string                 `json:"customerId"`
	PlanID             string                 `json:"planId"`
	Status             string                 `json:"status"` // active, canceled, past_due, trialing
	CurrentPeriodStart int64                  `json:"currentPeriodStart"`
	CurrentPeriodEnd   int64                  `json:"currentPeriodEnd"`
	CancelAtPeriodEnd  bool                   `json:"cancelAtPeriodEnd"`
	Metadata           map[string]interface{} `json:"metadata,omitempty"`
}

type SubscriptionProcessor interface {
	PaymentProcessor

	// CreateSubscription creates a recurring subscription
	CreateSubscription(ctx context.Context, req SubscriptionRequest) (*Subscription, error)

	// GetSubscription retrieves subscription details
	GetSubscription(ctx context.Context, subscriptionID string) (*Subscription, error)

	// CancelSubscription cancels a subscription
	CancelSubscription(ctx context.Context, subscriptionID string, immediately bool) error

	// UpdateSubscription modifies a subscription
	UpdateSubscription(ctx context.Context, subscriptionID string, req SubscriptionUpdate) (*Subscription, error)

	// ListSubscriptions lists subscriptions for a customer
	ListSubscriptions(ctx context.Context, customerID string) ([]*Subscription, error)
}

type SubscriptionRequest struct {
	CustomerID   string                 `json:"customerId"`
	PlanID       string                 `json:"planId"`
	Quantity     int                    `json:"quantity"`
	TrialDays    int                    `json:"trialDays,omitempty"`
	Metadata     map[string]interface{} `json:"metadata,omitempty"`
	PaymentToken string                 `json:"paymentToken,omitempty"`
}

type SubscriptionUpdate struct {
	PlanID            string `json:"planId,omitempty"`
	Quantity          int    `json:"quantity,omitempty"`
	CancelAtPeriodEnd *bool  `json:"cancelAtPeriodEnd,omitempty"`
}

type Transaction struct {
	ID           string                 `json:"id"`
	ProcessorRef string                 `json:"processorRef"`
	Type         string                 `json:"type"` // charge, refund, transfer
	Amount       currency.Cents         `json:"amount"`
	Currency     currency.Type          `json:"currency"`
	Status       string                 `json:"status"`
	Fee          currency.Cents         `json:"fee"`
	CustomerID   string                 `json:"customerId,omitempty"`
	Metadata     map[string]interface{} `json:"metadata,omitempty"`
	CreatedAt    int64                  `json:"createdAt"`
	UpdatedAt    int64                  `json:"updatedAt"`
}

type WebhookEvent struct {
	ID        string                 `json:"id"`
	Type      string                 `json:"type"`
	Processor ProcessorType          `json:"processor"`
	Data      map[string]interface{} `json:"data"`
	Timestamp int64                  `json:"timestamp"`
}