builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter(
        policyName: "fixed",
        configureOptions: limiter =>
        {
            limiter.PermitLimit          = 10;
            limiter.Window               = TimeSpan.FromSeconds(30);
            limiter.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
            limiter.QueueLimit           = 2;
        });
});

builder.Services.AddRateLimiter(options =>
{
    options.AddSlidingWindowLimiter(
        policyName: "sliding",
        configureOptions: limiter =>
        {
            limiter.PermitLimit         = 100;
            limiter.Window              = TimeSpan.FromMinutes(1);
            limiter.SegmentsPerWindow   = 6;
            limiter.QueueLimit          = 0;
        });
});

builder.Services.AddRateLimiter(options =>
{
    options.AddTokenBucketLimiter(
        policyName: "token-bucket",
        configureOptions: limiter =>
        {
            limiter.TokenLimit          = 50;
            limiter.TokensPerPeriod     = 10;
            limiter.ReplenishmentPeriod = TimeSpan.FromSeconds(1);
            limiter.AutoReplenishment   = true;
            limiter.QueueLimit          = 5;
        });
});

builder.Services.AddRateLimiter(options =>
{
    options.AddConcurrencyLimiter(
        policyName: "concurrency",
        configureOptions: limiter =>
        {
            limiter.PermitLimit          = 5;
            limiter.QueueProcessingOrder = QueueProcessingOrder.NewestFirst;
            limiter.QueueLimit           = 10;
        });
});

// 1. Реєстрація (у секції Services)
builder.Services.AddRateLimiter(options =>
{
    // Тут конфігуруємо алгоритми та globalLimiter
    // ...

    // Статус-код при відхиленні (за замовчуванням 503, правильніше 429)
    options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;

    // Глобальна функція-відповідь при відхиленні
    options.OnRejected = async (context, token) =>
    {
        context.HttpContext.Response.StatusCode  = 429;
        context.HttpContext.Response.ContentType = "application/json";

        // Стандартний заголовок Retry-After (RFC 7231)
        if (context.Lease.TryGetMetadata(
            MetadataName.RetryAfter, out var retryAfter))
        {
            context.HttpContext.Response.Headers.RetryAfter =
                ((int)retryAfter.TotalSeconds).ToString();
        }

        await context.HttpContext.Response.WriteAsJsonAsync(new
        {
            error      = "Too many requests.",
            retryAfter = retryAfter.TotalSeconds,
            message    = "Please reduce your request frequency."
        }, token);
    };
});

var app = builder.Build();

// 2. Підключення middleware (порядок має значення!)
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseRateLimiter();  // ← Після Auth, щоб знати UserId для per-user лімітів
app.MapControllers();

// Метод 1: через атрибут [EnableRateLimiting]
[EnableRateLimiting("sliding")]
[HttpGet("/api/products")]
public IActionResult GetProducts() => Ok(/* ... */);

// Метод 2: через Minimal API extension
app.MapGet("/api/products", () => Results.Ok())
    .RequireRateLimiting("sliding");

// Метод 3: вимкнути rate limiting для конкретного ендпоінту
app.MapGet("/health", () => Results.Ok())
    .DisableRateLimiting();

// Метод 4: застосувати до цілої групи маршрутів
var apiGroup = app.MapGroup("/api")
    .RequireRateLimiting("per-user-adaptive");

apiGroup.MapGet("/products", () => /* ... */);
apiGroup.MapGet("/orders",   () => /* ... */);

builder.Services.AddRateLimiter(options =>
{
    options.AddPolicy("per-ip", httpContext =>
    {
        // Визначаємо ключ партиції
        // Якщо застосунок стоїть за проксі — X-Forwarded-For важливіший
        var ip = httpContext.Request.Headers["X-Forwarded-For"]
                     .FirstOrDefault()
                 ?? httpContext.Connection.RemoteIpAddress?.ToString()
                 ?? "unknown";

        // Беремо лише першу IP з можливого списку (проксі може додавати кілька)
        ip = ip.Split(',')[0].Trim();

        return RateLimitPartition.GetSlidingWindowLimiter(
            partitionKey: $"ip:{ip}",
            factory: _ => new SlidingWindowRateLimiterOptions
            {
                PermitLimit       = 60,
                Window            = TimeSpan.FromMinutes(1),
                SegmentsPerWindow = 4,
                QueueLimit        = 0
            });
    });
});

