Case Study: Payment System

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"log"
	"math"
	"net/http"
	"os"
	"os/signal"
	"regexp"
	"sync"
	"syscall"
	"time"
)

// ===========================================
// 1. TYPES & STATE MACHINE
// ===========================================
type PaymentStatus string

const (
	StatusPending    PaymentStatus = "pending"
	StatusProcessing PaymentStatus = "processing"
	StatusCompleted  PaymentStatus = "completed"
	StatusFailed     PaymentStatus = "failed"
	StatusRefunded   PaymentStatus = "refunded"
)

var validTransitions = map[PaymentStatus][]PaymentStatus{
	StatusPending:    {StatusProcessing, StatusFailed},
	StatusProcessing: {StatusCompleted, StatusFailed},
	StatusCompleted:  {StatusRefunded},
	StatusFailed:     {},
	StatusRefunded:   {},
}

type Payment struct {
	ID             string            `json:"id"`
	MerchantID     string            `json:"merchantId"`
	Amount         float64           `json:"amount"`
	Currency       string            `json:"currency"`
	Status         PaymentStatus     `json:"status"`
	IdempotencyKey string            `json:"idempotencyKey"`
	Description    string            `json:"description"`
	CreatedAt      time.Time         `json:"createdAt"`
	UpdatedAt      time.Time         `json:"updatedAt"`
	Metadata       map[string]string `json:"metadata"`
}

type LedgerEntry struct {
	ID        string    `json:"id"`
	PaymentID string    `json:"paymentId"`
	AccountID string    `json:"accountId"`
	Amount    float64   `json:"amount"`
	Type      string    `json:"type"`
	CreatedAt time.Time `json:"createdAt"`
}

type WebhookEvent struct {
	ID          string
	PaymentID   string
	Type        string
	Data        interface{}
	WebhookURL  string
	Secret      string
	Attempts    int
	Delivered   bool
}

// ===========================================
// 2. IDEMPOTENCY MANAGER
// ===========================================
type IdempotencyManager struct {
	mu   sync.Mutex
	keys map[string]*Payment
}

func (im *IdempotencyManager) Check(key string) *Payment {
	im.mu.Lock()
	defer im.mu.Unlock()
	return im.keys[key]
}

func (im *IdempotencyManager) Store(key string, p *Payment) {
	im.mu.Lock()
	defer im.mu.Unlock()
	im.keys[key] = p
}

// ===========================================
// 3. DOUBLE-ENTRY LEDGER
// ===========================================
type Ledger struct {
	mu      sync.Mutex
	entries []LedgerEntry
}

func (l *Ledger) Record(paymentID, from, to string, amount float64) {
	l.mu.Lock()
	defer l.mu.Unlock()
	now := time.Now().UTC()
	l.entries = append(l.entries,
		LedgerEntry{ID: fmt.Sprintf("%d-d", time.Now().UnixNano()), PaymentID: paymentID, AccountID: from, Amount: -amount, Type: "debit", CreatedAt: now},
		LedgerEntry{ID: fmt.Sprintf("%d-c", time.Now().UnixNano()), PaymentID: paymentID, AccountID: to, Amount: amount, Type: "credit", CreatedAt: now},
	)
}

func (l *Ledger) GetBalance(accountID string) float64 {
	l.mu.Lock()
	defer l.mu.Unlock()
	var sum float64
	for _, e := range l.entries {
		if e.AccountID == accountID { sum += e.Amount }
	}
	return sum
}

func (l *Ledger) GetEntries(accountID string) []LedgerEntry {
	l.mu.Lock()
	defer l.mu.Unlock()
	var result []LedgerEntry
	for _, e := range l.entries {
		if e.AccountID == accountID { result = append(result, e) }
	}
	return result
}

func (l *Ledger) Reconcile() map[string]interface{} {
	l.mu.Lock()
	defer l.mu.Unlock()
	var debits, credits float64
	for _, e := range l.entries {
		if e.Amount < 0 { debits += math.Abs(e.Amount) } else { credits += e.Amount }
	}
	diff := math.Abs(credits - debits)
	return map[string]interface{}{
		"balanced": diff < 0.01, "totalDebits": debits,
		"totalCredits": credits, "difference": diff,
	}
}

// ===========================================
// 4. WEBHOOK DELIVERY
// ===========================================
type WebhookDelivery struct {
	mu    sync.Mutex
	queue []WebhookEvent
	stop  chan struct{}
}

