using System;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Event;
using NUnit.Framework;
// ReSharper disable ObjectCreationAsStatement

namespace Chernobyl.Creation.Collections
{
    [TestFixture, Description("Tests for the Warehouse type.")]
    public class WarehouseTests : EnumerationTests<int>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="WarehouseTests"/> class.
        /// </summary>
        public WarehouseTests()
            : base(true)
        {}

        [Test, Description("Ensures that the Warehouse<T>(IBuilder<T>, ICollection<T>) " +
                           "constructor throws an exception when its first argument " +
                           "is null.")]
        public void ConstructorExceptionOnNullFirstArgument()
        {
            Assert.Throws<ArgumentNullException>(() => new Warehouse<int>(null, new List<int>()));
        }

        [Test, Description("Ensures that the Warehouse<T>(IBuilder<T>, ICollection<T>) " +
                           "constructor throws an exception when its second argument " +
                           "is null.")]
        public void ConstructorExceptionOnNullSecondArgument()
        {
            Assert.Throws<ArgumentNullException>(() => new Warehouse<int>(new Builder(), null));
        }

        [Test, Description("Ensures that the Warehouse<T> does not store an item " +
                           "or cause a crash when construction has been canceled.")]
        public void DontStoreOnCancellation()
        {
            Builder builder = new Builder();
            Warehouse<int> warehouse = new Warehouse<int>(builder);
            builder.Cancel();

            Assert.False(warehouse.Any());
        }

        [Test, Description("Ensures that the Warehouse<T> does not store an item " +
                           "or cause a crash when construction has resulted in an " +
                           "error.")]
        public void DontStoreOnError()
        {
            Builder builder = new Builder();
            Warehouse<int> warehouse = new Warehouse<int>(builder);
            builder.Error();

            Assert.False(warehouse.Any());
        }

        protected override IEnumerable<int> CreateSingleItemEnumerable()
        {
            // The EnumerationTests<T> base class will be used to ensure the
            // Warehouse<T> properly stores an item from an IBuilder<T> that is
            // passed to its constructor.

            Builder builder = new Builder();
            Warehouse<int> warehouse = new Warehouse<int>(builder);
            builder.Create(5);

            return warehouse;
        }

        protected override IEnumerable<int> CreateManyItemEnumerable()
        {
            // The EnumerationTests<T> base class will be used to ensure the
            // Warehouse<T> properly stores an item from an IBuilder<T> that is
            // passed to its constructor and stores items that are passed to it
            // using its Warehouse<T>.OnItemCreated(object, CreationEventArgs<T>)
            // event handler method.

            // One builder will be passed into the constructor.
            Builder builder1 = new Builder();
            Warehouse<int> warehouse = new Warehouse<int>(builder1);

            // The other builder will use the Warehouse<int>.OnItemCreated method.
            Builder builder2 = new Builder();
            builder2.Created += warehouse.OnItemCreated;

            builder2.Create(1);
            builder1.Create(2);
            builder2.Create(3);
            builder1.Create(4);
            builder2.Create(5);

            return warehouse;
        }

        /// <summary>
        /// Returns the items created by <see cref="CreateManyItemEnumerable()"/>
        /// are expected to be in.
        /// </summary>
        protected override IEnumerable<int> OrderedItems => new[] { 1, 2, 3, 4, 5 };

        /// <summary>
        /// An <see cref="IBuilder{T}"/> used as a helper class to test
        /// <see cref="Warehouse{T}"/> functionality.
        /// </summary>
        class Builder : Builder<int>
        {
            /// <summary>
            /// Causes the <see cref="Builder{TResult}.Created"/> event to be raised with the
            /// passed in values as the created item.
            /// </summary>
            /// <param name="value">The value to "create".</param>
            public void Create(int value)
            {
                CreatedMethod?.Invoke(this, new CreationEventArgs<int>(value));
            }

            /// <summary>
            /// Causes the <see cref="Builder{TResult}.Created"/> event to be raised as if
            /// construction of an item was canceled.
            /// </summary>
            public void Cancel()
            {
                CreatedMethod?.Invoke(this, new CreationEventArgs<int>(true));
            }

            /// <summary>
            /// Causes the <see cref="Builder{TResult}.Created"/> event to be raised as if
            /// construction of an item resulted in an error.
            /// </summary>
            public void Error()
            {
                CreatedMethod?.Invoke(this, new CreationEventArgs<int>(new Exception()));
            }
        }
    }
}