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

namespace Chernobyl.Creation.Collections
{
    [TestFixture, Description("Tests for the BuilderCollection<T> type.")]
    public class BuilderCollectionTests : BuilderEnumerableTests
    {
        [Test, Description("Ensures that BuilderCollection<T>() constructor " +
            "builds the item as expected.")]
        public void DefaultConstructor()
        {
            BuilderCollection<IBuilder<int>, int> test = new BuilderCollection<IBuilder<int>, int>();
            Assert.False(test.Any());
        }

        [Test, Description("Ensures that when IBuilder<T> instances are added " +
            "using BuilderCollection{T}.Add(T) they can raise the " +
            "BuilderCollection{T}.Created event when necessary.")]
        public void AddedInstancesCanRaiseCreated()
        {
             BuilderCollection<IBuilder<int>, int> test = CreateBuilderCollection(Enumerable.Empty<IBuilder<int>>());
            test.Created += (sender, e) => Assert.Pass("IBuilder<T>.Created event was raised.");

            IFactory<int> factory = new DefaultConstructorFactory<int>();
            test.Add(factory);
            factory.Create();

            Assert.Fail("IBuilder<T>.Created event was not raised.");
        }

        [Test, Description("Ensures that when IBuilder<T> instances are removed " +
            "using BuilderCollection{T}.Remove(T) they do not raise the " +
            "BuilderCollection{T}.Created event when applicable.")]
        public void RemovedInstancesDoNotRaiseCreated()
        {
            IFactory<int> factory = new DefaultConstructorFactory<int>();
             BuilderCollection<IBuilder<int>, int> test = CreateBuilderCollection(new[] { factory });
            test.Created += (sender, e) => Assert.Fail("IBuilder<T>.Created event was raised.");

            test.Remove(factory);
            factory.Create();
        }

        [Test, Description("Ensures that when IBuilder<T> instances are removed " +
            "using BuilderCollection{T}.Clear() they do not raise the " +
            "BuilderCollection{T}.Created event when applicable.")]
        public void ClearedInstancesDoNotRaiseCreated()
        {
            IFactory<int> factory = new DefaultConstructorFactory<int>();
            BuilderCollection<IBuilder<int>, int> test = CreateBuilderCollection(new[] { factory });
            test.Created += (sender, e) => Assert.Fail("IBuilder<T>.Created event was raised.");

            test.Clear();
            factory.Create();
        }

        /// <summary>
        /// Creates the instances that are to be tested. This method should be
        /// overridden by any set of tests that are testing types derived from
        /// <see cref="BuilderEnumerable{TFactory, TItem}"/>. This method must
        /// return a new instance every time it is called.
        /// </summary>
        /// <param name="builders">The <see cref="IBuilder{T}"/> instances to
        /// be taken by the types constructor.</param>
        /// <returns>The instance that is to be tested.</returns>
        protected virtual BuilderCollection<IBuilder<int>, int> CreateBuilderCollection(IEnumerable<IBuilder<int>> builders)
        {
            return new BuilderCollection<IBuilder<int>, int>(builders);
        }

        [TestFixture, Description("Tests for the ICollection<T> portion of the " +
            "BuilderCollection<T> type.")]
        public class CollectionTests : CollectionTests<IBuilder<int>>
        {
            public CollectionTests()
            : base(false)
            {}

            protected override ICollection<IBuilder<int>> CreateCollection()
            {
                BuilderCollection<IBuilder<int>, int> collection = new BuilderCollection<IBuilder<int>, int>(new[]
                                       {
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>(),
                                           new DefaultConstructorFactory<int>()
                                       });
                return collection;
            }

            protected override ICollection<IBuilder<int>> CreateReadOnlyCollection()
            {
                // Read only BuilderCollection<T> not supported.
                return null;
            }

            protected override IBuilder<int> CreateItem()
            {
                return new DefaultConstructorFactory<int>();
            }
        }

        protected override BuilderEnumerable<IBuilder<int>, int> CreateBuilderEnumerable(IEnumerable<IBuilder<int>> builders)
        {
            return CreateBuilderCollection(builders);
        }
    }
}