Average QPS: 50M × 20 / 86,400 ≈ 11,600 writes/sec

Peak QPS (5× burst): ~58,000 writes/sec

Peak QPS (10× during finals): ~116,000 writes/sec

Average read QPS: 116,000 reads/sec

Peak read QPS: ~580,000 reads/sec

With caching, actual Redis reads may be 30-50% of this.

POST   /api/v1/leaderboards/{boardId}/scores
GET    /api/v1/leaderboards/{boardId}/rank/{userId}
GET    /api/v1/leaderboards/{boardId}/top?limit=100&offset=0
GET    /api/v1/leaderboards/{boardId}/nearby/{userId}?count=10
GET    /api/v1/leaderboards/{boardId}/percentile/{userId}
GET    /api/v1/leaderboards/{boardId}/friends/{userId}
GET    /api/v1/leaderboards/{boardId}/snapshots/{date}
GET    /api/v1/leaderboards/{boardId}/stats

// POST /api/v1/leaderboards/game_abc_daily/scores
{
    "userId": "user_12345",
    "score": 98500,
    "idempotencyKey": "evt_abc_123_456",
    "metadata": {
        "gameMode": "ranked",
        "duration": 342,
        "accuracy": 0.87
    }
}

// Response 200 OK
{
    "status": "accepted",
    "newRank": 42,
    "previousRank": 105,
    "rankChange": 63,
    "totalParticipants": 12500000
}

// GET /api/v1/leaderboards/game_abc_daily/top?limit=10&offset=0
{
    "leaderboardId": "game_abc_daily",
    "entries": [
        {
            "rank": 1,
            "userId": "user_99999",
            "username": "ShadowBlade",
            "avatarUrl": "https://cdn.example.com/avatars/99999.jpg",
            "score": 2450000,
            "country": "JP"
        },
        {
            "rank": 2,
            "userId": "user_88888",
            "username": "PixelQueen",
            "avatarUrl": "https://cdn.example.com/avatars/88888.jpg",
            "score": 2380000,
            "country": "KR"
        }
    ],
    "totalEntries": 12500000,
    "hasMore": true,
    "cursor": "eyJyYW5rIjozMH0="
}

# Update user_12345's score to 98500 on the daily leaderboard
ZADD lb:game_abc:daily:scores GT 98500 "user_12345"

# Get user_12345's rank (0-based, so add 1 for human-readable)
ZREVRANK lb:game_abc:daily:scores "user_12345"

# Get the top 100 players
ZREVRANGE lb:game_abc:daily:scores 0 99 WITHSCORES

# Count total participants
ZCARD lb:game_abc:daily:scores

# Get score distribution for percentile calculation
ZCOUNT lb:game_abc:daily:scores -inf +inf

# Get players around user_12345 (ranks 92-112)
ZREVRANGE lb:game_abc:daily:scores 91 111 WITHSCORES

1. API-level idempotency: The client sends a unique idempotencyKey per score event. The API checks Redis with SETNX before accepting. This prevents duplicate ingestion from retries.
2. Kafka producer acks=all: The Kafka producer is configured with acks=all and enable.idempotence=true, ensuring Kafka itself deduplicates within a partition.
3. Worker-level idempotent writes: The worker uses ZADD (which is naturally idempotent — setting the same score twice is harmless) and only appends to the history table with an ON CONFLICT DO NOTHING clause.

// Single leaderboard rank lookup — O(log N)
var rank = await redis.SortedSetRankAsync(
    "lb:game_abc:daily:scores",
    $"user_{userId}",
    Order.Descending
);

// Total participants
var total = await redis.SortedSetLengthAsync("lb:game_abc:daily:scores");

// Human-readable rank (1-based)
var displayRank = rank.HasValue ? rank.Value + 1 : -1;

// Cached top-100 with 5-second TTL
public async Task<List<LeaderboardEntry>> GetTopNAsync(string boardId, int limit)
{
    // Only use cache for small, popular queries
    if (limit <= 100)
    {
        var cacheKey = $"lb:{boardId}:top{limit}";
        var cached = await _redis.StringGetAsync(cacheKey);
        if (cached.HasValue)
            return JsonSerializer.Deserialize<List<LeaderboardEntry>>(cached!);
    }

    // Fetch from sorted set
    var entries = await _redis.SortedSetRangeByRankWithScoresAsync(
        $"lb:{boardId}:scores", 0, limit - 1, Order.Descending);

    var result = entries.Select((e, i) => new LeaderboardEntry
    {
        Rank = i + 1,
        UserId = e.Element.ToString(),
        Score = e.Score
    }).ToList();

    // Cache for 5 seconds (only popular pages)
    if (limit <= 100)
    {
        var cacheKey = $"lb:{boardId}:top{limit}";
        await _redis.StringSetAsync(cacheKey,
            JsonSerializer.Serialize(result), TimeSpan.FromSeconds(5));
    }

    return result;
}

