storage

type Action string

type Backend interface {
	RateLimiter
	StateStore

	Close() error

	Ping(ctx context.Context) error
}

type EntityType string

type GlobalRateLimitStats struct {
	MinuteRemaining int
	DayRemaining    int
}

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

type Notification struct {
	ID         int64      `json:"id"`       // monotonic, for cursor
	TraceID    string     `json:"trace_id"` // WHOOP's trace_id, for acking
	EntityType EntityType `json:"entity_type"`
	EntityID   string     `json:"entity_id"`
	Action     Action     `json:"action"`
	Timestamp  time.Time  `json:"timestamp"`
}

type NotificationStore interface {
	// Add persists a notification and publishes to real-time subscribers.
	// Idempotent: duplicate trace_ids are ignored.
	Add(ctx context.Context, userID int64, n Notification) error

	// GetUnacked returns unacknowledged notifications using cursor-based pagination.
	// Pass 0 for the first page. Returns notifications with id > cursor.
	GetUnacked(ctx context.Context, userID int64, cursor int64, limit int32) ([]Notification, error)

	// Acknowledge marks the specified notifications as acknowledged by trace_id.
	Acknowledge(ctx context.Context, userID int64, traceIDs []string) error

	// Subscribe returns a channel that receives notifications for a user.
	// The returned function should be called to unsubscribe.
	Subscribe(ctx context.Context, userID int64) (<-chan Notification, func(), error)
}

type RateLimitResult struct {
	Allowed    bool
	RetryAfter time.Duration
}

type RateLimiter interface {
	Allow(ctx context.Context, key string) (RateLimitResult, error)
}

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

type RedisConfig struct {
	Client *redis.Client
}

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

type StateEntry struct {
	LocalPort     string    `json:"local_port"`
	ClientVersion string    `json:"client_version"`
	CreatedAt     time.Time `json:"created_at"`
}

type StateStore interface {
	Set(ctx context.Context, state string, entry StateEntry, ttl time.Duration) error

	// GetAndDelete atomically retrieves and removes a state entry.
	// Returns ErrNotFound if the state does not exist or has expired.
	GetAndDelete(ctx context.Context, state string) (StateEntry, error)
}

type TokenCache interface {
	// GetUserID returns the cached user ID for a token hash.
	// Returns ErrNotFound if not cached or expired.
	GetUserID(ctx context.Context, tokenHash string) (int64, error)

	// SetUserID caches a user ID for a token hash with TTL.
	SetUserID(ctx context.Context, tokenHash string, userID int64, ttl time.Duration) error
}

type UserRateLimitStats struct {
	MinuteCount int
	DayCount    int
}

type WhoopRateLimitReason string

type WhoopRateLimitState struct {
	Allowed            bool
	MinuteRemaining    int
	MinuteReset        time.Time
	DayRemaining       int
	DayReset           time.Time
	Reason             *WhoopRateLimitReason
	DynamicMinuteLimit int // calculated limit for this user based on active users
	ActiveUserCount    int // current number of active users
}

type WhoopRateLimiter interface {
	// CheckAndIncrement checks both per-user and global limits, incrementing counters if allowed.
	// userKey: hash of access token or user ID extracted from token
	// Returns combined state - allowed only if BOTH per-user AND global limits pass
	CheckAndIncrement(ctx context.Context, userKey string) (*WhoopRateLimitState, error)

	// UpdateFromHeaders updates global rate limit state from WHOOP API response headers.
	// Syncs global counters with WHOOP's actual values.
	UpdateFromHeaders(ctx context.Context, headers http.Header) error

	GetUserStats(ctx context.Context, userKey string) (*UserRateLimitStats, error)

	GetGlobalStats(ctx context.Context) (*GlobalRateLimitStats, error)
}

type WhoopRateLimiterConfig struct {
	PerUserDayLimit       int // default: 1000
	GlobalMinuteLimit     int // default: 95
	GlobalDayLimit        int // default: 9950
	ReserveBuffer         int // default: 5 (reserve for new users)
	MinPerUserMinuteLimit int // default: 5 (floor)
	ActiveWindowSeconds   int // default: 60
}

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