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

namespace Chernobyl.Values
{
    [TestFixture, Description("Tests for the First<T> type.")]
    public class FirstTests : ValueTests<First<int>, int>
    {
        //------------------------------------------------------------------
        // First(IEventEnumerable<T>) Tests.
        //------------------------------------------------------------------

        [Test, Description("Ensures First(IEventEnumerable<T>) throws an " +
            "ArgumentNullException when the argument is null.")]
        public void ConstructorIEventEnumerableArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => CreateFirst(null));
        }

        //------------------------------------------------------------------
        // First(IEventEnumerable<T>, IComparer<int>) Tests.
        //------------------------------------------------------------------

        [Test, Description("Ensures First(IEventEnumerable<T>, IComparer<int>) " +
            "throws an ArgumentNullException when the first argument is null.")]
        public void ConstructorIEventEnumerableIComparerFirstArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => CreateFirst(null, EqualityComparer<int>.Default));
        }

        [Test, Description("Ensures First(IEventEnumerable<T>, IComparer<int>) " +
            "throws an ArgumentNullException when the first argument is null.")]
        public void ConstructorIEventEnumerableIComparerSecondArgumentNullException()
        {
            var list = new DecoratingEventList<int>();
            Assert.Throws<ArgumentNullException>(() => CreateFirst(list, null));
        }

        //----------------------------------------------------------------------
        // Ready Tests
        //----------------------------------------------------------------------

        [Test, Description("Ensures IValue<T>.Provide is raised when the " +
                   "IValue{T} is made ready.")]
        [Ignore("First doesn't become ready.")]
        public override void ProvideRaisedWhenMadeReady()
        {}

        [Test, Description("Ensures that event handlers that are added to " +
                           "IValue<T>.Provide are invoked when added to a ready" +
                           "IValue<T>.")]
        [Ignore("First doesn't become ready.")]
        public override void EventHandlersAddedToReadyValueAreInvokedWhenAdded()
        {}

        //------------------------------------------------------------------
        // Change Tests
        //------------------------------------------------------------------

        [Test, Description("A test to ensure that setting the internal value of " +
                           "IValue<T> to the value it is already set at does not raise the " +
                           "IValue<T>.Provide event. Override this test if it is not applicable.")]
        [Ignore("Fake value changes are not possible with this type.")]
        public override void ProvideNotRaisedWhenValueIsNotChanged()
        {}

        [Test, Description("A test to ensure that setting the internal value of " +
                           "IValue<T> to the value it is already set at raises the " +
                           "IValue<T>.Provide event if the IValue<T> is not ready. " +
                           "Override this test if it is not applicable.")]
        [Ignore("Fake value changes are not possible with this type.")]
        public override void ProvideRaisedWhenValueIsNotChangedButIsMadeReady()
        {}

        //------------------------------------------------------------------
        // Utility Methods
        //------------------------------------------------------------------

        /// <summary>
        /// Creates an <see cref="First{T}"/> instance to test. This method will
        /// always return a new instance and never return old instances.
        /// </summary>
        /// <param name="enumerable">The <see cref="IEventEnumerable{T}" /> that
        /// is to be watched for changes to its first item.</param>
        /// <returns>The instance to test.</returns>
        protected virtual First<int> CreateFirst(IEventEnumerable<int> enumerable)
        {
            return new First<int>(enumerable);
        }

        /// <summary>
        /// Creates an <see cref="First{T}"/> instance to test. This method will
        /// always return a new instance and never return old instances.
        /// </summary>
        /// <param name="enumerable">The <see cref="IEventEnumerable{T}" /> that
        /// is to be watched for changes to its first item.</param>
        /// <param name="comparer">The instance that is used to check if the
        /// <paramref name="enumerable"/> instance's latest first is equal to it's
        /// previous first and therefore results in a change.</param>
        /// <returns>The instance to test.</returns>
        protected virtual First<int> CreateFirst(IEventEnumerable<int> enumerable, IEqualityComparer<int> comparer)
        {
            return new First<int>(enumerable, comparer);
        }

        protected override ValueTests<First<int>, int>.Wrapper CreateValue()
        {
            return new Wrapper();
        }

        protected new class Wrapper : ValueTests<First<int>, int>.Wrapper
        {
            public Wrapper()
                : base(null, 1, 0)
            {
                _list = new DecoratingEventList<int>();
                _list.Add(ReadyValue);
                TestInstance = new First<int>(_list);
            }

            public override void MakeReady()
            {
                // Not needed. First doesn't become ready.
            }

            public override void ChangeValue()
            {
                _list.Remove(ReadyValue);
            }

            public override void FakeChangeValue()
            {
                // Mock value changes are not possible with this type.
                throw new NotImplementedException();
            }

            DecoratingEventList<int> _list;
        }
    }
}