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

namespace Chernobyl.Collections.Generic.Event
{
    // ReSharper disable ObjectCreationAsStatement

    [TestFixture, Description("Test for the AddRemove<T> type.")]
    public class AddRemoveTest
    {
        //----------------------------------------------------------------------
        // AddRemove(IEnumerable<T>, bool) Tests
        //----------------------------------------------------------------------

        [Test, Description("Ensures AddRemove(IEnumerable<T>, bool) throws an" +
                           "ArgumentNullException when the first argument is null.")]
        public void ConstructorIEnumerableBoolArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => new AddRemove<int>(null, true));
        }

        [Test, Description("Ensures that items are added to the value set on " +
                           "AddRemove<T>.Collection when the second argument " +
                           "of AddRemove(IEnumerable<T>, bool) is true.")]
        public void ItemsAddedWhenSecondArgumentIsTrueAndCollectionIsSet()
        {
            int[] items = new[] {1, 2, 3};
            AddRemove<int> addRemove = new AddRemove<int>(items, true);
            addRemove.Collection = new List<int>();

            Assert.AreEqual(items.Length, addRemove.Collection.Count,
                "The items were not added to AddRemove<T>.Collection when they " +
                "should have been.");
        }

        [Test, Description("Ensures that items are added to the value set on " +
                           "AddRemove<T>.Collection when the second argument " +
                           "of AddRemove(IEnumerable<T>, bool) is true.")]
        public void ItemsNotAddedWhenSecondArgumentIsFalseAndCollectionIsSet()
        {
            int[] items = new[] { 1, 2, 3 };
            AddRemove<int> addRemove = new AddRemove<int>(items, false);
            addRemove.Collection = new List<int>();

            Assert.AreEqual(0, addRemove.Collection.Count,
                "The items were added to AddRemove<T>.Collection when they should " +
                "not have been.");
        }

        //----------------------------------------------------------------------
        // AddRemove(IEnumerable<T>, ICollection<T>, bool) Tests
        //----------------------------------------------------------------------

        [Test, Description("Ensures AddRemove(IEnumerable<T>, ICollection<T>, bool) " +
                           "throws an ArgumentNullException when the first argument " +
                           "is null.")]
        public void ConstructorIEnumerableICollectionBoolArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => new AddRemove<int>(null, new List<int>(), true));
        }

        [Test, Description("Ensures AddRemove(IEnumerable<T>, ICollection<T>, bool) " +
                           "excepts a null second argument.")]
        public void ConstructorIEnumerableICollectionBoolExceptsNullSecondArgument()
        {
            AddRemove<int> addRemove = new AddRemove<int>(new[] { 1, 2, 3 }, null, true);
        }

        [Test, Description("Ensures AddRemove(IEnumerable<T>, ICollection<T>, bool) " +
                           "adds items when the third argument is true.")]
        public void ConstructorIEnumerableICollectionBoolAddsItemsWhenThirdArgumentIsTrue()
        {
            int[] items = new[] {1, 2, 3};
            AddRemove<int> addRemove = new AddRemove<int>(items, new List<int>(), true);

            Assert.AreEqual(items.Length, addRemove.Collection.Count,
                "The items were not added to AddRemove<T>.Collection when they " +
                "should have been.");
        }

        [Test, Description("Ensures AddRemove(IEnumerable<T>, ICollection<T>, bool) " +
                           "does NOT add items when the third argument is false.")]
        public void ConstructorIEnumerableICollectionBoolDoesNotAddItemsWhenThirdArgumentIsFalse()
        {
            AddRemove<int> addRemove = new AddRemove<int>(new[] { 1, 2, 3 }, new List<int>(), false);

            Assert.AreEqual(0, addRemove.Collection.Count,
                "The items were added to AddRemove<T>.Collection when they should " +
                "not have been.");
        }


        //----------------------------------------------------------------------
        // AddRemove<T>.Collection
        //----------------------------------------------------------------------

        [Test, Description("Ensures AddRemove<T>.Collection removes items from " +
                           "previous value and adds items to new value if " +
                           "AddRemove<T>.Add(object, EventArgs) was invoked previously.")]
        public void CollectionItemsRemovedFromPreviousValueAndAddedToNewValueIfAddWasInvokedPreviously()
        {
            int[] items = new[] { 1, 2, 3 };
            ICollection<int> oldCollection = new List<int>();
            AddRemove<int> addRemove = new AddRemove<int>(items, oldCollection, false);

            addRemove.Add(this, EventArgs.Empty);

            ICollection<int> newCollection = new List<int>();
            addRemove.Collection = newCollection;

            Assert.AreEqual(0, oldCollection.Count,
                "The items are in the previous value of AddRemove<T>.Collection " +
                "when they should not be.");
            Assert.AreEqual(items.Length, newCollection.Count,
                "The items are not in the previous value of AddRemove<T>.Collection " +
                "when they should be.");
        }

        [Test, Description("Ensures AddRemove<T>.Collection does not remove items " +
                           "from new value if AddRemove<T>.Remove(object, EventArgs) " +
                           "was invoked previously.")]
        public void CollectionItemsNotRemovedFromNewValueIfRemoveWasInvokedPreviously()
        {
            int[] items = new[] { 1, 2, 3 };
            ICollection<int> oldCollection = new List<int>();
            AddRemove<int> addRemove = new AddRemove<int>(items, oldCollection, true);

            addRemove.Remove(this, EventArgs.Empty);

            ICollection<int> newCollection = new List<int>();
            newCollection.AddRange(items);
            addRemove.Collection = newCollection;

            Assert.AreEqual(0, oldCollection.Count,
                "The items are in the previous value of AddRemove<T>.Collection " +
                "when they should not be.");
            Assert.AreEqual(items.Length, newCollection.Count,
                "The items are not in the previous value of AddRemove<T>.Collection " +
                "when they should be.");
        }

        [Test, Description("Ensures AddRemove<T>.Collection accepts null value.")]
        public void CollectionCanBeNull()
        {
            AddRemove<int> addRemove = new AddRemove<int>(new[] { 1, 2, 3 }, new List<int>(), true);
            addRemove.Collection = null;
        }

        //----------------------------------------------------------------------
        // AddRemove<T>.Add(object, EventArgs)
        //----------------------------------------------------------------------

        [Test, Description("Ensures AddRemove<T>.Add(object, EventArgs) adds " +
                           "items to AddRemove<T>.Collection.")]
        public void AddAddsItemsToCollection()
        {
            int[] items = new[] { 1, 2, 3 };
            AddRemove<int> addRemove = new AddRemove<int>(items, new List<int>(), false);

            addRemove.Add(this, EventArgs.Empty);
            Assert.AreEqual(items.Length, addRemove.Collection.Count,
                "The items were not added to AddRemove<T>.Collection when they " +
                "should have been.");
        }

        [Test, Description("Ensures AddRemove<T>.Add(object, EventArgs) does not " +
                           "add items to AddRemove<T>.Collection when it is null.")]
        public void AddDoesNotAddItemsToNullCollection()
        {
            int[] items = new[] { 1, 2, 3 };
            AddRemove<int> addRemove = new AddRemove<int>(items, null, false);

            addRemove.Add(this, EventArgs.Empty);
            Assert.AreEqual(null, addRemove.Collection,
                "AddRemove<T>.Collection should be null but it is not.");
        }

        //----------------------------------------------------------------------
        // AddRemove<T>.Remove(object, EventArgs)
        //----------------------------------------------------------------------

        [Test, Description("Ensures AddRemove<T>.Remove(object, EventArgs) removes " +
                           "items from AddRemove<T>.Collection.")]
        public void RemoveRemovesItemsFromCollection()
        {
            int[] items = new[] { 1, 2, 3 };
            AddRemove<int> addRemove = new AddRemove<int>(items, new List<int>(), true);

            addRemove.Remove(this, EventArgs.Empty);
            Assert.AreEqual(0, addRemove.Collection.Count,
                "The items were not removed from AddRemove<T>.Collection when they " +
                "should have been.");
        }

        [Test, Description("Ensures AddRemove<T>.Remove(object, EventArgs) does not " +
                           "remove items from AddRemove<T>.Collection when it is null.")]
        public void RemoveDoesNotRemoveItemsFromNullCollection()
        {
            int[] items = new[] { 1, 2, 3 };
            AddRemove<int> addRemove = new AddRemove<int>(items, null, true);

            addRemove.Remove(this, EventArgs.Empty);
            Assert.AreEqual(null, addRemove.Collection,
                "AddRemove<T>.Collection should be null but it is not.");
        }
    }

    // ReSharper restore ObjectCreationAsStatement
}