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

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// Tests for <see cref="IEventCollection{T}" /> types.
    /// </summary>
    /// <typeparam name="T">The type held by the <see cref="IEventCollection{T}" />
    /// being tested.</typeparam>
    public abstract class EventCollectionTests<T> : CollectionTests<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="EventCollectionTests{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="EnumerationTests{T}.OrderedItems" /> property.</param>
        protected EventCollectionTests(bool testIterationOrder)
            : base(testIterationOrder)
        {}

        [Test, Description("Ensures ICollection<T>.Add(T) reports the items " + 
            "added through IEventCollection<T>.ItemsAdded.")]
        public void AddReportsItems()
        {
            IEventCollection<T> collection = CreateSingleItemEventCollection();

            T itemToAdd = CreateItem();
            collection.ItemsAdded += (sender, args) =>
                {
                    Assert.AreEqual(1, args.Items.Length, "Only one items was " +
                        "added yet IEventCollection<T>.ItemsAdded does not report " +
                        "this.");
                    Assert.AreEqual(itemToAdd, args.Items[0], "The value added is not " +
                        "the value being reported by IEventCollection<T>.ItemsAdded.");
                    Assert.Pass();
                };

            collection.Add(itemToAdd);

            Assert.Fail("IEventCollection<T>.ItemsAdded was not raised.");
        }

        [Test, Description("Ensures ICollection<T>.Remove(T) reports the items " +
            "removed through IEventCollection<T>.ItemsRemoved.")]
        public void RemoveReportsItems()
        {
            IEventCollection<T> collection = CreateSingleItemEventCollection();

            T itemToAdd = CreateItem();
            collection.Add(itemToAdd);

            collection.ItemsRemoved += (sender, args) =>
            {
                Assert.AreEqual(1, args.Items.Length, "Only one items was " +
                    "removed yet IEventCollection<T>.ItemsRemoved does not report " +
                    "this.");
                Assert.AreEqual(itemToAdd, args.Items[0], "The value removed is not " +
                    "the value being reported by IEventCollection<T>.ItemsRemoved.");
                Assert.Pass();
            };

            collection.Remove(itemToAdd);

            Assert.Fail("IEventCollection<T>.ItemsRemoved was not raised.");
        }

        [Test, Description("Ensures ICollection<T>.Clear() reports the items " +
            "removed through IEventCollection<T>.ItemsRemoved.")]
        public void ClearReportsItems()
        {
            IEventCollection<T> collection = CreateSingleItemEventCollection();

            T itemToRemove = collection.First();

            collection.ItemsRemoved += (sender, args) =>
            {
                Assert.AreEqual(1, args.Items.Length, "Only one items was " +
                    "removed yet IEventCollection<T>.ItemsRemoved does not report " +
                    "this.");
                Assert.AreEqual(itemToRemove, args.Items[0], "The value removed is not " +
                    "the value being reported by IEventCollection<T>.ItemsRemoved.");
                Assert.Pass();
            };

            collection.Clear();

            Assert.Fail("IEventCollection<T>.ItemsRemoved was not raised.");
        }

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

        /// <summary>
        /// This method should return a new <see cref="IEventCollection{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="IEventCollection{T}"/> every time it is invoked and not 
        /// reuse instances. All instances returned  through iteration of the 
        /// <see cref="IEventCollection{T}"/> should be unique.
        /// </summary>
        /// <returns>The <see cref="IEventCollection{T}"/> containing many items.</returns>
        protected abstract IEventCollection<T> CreateManyItemEventCollection();

        protected override ICollection<T> CreateCollection()
        {
            return CreateManyItemEventCollection();
        }

        protected override ICollection<T> CreateReadOnlyCollection()
        {
            // Read only IEventCollection<T> not supported.
            return null;
        }

        protected override IEnumerable<T> CreateSingleItemEnumerable()
        {
            return CreateSingleItemEventCollection();
        }

        protected override IEnumerable<T> CreateManyItemEnumerable()
        {
            return CreateManyItemEventCollection();
        }
    }
}