func NewWebhookDelivery() *WebhookDelivery {
	wd := &WebhookDelivery{stop: make(chan struct{})}
	go wd.processLoop()
	return wd
}

func (wd *WebhookDelivery) Enqueue(paymentID, eventType string, data interface{}, url, secret string) {
	wd.mu.Lock()
	defer wd.mu.Unlock()
	wd.queue = append(wd.queue, WebhookEvent{
		ID: fmt.Sprintf("evt_%d", time.Now().UnixNano()),
		PaymentID: paymentID, Type: eventType, Data: data,
		WebhookURL: url, Secret: secret,
	})
}

func (wd *WebhookDelivery) processLoop() {
	ticker := time.NewTicker(5 * time.Second)
	defer ticker.Stop()
	for {
		select {
		case <-ticker.C:
			wd.mu.Lock()
			for i := range wd.queue {
				e := &wd.queue[i]
				if e.Delivered || e.Attempts >= 5 { continue }
				e.Attempts++
				payload, _ := json.Marshal(map[string]interface{}{"id": e.ID, "type": e.Type, "data": e.Data})
				mac := hmac.New(sha256.New, []byte(e.Secret))
				mac.Write(payload)
				sig := hex.EncodeToString(mac.Sum(nil))
				log.Printf("[WEBHOOK] → %s | %s | sig:%s...", e.WebhookURL, e.Type, sig[:8])
				e.Delivered = true
			}
			wd.mu.Unlock()
		case <-wd.stop: return
		}
	}
}

// ===========================================
// 5. PAYMENT PROCESSOR
// ===========================================
type PaymentProcessor struct {
	mu              sync.Mutex
	payments        map[string]*Payment
	idempotency     IdempotencyManager
	ledger          Ledger
	webhooks        *WebhookDelivery
	merchantHooks   map[string]struct{ URL, Secret string }
}

func NewPaymentProcessor() *PaymentProcessor {
	return &PaymentProcessor{
		payments:    make(map[string]*Payment),
		idempotency: IdempotencyManager{keys: make(map[string]*Payment)},
		webhooks:    NewWebhookDelivery(),
		merchantHooks: map[string]struct{ URL, Secret string }{
			"merchant_1": {URL: "https://merchant.example.com/webhooks", Secret: "whsec_test_secret"},
		},
	}
}

func (pp *PaymentProcessor) transition(p *Payment, newStatus PaymentStatus) error {
	valid := validTransitions[p.Status]
	for _, s := range valid {
		if s == newStatus {
			p.Status = newStatus
			p.UpdatedAt = time.Now().UTC()
			return nil
		}
	}
	return fmt.Errorf("invalid transition: %s → %s", p.Status, newStatus)
}

func (pp *PaymentProcessor) CreatePayment(merchantID string, amount float64, currency, desc, idempKey string, meta map[string]string) (*Payment, error) {
	if cached := pp.idempotency.Check(idempKey); cached != nil {
		return cached, nil
	}

	p := &Payment{
		ID: fmt.Sprintf("pay_%d", time.Now().UnixNano()),
		MerchantID: merchantID, Amount: amount, Currency: currency,
		Status: StatusPending, IdempotencyKey: idempKey, Description: desc,
		CreatedAt: time.Now().UTC(), UpdatedAt: time.Now().UTC(), Metadata: meta,
	}

	pp.mu.Lock()
	pp.payments[p.ID] = p
	pp.mu.Unlock()

	pp.transition(p, StatusProcessing)

	if amount < 10000 {
		pp.transition(p, StatusCompleted)
		pp.ledger.Record(p.ID, fmt.Sprintf("customer:%s", p.ID), fmt.Sprintf("merchant:%s", merchantID), amount)
		if hook, ok := pp.merchantHooks[merchantID]; ok {
			pp.webhooks.Enqueue(p.ID, "payment.completed", p, hook.URL, hook.Secret)
		}
	} else {
		pp.transition(p, StatusFailed)
	}

	pp.idempotency.Store(idempKey, p)
	return p, nil
}

