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

namespace Chernobyl.Collections.Generic.Event
{
    [TestFixture, Description("Tests for SelectManyEventEnumerable<TSource, TResult> type.")]
    public class SelectManyEventEnumerableTests : EnumerationTests<int>
    {
        public SelectManyEventEnumerableTests()
            : base(false)
        {}

        //------------------------------------------------------------------
        // Constructor Tests
        //------------------------------------------------------------------

        [Test, Description("Ensures the SelectManyEventEnumerable<TSource, TResult>(" +
            "IEventEnumerable<TSource>, Func<TSource, IEventEnumerable<TResult>>) " +
            "constructor throws an ArgumentNullException if the first argument is null.")]
        public void ConstructorFirstArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => CreateSelectManyEventEnumerable(null, tester => tester.Items));
        }

        [Test, Description("Ensures the SelectManyEventEnumerable<TSource, TResult>(" +
            "IEventEnumerable<TSource>, Func<TSource, IEventEnumerable<TResult>>) " +
            "constructor throws an ArgumentNullException if the second argument is null.")]
        public void ConstructorSecondArgumentNullException()
        {
            var source = new DecoratingEventList<Tester>();
            Assert.Throws<ArgumentNullException>(() => CreateSelectManyEventEnumerable(source, null));
        }

        //------------------------------------------------------------------
        // IEventEnumerable<T>.ItemsAdded Tests
        //------------------------------------------------------------------

        [Test, Description("Ensures the IEventEnumerable<T>.ItemsAdded event " +
            "is raised with the proper event data when a TSource containing a " +
            "TResult is added.")]
        public void ItemsAddedEventRaisedWhenFilledSourceAdded()
        {
            DecoratingEventList<Tester> testers = new DecoratingEventList<Tester>();

            const int firstItem = 1;
            const int secondItem = 2;

            SelectManyEventEnumerable<Tester, int> enumerable =
                CreateSelectManyEventEnumerable(testers, tester => tester.Items);
            enumerable.ItemsAdded += (sender, e) =>
                {
                    Assert.AreEqual(2, e.Items.Count(), "unexpected number of items added.");
                    Assert.AreEqual(firstItem, e.Items.ElementAt(0), "first item was an unexpected value.");
                    Assert.AreEqual(secondItem, e.Items.ElementAt(1), "second item was an unexpected value.");
                    Assert.Pass();
                };

            testers.Add(new Tester(firstItem, secondItem));

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

        [Test, Description("Ensures the IEventEnumerable<T>.ItemsAdded event " +
            "is raised with the proper event data when a TResult is added.")]
        public void ItemsAddedEventRaisedWhenResultAdded()
        {
            DecoratingEventList<Tester> testers = new DecoratingEventList<Tester>();
            Tester postTester = new Tester();
            testers.Add(postTester);

            const int firstItem = 1;

            SelectManyEventEnumerable<Tester, int> enumerable =
                CreateSelectManyEventEnumerable(testers, tester => tester.Items);
            enumerable.ItemsAdded += (sender, e) =>
            {
                Assert.AreEqual(1, e.Items.Count(), "unexpected number of items added.");
                Assert.AreEqual(firstItem, e.Items.ElementAt(0), "first item was an unexpected value.");
                Assert.Pass();
            };

            postTester.Items.Add(firstItem);

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

        [Test, Description("Ensures the IEventEnumerable<T>.ItemsAdded event " +
            "is not raised when an empty TSource is added.")]
        public void ItemsAddedEventNotRaisedWhenEmptySourceAdded()
        {
            DecoratingEventList<Tester> testers = new DecoratingEventList<Tester>();

            SelectManyEventEnumerable<Tester, int> enumerable =
                CreateSelectManyEventEnumerable(testers, tester => tester.Items);
            enumerable.ItemsAdded += (sender, e) => Assert.Fail("IEventEnumerable<T>.ItemsAdded was raised");

            testers.Add(new Tester());

            Assert.Pass();
        }

        //------------------------------------------------------------------
        // IEventEnumerable<T>.ItemsRemoved Tests
        //------------------------------------------------------------------

        [Test, Description("Ensures the IEventEnumerable<T>.ItemsRemoved event " +
            "is raised with the proper event data when a TSource containing a " +
            "TResult is removed.")]
        public void ItemsRemovedEventRaisedWhenFilledSourceRemoved()
        {
            DecoratingEventList<Tester> testers = new DecoratingEventList<Tester>();
            const int item = 1;
            Tester postTester = new Tester(item);
            testers.Add(postTester);

            SelectManyEventEnumerable<Tester, int> enumerable =
                CreateSelectManyEventEnumerable(testers, tester => tester.Items);
            enumerable.ItemsRemoved += (sender, e) =>
            {
                Assert.AreEqual(1, e.Items.Count(), "unexpected number of items removed.");
                Assert.AreEqual(item, e.Items.ElementAt(0), "first item was an unexpected value.");
                Assert.Pass();
            };

            testers.Remove(postTester);

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

        [Test, Description("Ensures the IEventEnumerable<T>.ItemsRemoved event " +
            "is raised with the proper event data when a TResult is removed.")]
        public void ItemsRemovedEventRaisedWhenResultRemoved()
        {
            DecoratingEventList<Tester> testers = new DecoratingEventList<Tester>();
            const int item = 1;
            Tester postTester = new Tester(item);
            testers.Add(postTester);

            SelectManyEventEnumerable<Tester, int> enumerable =
                CreateSelectManyEventEnumerable(testers, tester => tester.Items);
            enumerable.ItemsRemoved += (sender, e) =>
            {
                Assert.AreEqual(1, e.Items.Count(), "unexpected number of items removed.");
                Assert.AreEqual(item, e.Items.ElementAt(0), "first item was an unexpected value.");
                Assert.Pass();
            };

            postTester.Items.Remove(item);

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

        [Test, Description("Ensures the IEventEnumerable<T>.ItemsRemoved event " +
            "is not raised when an empty TSource.")]
        public void ItemsRemovedEventNotRaisedWhenEmptySourceRemoved()
        {
            DecoratingEventList<Tester> testers = new DecoratingEventList<Tester>();
            Tester postTester = new Tester();
            testers.Add(postTester);

            SelectManyEventEnumerable<Tester, int> enumerable =
                CreateSelectManyEventEnumerable(testers, tester => tester.Items);
            enumerable.ItemsRemoved += (sender, e) => Assert.Fail("IEventEnumerable<T>.ItemsRemoved was raised");

            testers.Remove(postTester);

            Assert.Pass();
        }

        /// <summary>
        /// Creates the instance to be tested. This method should never return
        /// the same instance twice.
        /// </summary>
        /// <param name="source">A sequence of values to project.</param>
        /// <param name="selector">A transform function to apply to each element.</param>
        protected virtual SelectManyEventEnumerable<Tester, int>
            CreateSelectManyEventEnumerable(IEventEnumerable<Tester> source,
                                            Func<Tester, IEventEnumerable<int>> selector)
        {
            return new SelectManyEventEnumerable<Tester, int>(source, selector);
        }

        protected override IEnumerable<int> CreateSingleItemEnumerable()
        {
            DecoratingEventList<Tester> testers = new DecoratingEventList<Tester>();
            testers.Add(new Tester());
            testers.Add(new Tester(1));

            return CreateSelectManyEventEnumerable(testers, tester => tester.Items);
        }

        protected override IEnumerable<int> CreateManyItemEnumerable()
        {
            DecoratingEventList<Tester> testers = new DecoratingEventList<Tester>();

            // Test for sources added prior to being given to the
            // SelectManyEventEnumerable<TSource, TResult>
            testers.Add(new Tester());
            testers.Add(new Tester(1));

            SelectManyEventEnumerable<Tester, int> enumerable =
                CreateSelectManyEventEnumerable(testers, tester => tester.Items);

            // Test for sources added after to being given to the
            // SelectManyEventEnumerable<TSource, TResult>
            testers.Add(new Tester(2, 3));
            testers.Add(new Tester());

            // Test for results added after being given to the
            // SelectManyEventEnumerable<TSource, TResult>
            Tester postTester = new Tester();
            testers.Add(postTester);
            postTester.Items.Add(4);
            postTester.Items.Add(5);

            return enumerable;
        }

        /// <summary>
        /// A utility type to help test the
        /// <see cref="SelectManyEventEnumerable{TSource,TResult}"/>
        /// </summary>
        protected class Tester
        {
            public Tester(params int[] items)
            {
                Items = new DecoratingEventList<int>(new List<int>(items));
            }

            public DecoratingEventList<int> Items { get; private set; }
        }
    }
}