// Create SQL rate limiter with custom table name
limiter, err := sqlrl.New(db, "example_rate_limits")
if err != nil {
    panic(err)
}

// Optional: create table if it doesn't exist
ctx := context.Background()
if err := limiter.Migrate(ctx); err != nil {
    panic(err)
}

limiter, err := redisrl.New(context.Background(), redisCli)
if err != nil {
    panic(err)
}

r, err := limiter.Reserve(ctx, &ratelimiter.ReserveRequest{
    Key:              "user:123",
    DurationPerToken: 10 * time.Minute,
    Burst:            5,
    Tokens:           1,
    MaxFutureReserve: 0, // No waiting allowed
})

if r.OK {
    fmt.Println("Request allowed, proceed immediately")
    // Perform action right away
} else {
    retryAfter := r.MustRetryAfterFrom(time.Now())
    fmt.Printf("Request denied, retry after %v\n", retryAfter)
}

func handleRequest(ctx context.Context, limiter ratelimiter.RateLimiter) error {
    r, err := limiter.Reserve(ctx, &ratelimiter.ReserveRequest{
        Key:              "user:123",
        DurationPerToken: 10 * time.Minute,
        Burst:            5,
        Tokens:           1,
        MaxFutureReserve: 30 * time.Second, // Allow up to 30s wait
    })
    if err != nil {
        return err
    }

    if r.OK {
        delay := r.MustDelayFrom(time.Now())
        if delay > 0 {
            fmt.Printf("Request allowed, wait %v before acting\n", delay)
            select {
            case <-time.After(delay):
                fmt.Println("Wait completed, proceeding with action")
            case <-ctx.Done():
                return ctx.Err()
            }
        } else {
            fmt.Println("No wait needed, proceeding with action immediately")
        }
        // Now perform the action
    } else {
        retryAfter := r.MustRetryAfterFrom(time.Now())
        fmt.Printf("Request denied, retry after %v\n", retryAfter)
    }
    return nil
}