builder.go

package ratelimiter

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

// LimiterBuilder provides a fluent API for constructing complex rate limiter configurations.
// It implements the builder pattern for creating rate limiters with advanced features.
type LimiterBuilder struct {
	algorithm string
	config    interface{}

	// Common configuration
	key           string
	onLimited     func(ctx context.Context, key string, waitTime time.Duration)
	onAllowed     func(ctx context.Context, key string)
	onError       func(ctx context.Context, key string, err error)

	// Circuit breaker
	enableCircuitBreaker bool
	circuitBreakerConfig CircuitBreakerConfig

	// Adaptive limiting
	enableAdaptive bool
	adaptiveConfig  AdaptiveConfig

	// Monitoring
	enableMonitoring bool
	metricsConfig    MetricsConfig

	// Redis configuration (if applicable)
	redisConfig RedisConfig

	// Middleware options
	middlewareConfig MiddlewareConfig
}

// NewLimiterBuilder creates a new rate limiter builder.
func NewLimiterBuilder() *LimiterBuilder {
	return &LimiterBuilder{
		middlewareConfig: MiddlewareConfig{
			Headers: make(map[string]string),
		},
	}
}

// Algorithm sets the rate limiting algorithm to use.
func (b *LimiterBuilder) Algorithm(algorithm string) *LimiterBuilder {
	b.algorithm = algorithm
	return b
}

// TokenBucket configures a token bucket algorithm.
func (b *LimiterBuilder) TokenBucket(capacity int64, refillRate float64) *LimiterBuilder {
	b.algorithm = "token_bucket"
	b.config = TokenBucketConfig{
		Capacity:   capacity,
		RefillRate: refillRate,
	}
	return b
}

// LeakyBucket configures a leaky bucket algorithm.
func (b *LimiterBuilder) LeakyBucket(capacity int64, leakRate float64) *LimiterBuilder {
	b.algorithm = "leaky_bucket"
	b.config = LeakyBucketConfig{
		Capacity: capacity,
		LeakRate: leakRate,
	}
	return b
}

// SlidingWindow configures a sliding window algorithm.
func (b *LimiterBuilder) SlidingWindow(windowSize time.Duration, maxRequests int64) *LimiterBuilder {
	b.algorithm = "sliding_window"
	b.config = SlidingWindowConfig{
		WindowSize:  windowSize,
		MaxRequests: maxRequests,
	}
	return b
}

// FixedWindow configures a fixed window algorithm.
func (b *LimiterBuilder) FixedWindow(windowSize time.Duration, maxRequests int64) *LimiterBuilder {
	b.algorithm = "fixed_window"
	b.config = FixedWindowConfig{
		WindowSize:  windowSize,
		MaxRequests: maxRequests,
	}
	return b
}

// WithKey sets an identifier key for the limiter.
func (b *LimiterBuilder) WithKey(key string) *LimiterBuilder {
	b.key = key
	return b
}

// WithCallbacks sets callback functions for rate limiting events.
func (b *LimiterBuilder) WithCallbacks(onLimited func(ctx context.Context, key string, waitTime time.Duration),
	onAllowed func(ctx context.Context, key string)) *LimiterBuilder {
	b.onLimited = onLimited
	b.onAllowed = onAllowed
	return b
}

// WithErrorCallback sets an error callback function.
func (b *LimiterBuilder) WithErrorCallback(onError func(ctx context.Context, key string, err error)) *LimiterBuilder {
	b.onError = onError
	return b
}

// WithCircuitBreaker enables circuit breaker functionality.
func (b *LimiterBuilder) WithCircuitBreaker(config CircuitBreakerConfig) *LimiterBuilder {
	b.enableCircuitBreaker = true
	b.circuitBreakerConfig = config
	return b
}

// WithAdaptiveLimiting enables adaptive rate limiting.
func (b *LimiterBuilder) WithAdaptiveLimiting(config AdaptiveConfig) *LimiterBuilder {
	b.enableAdaptive = true
	b.adaptiveConfig = config
	return b
}

// WithMonitoring enables comprehensive monitoring and metrics.
func (b *LimiterBuilder) WithMonitoring(config MetricsConfig) *LimiterBuilder {
	b.enableMonitoring = true
	b.metricsConfig = config
	return b
}

// WithRedis enables Redis support for distributed rate limiting.
// If no config is provided, uses default Redis settings.
func (b *LimiterBuilder) WithRedis(config ...RedisConfig) *LimiterBuilder {
	if len(config) > 0 {
		cfg := config[0]
		cfg.Enabled = true
		b.redisConfig = cfg
	} else {
		// Default Redis config
		b.redisConfig = RedisConfig{
			Enabled: true,
			Addr:    "localhost:6379",
		}
	}
	return b
}

