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

namespace Chernobyl.Values
{
    [TestFixture, Description("A set of tests for the DynamicContainer<T> type.")]
    public class DynamicContainerImplementationTests : ValueTests<DynamicContainer<int>, int>
    {
        //-----------------------------------------------------------------
        // Constructor Tests
        //-----------------------------------------------------------------

        [Test, Description("A test to ensure that the values passed to " +
            "DynamicContainer(T, IComparer<T>) are the correct values on the " +
            "properties themselves after construction.")]
        public void ConstructorValueComparerIsCorrect()
        {
            IEqualityComparer<int> comparer = new Comparer();
            DynamicContainer<int> container = new DynamicContainer<int>(3, comparer);

            Assert.AreEqual(3, container.Value, "DynamicContainer<T>.Value is not the expected container.");
            Assert.AreEqual(comparer, container.Comparer, "DynamicContainer<T>.Comparer is not the expected container.");
        }

        [Test, Description("A test to ensure that the value passed to " +
            "DynamicContainer(T) is the correct value on the property itself.")]
        public void ConstructorValue()
        {
            DynamicContainer<int> container = new DynamicContainer<int>(3);

            Assert.AreEqual(3, container.Value, "DynamicContainer<T>.Value is not the expected container.");
        }

        //-----------------------------------------------------------------
        // DynamicContainer<T>.Comparer Tests
        //-----------------------------------------------------------------

        [Test, Description("A test to ensure that DynamicContainer<T>.Comparer throws " +
            "an ArgumentNullException when it is set to a null value")]
        public void ComparerArgumentNullException()
        {
            DynamicContainer<int> container = new DynamicContainer<int>(3);
            Assert.Throws<ArgumentNullException>(() => container.Comparer = null);
        }

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

        [Test, Description("Ensures IValue<T>.Provide is raised when the " +
                   "IValue{T} is made ready.")]
        [Ignore("DynamicContainer 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("DynamicContainer 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 raises the " +
                           "IValue<T>.Provide event if the IValue<T> is not ready. " +
                           "Override this test if it is not applicable.")]
        [Ignore("DynamicContainer doesn't become ready.")]
        public override void ProvideRaisedWhenValueIsNotChangedButIsMadeReady()
        {}

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

        /// <summary>
        /// A helper <see cref="IComparer{T}"/> used for testing.
        /// </summary>
        public class Comparer : IEqualityComparer<int>
        {
            public bool Equals(int x, int y)
            {
                return x.Equals(y);
            }

            public int GetHashCode(int obj)
            {
                return obj.GetHashCode();
            }
        }

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

        protected new class Wrapper : ValueTests<DynamicContainer<int>, int>.Wrapper
        {
            public Wrapper()
                : base(new DynamicContainer<int>(3), 3, 4)
            {}

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

            public override void ChangeValue()
            {
                TestInstance.Value = FinalValue;
            }

            public override void FakeChangeValue()
            {
                TestInstance.Value = ReadyValue;
            }
        }
    }
}