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

namespace Chernobyl.Collections.Generic.Event
{
    [TestFixture, Description("Tests for the SourceEventEnumerable<T> type.")]
    public class SourceEventEnumerableTests : EnumerationTests<int>
    {
        public SourceEventEnumerableTests()
            : base(true)
        {}

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

        [Test, Description("Ensures SourceEventEnumerable(IEventEnumerable<T>) accepts " +
            "a null argument as a valid argument.")]
        public void ConstructorNullArgumentAccepted()
        {
            SourceEventEnumerable<int> sourceEnumerable = CreateSourceEventEnumerable(null);
        }

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

        [Test, Description("Ensures SourceEventEnumerable<T> raises its " +
            "IEventEnumerable<T>.ItemsAdded event when SourceEventEnumerable<T>.Source " +
            "raises the same event.")]
        public void ItemsAddedRaisedWhenSourceRaisesSameEvent()
        {
            DecoratingEventList<int> items = new DecoratingEventList<int>();
            SourceEventEnumerable<int> sourceEnumerable = CreateSourceEventEnumerable(items);
            
            sourceEnumerable.ItemsAdded += (sender, args) => Assert.Pass();
            items.Add(1);

            Assert.Fail("IEventEnumerable<T>.ItemsAdded was not raised when it should have been.");
        }

        [Test, Description("Ensures SourceEventEnumerable<T> does NOT raise its " +
            "IEventEnumerable<T>.ItemsAdded event when SourceEventEnumerable<T>.Source " +
            "is set to another value.")]
        public void ItemsAddedNotRaisedWhenSourceIsSetToAnotherValue()
        {
            DecoratingEventList<int> items = new DecoratingEventList<int>();
            SourceEventEnumerable<int> sourceEnumerable = CreateSourceEventEnumerable(items);

            sourceEnumerable.ItemsAdded += (sender, args) => Assert.Fail("IEventEnumerable<T>.ItemsAdded " + 
                "was raised when it should NOT have been.");
            sourceEnumerable.Source = null;
            items.Add(1);
        }

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

        [Test, Description("Ensures SourceEventEnumerable<T> raises its " +
            "IEventEnumerable<T>.ItemsRemoved event when SourceEventEnumerable<T>.Source " +
            "raises the same event.")]
        public void ItemsRemovedRaisedWhenSourceRaisesSameEvent()
        {
            DecoratingEventList<int> items = new DecoratingEventList<int>();
            items.Add(1);
            SourceEventEnumerable<int> sourceEnumerable = CreateSourceEventEnumerable(items);

            sourceEnumerable.ItemsRemoved += (sender, args) => Assert.Pass();
            items.Remove(1);

            Assert.Fail("IEventEnumerable<T>.ItemsRemoved was not raised when it should have been.");
        }

        [Test, Description("Ensures SourceEventEnumerable<T> does NOT raise its " +
            "IEventEnumerable<T>.ItemsRemoved event when SourceEventEnumerable<T>.Source " +
            "is set to another value.")]
        public void ItemsRemovedNotRaisedWhenSourceIsSetToAnotherValue()
        {
            DecoratingEventList<int> items = new DecoratingEventList<int>();
            items.Add(1);
            SourceEventEnumerable<int> sourceEnumerable = CreateSourceEventEnumerable(items);

            sourceEnumerable.ItemsRemoved += (sender, args) => Assert.Fail("IEventEnumerable<T>.ItemsRemoved " +
                "was raised when it should NOT have been.");
            sourceEnumerable.Source = null;
            items.Remove(1);
        }

        //------------------------------------------------------------------
        // Utility
        //------------------------------------------------------------------

        /// <summary>
        /// Creates the <see cref="SourceEventEnumerable{T}"/> that is to be
        /// tested. This method should always create a new 
        /// <see cref="SourceEventEnumerable{T}"/> instance.
        /// </summary>
        /// <param name="source">The source of the items that are being enumerated 
        /// and the events that are raised. If null is specified then <c>this</c> 
        /// instance will be empty.</param>
        /// <returns>The <see cref="SourceEventEnumerable{T}"/> that is to be tested.</returns>
        protected virtual SourceEventEnumerable<int> CreateSourceEventEnumerable(IEventEnumerable<int> source)
        {
            return new SourceEventEnumerable<int>(source);
        }

        protected override IEnumerable<int> CreateSingleItemEnumerable()
        {
            DecoratingEventList<int> items = new DecoratingEventList<int>();
            items.Add(1);
            return CreateSourceEventEnumerable(items);
        }

        protected override IEnumerable<int> CreateManyItemEnumerable()
        {
            DecoratingEventList<int> items = new DecoratingEventList<int>();
            items.AddRange(_orderedItems);
            return CreateSourceEventEnumerable(items);
        }

        protected override IEnumerable<int> OrderedItems
        {
            get { return _orderedItems; }
        }

        int[] _orderedItems = new[] { 1, 2, 3, 4, 5, 6, 7 };
    }
}