ratelimit

type AlgorithmType string

type BusinessRateLimitRule = Rule

type Config struct {
	Enabled      bool         `yaml:"enabled" json:"enabled"`             // 是否启用限流
	DefaultRate  float64      `yaml:"default_rate" json:"default_rate"`   // 默认速率
	DefaultBurst int          `yaml:"default_burst" json:"default_burst"` // 默认突发值
	Storage      string       `yaml:"storage" json:"storage"`             // 存储类型：local 或 redis
	Redis        *RedisConfig `yaml:"redis" json:"redis"`                 // Redis配置（可选）
	Rules        []*Rule      `yaml:"rules" json:"rules"`                 // 限流规则
}

type FallbackStrategyType string

type Limiter interface {
	// Allow 检查是否允许通过
	Allow(ctx context.Context, key string) (bool, error)
	// Wait 等待直到允许通过
	Wait(ctx context.Context, key string) error
	// Reserve 预留一个令牌
	Reserve(ctx context.Context, key string) (*Reservation, error)
}

type LimiterConfig struct {
	Enabled     bool   `yaml:"enabled" env:"RATELIMIT_ENABLED" default:"true"`
	Rate        int    `yaml:"rate" env:"RATELIMIT_RATE" default:"100"`
	Burst       int    `yaml:"burst" env:"RATELIMIT_BURST" default:"200"`
	Algorithm   string `yaml:"algorithm" env:"RATELIMIT_ALGORITHM" default:"token_bucket"`
	EnableTrace bool   `yaml:"enable_trace" env:"RATELIMIT_ENABLE_TRACE" default:"true"`
}

type LimiterFactory func(options *LimiterOptions) (Limiter, error)

type LimiterOptions struct {
	// 基础选项
	Rate       float64       `yaml:"rate" json:"rate"`               // 每秒请求数
	Burst      int           `yaml:"burst" json:"burst"`             // 突发请求数
	Algorithm  AlgorithmType `yaml:"algorithm" json:"algorithm"`     // 限流算法
	WindowSize time.Duration `yaml:"window_size" json:"window_size"` // 窗口大小（仅对窗口算法有效）

	// Redis 选项
	RedisPrefix string `yaml:"redis_prefix" json:"redis_prefix"` // Redis 键前缀

	// 追踪选项
	EnableTrace bool `yaml:"enable_trace" json:"enable_trace"` // 是否启用追踪（用于日志）

	// 性能选项
	CacheSize int `yaml:"cache_size" json:"cache_size"` // 本地缓存大小（LRU缓存）
}

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

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

type ManagerOptions struct {
	// 规则选项
	DefaultRulePriority int `yaml:"default_rule_priority" json:"default_rule_priority"` // 默认规则优先级

	// 限流器选项
	DefaultLimiterOptions *LimiterOptions `yaml:"default_limiter_options" json:"default_limiter_options"` // 默认限流器选项
	LimiterFactory        LimiterFactory  `yaml:"-" json:"-"`                                             // 限流器工厂函数

	// 键前缀（用于生成限流键）
	KeyPrefix string `yaml:"key_prefix" json:"key_prefix"` // 键前缀
}

type MatchCondition struct {
	ID       string        `yaml:"id" json:"id"`             // 条件ID
	Field    MatchField    `yaml:"field" json:"field"`       // 匹配字段
	Operator MatchOperator `yaml:"operator" json:"operator"` // 匹配操作符
	Value    string        `yaml:"value" json:"value"`       // 匹配值
	Negate   bool          `yaml:"negate" json:"negate"`     // 是否取反
}

type MatchField string

type MatchOperator string

type RateLimitConfig = Config

type RateLimitDimension string

type RateLimitManager interface {
	// Allow 检查请求是否允许通过
	Allow(ctx context.Context, req *http.Request) (*RateLimitResult, error)

	// RegisterRule 注册限流规则
	RegisterRule(rule *Rule) error

	// UpdateRule 更新限流规则
	UpdateRule(name string, rule *Rule) error

	// RemoveRule 移除限流规则
	RemoveRule(name string) error

	// GetRules 获取所有限流规则
	GetRules() []*Rule
}

type RateLimitResult struct {
	Allowed     bool                   `json:"allowed"`      // 是否允许通过
	RuleName    string                 `json:"rule_name"`    // 匹配的规则名称
	Dimension   RateLimitDimension     `json:"dimension"`    // 触发限流的维度
	Reason      string                 `json:"reason"`       // 限流原因
	Strategy    FallbackStrategyType   `json:"strategy"`     // 托底策略类型
	WaitTime    time.Duration          `json:"wait_time"`    // 等待时间（仅对queue类型有效）
	RedirectURL string                 `json:"redirect_url"` // 重定向URL（仅对redirect类型有效）
	Degraded    bool                   `json:"degraded"`     // 是否降级处理
	Metadata    map[string]interface{} `json:"metadata"`     // 元数据
}

type RedisClient interface {
	Eval(ctx context.Context, script string, keys []string, args ...interface{}) (interface{}, error)
}

type RedisConfig struct {
	Address  string `yaml:"address" json:"address"`   // Redis地址
	Password string `yaml:"password" json:"password"` // Redis密码
	DB       int    `yaml:"db" json:"db"`             // Redis数据库
	Prefix   string `yaml:"prefix" json:"prefix"`     // 键前缀
}

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

type Reservation struct {
	OK     bool
	Delay  time.Duration
	Tokens int
}

type Rule struct {
	Name        string               `yaml:"name" json:"name"`               // 规则名称
	Enabled     bool                 `yaml:"enabled" json:"enabled"`         // 是否启用
	Priority    int                  `yaml:"priority" json:"priority"`       // 优先级（数字越小优先级越高）
	Dimensions  []RateLimitDimension `yaml:"dimensions" json:"dimensions"`   // 限流维度
	Conditions  []*MatchCondition    `yaml:"conditions" json:"conditions"`   // 匹配条件
	Rate        float64              `yaml:"rate" json:"rate"`               // 每秒请求数
	Burst       int                  `yaml:"burst" json:"burst"`             // 突发请求数
	Algorithm   AlgorithmType        `yaml:"algorithm" json:"algorithm"`     // 限流算法
	Fallback    FallbackStrategyType `yaml:"fallback" json:"fallback"`       // 托底策略类型（简化）
	Description string               `yaml:"description" json:"description"` // 规则描述
	CreatedAt   time.Time            `yaml:"created_at" json:"created_at"`   // 创建时间
	UpdatedAt   time.Time            `yaml:"updated_at" json:"updated_at"`   // 更新时间
}

type RuleConfigFile struct {
	Rules []*Rule `yaml:"rules" json:"rules"`
}

type UserIDExtractor interface {
	ExtractUserID(req *http.Request) string
}