AccessQueueService/AccessQueueService/Data/TakeANumberAccessQueueRepo.cs

using AccessQueueService.Models;
using Microsoft.Extensions.Configuration;

namespace AccessQueueService.Data
{
    public class TakeANumberAccessQueueRepo : IAccessQueueRepo
    {
        private readonly Dictionary<string, AccessTicket> _accessTickets = [];
        private Dictionary<string, ulong> _queueNumbers = [];
        private Dictionary<ulong, AccessTicket> _accessQueue = [];

        internal ulong _nowServing = 0;
        internal ulong _nextUnusedTicket = 0; 

        public int GetUnexpiredTicketsCount() => _accessTickets.Count(t => t.Value.ExpiresOn > DateTime.UtcNow);
        public int GetActiveTicketsCount(DateTime activeCutoff) => _accessTickets
            .Count(t => t.Value.ExpiresOn > DateTime.UtcNow && t.Value.LastActive > activeCutoff);
        public int GetQueueCount() => (int)(_nextUnusedTicket - _nowServing);
        public int GetRequestsAhead(string userId)
        {
            if(_queueNumbers.TryGetValue(userId, out var queueNumber))
            {
                if(_accessQueue.TryGetValue(queueNumber, out var ticket))
                {
                    ticket.LastActive = DateTime.UtcNow;
                    return queueNumber >= _nowServing ? (int)(queueNumber - _nowServing) : -1;
                }
            }
            return -1;
            
        }

        public void Enqueue(AccessTicket ticket)
        {
            if(_nextUnusedTicket >= long.MaxValue)
            {
                // Prevent overflow
                Optimize();
            }
            _queueNumbers[ticket.UserId] = _nextUnusedTicket;
            _accessQueue[_nextUnusedTicket] = ticket;
            _nextUnusedTicket++;
        }

        public int DeleteExpiredTickets()
        {
            var cutoff = DateTime.UtcNow;
            var expiredTickets = _accessTickets.Where(t => t.Value.ExpiresOn < cutoff);
            int count = 0;
            foreach (var ticket in expiredTickets)
            {
                count++;
                _accessTickets.Remove(ticket.Key);
            }
            return count;
        }

        public bool DidDequeueUntilFull(int activeSeconds, int expirationSeconds, int capacityLimit)
        {
            var now = DateTime.UtcNow;
            var activeCutoff = now.AddSeconds(-activeSeconds);
            var numberOfActiveUsers = _accessTickets.Count(t => t.Value.ExpiresOn > now && t.Value.LastActive > activeCutoff);
            var openSpots = capacityLimit - numberOfActiveUsers;
            if(openSpots <= 0)
            {
                return true;
            }
            int filledSpots = 0;
            while (filledSpots < openSpots && _nowServing < _nextUnusedTicket)
            {
                if (_accessQueue.TryGetValue(_nowServing, out var nextUser))
                {
                    _accessQueue.Remove(_nowServing);
                    _queueNumbers.Remove(nextUser.UserId);
                    if (nextUser.LastActive < activeCutoff)
                    {
                        // User is inactive, throw away their ticket
                        continue;
                    }
                    _accessTickets[nextUser.UserId] = new AccessTicket
                    {
                        UserId = nextUser.UserId,
                        ExpiresOn = now.AddSeconds(expirationSeconds),
                        LastActive = now
                    };
                    filledSpots++;
                }
                _nowServing++;
            }
            return filledSpots == openSpots;
        }

        public AccessTicket? GetTicket(string userId)
        {
            return _accessTickets.TryGetValue(userId, out var ticket) ? ticket : null;
        }

        public void UpsertTicket(AccessTicket ticket)
        {
            _accessTickets[ticket.UserId] = ticket;
        }

        public bool RemoveUser(string userId)
        {
            if(_queueNumbers.TryGetValue(userId, out var queueNumber))
            {
                _accessQueue.Remove(queueNumber);
                _queueNumbers.Remove(userId);
            }
            return _accessTickets.Remove(userId);
        }

        internal void Optimize()
        {
            var newQueue = new Dictionary<ulong, AccessTicket>();
            var newQueueNumbers = new Dictionary<string, ulong>();
            ulong newIndex = 0;
            for (ulong i = _nowServing; i < _nextUnusedTicket; i++)
            {
                var user = _accessQueue[i];
                newQueue[newIndex] = user;
                newQueueNumbers[user.UserId] = newIndex++;
            }
            _accessQueue = newQueue;
            _queueNumbers = newQueueNumbers;
            _nowServing = 0;
            _nextUnusedTicket = newIndex;
        }
    }
}