using System;
using System.Linq;
using Chernobyl.Mathematics.Geometry;
using NUnit.Framework;

namespace Chernobyl.Mathematics.Collision
{
    [TestFixture, Description("Tests for the CollisionChecker type.")]
    public class CollisionCheckerTests
    {
        [Test, Description("A test that ensures CollisionChecker<TContainedCollidable, TCollider> " +
            "throws an ArgumentNullException when it receives a null value for its " +
            "first argument.")]
        public void ConstructorArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => new CollisionChecker<Point2D, Rectangle>(null, new Rectangle()));
        }

        [Test, Description("A test the ensures the " +
            "CollisionChecker<TContainedCollidable, TCollider>.CollisionStarted " +
            "is raised when a collision occurs.")]
        public void CollisionStartedRaisedWhenCollisionStarts()
        {
            QuadTree<Rectangle, Point2D> quadTree = new QuadTree<Rectangle, Point2D>(new Rectangle(4, 4));
            Rectangle rectangle = new Rectangle(2, 2, 1, 1);
            quadTree.Add(rectangle);
            Point2D point = new Point2D(6, 6);
            CollisionChecker<Rectangle, Point2D> collisionChecker = new CollisionChecker<Rectangle, Point2D>(quadTree, point);

            // Ensure the CollisionStarted event is not raised when a collision
            // is not occurring.
            collisionChecker.CollisionStarted += CollisionStartedFail;
            collisionChecker.Update(TimeSpan.Zero);
            collisionChecker.CollisionStarted -= CollisionStartedFail;

            // Now check to make sure the CollisionStarted event is raised when
            // a collision is occurring.
            collisionChecker.CollisionStarted += (sender, e) =>
            {
                Assert.AreEqual(point, e.Collider);
                Assert.AreEqual(e.Collidables.Count(), 1);
                Assert.True(e.Collidables.Contains(rectangle));
                Assert.Pass(
                    "CollisionChecker<TContainedCollidable, TCollider>.CollisionStarted was raised.");
            };

            // Position the point so it collides.
            point.X = 2.5f;
            point.Y = 2.5f;
            collisionChecker.Update(TimeSpan.Zero);

            Assert.Fail("CollisionChecker<TContainedCollidable, TCollider>.CollisionStarted was not raised.");
        }

        [Test, Description("A test that ensures the an event handler added to " +
            "CollisionChecker<TContainedCollidable, TCollider>.CollisionStarted " +
            "is raised if a collision is currently occurring.")]
        public void EventHandlerRaisedWhenCollionStarted()
        {
            QuadTree<Rectangle, Point2D> quadTree = new QuadTree<Rectangle, Point2D>(new Rectangle(4, 4));
            Rectangle rectangle = new Rectangle(2, 2, 1, 1);
            quadTree.Add(rectangle);
            Point2D point = new Point2D(6, 6);
            CollisionChecker<Rectangle, Point2D> collisionChecker = new CollisionChecker<Rectangle, Point2D>(quadTree, point);

            // Position the point so it collides.
            point.X = 2.5f;
            point.Y = 2.5f;
            collisionChecker.Update(TimeSpan.Zero);

            // Now check to make sure the event handler is raised when an event
            // is added to the CollisionStarted event.
            collisionChecker.CollisionStarted += (sender, e) =>
            {
                Assert.AreEqual(point, e.Collider);
                Assert.AreEqual(e.Collidables.Count(), 1);
                Assert.True(e.Collidables.Contains(rectangle));
                Assert.Pass(
                    "CollisionChecker<TContainedCollidable, TCollider>.CollisionStarted was raised.");
            };
        }

        [Test, Description("A test the ensures the " +
            "CollisionChecker<TContainedCollidable, TCollider>.CollisionEnded " +
            "is raised when a collision has ended.")]
        public void CollisionEndedRaisedWhenCollisionEnds()
        {
            QuadTree<Rectangle, Point2D> quadTree = new QuadTree<Rectangle, Point2D>(new Rectangle(4, 4));
            Rectangle rectangle = new Rectangle(2, 2, 1, 1);
            quadTree.Add(rectangle);
            Point2D point = new Point2D(2.5f, 2.5f); // Position the point so it collides.
            CollisionChecker<Rectangle, Point2D> collisionChecker = new CollisionChecker<Rectangle, Point2D>(quadTree, point);
            collisionChecker.Update(TimeSpan.Zero);

            // Now check to make sure the CollisionEnded event is raised when
            // a collision ends.
            collisionChecker.CollisionEnded += (sender, e) =>
            {
                Assert.AreEqual(point, e.Collider);
                Assert.AreEqual(e.Collidables.Count(), 1);
                Assert.True(e.Collidables.Contains(rectangle));
                Assert.Pass(
                    "CollisionChecker<TContainedCollidable, TCollider>.CollisionEnded was raised.");
            };

            // Position the point so it does not collide.
            point.X = 8f;
            point.Y = 8f;
            collisionChecker.Update(TimeSpan.Zero);

            Assert.Fail("CollisionChecker<TContainedCollidable, TCollider>.CollisionEnded was not raised.");
        }

        /// <summary>
        /// An event handler that, when invoked, performs an
        /// <see cref="Assert.Pass(string)"/> that states that the
        /// <see cref="CollisionChecker{TContainedCollidable, TCollider}.CollisionStarted"/>
        /// should not have been invoked.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="CollisionChecker{TContainedCollidable, TCollider}.CollisionEventArgs"/>
        /// that contains the event data..</param>
        void CollisionStartedFail(object sender, CollisionChecker<Rectangle, Point2D>.CollisionEventArgs e)
        {
            Assert.Fail("CollisionChecker<TContainedCollidable, TCollider>.CollisionStarted " +
                "was raised when should not have been.");
        }
    }
}