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

namespace Chernobyl.Mathematics.Collision
{
    /// <summary>
    /// A reusable test fixture base class that tests 
    /// <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> types.
    /// </summary>
    /// <typeparam name="TContainedCollidable">The type of 
    /// <see cref="IExtendedCollidable{TCollider}"/> contained within the 
    /// <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> to be 
    /// tested.</typeparam>
    /// <typeparam name="TCollider">The type of 
    /// <see cref="IExtendedCollidable{TCollider}"/> that can collide with the 
    /// <see cref="IExtendedCollidable{TCollider}"/>s contained in the 
    /// <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> to be
    /// tested.</typeparam>
    public abstract class CollidableEnumerableTests<TContainedCollidable, TCollider>
        where TContainedCollidable : IExtendedCollidable<TCollider>
    {
        [Test, Description("Tests the " +
                           "ICollidableEnumerable<TContainedCollidable, TCollider>.GetCollidables(TCollider collidable) " + 
                           "method to see if it returns the proper collidable when " +
                           "passed a collider that should collide with that collidable.")]
        public void FindsCollidable()
        {
            ICollidableEnumerable<TContainedCollidable, TCollider> collidableCollection = CreateAndCheckCollisionEnumerable();
            TCollider collider = CreateCollider();
            
            IEnumerable<TContainedCollidable> collidables = collidableCollection.GetCollidables(collider);
            TContainedCollidable collided = GetCollided();

            int collidablesCount = collidables.Count();
            Assert.True(collidablesCount == 1, "There should have only been one " +
                                               "collidable that was collided with. But \"" + 
                                               collidablesCount + "\" were collided against.");

            Assert.AreEqual(collided, collidables.First(), "The collidable that " + 
                                                           "was collided against was not the collidable that was expected.");
        }

        [Test, Description("Tests the " +
                           "ICollidableEnumerable<TContainedCollidable, TCollider>.GetCollidables(TCollider collidable) " +
                           "method to see if it properly returns no collidable when " +
                           "passed a collider that should not collide with anything in the " +
                           "ICollidableEnumerable<TContainedCollidable, TCollider>.")]
        public void FindsNoCollidables()
        {
            ICollidableEnumerable<TContainedCollidable, TCollider> collidableCollection = CreateAndCheckCollisionEnumerable();
            TCollider nonCollider = CreateNonCollider();

            IEnumerable<TContainedCollidable> collidables = collidableCollection.GetCollidables(nonCollider);

            int collidablesCount = collidables.Count();
            Assert.True(collidablesCount == 0, "The CreateNonCollider() method " +
                                               "should have returned a collider that did not collide with any " +
                                               "of the collidables contained within the " + 
                                               "ICollidableEnumerable<TContainedCollidable, TCollider> created by the " +
                                               "method CreateCollidableEnumerable(), but \"" + collidablesCount + 
                                               "\" were collided against.");
        }

        /// <summary>
        /// The number of <see cref="IExtendedCollidable{TCollider}"/> that must 
        /// be contained within the 
        /// <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> that 
        /// are created by the <see cref="CreateCollidableEnumerable"/> method. The 
        /// value of this 
        /// </summary>
        public const uint CollidableEnumerableCount = 7;

        /// <summary>
        /// Creates an <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/>
        /// that is to be tested. This collision group create should have at least 
        /// the number of items specified by <see cref="CollidableEnumerableCount"/> 
        /// of <see cref="IExtendedCollidable{TCollider}"/>s contained within it.
        /// </summary>
        /// <returns>The <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> 
        /// that is to be tested.</returns>
        protected abstract ICollidableEnumerable<TContainedCollidable, TCollider> CreateCollidableEnumerable();

        /// <summary>
        /// Creates a <typeparamref name="TCollider"/> to test for collisions 
        /// against the <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> 
        /// created by <see cref="CreateCollidableEnumerable"/>. The 
        /// <typeparamref name="TCollider"/> must intersect with ONLY the 
        /// <typeparamref name="TContainedCollidable"/> created by 
        /// <see cref="GetCollided()"/>. This method must create a new 
        /// <typeparamref name="TCollider"/> every time it is called and not 
        /// reuse instances.
        /// </summary>
        /// <returns>The <typeparamref name="TCollider"/> to test with the 
        /// <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/>.</returns>
        protected abstract TCollider CreateCollider();

        /// <summary>
        /// Retrieves a <typeparamref name="TContainedCollidable"/> that is 
        /// contained within the 
        /// <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> 
        /// created by <see cref="CreateCollidableEnumerable"/>. The 
        /// <typeparamref name="TContainedCollidable"/> created must also 
        /// collide with the <typeparamref name="TCollider"/> that is created 
        /// by the method <see cref="CreateCollider()"/>.
        /// </summary>
        /// <returns>The <typeparamref name="TContainedCollidable"/> that is 
        /// being collided against the <typeparamref name="TCollider"/> created 
        /// by <see cref="CreateCollider()"/>.</returns>
        protected abstract TContainedCollidable GetCollided();

        /// <summary>
        /// Creates a <typeparamref name="TCollider"/> that does not collide 
        /// with any <typeparamref name="TContainedCollidable"/> contained within 
        /// the <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> 
        /// created by <see cref="CreateCollidableEnumerable"/>. This method must 
        /// create a new <typeparamref name="TCollider"/> every time it is 
        /// called and not reuse instances.
        /// </summary>
        /// <returns>The <typeparamref name="TCollider"/> to test with the 
        /// <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/>.</returns>
        protected abstract TCollider CreateNonCollider();

        /// <summary>
        /// Creates the <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> 
        /// using <see cref="CreateCollidableEnumerable"/> and then checks it to 
        /// ensure it is setup properly.
        /// </summary>
        /// <returns>The created and verified 
        /// <see cref="ICollidableEnumerable{TContainedCollidable,TCollider}"/> .</returns>
        ICollidableEnumerable<TContainedCollidable, TCollider> CreateAndCheckCollisionEnumerable()
        {
            ICollidableEnumerable<TContainedCollidable, TCollider> collidableEnumerable = CreateCollidableEnumerable();

            Assert.That(collidableEnumerable.Count() == CollidableEnumerableCount,
                        "The ICollidableEnumerable<TContainedCollidable, TCollider> created by " +
                        "CreateCollidableEnumerable() must contain \"" + CollidableEnumerableCount + "\" " +
                        "collidables. IT currently contains: \"" + collidableEnumerable.Count() + "\".");

            return collidableEnumerable;
        }
    }
}