// Get 10 players above and below the user
public async Task<NearbyResult> GetNearbyRanksAsync(
    string boardId, string userId, int count = 10)
{
    var key = $"lb:{boardId}:scores";

    // Step 1: Get user's rank — O(log N)
    var rank = await _redis.SortedSetRankAsync(key, userId, Order.Descending);
    if (!rank.HasValue)
        return new NearbyResult { Found = false };

    var centerRank = rank.Value;
    var start = Math.Max(0, centerRank - count);
    var end = centerRank + count;

    // Step 2: Fetch surrounding entries — O(log N + 2*count)
    var entries = await _redis.SortedSetRangeByRankWithScoresAsync(
        key, start, end, Order.Descending);

    // Step 3: Get user's own score
    var userScore = await _redis.SortedSetScoreAsync(key, userId);

    return new NearbyResult
    {
        Found = true,
        UserRank = centerRank + 1,
        UserScore = userScore ?? 0,
        Entries = entries.Select((e, i) => new NearbyEntry
        {
            Rank = start + i + 1,
            UserId = e.Element.ToString(),
            Score = e.Score,
            IsCurrentUser = e.Element.ToString() == userId
        }).ToList()
    };
}

// Snapshot data structure
public class LeaderboardSnapshot
{
    public string LeaderboardId { get; set; }
    public DateTime SnapshotTime { get; set; }
    public string TimeWindow { get; set; } // "daily", "weekly"
    public DateTime WindowStart { get; set; }
    public DateTime WindowEnd { get; set; }
    public int TotalParticipants { get; set; }
    public List<SnapshotEntry> TopEntries { get; set; }
    public Dictionary<string, double> ScoreDistribution { get; set; } // percentile buckets
}

public class SnapshotEntry
{
    public int Rank { get; set; }
    public string UserId { get; set; }
    public double Score { get; set; }
    public string Country { get; set; }
}

// Pre-compute percentile thresholds
public async Task<Dictionary<string, double>> ComputePercentileThresholdsAsync(
    string boardId)
{
    var key = $"lb:{boardId}:scores";
    var total = await _redis.SortedSetLengthAsync(key);
    if (total == 0) return new Dictionary<string, double>();

    var percentiles = new[] { 10, 25, 50, 75, 90, 95, 99 };
    var thresholds = new Dictionary<string, double>();

    foreach (var p in percentiles)
    {
        // Rank from the top (highest score = rank 0)
        var targetRank = (int)Math.Ceiling(total * (100 - p) / 100.0) - 1;
        var entries = await _redis.SortedSetRangeByRankWithScoresAsync(
            key, targetRank, targetRank, Order.Descending);

        if (entries.Length > 0)
            thresholds[$"P{p}"] = entries[0].Score;
    }

    return thresholds;
}

// User percentile from thresholds — O(log N)
public int GetUserPercentile(double userScore,
    Dictionary<string, double> thresholds)
{
    var percentiles = thresholds.OrderBy(kvp => kvp.Value).ToList();
    var percentile = 100; // default: bottom

    foreach (var threshold in percentiles)
    {
        if (userScore >= threshold.Value)
        {
            var p = int.Parse(threshold.Key.Substring(1));
            percentile = Math.Min(percentile, 100 - p);
        }
    }
    return percentile;
}

public class ScoreValidator
{
    private readonly IConnectionMultiplexer _redis;
    private readonly ILogger<ScoreValidator> _logger;

    // Configurable per game mode
    private const double MaxPossibleScore = 1_000_000;
    private const int MaxSubmissionsPerMinute = 10;
    private const int MinGameDurationSeconds = 30;

    public async Task<ValidationResult> ValidateAsync(ScoreEvent scoreEvent)
    {
        // 1. Idempotency check
        var dedupKey = $"dedup:{scoreEvent.IdempotencyKey}";
        var isNew = await _redis.GetDatabase().StringSetAsync(
            dedupKey, "1", TimeSpan.FromHours(24), When.NotExists);
        if (!isNew)
            return ValidationResult.Duplicate("Event already processed");

        // 2. Bounds check
        if (scoreEvent.Score < 0 || scoreEvent.Score > MaxPossibleScore)
        {
            _logger.LogWarning(
                "Score {Score} out of bounds for user {UserId}",
                scoreEvent.Score, scoreEvent.UserId);
            return ValidationResult.Invalid("Score out of valid range");
        }

        // 3. Rate limit check
        var rateKey = $"ratelimit:{scoreEvent.UserId}:{scoreEvent.LeaderboardId}";
        var db = _redis.GetDatabase();
        var count = await db.StringIncrementAsync(rateKey);
        if (count == 1)
            await db.KeyExpireAsync(rateKey, TimeSpan.FromMinutes(1));
        if (count > MaxSubmissionsPerMinute)
            return ValidationResult.RateLimited("Too many submissions");

        // 4. Temporal check
        if (scoreEvent.Metadata.DurationSeconds < MinGameDurationSeconds)
            return ValidationResult.Invalid("Game duration too short");

        // 5. Consistency check (score shouldn't exceed theoretical max
        //    based on duration)
        var theoreticalMax = scoreEvent.Metadata.DurationSeconds * 3000; // 3K pts/sec max
        if (scoreEvent.Score > theoreticalMax)
            return ValidationResult.Suspicious("Score exceeds theoretical maximum");

        return ValidationResult.Valid();
    }
}

1. Lazy computation: Fetch friend IDs from the social graph, look up their scores via ZMSCORE on the main board, sort locally. Cache for 60 seconds. Works well when friend lists are under 500.
2. Pre-materialized: Maintain a separate sorted set per user's friend group. Updated asynchronously via a Kafka consumer when any friend's score changes. Higher write cost but instant reads.
3. Hybrid: Pre-materialize for users with many friend interactions, lazy-compute for the long tail. Most production systems use this approach.

