using System;
using System.Utility;
using Chernobyl.Event;
using NUnit.Framework;

namespace Chernobyl.Values
{
    /// <summary>
    /// Tests for types that implement <see cref="IValue{T}"/>
    /// </summary>
    public abstract class ValueTests<TValue, T> where TValue : IValue<T>
    {
        //----------------------------------------------------------------------
        // Ready Tests
        //----------------------------------------------------------------------

        [Test, Description("Ensures IValue<T>.Provide is raised when the " +
                   "IValue{T} is made ready.")]
        public virtual void ProvideRaisedWhenMadeReady()
        {
            Wrapper tested = CreateValue();

            InvokeTester tester = new InvokeTester("IReadyable<T>.BecameReady " +
                                                   "should not have been invoked.");
            tested.TestInstance.Provide += tester.EventHandler;
            tester.Pass = true;
            tested.MakeReady();

            Assert.Fail("IReadyable<T>.BecameReady was not invoked when intended.");
        }

        [Test, Description("Ensures that event handlers that are added to " +
                           "IValue<T>.Provide are invoked when added to a ready" +
                           "IValue<T>.")]
        public virtual void EventHandlersAddedToReadyValueAreInvokedWhenAdded()
        {
            Wrapper tested = CreateValue();

            InvokeTester tester = new InvokeTester(true, "IReadyable<T>.BecameReady " +
                                                   "should not have been invoked.");
            tested.MakeReady();
            tested.TestInstance.Provide += tester.EventHandler;

            Assert.Fail("IReadyable<T>.BecameReady was not invoked when intended.");
        }

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

        [Test, Description("A test to ensure that changing the internal value of " +
                           "IValue<T> to another value raises the IValue<T>.Provide event.")]
        public virtual void ProvideRaisedWhenValueChanged()
        {
            Wrapper wrapper = CreateValue();
            wrapper.MakeReady();
            TValue value = wrapper.TestInstance;

            // Provide will invoke the first time it is added so we make sure
            // the first run is a no-op.
            EventHandler<ValueChangedEventArgs<T>> invoke = (sender, e) => { /*no-op*/ };
            value.Provide += (sender, e) => invoke(sender, e);
            
            // Now we can provide the method we actually want to run.
            invoke += (sender, e) =>
            {
                e.OldValue.IsEqualTo(wrapper.ReadyValue, "ValueChangedEventArgs.OldValue");
                e.NewValue.IsEqualTo(wrapper.FinalValue, "ValueChangedEventArgs.NewValue");
                Assert.Pass();
            };
            wrapper.ChangeValue();

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

        [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.")]
        public virtual void ProvideNotRaisedWhenValueIsNotChanged()
        {
            Wrapper wrapper = CreateValue();
            wrapper.MakeReady();
            TValue value = wrapper.TestInstance;

            // Provide will invoke the first time it is added so we make sure
            // the first run is a no-op.
            EventHandler<ValueChangedEventArgs<T>> invoke = (sender, e) => { /*no-op*/ };
            value.Provide += (sender, e) => invoke(sender, e);

            // Now we can provide the method we actually want to run.
            invoke += (sender, e) =>
                Assert.Fail("IValue<T>.Provide was raised when it should not have been.");
            wrapper.FakeChangeValue();

            Assert.Pass();
        }

        [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.")]
        public virtual void ProvideRaisedWhenValueIsNotChangedButIsMadeReady()
        {
            Wrapper wrapper = CreateValue();
            TValue value = wrapper.TestInstance;

            // Provide will invoke the first time it is added so we make sure
            // the first run is a no-op.
            EventHandler<ValueChangedEventArgs<T>> invoke = (sender, e) => { /*no-op*/ };
            value.Provide += (sender, e) => invoke(sender, e);

            // Now we can provide the method we actually want to run.
            invoke += (sender, e) => Assert.Pass();
            wrapper.FakeChangeValue();

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

        /// <summary>
        /// The <see cref="IValue{T}"/> that is to be tested. The value contained 
        /// by the returned instance must be equal to <see cref="Wrapper.ReadyValue"/>.
        /// The instance returned should never be re-used.
        /// </summary>
        /// <returns>The instance that is to be tested.</returns>
        protected abstract Wrapper CreateValue();

        /// <summary>
        /// A type used to contain and operate on the instance to be tested.
        /// </summary>
        protected abstract class Wrapper
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="Wrapper" /> class.
            /// </summary>
            /// <param name="testInstance">The instance that is to be tested.</param>
            /// <param name="readyValue">The value of the instance contained 
            /// within the <see cref="IValue{T}"/> created by <see cref="CreateValue()"/>.</param>
            /// <param name="finalValue">The value of the instance contained 
            /// within the <see cref="IValue{T}"/> when <see cref="ChangeValue()"/> 
            /// is invoked upon it.</param>
            protected Wrapper(TValue testInstance, T readyValue, T finalValue)
            {
                TestInstance = testInstance;
                ReadyValue = readyValue;
                FinalValue = finalValue;
            }

            /// <summary>
            /// The instance that is to be tested.
            /// </summary>
            public TValue TestInstance { get; protected set; }

            /// <summary>
            /// Makes the <see cref="TestInstance"/> ready.
            /// </summary>
            public abstract void MakeReady();

            /// <summary>
            /// Modifies the internal value of the <see cref="TestInstance"/> to 
            /// be equal to <see cref="FinalValue"/>.
            /// </summary>
            public abstract void ChangeValue();

            /// <summary>
            /// Modifies the value of the <see cref="TestInstance"/> to be equal 
            /// to <see cref="ReadyValue"/>. In other words the value should 
            /// not be changed but <see cref="TValue"/> should still be acted 
            /// upon as if it was being changed.
            /// </summary>
            public abstract void FakeChangeValue();

            /// <summary>
            /// The value of the instance contained within the <see cref="IValue{T}"/>
            /// created by <see cref="CreateValue()"/>.
            /// </summary>
            public T ReadyValue { get; protected set; }

            /// <summary>
            /// The value of the instance contained within the <see cref="IValue{T}"/>
            /// when <see cref="ChangeValue()"/> is invoked upon it.
            /// </summary>
            public T FinalValue { get; protected set; }
        }
    }
}