// 可能的優化點：
// 1. 使用 ConcurrentDictionary 代替 Dictionary + lock
// 2. 使用快取來減少 Sum() 操作的頻率
// 3. 定期清理而不是每次請求時清理過期數據
public class SlidingWindowRateLimiter
{
    private readonly Dictionary<long, int> _windows = new();
    private readonly int _limit;
    private readonly int _windowMilliseconds;
    private readonly int _bucketSizeMillis;
    private readonly object _lock = new();
    
    public SlidingWindowRateLimiter(int limit, int windowSeconds, int bucketSizeMillis = 1000)
    {
        _limit = limit;
        _windowMilliseconds = windowSeconds * 1000;
        _bucketSizeMillis = bucketSizeMillis;
    }
    
    public bool ShouldAllowRequest()
    {
        lock (_lock)
        {
            var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            var currentBucket = now - (now % _bucketSizeMillis);
            var windowStart = now - _windowMilliseconds;
            
            // 清除過期的窗口
            _windows.Keys.Where(k => k < windowStart).ToList()
                .ForEach(k => _windows.Remove(k));
                
            // 計算當前窗口內的請求總數
            var requestCount = _windows.Values.Sum();
            if (requestCount >= _limit)
                return false;
                
            // 新增新請求到當前bucket
            if (!_windows.ContainsKey(currentBucket))
                _windows[currentBucket] = 0;
            _windows[currentBucket]++;
            
            return true;
        }
    }
}
// 創建一個限流器：每分鐘最多100個請求，bucket大小為1秒
var rateLimiter = new SlidingWindowRateLimiter(100, 60, 1000);

// 使用
if (rateLimiter.ShouldAllowRequest())
{
    // 處理請求
}
else
{
    // 拒絕請求
}

public class TokenBucketRateLimiter
{
    private readonly int _bucketCapacity;
    private readonly int _tokensPerSecond;
    private double _currentTokens;
    private DateTime _lastRefillTime;
    private readonly object _lock = new object();

    public TokenBucketRateLimiter(int bucketCapacity, int tokensPerSecond)
    {
        _bucketCapacity = bucketCapacity;
        _tokensPerSecond = tokensPerSecond;
        _currentTokens = bucketCapacity;
        _lastRefillTime = DateTime.UtcNow;
    }

    public bool ShouldAllowRequest(int tokens = 1)
    {
        lock (_lock)
        {
            RefillTokens();

            if (_currentTokens >= tokens)
            {
                _currentTokens -= tokens;
                return true;
            }

            return false;
        }
    }

    private void RefillTokens()
    {
        var now = DateTime.UtcNow;
        var timeElapsed = (now - _lastRefillTime).TotalSeconds;
        var tokensToAdd = timeElapsed * _tokensPerSecond;

        _currentTokens = Math.Min(_bucketCapacity, _currentTokens + tokensToAdd);
        _lastRefillTime = now;
    }

    // 獲取當前令牌數量（用於監控）
    public double GetCurrentTokens()
    {
        lock (_lock)
        {
            RefillTokens();
            return _currentTokens;
        }
    }
}
// 創建限流器：桶容量100，每秒產生10個令牌
var rateLimiter = new TokenBucketRateLimiter(100, 10);

// 基本使用
if (rateLimiter.ShouldAllowRequest())
{
    // 處理請求
}

// 消耗多個令牌的使用場景
if (rateLimiter.ShouldAllowRequest(5)) // 大請求消耗5個令牌
{
    // 處理大請求
}

public class LeakyBucketRateLimiter
{
    private readonly Queue<DateTime> _bucket = new();
    private readonly int _bucketCapacity;
    private readonly TimeSpan _leakInterval;
    private readonly object _lock = new object();
    private DateTime _lastLeakTime;

    public LeakyBucketRateLimiter(int bucketCapacity, TimeSpan leakInterval)
    {
        _bucketCapacity = bucketCapacity;
        _leakInterval = leakInterval;
        _lastLeakTime = DateTime.UtcNow;
    }

    public bool ShouldAllowRequest()
    {
        lock (_lock)
        {
            var now = DateTime.UtcNow;
            LeakRequests(now);

            if (_bucket.Count < _bucketCapacity)
            {
                _bucket.Enqueue(now);
                return true;
            }

            return false;
        }
    }