• Score distribution: Histogram of scores to identify difficulty curves
• Churn correlation: Do players who drop below P50 churn faster?
• Session lift: Does viewing the leaderboard increase session length?
• Rank velocity: How quickly do new players climb the ranks?
• Score update frequency: How often do players actively compete?
• Friend engagement: Does the friends leaderboard drive more return visits?
• Notification CTR: Do rank-change push notifications drive re-engagement?

-- Partitioned by time for efficient queries
CREATE TABLE score_history (
    id              BIGSERIAL,
    leaderboard_id  VARCHAR(64) NOT NULL,
    user_id         VARCHAR(64) NOT NULL,
    score           DOUBLE PRECISION NOT NULL,
    event_type      VARCHAR(32) NOT NULL,
    idempotency_key VARCHAR(128) UNIQUE,
    validated       BOOLEAN DEFAULT TRUE,
    created_at      TIMESTAMPTZ DEFAULT NOW()
) PARTITION BY RANGE (created_at);

-- Monthly partitions
CREATE TABLE score_history_2026_07 PARTITION OF score_history
    FOR VALUES FROM ('2026-07-01') TO ('2026-08-01');

CREATE INDEX idx_score_history_board_user
    ON score_history (leaderboard_id, user_id, created_at DESC);

-- Leaderboard snapshots
CREATE TABLE leaderboard_snapshots (
    id              BIGSERIAL PRIMARY KEY,
    leaderboard_id  VARCHAR(64) NOT NULL,
    snapshot_time   TIMESTAMPTZ NOT NULL,
    time_window     VARCHAR(16) NOT NULL,
    window_start    TIMESTAMPTZ NOT NULL,
    window_end      TIMESTAMPTZ NOT NULL,
    total_entries   INTEGER NOT NULL,
    snapshot_url    TEXT NOT NULL,
    created_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX idx_snapshots_board_time
    ON leaderboard_snapshots (leaderboard_id, snapshot_time DESC);

-- User stats materialized view
CREATE MATERIALIZED VIEW user_leaderboard_stats AS
SELECT
    leaderboard_id,
    user_id,
    COUNT(*) AS total_submissions,
    MAX(score) AS best_score,
    AVG(score) AS avg_score,
    MIN(created_at) AS first_submission,
    MAX(created_at) AS last_submission
FROM score_history
WHERE validated = TRUE
GROUP BY leaderboard_id, user_id;

public class CacheWarmer
{
    private readonly IConnectionMultiplexer _redis;
    private readonly ILogger<CacheWarmer> _logger;

    public async Task WarmLeaderboardCacheAsync(string boardId)
    {
        var sw = Stopwatch.StartNew();
        var db = _redis.GetDatabase();
        var key = $"lb:{boardId}:scores";

        // Pre-fetch top 1000
        var topEntries = await db.SortedSetRangeByRankWithScoresAsync(
            key, 0, 999, Order.Descending);

        // Cache top-10, top-50, top-100
        foreach (var limit in new[] { 10, 50, 100 })
        {
            var subset = topEntries.Take(limit).Select((e, i) => new
            {
                Rank = i + 1,
                UserId = e.Element.ToString(),
                Score = e.Score
            });

            var cacheKey = $"lb:{boardId}:top{limit}";
            await db.StringSetAsync(cacheKey,
                JsonSerializer.Serialize(subset),
                TimeSpan.FromSeconds(5));
        }

        // Warm percentile thresholds
        var total = await db.SortedSetLengthAsync(key);
        var percentiles = new[] { 10, 25, 50, 75, 90, 95, 99 };
        var thresholds = new Dictionary<string, double>();

        foreach (var p in percentiles)
        {
            var targetRank = (int)Math.Ceiling(total * (100 - p) / 100.0) - 1;
            var entries = await db.SortedSetRangeByRankWithScoresAsync(
                key, targetRank, targetRank, Order.Descending);
            if (entries.Length > 0)
                thresholds[$"P{p}"] = entries[0].Score;
        }

        await db.StringSetAsync($"lb:{boardId}:percentiles",
            JsonSerializer.Serialize(thresholds),
            TimeSpan.FromHours(1));

        sw.Stop();
        _logger.LogInformation(
            "Cache warmed for {BoardId} in {Elapsed}ms",
            boardId, sw.ElapsedMilliseconds);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using StackExchange.Redis;

namespace LeaderboardSystem.Models
{
    public class ScoreEvent
    {
        public string IdempotencyKey { get; set; }
        public string LeaderboardId { get; set; }
        public string UserId { get; set; }
        public double Score { get; set; }
        public string EventType { get; set; }
        public ScoreMetadata Metadata { get; set; }
    }

    public class ScoreMetadata
    {
        public string GameMode { get; set; }
        public int DurationSeconds { get; set; }
        public double Accuracy { get; set; }
    }

    public class LeaderboardEntry
    {
        public int Rank { get; set; }
        public string UserId { get; set; }
        public double Score { get; set; }
        public bool IsCurrentUser { get; set; }
    }

    public class NearbyResult
    {
        public bool Found { get; set; }
        public int UserRank { get; set; }
        public double UserScore { get; set; }
        public int TotalParticipants { get; set; }
        public List<LeaderboardEntry> Entries { get; set; } = new();
    }

    public class ValidationResult
    {
        public bool IsValid { get; set; }
        public bool IsDuplicate { get; set; }
        public bool IsSuspicious { get; set; }
        public string Reason { get; set; }

        public static ValidationResult Valid() =>
            new() { IsValid = true };
        public static ValidationResult Duplicate(string reason) =>
            new() { IsDuplicate = true, Reason = reason };
        public static ValidationResult Invalid(string reason) =>
            new() { Reason = reason };
        public static ValidationResult Suspicious(string reason) =>
            new() { IsSuspicious = true, Reason = reason };
    }

    public class PercentileThresholds
    {
        public int TotalParticipants { get; set; }
        public Dictionary<int, double> Thresholds { get; set; } = new();
    }

    public class LeaderboardSnapshot
    {
        public string LeaderboardId { get; set; }
        public DateTime SnapshotTime { get; set; }
        public string TimeWindow { get; set; }
        public int TotalParticipants { get; set; }
        public List<LeaderboardEntry> TopEntries { get; set; } = new();
    }

    public class LeaderboardConfig
    {
        public string BoardId { get; set; }
        public string Name { get; set; }
        public string SortOrder { get; set; } = "descending";
        public double MaxScore { get; set; } = 1_000_000;
        public int MaxSubmissionsPerMinute { get; set; } = 10;
        public int MinGameDurationSeconds { get; set; } = 30;
        public int SnapshotTopN { get; set; } = 10_000;
    }
}

namespace LeaderboardSystem.Services
{
    using LeaderboardSystem.Models;

    public class LeaderboardService
    {
        private readonly IConnectionMultiplexer _redis;
        private readonly ILogger<LeaderboardService> _logger;
        private readonly Dictionary<string, LeaderboardConfig> _configs;

        private const double THEORETICAL_MAX_PER_SECOND = 3000.0;
        private const int DEDUP_TTL_HOURS = 24;
        private const int CACHE_TTL_SECONDS = 5;
        private const int FRIENDS_CACHE_TTL_SECONDS = 60;
        private const int PERCENTILE_CACHE_TTL_SECONDS = 3600;

        public LeaderboardService(
            IConnectionMultiplexer redis,
            ILogger<LeaderboardService> logger)
        {
            _redis = redis;
            _logger = logger;
            _configs = new Dictionary<string, LeaderboardConfig>();
        }

        public void RegisterLeaderboard(LeaderboardConfig config)
        {
            _configs[config.BoardId] = config;
        }

        private string ScoresKey(string boardId) =>
            $"lb:{boardId}:scores";
        private string DedupKey(string idempotencyKey) =>
            $"dedup:{idempotencyKey}";
        private string RateLimitKey(string userId, string boardId) =>
            $"ratelimit:{userId}:{boardId}";
        private string TopCacheKey(string boardId, int limit) =>
            $"lb:{boardId}:top{limit}";
        private string PercentileCacheKey(string boardId) =>
            $"lb:{boardId}:percentiles";
        private string SnapshotKey(string boardId, string date) =>
            $"lb:{boardId}:snapshot:{date}";
        private string FriendsCacheKey(string boardId, string userId) =>
            $"lb:{boardId}:friends:{userId}";

        public async Task<(bool success, string reason, int newRank)>
            SubmitScoreAsync(ScoreEvent scoreEvent)
        {
            var config = GetConfig(scoreEvent.LeaderboardId);

            // Step 1: Idempotency check
            var db = _redis.GetDatabase();
            var dedupSet = await db.StringSetAsync(
                DedupKey(scoreEvent.IdempotencyKey),
                scoreEvent.UserId,
                TimeSpan.FromHours(DEDUP_TTL_HOURS),
                When.NotExists);

            if (!dedupSet)
            {
                _logger.LogDebug(
                    "Duplicate event {Key} ignored",
                    scoreEvent.IdempotencyKey);
                return (true, "duplicate", 0);
            }

            // Step 2: Score validation
            var validation = await ValidateScoreAsync(scoreEvent, config);
            if (!validation.IsValid)
            {
                if (validation.IsDuplicate)
                    return (true, "duplicate", 0);

                _logger.LogWarning(
                    "Score rejected for user {UserId}: {Reason}",
                    scoreEvent.UserId, validation.Reason);

                // Remove the dedup key so retries can succeed
                await db.KeyDeleteAsync(DedupKey(scoreEvent.IdempotencyKey));
                return (false, validation.Reason, 0);
            }

            // Step 3: Write to Redis sorted set
            var scoreKey = ScoresKey(scoreEvent.LeaderboardId);
            await db.SortedSetAddAsync(
                scoreKey,
                scoreEvent.UserId,
                scoreEvent.Score);

            // Step 4: Write to all applicable time windows
            var timeWindows = GetApplicableWindows();
            foreach (var window in timeWindows)
            {
                var windowKey = $"lb:{scoreEvent.LeaderboardId}:{window}:scores";
                await db.SortedSetAddAsync(
                    windowKey,
                    scoreEvent.UserId,
                    scoreEvent.Score);
            }

            // Step 5: Get new rank
            var newRank = await db.SortedSetRankAsync(
                scoreKey, scoreEvent.UserId, Order.Descending);

            var rank = newRank.HasValue ? newRank.Value + 1 : -1;

            // Step 6: Invalidate caches
            await InvalidateCachesAsync(scoreEvent.LeaderboardId);

            _logger.LogInformation(
                "Score {Score} recorded for user {UserId} on {BoardId}. " +
                "New rank: {Rank}",
                scoreEvent.Score, scoreEvent.UserId,
                scoreEvent.LeaderboardId, rank);

            return (true, "accepted", rank);
        }

        private async Task<ValidationResult> ValidateScoreAsync(
            ScoreEvent scoreEvent, LeaderboardConfig config)
        {
            // Bounds check
            if (scoreEvent.Score < 0 ||
                scoreEvent.Score > config.MaxScore)
            {
                return ValidationResult.Invalid(
                    $"Score {scoreEvent.Score} outside " +
                    $"valid range [0, {config.MaxScore}]");
            }

            // Rate limit check
            var db = _redis.GetDatabase();
            var rateKey = RateLimitKey(
                scoreEvent.UserId, scoreEvent.LeaderboardId);
            var count = await db.StringIncrementAsync(rateKey);
            if (count == 1)
            {
                await db.KeyExpireAsync(
                    rateKey, TimeSpan.FromMinutes(1));
            }
            if (count > config.MaxSubmissionsPerMinute)
            {
                return ValidationResult.Invalid(
                    "Rate limit exceeded");
            }

            // Temporal check
            if (scoreEvent.Metadata != null &&
                scoreEvent.Metadata.DurationSeconds <
                    config.MinGameDurationSeconds)
            {
                return ValidationResult.Invalid(
                    "Game duration too short");
            }

            // Consistency check
            if (scoreEvent.Metadata != null)
            {
                var maxPossible = scoreEvent.Metadata.DurationSeconds
                    * THEORETICAL_MAX_PER_SECOND;
                if (scoreEvent.Score > maxPossible)
                {
                    return ValidationResult.Suspicious(
                        "Score exceeds theoretical maximum");
                }
            }

            return ValidationResult.Valid();
        }

        public async Task<LeaderboardEntry?> GetRankAsync(
            string boardId, string userId)
        {
            var db = _redis.GetDatabase();
            var scoreKey = ScoresKey(boardId);

            var rank = await db.SortedSetRankAsync(
                scoreKey, userId, Order.Descending);
            var score = await db.SortedSetScoreAsync(
                scoreKey, userId);

            if (!rank.HasValue || !score.HasValue)
                return null;

            return new LeaderboardEntry
            {
                Rank = rank.Value + 1,
                UserId = userId,
                Score = score.Value,
                IsCurrentUser = true
            };
        }

        public async Task<List<LeaderboardEntry>> GetTopNAsync(
            string boardId, int limit, int offset = 0)
        {
            // Try cache for popular small queries
            if (limit <= 100 && offset == 0)
            {
                var cacheKey = TopCacheKey(boardId, limit);
                var db = _redis.GetDatabase();
                var cached = await db.StringGetAsync(cacheKey);
                if (cached.HasValue)
                {
                    return JsonSerializer.Deserialize
                        <List<LeaderboardEntry>>(cached!)
                        ?? new List<LeaderboardEntry>();
                }
            }

            var scoreKey = ScoresKey(boardId);
            var entries = await db.SortedSetRangeByRankWithScoresAsync(
                scoreKey,
                offset,
                offset + limit - 1,
                Order.Descending);

            var result = entries.Select((e, i) => new LeaderboardEntry
            {
                Rank = offset + i + 1,
                UserId = e.Element.ToString(),
                Score = e.Score
            }).ToList();

            // Cache popular queries
            if (limit <= 100 && offset == 0)
            {
                var cacheKey = TopCacheKey(boardId, limit);
                await db.StringSetAsync(
                    cacheKey,
                    JsonSerializer.Serialize(result),
                    TimeSpan.FromSeconds(CACHE_TTL_SECONDS));
            }

            return result;
        }

        public async Task<NearbyResult> GetNearbyRanksAsync(
            string boardId, string userId, int count = 10)
        {
            var db = _redis.GetDatabase();
            var scoreKey = ScoresKey(boardId);

            // Get user's rank
            var rank = await db.SortedSetRankAsync(
                scoreKey, userId, Order.Descending);

            if (!rank.HasValue)
            {
                return new NearbyResult { Found = false };
            }

            var centerRank = rank.Value;
            var start = Math.Max(0, centerRank - count);
            var end = centerRank + count;

            // Fetch surrounding entries
            var entries = await db.SortedSetRangeByRankWithScoresAsync(
                scoreKey, start, end, Order.Descending);

            var total = await db.SortedSetLengthAsync(scoreKey);

            var userScore = await db.SortedSetScoreAsync(
                scoreKey, userId);

            var nearbyEntries = new List<LeaderboardEntry>();
            for (int i = 0; i < entries.Length; i++)
            {
                nearbyEntries.Add(new LeaderboardEntry
                {
                    Rank = start + i + 1,
                    UserId = entries[i].Element.ToString(),
                    Score = entries[i].Score,
                    IsCurrentUser =
                        entries[i].Element.ToString() == userId
                });
            }

            return new NearbyResult
            {
                Found = true,
                UserRank = centerRank + 1,
                UserScore = userScore ?? 0,
                TotalParticipants = (int)total,
                Entries = nearbyEntries
            };
        }

        public async Task<int> GetUserPercentileAsync(
            string boardId, string userId)
        {
            var db = _redis.GetDatabase();
            var scoreKey = ScoresKey(boardId);

            var rank = await db.SortedSetRankAsync(
                scoreKey, userId, Order.Descending);
            var total = await db.SortedSetLengthAsync(scoreKey);

            if (!rank.HasValue || total == 0)
                return -1;

            // percentile = (1 - rank/total) * 100
            // rank is 0-based, so top player has rank 0 = P100
            var percentile = (int)Math.Round(
                (1.0 - (double)rank.Value / total) * 100);

            return Math.Clamp(percentile, 1, 100);
        }

        public async Task<PercentileThresholds>
            GetPercentileThresholdsAsync(string boardId)
        {
            var db = _redis.GetDatabase();
            var cacheKey = PercentileCacheKey(boardId);

            // Try cache
            var cached = await db.StringGetAsync(cacheKey);
            if (cached.HasValue)
            {
                return JsonSerializer.Deserialize
                    <PercentileThresholds>(cached!)
                    ?? new PercentileThresholds();
            }

            var scoreKey = ScoresKey(boardId);
            var total = await db.SortedSetLengthAsync(scoreKey);
            if (total == 0)
                return new PercentileThresholds();

            var percentiles = new[] { 10, 25, 50, 75, 90, 95, 99 };
            var thresholds = new PercentileThresholds
            {
                TotalParticipants = (int)total
            };

            foreach (var p in percentiles)
            {
                var targetRank = (int)Math.Ceiling(
                    total * (100 - p) / 100.0) - 1;
                targetRank = Math.Max(0, targetRank);

                var entries =
                    await db.SortedSetRangeByRankWithScoresAsync(
                        scoreKey, targetRank, targetRank,
                        Order.Descending);

                if (entries.Length > 0)
                {
                    thresholds.Thresholds[p] = entries[0].Score;
                }
            }

            // Cache thresholds
            await db.StringSetAsync(
                cacheKey,
                JsonSerializer.Serialize(thresholds),
                TimeSpan.FromSeconds(
                    PERCENTILE_CACHE_TTL_SECONDS));

            return thresholds;
        }

        public async Task<List<LeaderboardEntry>>
            GetFriendsLeaderboardAsync(
                string boardId, string userId,
                List<string> friendIds)
        {
            var db = _redis.GetDatabase();
            var cacheKey = FriendsCacheKey(boardId, userId);

            // Try cache
            var cached = await db.StringGetAsync(cacheKey);
            if (cached.HasValue)
            {
                return JsonSerializer.Deserialize
                    <List<LeaderboardEntry>>(cached!)
                    ?? new List<LeaderboardEntry>();
            }

            var scoreKey = ScoresKey(boardId);
            var allIds = new List<string>(friendIds) { userId };

            // Batch fetch scores for all friends + self
            var redisIds = allIds.Select(id =>
                (RedisValue)id).ToArray();
            var scores = await db.SortedSetScoreAsync(
                scoreKey, redisIds);

            // Build entries
            var friendEntries = new List<LeaderboardEntry>();
            for (int i = 0; i < allIds.Count; i++)
            {
                if (scores[i].HasValue)
                {
                    friendEntries.Add(new LeaderboardEntry
                    {
                        UserId = allIds[i],
                        Score = scores[i].Value,
                        IsCurrentUser = allIds[i] == userId
                    });
                }
            }

            // Sort by score descending and assign ranks
            friendEntries = friendEntries
                .OrderByDescending(e => e.Score)
                .ToList();

            for (int i = 0; i < friendEntries.Count; i++)
            {
                friendEntries[i].Rank = i + 1;
            }

            // Cache
            await db.StringSetAsync(
                cacheKey,
                JsonSerializer.Serialize(friendEntries),
                TimeSpan.FromSeconds(FRIENDS_CACHE_TTL_SECONDS));

            return friendEntries;
        }

        public async Task<LeaderboardSnapshot>
            CreateSnapshotAsync(
                string boardId, string timeWindow)
        {
            var db = _redis.GetDatabase();
            var config = GetConfig(boardId);
            var scoreKey = $"lb:{boardId}:{timeWindow}:scores";

            // Fetch top N entries
            var entries =
                await db.SortedSetRangeByRankWithScoresAsync(
                    scoreKey, 0, config.SnapshotTopN - 1,
                    Order.Descending);

            var total = await db.SortedSetLengthAsync(scoreKey);

            var snapshot = new LeaderboardSnapshot
            {
                LeaderboardId = boardId,
                SnapshotTime = DateTime.UtcNow,
                TimeWindow = timeWindow,
                TotalParticipants = (int)total,
                TopEntries = entries.Select((e, i) =>
                    new LeaderboardEntry
                {
                    Rank = i + 1,
                    UserId = e.Element.ToString(),
                    Score = e.Score
                }).ToList()
            };

            // Store in Redis with long TTL
            var date = DateTime.UtcNow.ToString("yyyy-MM-dd");
            var snapshotKey = SnapshotKey(boardId, date);
            await db.StringSetAsync(
                snapshotKey,
                JsonSerializer.Serialize(snapshot),
                TimeSpan.FromDays(90));

            // Also persist to S3/DB (async fire-and-forget)
            _logger.LogInformation(
                "Snapshot created for {BoardId} ({Window}): " +
                "{Count} entries, {Total} total participants",
                boardId, timeWindow,
                snapshot.TopEntries.Count, total);

            return snapshot;
        }

        public async Task<LeaderboardSnapshot?>
            GetHistoricalSnapshotAsync(
                string boardId, DateTime date)
        {
            var db = _redis.GetDatabase();
            var dateStr = date.ToString("yyyy-MM-dd");
            var key = SnapshotKey(boardId, dateStr);
            var data = await db.StringGetAsync(key);

            if (!data.HasValue)
                return null;

            return JsonSerializer.Deserialize
                <LeaderboardSnapshot>(data!);
        }

        private async Task InvalidateCachesAsync(string boardId)
        {
            var db = _redis.GetDatabase();
            var server = _redis.GetServer(
                _redis.GetEndPoints().First());

            // Invalidate top caches
            foreach (var limit in new[] { 10, 50, 100 })
            {
                await db.KeyDeleteAsync(
                    TopCacheKey(boardId, limit));
            }

            // Invalidate percentile cache
            await db.KeyDeleteAsync(
                PercentileCacheKey(boardId));
        }

        private List<string> GetApplicableWindows()
        {
            return new List<string>
            {
                "daily", "weekly", "monthly", "alltime"
            };
        }

        private LeaderboardConfig GetConfig(string boardId)
        {
            if (_configs.TryGetValue(boardId, out var config))
                return config;

            // Default config
            return new LeaderboardConfig
            {
                BoardId = boardId,
                MaxScore = 1_000_000,
                MaxSubmissionsPerMinute = 10,
                MinGameDurationSeconds = 30,
                SnapshotTopN = 10_000
            };
        }
    }
}

public class AdaptiveScoringService
{
    private readonly IConnectionMultiplexer _redis;

    public async Task<double> UpdateEloRatingAsync(
        string userId, string problemId,
        bool solved, double problemDifficulty)
    {
        var db = _redis.GetDatabase();
        var ratingKey = $"edu:{userId}:elo_rating";
        var historyKey = $"edu:{userId}:problem_history";

        // Get current rating (default 1500)
        var currentRating = await db.StringGetAsync(ratingKey);
        var playerRating = currentRating.HasValue
            ? (double)currentRating
            : 1500.0;

        // Calculate expected score using logistic curve
        var expectedScore = 1.0 / (1.0 +
            Math.Pow(10, (problemDifficulty - playerRating) / 400.0));

        // K-factor: higher for new players, lower for established
        var totalProblems = await db.SortedSetLengthAsync(historyKey);
        var kFactor = totalProblems < 30 ? 32.0 :
                      totalProblems < 100 ? 24.0 : 16.0;

        // Actual score: 1 if solved, 0 if not
        var actualScore = solved ? 1.0 : 0.0;

        // Update rating
        var newRating = playerRating +
            kFactor * (actualScore - expectedScore);
        newRating = Math.Max(100, newRating); // floor at 100

        await db.StringSetAsync(ratingKey, newRating);

        // Record in history sorted set (score = rating, member = timestamp)
        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        await db.SortedSetAddAsync(
            historyKey,
            timestamp.ToString(),
            newRating);

        // Trim history to last 500 entries
        await db.SortedSetRemoveRangeByRankAsync(
            historyKey, 0, -501);

        return newRating;
    }

    public async Task<double> GetAdaptivePercentileAsync(
        string boardId, string userId)
    {
        var db = _redis.GetDatabase();
        var boardKey = $"edu:{boardId}:elo_ratings";
        var rating = await db.SortedSetScoreAsync(
            boardKey, userId);
        var total = await db.SortedSetLengthAsync(boardKey);
        var rank = await db.SortedSetRankAsync(
            boardKey, userId, Order.Descending);

        if (!rank.HasValue || total == 0)
            return -1;

        return Math.Round(
            (1.0 - (double)rank.Value / total) * 100, 1);
    }
}

public class AntiCheatIntegrityService
{
    private readonly IConnectionMultiplexer _redis;
    private readonly IFraudDetectionModel _mlModel;
    private readonly ILogger<AntiCheatIntegrityService> _logger;

    private const int VELOCITY_WINDOW_SIZE = 20;
    private const double ZSCORE_THRESHOLD = 3.0;
    private const double ML_REJECT_THRESHOLD = 0.7;
    private const double ML_FLAG_THRESHOLD = 0.3;
    private const int MAX_CONSECUTIVE_HIGH_SCORES = 5;

    public async Task<IntegrityVerdict> EvaluateScoreAsync(
        ScoreEvent scoreEvent)
    {
        var db = _redis.GetDatabase();
        var userKey = $"ac:{scoreEvent.UserId}:recent_scores";
        var statsKey = $"ac:{scoreEvent.UserId}:velocity_stats";

        // 1. Fetch recent scores (last 20 games)
        var recentScores = await db.SortedSetRangeByRankWithScoresAsync(
            userKey, -VELOCITY_WINDOW_SIZE, -1);

        var scoreValues = recentScores
            .Select(e => e.Score).ToList();

        // 2. Compute velocity statistics
        var mean = scoreValues.Any()
            ? scoreValues.Average() : scoreEvent.Score;
        var stdDev = scoreValues.Any()
            ? Math.Sqrt(scoreValues.Average(s =>
                Math.Pow(s - mean, 2))) : 1.0;

        // 3. Z-Score anomaly check
        var zScore = stdDev > 0
            ? (scoreEvent.Score - mean) / stdDev
            : 0;

        if (zScore > ZSCORE_THRESHOLD)
        {
            _logger.LogWarning(
                "Z-Score anomaly for {UserId}: " +
                "score={Score}, z={ZScore:F2}",
                scoreEvent.UserId,
                scoreEvent.Score, zScore);
        }

        // 4. Consecutive high-score check
        var consecutiveHigh = 0;
        for (int i = scoreValues.Count - 1; i >= 0; i--)
        {
            if (scoreValues[i] > mean + 2 * stdDev)
                consecutiveHigh++;
            else
                break;
        }

        // 5. ML feature extraction
        var features = new FraudFeatures
        {
            CurrentScore = scoreEvent.Score,
            RecentMean = mean,
            RecentStdDev = stdDev,
            ZScore = zScore,
            ConsecutiveHighScores = consecutiveHigh,
            SessionDuration = scoreEvent.Metadata?.DurationSeconds ?? 0,
            ScoreVelocity = scoreValues.Count > 1
                ? (scoreEvent.Score - scoreValues.First()) /
                  scoreValues.Count
                : 0,
            TimeSinceLastScore = recentScores.Length > 0
                ? (DateTimeOffset.UtcNow - recentScores.Last().Key)
                    .TotalMinutes
                : double.MaxValue,
            TotalGamesPlayed = await db.SortedSetLengthAsync(userKey)
        };

        // 6. Get ML risk score
        var riskScore = await _mlModel.PredictFraudProbabilityAsync(
            features);

        // 7. Record this score
        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        await db.SortedSetAddAsync(userKey,
            timestamp, scoreEvent.Score);
        await db.SortedSetRemoveRangeByRankAsync(userKey, 0,
            -VELOCITY_WINDOW_SIZE - 1);
        await db.KeyExpireAsync(userKey,
            TimeSpan.FromDays(30));

        // 8. Determine verdict
        if (riskScore >= ML_REJECT_THRESHOLD)
        {
            _logger.LogWarning(
                "Score REJECTED for {UserId}: " +
                "risk={Risk:F3}, score={Score}",
                scoreEvent.UserId,
                riskScore, scoreEvent.Score);

            // Add to watch list
            await db.SortedSetAddAsync(
                "ac:watch_list",
                scoreEvent.UserId, riskScore);

            return IntegrityVerdict.Rejected(
                $"Risk score {riskScore:F3} exceeds threshold");
        }

        if (riskScore >= ML_FLAG_THRESHOLD)
        {
            return IntegrityVerdict.FlaggedForReview(
                riskScore, "Medium risk — queued for review");
        }

        return IntegrityVerdict.Clean(riskScore);
    }

    public async Task<BatchIntegrityReport>
        RunBatchAnalysisAsync(string boardId)
    {
        var db = _redis.GetDatabase();
        var report = new BatchIntegrityReport
        {
            BoardId = boardId,
            AnalysisTime = DateTime.UtcNow
        };

        // Get all players with recent activity
        var allUserKeys = new List<string>();
        var server = _redis.GetServer(
            _redis.GetEndPoints().First());
        await foreach (var key in server.KeysAsync(
            pattern: "ac:*:recent_scores"))
        {
            allUserKeys.Add(key.ToString());
        }

        foreach (var userKey in allUserKeys)
        {
            var userId = userKey.Split(':')[1];
            var scores = await db.SortedSetRangeByRankWithScoresAsync(
                userKey, 0, -1);

            if (scores.Length < 5) continue;

            var values = scores.Select(s => s.Score).ToArray();
            var mean = values.Average();
            var variance = values.Average(v =>
                Math.Pow(v - mean, 2));

            // Coefficient of variation check
            // (low variance = suspicious)
            var cv = mean > 0
                ? Math.Sqrt(variance) / mean : 0;
            if (cv < 0.05 && values.Length > 10)
            {
                report.SuspiciousUsers.Add(
                    new SuspiciousUser
                {
                    UserId = userId,
                    Reason = "Unnaturally low score variance",
                    CoefficientOfVariation = cv,
                    AverageScore = mean,
                    SampleSize = values.Length
                });
            }
        }

        _logger.LogInformation(
            "Batch integrity scan for {BoardId}: " +
            "{Count} suspicious users flagged",
            boardId, report.SuspiciousUsers.Count);

        return report;
    }
}

public class FraudFeatures
{
    public double CurrentScore { get; set; }
    public double RecentMean { get; set; }
    public double RecentStdDev { get; set; }
    public double ZScore { get; set; }
    public int ConsecutiveHighScores { get; set; }
    public int SessionDuration { get; set; }
    public double ScoreVelocity { get; set; }
    public double TimeSinceLastScore { get; set; }
    public long TotalGamesPlayed { get; set; }
}

public class IntegrityVerdict
{
    public bool IsAccepted { get; set; }
    public bool IsFlagged { get; set; }
    public bool IsRejected { get; set; }
    public double RiskScore { get; set; }
    public string Reason { get; set; }

    public static IntegrityVerdict Clean(double risk) =>
        new() { IsAccepted = true, RiskScore = risk };

    public static IntegrityVerdict FlaggedForReview(
        double risk, string reason) =>
        new() { IsFlagged = true, RiskScore = risk,
                Reason = reason };

    public static IntegrityVerdict Rejected(string reason) =>
        new() { IsRejected = true, RiskScore = 1.0,
                Reason = reason };
}

public class BatchIntegrityReport
{
    public string BoardId { get; set; }
    public DateTime AnalysisTime { get; set; }
    public List<SuspiciousUser> SuspiciousUsers { get; set; }
        = new();
}

public class SuspiciousUser
{
    public string UserId { get; set; }
    public string Reason { get; set; }
    public double CoefficientOfVariation { get; set; }
    public double AverageScore { get; set; }
    public int SampleSize { get; set; }
}

Further Reading

• Redis documentation: Sorted Sets — redis.io/docs/data-types/sorted-sets
• Martin Kleppmann — "Designing Data-Intensive Applications" (Chapter 6: partitioning)
• Apache Kafka documentation — exactly-once semantics
• Real-world case studies: League of Legends, Fortnite, and Strava engineering blogs