package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "time"
)

// Basic timeout middleware
func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            ctx, cancel := context.WithTimeout(r.Context(), timeout)
            defer cancel()
            
            // Create channel to signal completion
            done := make(chan struct{})
            
            // Run handler in goroutine
            go func() {
                next.ServeHTTP(w, r.WithContext(ctx))
                close(done)
            }()
            
            // Wait for either completion or timeout
            select {
            case <-done:
                return
            case <-ctx.Done():
                w.WriteHeader(http.StatusGatewayTimeout)
                w.Write([]byte("Request timeout"))
            }
        })
    }
}

// Handler that respects context timeout
func slowHandler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    
    // Simulate slow operation
    select {
    case <-time.After(3 * time.Second):
        w.Write([]byte("Operation completed"))
    case <-ctx.Done():
        // Context cancelled/timeout - stop processing
        log.Println("Request timeout:", ctx.Err())
        return
    }
}

// Handler with database query example
func databaseHandler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    
    // Pass context to database queries
    // rows, err := db.QueryContext(ctx, "SELECT * FROM users")
    // if err != nil {
    //     if ctx.Err() == context.DeadlineExceeded {
    //         log.Println("Database query timeout")
    //         return
    //     }
    //     // Handle other errors
    // }
    
    // Simulate work
    for i := 0; i < 10; i++ {
        select {
        case <-ctx.Done():
            log.Println("Context cancelled, stopping work")
            return
        default:
            time.Sleep(500 * time.Millisecond)
            fmt.Printf("Processing step %d\n", i+1)
        }
    }
    
    w.Write([]byte("Database operation completed"))
}

func main() {
    mux := http.NewServeMux()
    
    // Apply timeout middleware
    mux.Handle("/slow", TimeoutMiddleware(2*time.Second)(http.HandlerFunc(slowHandler)))
    mux.Handle("/db", TimeoutMiddleware(5*time.Second)(http.HandlerFunc(databaseHandler)))
    mux.HandleFunc("/fast", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Fast response"))
    })
    
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

package main

import (
	"github.com/sony/gobreaker"
)

type ResilientPaymentClient struct {
	service        *PaymentService
	circuitBreaker *gobreaker.CircuitBreaker
}

func NewResilientPaymentClient(service *PaymentService) *ResilientPaymentClient {
	// Configure circuit breaker
	settings := gobreaker.Settings{
		Name: "PaymentService",
		// Maximum requests allowed in half-open state before deciding to close
		MaxRequests: 2,
		// Time period after which failure counts reset in closed state
		Interval: 10 * time.Second,
		// Time to wait before attempting half-open state
		Timeout: 5 * time.Second,
		// Function to determine when circuit should trip open
		ReadyToTrip: func(counts gobreaker.Counts) bool {
			failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
			return counts.Requests >= 3 && failureRatio >= 0.6
		},
		// Callback for state transitions (useful for monitoring)
		OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
			log.Printf("[CIRCUIT BREAKER] %s: State changed from %s to %s", 
				name, from.String(), to.String())
		},
	}

	return &ResilientPaymentClient{
		service:        service,
		circuitBreaker: gobreaker.NewCircuitBreaker(settings),
	}
}

func (r *ResilientPaymentClient) ProcessPayment(ctx context.Context, amount float64) (string, error) {
	// Execute through circuit breaker
	result, err := r.circuitBreaker.Execute(func() (interface{}, error) {
		return r.service.ProcessPayment(ctx, amount)
	})
	
	if err != nil {
		return "", err
	}
	
	return result.(string), nil
}

type LoadShedder struct {
	maxConcurrent   int64
	currentLoad     atomic.Int64
	cpuThreshold    float64
	dropProbability atomic.Value // stores float64
}

func NewLoadShedder(maxConcurrent int, cpuThreshold float64) *LoadShedder {
	ls := &LoadShedder{
		maxConcurrent: int64(maxConcurrent),
		cpuThreshold:  cpuThreshold,
	}
	ls.dropProbability.Store(0.0)
	
	// Background goroutine to monitor system load
	go ls.monitorSystemLoad()
	
	return ls
}

// Monitor CPU and adjust drop probability
func (ls *LoadShedder) monitorSystemLoad() {
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()
	
	for range ticker.C {
		// Get current CPU usage (simplified - in production use actual metrics)
		numGoroutines := runtime.NumGoroutine()
		cpuUsage := float64(numGoroutines) / 1000.0 // Simulated CPU usage
		
		// Calculate drop probability based on load
		var dropProb float64
		if cpuUsage > ls.cpuThreshold {
			// Linear increase from threshold to 100%
			dropProb = (cpuUsage - ls.cpuThreshold) / (1.0 - ls.cpuThreshold)
			if dropProb > 0.9 {
				dropProb = 0.9 // Never drop more than 90%
			}
		}
		
		ls.dropProbability.Store(dropProb)
		
		if dropProb > 0 {
			log.Printf("[LOAD SHEDDER] System overloaded. Goroutines: %d, Drop probability: %.2f%%",
				numGoroutines, dropProb*100)
		}
	}
}

// ShouldAcceptRequest decides whether to accept or reject a request
func (ls *LoadShedder) ShouldAcceptRequest() bool {
	// Check 1: Hard limit on concurrent requests
	current := ls.currentLoad.Load()
	if current >= ls.maxConcurrent {
		log.Println("[LOAD SHEDDER] ❌ Rejected: Max concurrent limit reached")
		return false
	}
	
	// Check 2: Probabilistic rejection based on system load
	dropProb := ls.dropProbability.Load().(float64)
	if dropProb > 0 && rand.Float64() < dropProb {
		log.Printf("[LOAD SHEDDER] ❌ Rejected: Probabilistic shedding (%.0f%% drop rate)", 
			dropProb*100)
		return false
	}
	
	return true
}

// Acquire increments the load counter
func (ls *LoadShedder) Acquire() {
	ls.currentLoad.Add(1)
}

// Release decrements the load counter
func (ls *LoadShedder) Release() {
	ls.currentLoad.Add(-1)
}

// Bulkhead represents a resource pool with limited capacity
type Bulkhead struct {
	name      string
	semaphore chan struct{} // Acts as a token bucket
	maxWorkers int
	timeout    time.Duration
	mu         sync.Mutex
	activeCount int
}

// NewBulkhead creates a new bulkhead with specified capacity
func NewBulkhead(name string, maxWorkers int, timeout time.Duration) *Bulkhead {
	return &Bulkhead{
		name:       name,
		semaphore:  make(chan struct{}, maxWorkers),
		maxWorkers: maxWorkers,
		timeout:    timeout,
	}
}

// Execute runs a function within the bulkhead's resource limits
func (b *Bulkhead) Execute(ctx context.Context, fn func() error) error {
	// Try to acquire a permit (worker slot)
	select {
	case b.semaphore <- struct{}{}: // Acquired
		b.mu.Lock()
		b.activeCount++
		active := b.activeCount
		b.mu.Unlock()
		
		log.Printf("[%s] Acquired permit. Active workers: %d/%d", 
			b.name, active, b.maxWorkers)
		
		defer func() {
			<-b.semaphore // Release permit
			b.mu.Lock()
			b.activeCount--
			b.mu.Unlock()
			log.Printf("[%s] Released permit. Active workers: %d/%d", 
				b.name, b.activeCount, b.maxWorkers)
		}()
		
		// Execute the function
		return fn()
		
	case <-time.After(b.timeout):
		return fmt.Errorf("bulkhead %s: timeout waiting for available worker", b.name)
		
	case <-ctx.Done():
		return ctx.Err()
	}
}