builder.Services.AddRateLimiter(options =>
{
    options.AddPolicy("adaptive", httpContext =>
    {
        var user = httpContext.User;

        // Сценарій 1: Аутентифікований користувач
        if (user.Identity?.IsAuthenticated == true)
        {
            var userId = user.FindFirst(ClaimTypes.NameIdentifier)!.Value;
            var plan   = user.FindFirst("subscription_plan")?.Value ?? "free";

            // Параметри залежать від тарифного плану
            var (limit, window) = plan switch
            {
                "enterprise" => (int.MaxValue, TimeSpan.FromDays(1)),
                "pro"        => (5_000, TimeSpan.FromHours(1)),
                "starter"    => (500,   TimeSpan.FromHours(1)),
                _            => (100,   TimeSpan.FromHours(1)) // free
            };

            if (plan == "enterprise")
                return RateLimitPartition.GetNoLimiter($"enterprise:{userId}");

            return RateLimitPartition.GetTokenBucketLimiter(
                partitionKey: $"user:{userId}:{plan}",
                factory: _ => new TokenBucketRateLimiterOptions
                {
                    TokenLimit          = limit,
                    TokensPerPeriod     = limit / 60, // рівномірно по хвилинах
                    ReplenishmentPeriod = TimeSpan.FromMinutes(1),
                    AutoReplenishment   = true,
                    QueueLimit          = 10
                });
        }

        // Сценарій 2: Анонімний — суворіший ліміт, за IP
        var ip = httpContext.Connection.RemoteIpAddress?.ToString() ?? "unknown";

        return RateLimitPartition.GetFixedWindowLimiter(
            partitionKey: $"anon:{ip}",
            factory: _ => new FixedWindowRateLimiterOptions
            {
                PermitLimit = 20,
                Window      = TimeSpan.FromMinutes(1),
                QueueLimit  = 0
            });
    });
});

builder.Services.AddRateLimiter(options =>
{
    // GlobalLimiter застосовується ДО перевірки конкретних policy
    options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(
        httpContext =>
        {
            var ip = httpContext.Connection.RemoteIpAddress?.ToString()
                     ?? "unknown";

            return RateLimitPartition.GetSlidingWindowLimiter(
                partitionKey: $"global:{ip}",
                factory: _ => new SlidingWindowRateLimiterOptions
                {
                    PermitLimit       = 1_000, // Верхня межа для будь-якого IP
                    Window            = TimeSpan.FromMinutes(1),
                    SegmentsPerWindow = 6,
                    QueueLimit        = 0
                });
        });

    // Локальні policy додаються поверх GlobalLimiter
    options.AddPolicy("per-user", httpContext => /* ... */ null!);
});

options.OnRejected = async (context, token) =>
{
    var response = context.HttpContext.Response;
    response.StatusCode  = 429;
    response.ContentType = "application/json";

    // Retry-After зі стандартного метадата RateLimiter
    var retryAfter = 60.0;
    if (context.Lease.TryGetMetadata(
        MetadataName.RetryAfter, out var retryAfterSpan))
    {
        retryAfter = retryAfterSpan.TotalSeconds;
    }

    response.Headers["Retry-After"]          = ((int)retryAfter).ToString();
    response.Headers["X-RateLimit-Limit"]    = "100";
    response.Headers["X-RateLimit-Remaining"] = "0";
    response.Headers["X-RateLimit-Reset"]    =
        DateTimeOffset.UtcNow.AddSeconds(retryAfter)
            .ToUnixTimeSeconds().ToString();

    await response.WriteAsJsonAsync(new
    {
        type   = "https://tools.ietf.org/html/rfc6585#section-4",
        title  = "Too Many Requests",
        status = 429,
        detail = "API rate limit exceeded. Reduce request frequency.",
        retryAfterSeconds = (int)retryAfter
    }, cancellationToken: token);
};

