using System.Collections.Concurrent;

namespace GermanApp.Infrastructure.Services;

/// <summary>
/// Simple in-memory rate limiter for Mistral API requests.
/// This is part of the Infrastructure layer.
/// </summary>
public class MistralRateLimiter
{
    private readonly int _maxRequests;
    private readonly TimeSpan _window;
    private readonly ConcurrentDictionary<string, List<DateTime>> _requests = new();

    /// <summary>
    /// Creates a new rate limiter.
    /// </summary>
    /// <param name="maxRequestsPerMinute">Maximum requests allowed per minute</param>
    public MistralRateLimiter(int maxRequestsPerMinute)
    {
        _maxRequests = maxRequestsPerMinute;
        _window = TimeSpan.FromMinutes(1);
    }

    /// <summary>
    /// Attempts to acquire a rate limit token for the specified endpoint.
    /// </summary>
    /// <param name="endpoint">The API endpoint being called</param>
    /// <returns>True if request is allowed, false if rate limit exceeded</returns>
    public bool TryAcquire(string endpoint)
    {
        var now = DateTime.UtcNow;
        var requests = _requests.GetOrAdd(endpoint, _ => new List<DateTime>());

        lock (requests)
        {
            // Remove old requests outside the window
            requests.RemoveAll(r => now - r > _window);

            // Check if limit exceeded
            if (requests.Count >= _maxRequests)
                return false;

            // Add new request
            requests.Add(now);
            return true;
        }
    }

    /// <summary>
    /// Gets the current request count for an endpoint.
    /// </summary>
    /// <param name="endpoint">The API endpoint</param>
    /// <returns>Number of requests in the current window</returns>
    public int GetCurrentCount(string endpoint)
    {
        if (_requests.TryGetValue(endpoint, out var requests))
        {
            lock (requests)
            {
                var now = DateTime.UtcNow;
                requests.RemoveAll(r => now - r > _window);
                return requests.Count;
            }
        }
        return 0;
    }

    /// <summary>
    /// Resets the rate limiter for a specific endpoint.
    /// </summary>
    /// <param name="endpoint">The API endpoint</param>
    public void Reset(string endpoint)
    {
        if (_requests.TryGetValue(endpoint, out var requests))
        {
            lock (requests)
            {
                requests.Clear();
            }
        }
    }

    /// <summary>
    /// Resets all rate limiters.
    /// </summary>
    public void ResetAll()
    {
        foreach (var kvp in _requests)
        {
            lock (kvp.Value)
            {
                kvp.Value.Clear();
            }
        }
    }
}