// WithMiddleware configures HTTP middleware options.
func (b *LimiterBuilder) WithMiddleware(config MiddlewareConfig) *LimiterBuilder {
	b.middlewareConfig = config
	return b
}

// Build creates the rate limiter instance with all configured options.
func (b *LimiterBuilder) Build() (Limiter, error) {
	if b.algorithm == "" {
		return nil, ErrInvalidConfig
	}

	// Create the base limiter
	baseLimiter, err := b.createBaseLimiter()
	if err != nil {
		return nil, err
	}

	// Apply decorators in order of increasing complexity
	limiter := Limiter(baseLimiter)

	// Add error handling wrapper
	if b.onError != nil {
		limiter = &ErrorHandlingLimiter{
			Limiter:  limiter,
			OnError:  b.onError,
			Key:      b.key,
		}
	}

	// Add monitoring
	if b.enableMonitoring {
		limiter = &MonitoringLimiter{
			Limiter:       limiter,
			MetricsConfig: b.metricsConfig,
			Key:           b.key,
		}
	}

	// Add adaptive limiting
	if b.enableAdaptive {
		limiter = &AdaptiveLimiter{
			Limiter:         limiter,
			AdaptiveConfig:  b.adaptiveConfig,
			Key:             b.key,
		}
	}

	// Add circuit breaker (most outer decorator)
	if b.enableCircuitBreaker {
		limiter = &CircuitBreakerLimiter{
			Limiter:             limiter,
			CircuitBreakerConfig: b.circuitBreakerConfig,
			Key:                 b.key,
		}
	}

	return limiter, nil
}

// BuildMiddleware creates an HTTP middleware with the configured limiter.
func (b *LimiterBuilder) BuildMiddleware() (func(http.Handler) http.Handler, error) {
	limiter, err := b.Build()
	if err != nil {
		return nil, err
	}

	b.middlewareConfig.Limiter = limiter
	return HTTPMiddleware(b.middlewareConfig), nil
}

