limited

type AtomicRateLimiter interface {
	RateLimiter

	// CheckAndIncrement performs an atomic check-and-increment operation.
	CheckAndIncrement(ctx context.Context, key RateLimitKey) (*LimitDecision, error)
}

type Clock interface {
	Now() time.Time
}

type Config struct {
	DefaultRequestsPerHour   int
	DefaultRequestsPerMinute int
	DefaultBurstCapacity     int

	EnableBurstCapacity bool
	EnableSoftLimits    bool
	FailOpen            bool

	// TableName is kept for configuration parity; TableTheory table names are derived
	// from model metadata, so callers should set table name via environment before use.
	TableName      string
	ConsistentRead bool
	TTLHours       int

	IdentifierLimits map[string]Limit
	ResourceLimits   map[string]Limit
}

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

type Error struct {
	Type    ErrorType
	Message string
	Cause   error
}

type ErrorType string

type FixedWindowStrategy struct {
	WindowSize  time.Duration
	MaxRequests int

	IdentifierLimits map[string]int
	ResourceLimits   map[string]int
}

type Limit struct {
	RequestsPerHour   int
	RequestsPerMinute int
	BurstCapacity     int
	CustomWindows     map[string]WindowLimit
}

type LimitDecision struct {
	Allowed      bool
	CurrentCount int
	Limit        int
	ResetsAt     time.Time
	RetryAfter   *time.Duration
}

type MultiWindowStrategy struct {
	Windows          []WindowConfig
	IdentifierLimits map[string][]WindowConfig
	ResourceLimits   map[string][]WindowConfig
}

type RateLimitEntry struct {
	PK string `theorydb:"pk" json:"pk"`
	SK string `theorydb:"sk" json:"sk"`

	Identifier string `json:"identifier"`
	Resource   string `json:"resource"`
	Operation  string `json:"operation"`

	WindowStart int64  `json:"window_start"`
	WindowType  string `json:"window_type"`
	WindowID    string `json:"window_id"`

	Count int64 `json:"count"`

	TTL int64 `theorydb:"ttl" json:"ttl"`

	CreatedAt time.Time         `theorydb:"created_at" json:"created_at"`
	UpdatedAt time.Time         `theorydb:"updated_at" json:"updated_at"`
	Metadata  map[string]string `json:"metadata,omitempty"`
}

type RateLimitKey struct {
	Identifier string
	Resource   string
	Operation  string
	Metadata   map[string]string
}

type RateLimitStrategy interface {
	CalculateWindows(now time.Time) []TimeWindow
	GetLimit(key RateLimitKey) int
	ShouldAllow(counts map[string]int, limit int) bool
}

type RateLimitWindow struct {
	WindowType string
	Start      time.Time
	End        time.Time
}

type RateLimiter interface {
	// CheckLimit checks whether a request should be allowed under the current strategy.
	CheckLimit(ctx context.Context, key RateLimitKey) (*LimitDecision, error)

	// RecordRequest records a request occurrence (for non-atomic implementations).
	RecordRequest(ctx context.Context, key RateLimitKey) error

	// GetUsage returns current usage statistics for a key.
	GetUsage(ctx context.Context, key RateLimitKey) (*UsageStats, error)
}

type RealClock struct{}

type SlidingWindowStrategy struct {
	WindowSize  time.Duration
	MaxRequests int
	Granularity time.Duration

	IdentifierLimits map[string]int
	ResourceLimits   map[string]int
}

type TimeWindow struct {
	Start time.Time
	End   time.Time
	Key   string
}

type UsageStats struct {
	Identifier    string
	Resource      string
	CurrentHour   UsageWindow
	CurrentMinute UsageWindow
	DailyTotal    int
	CustomWindows map[string]UsageWindow
}

type UsageWindow struct {
	Count       int
	Limit       int
	WindowStart time.Time
	WindowEnd   time.Time
}

type WindowConfig struct {
	Duration    time.Duration
	MaxRequests int
}

type WindowLimit struct {
	Duration time.Duration
	Requests int
}