using System;
using System.Linq;
using Developpez.Dotnet.Collections;
using NUnit.Framework;

namespace Developpez.Dotnet.Tests.Collections
{
    [TestFixture]
    public class QueueSetTests
    {
        [Test]
        public void Test_EnumerationOrderIsFIFO()
        {
            var queue = new QueueSet<int>();
            queue.Enqueue(4);
            queue.Enqueue(8);
            queue.Enqueue(15);
            queue.Enqueue(16);
            queue.Enqueue(23);
            queue.Enqueue(42);

            var expected = new[] { 4, 8, 15, 16, 23, 42 };
            var actual = queue.ToArray();
            CollectionAssert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_EnqueueMovesAlreadyPresentItemToEndOfQueue()
        {
            var queue = new QueueSet<int>();
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
            queue.Enqueue(2);

            var expected = 2;
            var actual = queue.Last();
            Assert.AreEqual(expected, actual);
            Assert.AreEqual(3, queue.Count);
        }
        
        [Test]
        public void Test_PeekReturnsFirstAddedItemAndDoesntRemoveIt()
        {
            var queue = new QueueSet<int>();
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);

            var expected = 1;
            var actual = queue.Peek();
            Assert.AreEqual(expected, actual);
            Assert.AreEqual(3, queue.Count);
        }

        [Test]
        public void Test_DequeueReturnsFirstAddedItemAndRemovesIt()
        {
            var queue = new QueueSet<int>();
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);

            var expected = 1;
            var actual = queue.Dequeue();
            Assert.AreEqual(expected, actual);
            Assert.AreEqual(2, queue.Count);
            expected = 2;
            actual = queue.Peek();
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void Test_PeekAndDequeueThrowIfQueueIsEmpty()
        {
            var queue = new QueueSet<int>();
            Assert.Throws<InvalidOperationException>(() => queue.Peek());
            Assert.Throws<InvalidOperationException>(() => queue.Dequeue());
        }

        [Test]
        public void Test_SpecificComparerIsUsedAndLatestValueIsKept()
        {
            QueueSet<string> queue = new QueueSet<string>(StringComparer.CurrentCultureIgnoreCase);
            queue.Enqueue("hello");
            queue.Enqueue("world");
            queue.Enqueue("foo");
            queue.Enqueue("bar");

            // Re-enqueue value that is already present
            queue.Enqueue("HELLO");
            
            string expected = "world";
            string actual = queue.Peek();
            Assert.AreEqual(expected, actual);

            expected = "HELLO";
            actual = queue.Last();
            Assert.AreEqual(expected, actual);

            queue.Enqueue("FOO");

            string[] expected2 = new[] { "world", "bar", "HELLO", "FOO" };
            string[] actual2 = queue.ToArray();
            CollectionAssert.AreEqual(expected2, actual2);
        }
    }
}