// createBaseLimiter creates the base rate limiter without decorators.
func (b *LimiterBuilder) createBaseLimiter() (Limiter, error) {
	// Determine if we should use Redis
	useRedis := b.redisConfig.Enabled

	// Apply callbacks to config if present
	switch cfg := b.config.(type) {
	case TokenBucketConfig:
		cfg.Key = b.key
		if b.onLimited != nil {
			cfg.OnLimited = func(ctx context.Context, waitTime time.Duration) {
				b.onLimited(ctx, b.key, waitTime)
			}
		}
		if b.onAllowed != nil {
			cfg.OnAllowed = func(ctx context.Context) {
				b.onAllowed(ctx, b.key)
			}
		}

		if useRedis {
			redisCfg := b.redisConfig
			redisCfg.Key = b.key
			redisCfg.OnLimited = func(ctx context.Context, key string, waitTime time.Duration) {
				if cfg.OnLimited != nil {
					cfg.OnLimited(ctx, waitTime)
				}
			}
			redisCfg.OnAllowed = func(ctx context.Context, key string) {
				if cfg.OnAllowed != nil {
					cfg.OnAllowed(ctx)
				}
			}
			redisCfg.OnError = b.onError
			return NewRedisTokenBucket(RedisTokenBucketConfig{
				Capacity:     cfg.Capacity,
				RefillRate:   cfg.RefillRate,
				InitialTokens: cfg.InitialTokens,
				Key:          cfg.Key,
				Redis:        redisCfg,
			})
		}
		b.config = cfg

	case LeakyBucketConfig:
		cfg.Key = b.key
		if b.onLimited != nil {
			cfg.OnLimited = func(ctx context.Context, waitTime time.Duration) {
				b.onLimited(ctx, b.key, waitTime)
			}
		}
		if b.onAllowed != nil {
			cfg.OnAllowed = func(ctx context.Context) {
				b.onAllowed(ctx, b.key)
			}
		}

		if useRedis {
			redisCfg := b.redisConfig
			redisCfg.Key = b.key
			redisCfg.OnLimited = func(ctx context.Context, key string, waitTime time.Duration) {
				if cfg.OnLimited != nil {
					cfg.OnLimited(ctx, waitTime)
				}
			}
			redisCfg.OnAllowed = func(ctx context.Context, key string) {
				if cfg.OnAllowed != nil {
					cfg.OnAllowed(ctx)
				}
			}
			redisCfg.OnError = b.onError
			return NewRedisLeakyBucket(RedisLeakyBucketConfig{
				Capacity:     cfg.Capacity,
				LeakRate:     cfg.LeakRate,
				InitialWater: cfg.InitialWater,
				Key:          cfg.Key,
				Redis:        redisCfg,
			})
		}
		b.config = cfg

	case SlidingWindowConfig:
		cfg.Key = b.key
		if b.onLimited != nil {
			cfg.OnLimited = func(ctx context.Context, waitTime time.Duration) {
				b.onLimited(ctx, b.key, waitTime)
			}
		}
		if b.onAllowed != nil {
			cfg.OnAllowed = func(ctx context.Context) {
				b.onAllowed(ctx, b.key)
			}
		}

		if useRedis {
			redisCfg := b.redisConfig
			redisCfg.Key = b.key
			redisCfg.OnLimited = func(ctx context.Context, key string, waitTime time.Duration) {
				if cfg.OnLimited != nil {
					cfg.OnLimited(ctx, waitTime)
				}
			}
			redisCfg.OnAllowed = func(ctx context.Context, key string) {
				if cfg.OnAllowed != nil {
					cfg.OnAllowed(ctx)
				}
			}
			redisCfg.OnError = b.onError
			return NewRedisSlidingWindow(RedisSlidingWindowConfig{
				WindowSize:  cfg.WindowSize,
				MaxRequests: cfg.MaxRequests,
				BucketCount: cfg.BucketCount,
				Key:         cfg.Key,
				Redis:       redisCfg,
			})
		}
		b.config = cfg

	case FixedWindowConfig:
		cfg.Key = b.key
		if b.onLimited != nil {
			cfg.OnLimited = func(ctx context.Context, waitTime time.Duration) {
				b.onLimited(ctx, b.key, waitTime)
			}
		}
		if b.onAllowed != nil {
			cfg.OnAllowed = func(ctx context.Context) {
				b.onAllowed(ctx, b.key)
			}
		}

		if useRedis {
			redisCfg := b.redisConfig
			redisCfg.Key = b.key
			redisCfg.OnLimited = func(ctx context.Context, key string, waitTime time.Duration) {
				if cfg.OnLimited != nil {
					cfg.OnLimited(ctx, waitTime)
				}
			}
			redisCfg.OnAllowed = func(ctx context.Context, key string) {
				if cfg.OnAllowed != nil {
					cfg.OnAllowed(ctx)
				}
			}
			redisCfg.OnError = b.onError
			return NewRedisFixedWindow(RedisFixedWindowConfig{
				WindowSize:  cfg.WindowSize,
				MaxRequests: cfg.MaxRequests,
				Key:         cfg.Key,
				Redis:       redisCfg,
			})
		}
		b.config = cfg
	}

	// Create in-memory limiter using registry
	return GlobalRegistry().CreateLimiter(b.algorithm, b.config)
}

// BuildAndRegister builds the limiter and registers it in the global registry.
func (b *LimiterBuilder) BuildAndRegister(name string) (Limiter, error) {
	limiter, err := b.Build()
	if err != nil {
		return nil, err
	}

	GlobalRegistry().CacheInstance(name, limiter)
	return limiter, nil
}

// MustBuild is like Build but panics on error.
func (b *LimiterBuilder) MustBuild() Limiter {
	limiter, err := b.Build()
	if err != nil {
		panic(err)
	}
	return limiter
}

// Preset configurations for common use cases
var (
	// APIProtection provides rate limiting suitable for API protection
	APIProtection = func() *LimiterBuilder {
		return NewLimiterBuilder().
			TokenBucket(100, 10). // 100 requests, 10 per second
			WithKey("api_protection").
			WithCircuitBreaker(CircuitBreakerConfig{
				FailureThreshold: 10,
				RecoveryTimeout:  time.Minute,
			}).
			WithMonitoring(MetricsConfig{
				EnablePrometheus: true,
				Namespace:        "ratelimiter",
				Subsystem:        "api",
			})
	}

	// UserBasedLimiting provides per-user rate limiting
	UserBasedLimiting = func(userID string) *LimiterBuilder {
		return NewLimiterBuilder().
			TokenBucket(1000, 100). // Generous limits for premium users
			WithKey("user:" + userID).
			WithAdaptiveLimiting(AdaptiveConfig{
				Enabled:             true,
				AdjustmentInterval:  time.Minute,
				TargetUtilization:   0.8,
			})
	}

	// ServiceProtection provides rate limiting for service protection
	ServiceProtection = func() *LimiterBuilder {
		return NewLimiterBuilder().
			LeakyBucket(1000, 100). // Smooth traffic for service calls
			WithKey("service_protection").
			WithCircuitBreaker(CircuitBreakerConfig{
				FailureThreshold: 20,
				RecoveryTimeout:  time.Minute * 5,
			})
	}
)