using System.Collections.Concurrent;
using System.Threading.Tasks;

namespace AsyncQueue
{
    public class AsyncLimitedQueue<TItem>
    {
        private readonly ConcurrentQueue<TItem> _itemsQueue = new ConcurrentQueue<TItem>();
        private readonly ConcurrentQueue<TaskCompletionSource<TItem>> _requestsQueue = new ConcurrentQueue<TaskCompletionSource<TItem>>();
        private readonly object _lock = new object();
        private readonly int _sizeLimit;

        public AsyncLimitedQueue(int sizeLimit)
        {
            _sizeLimit = sizeLimit;
        }

        public void Enqueue(TItem item)
        {
            if (_requestsQueue.TryDequeue(out TaskCompletionSource<TItem> completionSource))
            {
                completionSource.SetResult(item);
                return;
            }

            lock (_lock)
            {
                if (_itemsQueue.Count < _sizeLimit)
                {
                    _itemsQueue.Enqueue(item);
                }
            }
        }

        public Task<TItem> DequeueAsync()
        {
            if (_itemsQueue.TryDequeue(out TItem item))
            {
                return Task.FromResult(item);
            }

            var taskCompletionSource = new TaskCompletionSource<TItem>();

            _requestsQueue.Enqueue(taskCompletionSource);

            return taskCompletionSource.Task;
        }
    }
}