ratelimit

type AdaptiveConfig struct {
	// CPU thresholds
	CPULowThreshold    float64 // < 50%
	CPUMediumThreshold float64 // < 80%
	CPUHighThreshold   float64 // >= 80%

	// Memory thresholds
	MemoryLowThreshold    float64 // < 60%
	MemoryMediumThreshold float64 // < 85%
	MemoryHighThreshold   float64 // >= 85%

	// Response time thresholds
	ResponseTimeLow    time.Duration // < 100ms
	ResponseTimeMedium time.Duration // < 500ms
	ResponseTimeHigh   time.Duration // >= 500ms

	// Adjustment factors
	LowLoadMultiplier    float64 // 1.5x normal limit
	MediumLoadMultiplier float64 // 1.0x normal limit
	HighLoadMultiplier   float64 // 0.5x normal limit

	// Evaluation interval
	EvaluationInterval time.Duration
}

type HeaderConfig struct {
	RateLimitHeader  string // X-RateLimit-Limit
	RemainingHeader  string // X-RateLimit-Remaining
	ResetHeader      string // X-RateLimit-Reset
	RetryAfterHeader string // Retry-After
}

type IntelligentRateLimitConfig struct {
	// Strategy to use
	Strategy RateLimitStrategy

	// Default limits
	DefaultRequestsPerMin int
	DefaultBurstSize      int
	DefaultWindowSize     time.Duration

	// User tiers
	UserTiers map[string]*TierConfig

	// Key generators
	KeyGenerator      func(*gin.Context) string
	UserTierExtractor func(*gin.Context) string

	// Adaptive settings
	AdaptiveConfig *AdaptiveConfig

	// Storage
	CacheClient cache.CacheInterface
	CachePrefix string

	// Behavior
	SkipSuccessfulRequests bool
	SkipPaths              []string
	Headers                *HeaderConfig

	// Callbacks
	OnLimitExceeded func(*gin.Context, *LimitInfo)
	OnLimitWarning  func(*gin.Context, *LimitInfo)

	// Monitoring
	MetricsEnabled bool
}

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

type KeyGeneratorFunc func(c *gin.Context) string

type LimitInfo struct {
	Key        string
	Limit      int
	Remaining  int
	ResetTime  time.Time
	RetryAfter time.Duration
	WindowSize time.Duration
	Strategy   RateLimitStrategy
	UserTier   string
	IsExceeded bool
	IsWarning  bool
}

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

type RateLimit struct {
	Key             string
	Limit           int
	Remaining       int
	Reset           time.Time
	ResetDuration   time.Duration
	WindowStart     time.Time
	RequestCount    int
	LastRequestTime time.Time
}

type RateLimitConfig struct {
	// Rate limiting settings
	RequestsPerSecond int
	RequestsPerMinute int
	RequestsPerHour   int
	BurstSize         int

	// Window settings
	WindowSize time.Duration

	// Key generation
	KeyGenerator KeyGeneratorFunc

	// Skip conditions
	SkipPaths    []string
	SkipIPs      []string
	WhitelistIPs []string

	// Response settings
	IncludeHeaders bool
	CustomMessage  string

	// Storage
	UseRedis    bool
	RedisClient *redis.Client
	RedisPrefix string

	// Callbacks
	OnLimitExceeded func(c *gin.Context, limit *RateLimit)
	OnReset         func(c *gin.Context, limit *RateLimit)
}

type RateLimitStrategy string

type RateLimiter interface {
	Allow(ctx context.Context, key string) (*RateLimit, error)
	Reset(ctx context.Context, key string) error
	GetStats(ctx context.Context, key string) (*RateLimit, error)
}

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

type SystemMetrics struct {
	CPUUsage        float64
	MemoryUsage     float64
	AvgResponseTime time.Duration
	RequestRate     float64
	ErrorRate       float64

	LastUpdated time.Time
	// contains filtered or unexported fields
}

type TierConfig struct {
	Name           string
	RequestsPerMin int
	BurstSize      int
	WindowSize     time.Duration
}