using System.Linq;
using Chernobyl;
using Chernobyl.Collections.Generic;
using NUnit.Framework;

namespace System.Collections.Generic
{
    /// <summary>
    /// An NUnit base test fixture class that is made to test 
    /// <see cref="IEnumerable{T}"/> and <see cref="IEnumerator{T}"/> types. 
    /// This tests includes:
    /// <list type="number">
    ///     <item>Iteration of a single item.</item>
    ///     <item>Iteration of many items.</item>
    /// </list>
    /// </summary>
    /// <typeparam name="T">The type held by the <see cref="IEnumerable{T}"/></typeparam>
    public abstract class EnumerationTests<T>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="EnumerationTests{T}"/> class.
        /// </summary>
        /// <param name="testIterationOrder">True if the order of iteration by 
        /// the <see cref="IEnumerable{T}"/> should be tested, false if otherwise. 
        /// If you specify true, be sure to implement the <see cref="OrderedItems"/>
        /// property.</param>
        protected EnumerationTests(bool testIterationOrder)
            : this(testIterationOrder, null)
        { }

        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="EnumerationTests{T}"/> class.
        /// </summary>
        /// <param name="testIterationOrder">True if the order of iteration by 
        /// the <see cref="IEnumerable{T}"/> should be tested, false if otherwise.
        /// If you specify true, be sure to implement the <see cref="OrderedItems"/>
        /// property.</param>
        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> that 
        /// is used to compare values in the <see cref="IEnumerable{T}"/> for 
        /// uniqueness or null if the default <see cref="IEnumerable{T}"/> 
        /// specified by <see cref="EqualityComparer{T}.Default"/> is to be used.</param>
        protected EnumerationTests(bool testIterationOrder, IEqualityComparer<T> comparer)
        {
            TestIterationOrder = testIterationOrder;
            Comparer = comparer ?? EqualityComparer<T>.Default;
        }

        [Test, Description("Tests the iteration of a single item.")]
        public virtual void SingleItemIteration()
        {
            int count = 0;
            foreach (T foobar in CreateSingleItemEnumerable())
                count++;

            Assert.AreEqual(1, count, "Failed to iterate over single item in the " +
                "IEnumerable<T>. Instead this method iterated over \"" + count + 
                "\" items.");
        }

        [Test, Description("Tests the order of the items iterated in the IEnumerable<T> " + 
            "if testing of ordered iteration is required (see the constructor for " + 
            "more information).")]
        public virtual void ManyItemIteration()
        {
            IEnumerable<T> enumerable = CreateManyItemEnumerable();
            int enumerableCount = enumerable.Count();

            if(TestIterationOrder == true)
            {
                int orderedItemsCount = OrderedItems.Count();
                Assert.AreEqual(orderedItemsCount, enumerableCount,
                    "The IEnumerable<T> does not have the expected number " +
                    "of items.");

                for (int i = 0; i < orderedItemsCount; i++)
                {
                    T expected = OrderedItems.ElementAt(i);
                    T actual = enumerable.ElementAt(i);
                    Assert.That(Comparer.Equals(expected, actual),
                        "The item " + actual + " does not equal " + expected +
                        " when it was expected to.");
                }
            }

            Assert.That(enumerableCount >= 5, "The IEnumerable<T> did not contain 5 or " +
                "more items. It contained " + enumerableCount + " items.");
        }

        [Test, Description("Ensures the items in the IEnumerable<T> are unique.")]
        public virtual void ManyItemUniqueness()
        {
            IEnumerable<T> enumerable = CreateManyItemEnumerable();
            int enumerableCount = enumerable.Count();

            Assert.That(enumerableCount >= 5, "The IEnumerable<T> did not contain 5 or " +
                "more items. It contained " + enumerableCount + " items.");

            Assert.That(enumerable.IsUnique(Comparer), "The items in " +
                        "the list must be unique.");
        }

        /// <summary>
        /// This method should return a new <see cref="IEnumerable{T}"/> that can
        /// be iterated over exactly once. This method should create a new
        /// <see cref="IEnumerable{T}"/> every time it is invoked and not reuse
        /// instances.
        /// </summary>
        /// <returns>The <see cref="IEnumerable{T}"/> containing a single item.</returns>
        protected abstract IEnumerable<T> CreateSingleItemEnumerable();

        /// <summary>
        /// This method should return a new <see cref="IEnumerable{T}"/> that can
        /// be iterated over five or more times. The items will be compared to
        /// the items in <see cref="EnumerationTests{T}.OrderedItems"/> but only
        /// if the  <see cref="EnumerationTests{T}.TestIterationOrder"/> property
        /// is set to true. This method should create a new 
        /// <see cref="IEnumerable{T}"/> every time it is invoked and not reuse
        /// instances. All instances returned  through iteration of the 
        /// <see cref="IEnumerable{T}"/> should be unique.
        /// </summary>
        /// <returns>The <see cref="IEnumerable{T}"/> containing many items.</returns>
        protected abstract IEnumerable<T> CreateManyItemEnumerable();

        /// <summary>
        /// Returns the items created by <see cref="CreateManyItemEnumerable()"/>
        /// are expected to be in.
        /// </summary>
        protected virtual IEnumerable<T> OrderedItems
        {
            get
            {
                throw new NotImplementedException("The deriving class has not " +
                                                  "implemented this property.");
            }
        }

        /// <summary>
        /// The <see cref="IEqualityComparer{T}"/> that is used to compare 
        /// values in the <see cref="IEnumerable{T}"/> for uniqueness.
        /// </summary>
        protected IEqualityComparer<T> Comparer { get; set; }

        /// <summary>
        /// True if the order of iteration by the <see cref="IEnumerable{T}"/> 
        /// should be tested, false if otherwise.
        /// </summary>
        bool TestIterationOrder { get; set; }
    }
}