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

namespace Chernobyl.Values
{
    /// <summary>
    /// Tests for the <see cref="Composite{T}"/> type.
    /// </summary>
    public class CompositeTests : ValueTests<Composite<string>, IEnumerable<string>>
    {
        [Test, Description("Ensures the Composite<T> throws an ArgumentNullException " +
                           "when given a null constructor argument.")]
        public virtual void ConstructorArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => CreateComposite(null));
        }

        [Test, Description("Ensures the Composite<T> reports properly handles " +
                           "cases where there are several items.")]
        public virtual void SeveralItemsTest()
        {
            var containers = new[]
            {
                new DynamicContainer<string>(Strings[0]),
                new DynamicContainer<string>(Strings[1])
            };

            Composite<string> composite = CreateComposite(containers);
            composite.Provide += (sender, args) =>
            {
                // Check the number of items.
                args.NewValue.Count().IsEqualTo(containers.Length,
                                                "Composite<T> count");

                // Check each of the values.
                for (int i = 0; i < containers.Length; i++)
                {
                    args.NewValue.ElementAt(i).IsEqualTo(containers[i].Value,
                                                         "Composite<T> " +
                                                         "item at index " + i);
                }

                Assert.Pass();
            };

            Assert.Fail("The IValue<T>.Provide event on Composite<T> was not raised.");
        }

        [Test, Description("Ensures the Composite<T> reports properly handles " +
                           "cases where there are several items.")]
        public virtual void NoItemsTest()
        {
            Composite<string> composite = CreateComposite(Enumerable.Empty<IValue<string>>());
            composite.Provide += (sender, args) =>
            {
                // Check the number of items.
                args.NewValue.Count().IsEqualTo(0, "Composite<string> count");

                Assert.Pass();
            };

            Assert.Fail("The IValue<T>.Provide event on Composite<T> was not raised.");
        }

        //----------------------------------------------------------------------
        // 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 Composite<T> is only made ready when " +
                "all IValue<T> instance's it holds are made ready.")]
        public override void ProvideRaisedWhenValueIsNotChangedButIsMadeReady()
        {}

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

        /// <summary>
        /// Creates a new instance of the type to be tested.
        /// </summary>
        /// <param name="values">The instance to be given to the constructor.</param>
        /// <returns>
        /// The instance to be tested.
        /// </returns>
        protected virtual Composite<string> CreateComposite(IEnumerable<IValue<string>> values)
        {
            return new Composite<string>(values);
        }

        protected override Wrapper CreateValue()
        {
            var containers = new[]
            {
                new DynamicContainer<string>(ReadyValue[0]),

                // Set the second value to null so that we can later make it
                // ready by setting it to non-null.
                new DynamicContainer<string>(null)
            };

            return new CompositeWrapper(
                CreateComposite(new[] { containers[0], containers[1].NotNull() }),
                    containers, ReadyValue, FinalValue);
        }

        /// <summary>
        /// Strings used for testing purposes.
        /// </summary>
        protected static readonly string[] Strings = { "Apple", "Pear", "Grape" };
        protected static readonly string[] ReadyValue = { Strings[0], null };
        protected static readonly string[] FinalValue = { Strings[2], Strings[1] };

        class CompositeWrapper : Wrapper
        {
            public CompositeWrapper(Composite<string> testInstance,
                                    IEnumerable<IDynamicContainer<string>> containers,
                                    IEnumerable<string> readyValue, IEnumerable<string> finalValue)
                : base(testInstance, readyValue, finalValue)
            {
                _containers = containers;
            }

            public override void MakeReady()
            {
                // Changing the second container from null to non-null will make
                // the type ready. Note that we use the "FinalValue" here. This
                // is because ChangeValue only changes one of the values. The
                // check that verifies the value assumes both have become the
                // FinalValue.
                _containers.ElementAt(1).Value = FinalValue.ElementAt(1);
            }

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

            public override void FakeChangeValue()
            {
                _containers.First().Value = _containers.First().Value;
            }

            IEnumerable<IDynamicContainer<string>> _containers;
        }
    }
}