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

namespace Chernobyl.Reflection
{
    /// <summary>
    /// Tests for the <see cref="ReturnValue{T}"/> type.
    /// </summary>
    public class ReturnValueTests : ValueTests<ReturnValue<string>, string>
    {
        //----------------------------------------------------------------------
        // 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("Test not required since ReturnValue<T> is only made ready when " +
                "all IValue<T> instance's it holds are made ready.")]
        public override void ProvideRaisedWhenValueIsNotChangedButIsMadeReady()
        { }

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

        protected virtual ReturnValue<string> CreateReturnValue(
            IValue<Object> instance,
            MethodBase method,
            IEventEnumerable<IValue<Object>> parameters)
        {
            return new ReturnValue<string>(instance, method, parameters);
        }

        protected override Wrapper CreateValue()
        {
            var parameters = new[]
            {
                new DynamicContainer<object>(Strings[0]),
                new DynamicContainer<object>(null)
            };

            MethodInfo concatMethod = GetType().GetMethod("Concat",
                BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly);
            return new ReturnValueWrapper(
                CreateReturnValue(new BasicContainer<object>(this), concatMethod,
                                  new DecoratingEventList<IValue<object>>(new[] { parameters[0], parameters[1].NotNull() })),
                                  parameters, Strings[0] + Strings[1], 
                                  Strings[0] + Strings[2]);
        }

        /// <summary>
        /// Strings used for testing purposes.
        /// </summary>
        internal static readonly string[] Strings = { "hello", " Bob", " John" };

        protected static string Concat(string first, string second)
        {
            return first + second;
        }

        class ReturnValueWrapper : Wrapper
        {
            public ReturnValueWrapper(ReturnValue<string> testInstance,
                                      IDynamicContainer<Object>[] parameters,
                                      string readyValue,
                                      string finalValue)
                : base(testInstance, readyValue, finalValue)
            {
                _parameters = parameters;
            }

            public override void MakeReady()
            {
                _parameters[1].Value = Strings[1];
            }

            public override void ChangeValue()
            {
                _parameters[1].Value = Strings[2];
            }

            public override void FakeChangeValue()
            {
                _parameters[0].Value = Strings[0];
            }

            IDynamicContainer<Object>[] _parameters;
        }
    }
}