package main

import (
    "context"
    "time"
    "github.com/arielfikru/gibrun"
)

func main() {
    // Connect to Redis
    app := gibrun.New(gibrun.Config{
        Addr: "localhost:6379",
    })
    defer app.Close()

    ctx := context.Background()

    // Store data (Gib)
    type User struct {
        Name  string `json:"name"`
        Email string `json:"email"`
    }

    user := User{Name: "John", Email: "[email protected]"}
    app.Gib(ctx, "user:123").Value(user).TTL(5 * time.Minute).Exec()

    // Retrieve data (Run)
    var result User
    found, _ := app.Run(ctx, "user:123").Bind(&result)
    if found {
        fmt.Printf("User: %s\n", result.Name)
    }

    // Atomic operations (Sprint)
    count, _ := app.Sprint(ctx, "counter:visitors").Incr()
    fmt.Printf("Visitors: %d\n", count)
}

cluster := gibrun.NewCluster(gibrun.ClusterConfig{
    Addrs: []string{"node1:6379", "node2:6379", "node3:6379"},
})

// Same API as single-node
cluster.Gib(ctx, "key").Value(data).Exec()

result, _ := gibrun.Migrate(ctx, srcClient, dstClient, gibrun.MigrateOptions{
    Pattern:   "user:*",
    BatchSize: 100,
    OnProgress: func(done, total int) {
        fmt.Printf("Progress: %d/%d\n", done, total)
    },
})

scanner := app.Blusukan(ctx, gibrun.ScanOptions{
    Pattern: "session:*",
    Count:   100,
})

for scanner.Next() {
    fmt.Println(scanner.Key())
}

limiter := gibrun.NewRateLimiter(client, gibrun.RateLimitConfig{
    Rate:   100,           // 100 requests
    Window: time.Minute,   // per minute
})

// Use as middleware
http.Handle("/api/", limiter.Middleware(apiHandler))

// Or check manually
result, _ := limiter.Allow(ctx, "user:123")
if !result.Allowed {
    // Rate limited
}