    private void LeakRequests(DateTime now)
    {
        // 計算從上次漏水到現在應該漏出多少請求
        var elapsedTime = now - _lastLeakTime;
        var leaksCount = (int)(elapsedTime.TotalMilliseconds / _leakInterval.TotalMilliseconds);

        if (leaksCount > 0)
        {
            // 最多漏出當前桶中的所有請求
            leaksCount = Math.Min(leaksCount, _bucket.Count);
            
            for (int i = 0; i < leaksCount; i++)
            {
                _bucket.Dequeue();
            }

            _lastLeakTime = now;
        }
    }

    // 獲取當前桶中請求數（用於監控）
    public int GetCurrentQueueSize()
    {
        lock (_lock)
        {
            return _bucket.Count;
        }
    }
}
// 創建限流器：桶容量100，每100ms處理一個請求
var rateLimiter = new LeakyBucketRateLimiter(100, TimeSpan.FromMilliseconds(100));

// 使用
if (rateLimiter.ShouldAllowRequest())
{
    // 處理請求
}
else
{
    // 請求被拒絕
}

var builder = WebApplication.CreateBuilder(args);

// 加入記憶體快取
builder.Services.AddMemoryCache();

// 設定限流選項
builder.Services.Configure<IpRateLimitOptions>(builder.Configuration.GetSection("IpRateLimiting"));
builder.Services.Configure<IpRateLimitPolicies>(builder.Configuration.GetSection("IpRateLimitPolicies"));

// 加入相依服務
builder.Services.AddInMemoryRateLimiting();
builder.Services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();

var app = builder.Build();

// 啟用 IP 限流中介軟體
app.UseIpRateLimiting();

public class RateLimitMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMemoryCache _cache;
    private readonly string _cacheKey = "RateLimit";

    public RateLimitMiddleware(RequestDelegate next, IMemoryCache cache)
    {
        _next = next;
        _cache = cache;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var ipAddress = context.Connection.RemoteIpAddress?.ToString();
        var cacheKey = $"{_cacheKey}_{ipAddress}";

        var rateLimiter = _cache.GetOrCreate(cacheKey, entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(1);
            return new FixedWindowRateLimiter(100, TimeSpan.FromMinutes(1));
        });

        if (!rateLimiter.ShouldAllowRequest())
        {
            context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
            context.Response.Headers.Add("Retry-After", "60");
            context.Response.Headers.Add("X-RateLimit-Limit", "100");
            context.Response.Headers.Add("X-RateLimit-Remaining", "0");
            context.Response.Headers.Add("X-RateLimit-Reset", 
                DateTimeOffset.UtcNow.AddMinutes(1).ToUnixTimeSeconds().ToString());
            
            await context.Response.WriteAsync("Too many requests. Please try again later.");
            return;
        }

        await _next(context);
    }
}

public class RedisRateLimiter
{
    private readonly IConnectionMultiplexer _redis;
    private readonly string _keyPrefix;
    
    public RedisRateLimiter(IConnectionMultiplexer redis, string keyPrefix)
    {
        _redis = redis;
        _keyPrefix = keyPrefix;
    }
    
    public async Task<bool> ShouldAllowRequestAsync(string clientId, int limit, TimeSpan window)
    {
        var db = _redis.GetDatabase();
        var key = $"{_keyPrefix}:{clientId}";
        
        // 使用 Redis 的 MULTI 指令確保原子性
        var tran = db.CreateTransaction();
        
        // 獲取當前計數
        var countTask = db.StringGetAsync(key);
        var count = int.Parse((await countTask).ToString() ?? "0");
        
        if (count >= limit)
            return false;
            
        // 增加計數並設置過期時間
        await db.StringIncrementAsync(key);
        await db.KeyExpireAsync(key, window);
        
        return true;
    }
}

public class DistributedRateLimitMiddleware
{
    private readonly RequestDelegate _next;
    private readonly RedisRateLimiter _rateLimiter;
    
    public DistributedRateLimitMiddleware(RequestDelegate next, 
        IConnectionMultiplexer redis)
    {
        _next = next;
        _rateLimiter = new RedisRateLimiter(redis, "ratelimit");
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        var clientId = context.Connection.RemoteIpAddress?.ToString() ?? "unknown";
        
        if (!await _rateLimiter.ShouldAllowRequestAsync(clientId, 100, 
            TimeSpan.FromMinutes(1)))
        {
            context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
            await context.Response.WriteAsync("Rate limit exceeded");
            return;
        }
        
        await _next(context);
    }
}