Payment Service

// PaymentGateway: business logic depends on this interface, never on concrete gateways.
type PaymentGateway interface {
    CreatePayment(ctx context.Context, req PaymentRequest) (*PaymentResult, error)
    VerifyWebhook(payload []byte, signature string) (WebhookEvent, error)
    Refund(ctx context.Context, id string, amount int64) (*RefundResult, error)
}

// StripeAdapter implements PaymentGateway for Stripe.
type StripeAdapter struct {
    client *stripe.Client
}

func (a *StripeAdapter) CreatePayment(ctx context.Context, req PaymentRequest) (*PaymentResult, error) {
    pi, err := a.client.PaymentIntents.New(&stripe.PaymentIntentParams{
        Amount:   stripe.Int64(req.Amount),
        Currency: stripe.String(req.Currency),
    })
    if err != nil {
        return nil, fmt.Errorf("stripe: %w", err)
    }
    return &PaymentResult{
        ExternalID: pi.ID,
        Status:     mapStripeStatus(pi.Status),
    }, nil
}

// Payment state machine: guards prevent invalid transitions.
var transitions = map[PaymentState][]PaymentState{
    StatePending:   {StateCompleted, StateFailed},
    StateCompleted: {StateRefunded},
    StateFailed:    {},
    StateRefunded:  {},
}

func TransitionPayment(p *Payment, target PaymentState) error {
    for _, s := range transitions[p.Status] {
        if s == target {
            p.Status = target
            p.UpdatedAt = time.Now()
            return nil
        }
    }
    return fmt.Errorf("invalid transition: %s -> %s", p.Status, target)
}

// WebhookHandler processes gateway callbacks with idempotency protection.
func (h *WebhookHandler) Handle(w http.ResponseWriter, r *http.Request) {
    event, err := h.gateway.VerifyWebhook(r.Body, r.Header.Get("X-Signature"))
    if err != nil {
        http.Error(w, "invalid signature", http.StatusBadRequest)
        return
    }

    // Idempotency check: skip if already processed
    key := "webhook:" + event.ID
    if exists, _ := h.redis.Exists(r.Context(), key).Result(); exists == 1 {
        w.WriteHeader(http.StatusOK)
        return
    }

    if err := h.processEvent(r.Context(), event); err != nil {
        http.Error(w, "processing failed", http.StatusInternalServerError)
        return
    }

    // Mark as processed (TTL matches provider retry window)
    h.redis.Set(r.Context(), key, "1", 24*time.Hour)
    w.WriteHeader(http.StatusOK)
}