builder.Services.AddRateLimiter(options =>
{
    options.AddPolicy("smart-limit", httpContext =>
    {
        // Bypass 1: Внутрішні сервіси за спеціальним заголовком
        // Заголовок має містити секретний токен, відомий лише внутрішнім сервісам
        if (httpContext.Request.Headers.TryGetValue(
            "X-Internal-Service-Token", out var token) &&
            token == "internal-secret-token")
        {
            return RateLimitPartition.GetNoLimiter("internal");
        }

        // Bypass 2: Адміністратори
        if (httpContext.User.IsInRole("admin"))
        {
            return RateLimitPartition.GetNoLimiter("admin");
        }

        // Bypass 3: Конкретні IP адреси (whitelist)
        var ip = httpContext.Connection.RemoteIpAddress?.ToString();
        var trustedIps = new[] { "10.0.0.1", "192.168.1.100" };
        if (ip is not null && trustedIps.Contains(ip))
            return RateLimitPartition.GetNoLimiter($"trusted:{ip}");

        // Стандартний ліміт для інших
        return RateLimitPartition.GetSlidingWindowLimiter(
            partitionKey: $"default:{ip ?? "unknown"}",
            factory: _ => new SlidingWindowRateLimiterOptions
            {
                PermitLimit       = 60,
                Window            = TimeSpan.FromMinutes(1),
                SegmentsPerWindow = 4
            });
    });
});

using StackExchange.Redis;

public class RedisRateLimiterStore
{
    private readonly IDatabase _db;

    public RedisRateLimiterStore(IConnectionMultiplexer redis)
        => _db = redis.GetDatabase();

    /// <summary>
    /// Атомарний Fixed Window Rate Limiter через Redis Lua-скрипт.
    /// Lua вирішує race condition: INCR та EXPIRE — одна атомарна операція.
    /// </summary>
    public async Task<RateLimitResult> CheckFixedWindowAsync(
        string partitionKey,
        int limit,
        TimeSpan window)
    {
        // Lua-скрипт виконується атомарно (Redis single-threaded)
        // INCR key → збільшує лічильник
        // Якщо це перший запит (current == 1) → встановлюємо TTL
        const string luaScript = @"
            local current = redis.call('INCR', KEYS[1])
            if current == 1 then
                redis.call('EXPIRE', KEYS[1], ARGV[1])
            end
            local ttl = redis.call('TTL', KEYS[1])
            return {current, ttl}";

        var result = (RedisValue[])await _db.ScriptEvaluateAsync(
            luaScript,
            keys:   [new RedisKey(partitionKey)],
            values: [new RedisValue((int)window.TotalSeconds)]);

        var current   = (int)result[0];
        var ttlSeconds = (int)result[1];

        return new RateLimitResult(
            IsAllowed: current <= limit,
            Current:   current,
            Limit:     limit,
            ResetAfter: TimeSpan.FromSeconds(ttlSeconds));
    }
}

public record RateLimitResult(
    bool     IsAllowed,
    int      Current,
    int      Limit,
    TimeSpan ResetAfter);

public class RedisRateLimitMiddleware
{
    private readonly RequestDelegate      _next;
    private readonly RedisRateLimiterStore _store;
    private readonly ILogger<RedisRateLimitMiddleware> _logger;

    public RedisRateLimitMiddleware(
        RequestDelegate next,
        RedisRateLimiterStore store,
        ILogger<RedisRateLimitMiddleware> logger)
    {
        _next   = next;
        _store  = store;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext ctx)
    {
        var key    = GetPartitionKey(ctx);
        var result = await _store.CheckFixedWindowAsync(key, limit: 60,
            window: TimeSpan.FromMinutes(1));

        // Завжди повертаємо інформативні заголовки
        ctx.Response.Headers["X-RateLimit-Limit"]     = result.Limit.ToString();
        ctx.Response.Headers["X-RateLimit-Remaining"] =
            Math.Max(0, result.Limit - result.Current).ToString();
        ctx.Response.Headers["X-RateLimit-Reset"]     =
            ((long)DateTimeOffset.UtcNow.Add(result.ResetAfter)
                .ToUnixTimeSeconds()).ToString();

        if (!result.IsAllowed)
        {
            _logger.LogWarning(
                "Rate limit exceeded for {Key}: {Current}/{Limit}",
                key, result.Current, result.Limit);

            ctx.Response.StatusCode  = 429;
            ctx.Response.ContentType = "application/json";
            ctx.Response.Headers["Retry-After"] =
                ((int)result.ResetAfter.TotalSeconds).ToString();

            await ctx.Response.WriteAsJsonAsync(new
            {
                error = "Rate limit exceeded.",
                retryAfter = (int)result.ResetAfter.TotalSeconds
            });
            return;
        }

        await _next(ctx);
    }