func (pp *PaymentProcessor) Refund(paymentID string) (*Payment, error) {
	pp.mu.Lock()
	p, ok := pp.payments[paymentID]
	pp.mu.Unlock()
	if !ok { return nil, fmt.Errorf("payment not found") }

	if err := pp.transition(p, StatusRefunded); err != nil { return nil, err }
	pp.ledger.Record(p.ID+"_refund", fmt.Sprintf("merchant:%s", p.MerchantID), fmt.Sprintf("customer:%s", paymentID), p.Amount)

	if hook, ok := pp.merchantHooks[p.MerchantID]; ok {
		pp.webhooks.Enqueue(p.ID, "payment.refunded", p, hook.URL, hook.Secret)
	}
	return p, nil
}

func (pp *PaymentProcessor) GetPayment(id string) *Payment {
	pp.mu.Lock()
	defer pp.mu.Unlock()
	return pp.payments[id]
}

// ===========================================
// 6. HTTP SERVER
// ===========================================
func writeJSON(w http.ResponseWriter, status int, data interface{}) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(data)
}

func main() {
	pp := NewPaymentProcessor()
	paymentPattern := regexp.MustCompile(`^/api/payments/([^/]+)$`)
	refundPattern := regexp.MustCompile(`^/api/payments/([^/]+)/refund$`)
	ledgerPattern := regexp.MustCompile(`^/api/ledger/([^/]+)$`)

	mux := http.NewServeMux()

	mux.HandleFunc("/api/payments", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			writeJSON(w, 405, map[string]string{"error": "Method not allowed"}); return
		}
		idempKey := r.Header.Get("Idempotency-Key")
		if idempKey == "" {
			writeJSON(w, 400, map[string]string{"error": "Idempotency-Key header required"}); return
		}
		var body struct {
			MerchantID  string            `json:"merchantId"`
			Amount      float64           `json:"amount"`
			Currency    string            `json:"currency"`
			Description string            `json:"description"`
			Metadata    map[string]string `json:"metadata"`
		}
		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&body); err != nil {
			writeJSON(w, 400, map[string]string{"error": "Invalid JSON"}); return
		}
		if body.MerchantID == "" || body.Amount == 0 || body.Currency == "" {
			writeJSON(w, 400, map[string]string{"error": "merchantId, amount, currency required"}); return
		}
		p, err := pp.CreatePayment(body.MerchantID, body.Amount, body.Currency, body.Description, idempKey, body.Metadata)
		if err != nil { writeJSON(w, 400, map[string]string{"error": err.Error()}); return }
		writeJSON(w, 201, p)
	})

	mux.HandleFunc("/api/payments/", func(w http.ResponseWriter, r *http.Request) {
		if m := refundPattern.FindStringSubmatch(r.URL.Path); m != nil && r.Method == http.MethodPost {
			p, err := pp.Refund(m[1])
			if err != nil { writeJSON(w, 400, map[string]string{"error": err.Error()}); return }
			writeJSON(w, 200, p); return
		}
		if m := paymentPattern.FindStringSubmatch(r.URL.Path); m != nil && r.Method == http.MethodGet {
			p := pp.GetPayment(m[1])
			if p == nil { writeJSON(w, 404, map[string]string{"error": "Not found"}); return }
			writeJSON(w, 200, p); return
		}
		writeJSON(w, 404, map[string]string{"error": "Not found"})
	})

	mux.HandleFunc("/api/ledger/", func(w http.ResponseWriter, r *http.Request) {
		m := ledgerPattern.FindStringSubmatch(r.URL.Path)
		if m == nil { writeJSON(w, 404, map[string]string{"error": "Not found"}); return }
		writeJSON(w, 200, map[string]interface{}{
			"balance": pp.ledger.GetBalance(m[1]),
			"entries": pp.ledger.GetEntries(m[1]),
		})
	})

	mux.HandleFunc("/api/reconcile", func(w http.ResponseWriter, r *http.Request) {
		writeJSON(w, 200, pp.ledger.Reconcile())
	})

	mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
		writeJSON(w, 200, map[string]string{"status": "ok"})
	})

	port := os.Getenv("PORT"); if port == "" { port = "3000" }
	srv := &http.Server{Addr: ":" + port, Handler: mux, ReadTimeout: 5 * time.Second, WriteTimeout: 10 * time.Second}

	go func() {
		log.Printf("Payment Service on http://localhost:%s", port)
		if err := srv.ListenAndServe(); err != http.ErrServerClosed { log.Fatal(err) }
	}()

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	log.Println("Shutting down...")
	pp.webhooks.stop <- struct{}{}
	srv.Close()
}