    private static string GetPartitionKey(HttpContext ctx)
    {
        if (ctx.User.Identity?.IsAuthenticated == true)
            return $"rl:user:{ctx.User.FindFirst(ClaimTypes.NameIdentifier)?.Value}";

        var ip = ctx.Connection.RemoteIpAddress?.ToString() ?? "unknown";
        return $"rl:ip:{ip}";
    }
}

builder.Services.AddSingleton<IConnectionMultiplexer>(
    ConnectionMultiplexer.Connect("localhost:6379"));
builder.Services.AddSingleton<RedisRateLimiterStore>();

// ...
app.UseMiddleware<RedisRateLimitMiddleware>();

builder.Services.AddRateLimiter(options =>
{
    // Логін: суворий per-IP (може бути клієнта за NAT)
    // Допускаємо 5 спроб за 15 хвилин — цього достатньо для ручного логіну
    options.AddFixedWindowLimiter("auth-login", limiter =>
    {
        limiter.PermitLimit = 5;
        limiter.Window      = TimeSpan.FromMinutes(15);
        limiter.QueueLimit  = 0; // Без черги для auth — безпечніше відхиляти
    });

    // Реєстрація: трохи ліберальніше, але все одно суворо
    options.AddFixedWindowLimiter("auth-register", limiter =>
    {
        limiter.PermitLimit = 3;
        limiter.Window      = TimeSpan.FromHours(1);
    });

    // Password reset: email дозволяє enumerate users, тому обмежуємо
    options.AddFixedWindowLimiter("auth-reset", limiter =>
    {
        limiter.PermitLimit = 3;
        limiter.Window      = TimeSpan.FromHours(1);
    });
});

// Застосування
app.MapPost("/auth/login",    LoginHandler).RequireRateLimiting("auth-login");
app.MapPost("/auth/register", RegisterHandler).RequireRateLimiting("auth-register");
app.MapPost("/auth/forgot",   ForgotHandler).RequireRateLimiting("auth-reset");

public class RateLimitingTests
    : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;

    public RateLimitingTests(WebApplicationFactory<Program> factory)
        => _factory = factory;

    [Fact]
    public async Task FixedWindow_RejectsAfterLimit()
    {
        var client = _factory.CreateClient();

        // Надсилаємо запити до/після ліміту
        for (var i = 0; i < 10; i++)
        {
            var response = await client.GetAsync("/api/products");
            response.StatusCode.Should().Be(HttpStatusCode.OK);
        }

        // 11-й запит — повинен бути відхилений
        var rejected = await client.GetAsync("/api/products");
        rejected.StatusCode.Should().Be(HttpStatusCode.TooManyRequests);

        // Перевіряємо наявність Retry-After заголовку
        rejected.Headers.Should()
            .ContainKey("Retry-After");
    }

    [Fact]
    public async Task DifferentIPs_HaveIndependentCounters()
    {
        // Клієнт 1 симулює IP 1.1.1.1
        var client1 = _factory.WithWebHostBuilder(b =>
            b.ConfigureTestServices(services =>
                services.PostConfigure<TestOptions>(o =>
                    o.RemoteIpAddress = "1.1.1.1")))
            .CreateClient();

        // Клієнт 2 симулює IP 2.2.2.2
        var client2 = _factory.WithWebHostBuilder(b =>
            b.ConfigureTestServices(services =>
                services.PostConfigure<TestOptions>(o =>
                    o.RemoteIpAddress = "2.2.2.2")))
            .CreateClient();

        // Client1 вичерпує ліміт
        for (var i = 0; i < 10; i++)
            await client1.GetAsync("/api/products");

        // Client2 має власний незалежний лічильник
        var response = await client2.GetAsync("/api/products");
        response.StatusCode.Should().Be(HttpStatusCode.OK);
    }
}