using System;
using Chernobyl.Mathematics.Vectors;
using NUnit.Framework;

namespace Chernobyl.Mathematics.Movement
{
    [TestFixture, Description("Tests for the LookAtTransform type.")]
    public class LookAtTransformTests
    {
        [Test, Description("A test to ensure the constructor " +
            "LookAtTransform(ITransform) sets the proper values.")]
        public void ConstructorITransformTest()
        {
            ITransform expectedTarget = new MatrixTransform();
            LookAtTransform transform = new LookAtTransform(expectedTarget);

            Assert.AreEqual(expectedTarget, transform.Target,
                "LookAtTransform.Target was not the value passed to the constructor.");
        }

        [Test, Description("A test to ensure the constructor " +
            "LookAtTransform(ITransform, bool) sets the proper values.")]
        public void ConstructorITransformBoolTest()
        {
            ITransform expectedTarget = new MatrixTransform();
            bool expectedEnable = false;
            LookAtTransform transform = new LookAtTransform(expectedTarget, expectedEnable);

            Assert.AreEqual(expectedTarget, transform.Target,
                "LookAtTransform.Target was not the value passed to the constructor.");
            Assert.AreEqual(expectedEnable, transform.IsEnabled,
                "LookAtTransform.IsEnabled was not the value passed to the constructor.");
        }

        // ReSharper disable ObjectCreationAsStatement

        [Test, Description("A test to ensure the constructor " +
            "LookAtTransform(ITransform) throws an ArgumentNullException when " +
            "it is given a null target.")]
        public void ConstructorITransformExceptionTest()
        {
            Assert.Throws<ArgumentNullException>(() => new LookAtTransform(null));
        }

        [Test, Description("A test to ensure the constructor " +
            "LookAtTransform(ITransform, bool) throws an ArgumentNullException " +
            "when it is given a null target.")]
        public void ConstructorITransformBoolExceptionTest()
        {
            Assert.Throws<ArgumentNullException>(() => new LookAtTransform(null, true));
        }

        // ReSharper restore ObjectCreationAsStatement

        [Test, Description("A test to ensure the property " +
            "LookAtTransform.Target throws an ArgumentNullException when " +
            "it is given a null target.")]
        public void TargetArgumentNullExceptionTest()
        {
            LookAtTransform transform = new LookAtTransform(new MatrixTransform());
            Assert.Throws<ArgumentNullException>(() => transform.Target = null);
        }

        [Test, Description("A test to ensure LookAtTransform.Enable(object, EventArgs) " +
            "sets the LookAtTransform.IsEnabled property to true")]
        public void EnableTest()
        {
            LookAtTransform transform = new LookAtTransform(new MatrixTransform(), false);

            Assert.False(transform.IsEnabled, "LookAtTransform.IsEnabled was " +
                "constructed with an unexpected value.");

            transform.Enable(this, EventArgs.Empty);

            Assert.True(transform.IsEnabled, "LookAtTransform.IsEnabled was not " +
                "true when it was expected to be.");
        }

        [Test, Description("A test to ensure LookAtTransform.Disable(object, EventArgs) " +
            "sets the LookAtTransform.IsEnabled property to false")]
        public void DisableTest()
        {
            LookAtTransform transform = new LookAtTransform(new MatrixTransform(), true);

            Assert.True(transform.IsEnabled, "LookAtTransform.IsEnabled was " +
                "constructed with an unexpected value.");

            transform.Disable(this, EventArgs.Empty);

            Assert.False(transform.IsEnabled, "LookAtTransform.IsEnabled was not " +
                "false when it was expected to be.");
        }

        [Test, Description("A test to ensure the LookAtTransform properly rotates " +
            "when the target moves.")]
        public void RotationTest()
        {
            ITransform target = new MatrixTransform();
            target.TranslateZ(-100.0f);

            LookAtTransform transform = new LookAtTransform(target);

            Assert.AreEqual(-Vector3.UnitZ, transform.Forward,
                "The forward vector was not the expected value before the target moved.");

            // Move the target to the right (+X) of the LookAtTransform.
            target.Translate(100.0f, 0.0f, 100.0f);

            Assert.AreEqual(Vector3.UnitX, transform.Forward,
                "The forward vector was not the expected value after the target moved.");

            // Move the target to the left (-X) of the LookAtTransform.
            target.Translate(-200.0f, 0.0f, 0.0f);

            Assert.AreEqual(-Vector3.UnitX, transform.Forward,
                "The forward vector was not the expected value after the target moved.");
        }

        [Test, Description("A test to ensure the LookAtTransform properly rotates " +
            "when the target and the LookAtTransform move.")]
        public void TranslateRotationTest()
        {
            // Start the target in front (-Z) of the LookAtTransform
            ITransform target = new MatrixTransform();
            target.Translate(50, 50, -100);

            Vector3 expectedPosition = new Vector3(50, 50, 0);
            LookAtTransform transform = new LookAtTransform(target);
            transform.Translate(expectedPosition);

            Assert.AreEqual(-Vector3.UnitZ, transform.Forward,
                "The forward vector was not the expected value before the target moved.");
            Assert.AreEqual(expectedPosition, transform.Position,
                "The position was not the expected value before the target moved.");

            // Move the target to the right (+X) of the LookAtTransform.
            target.Translate(100, 0, 100);

            Assert.AreEqual(Vector3.UnitX, transform.Forward,
                "The forward vector was not the expected value after the target moved.");
            Assert.AreEqual(expectedPosition, transform.Position,
                "The position was not the expected value before the target moved.");

            // Move the target to the left (-X) of the LookAtTransform.
            target.Translate(-200.0f, 0.0f, 0.0f);

            Assert.AreEqual(-Vector3.UnitX, transform.Forward,
                "The forward vector was not the expected value after the target moved.");
            Assert.AreEqual(expectedPosition, transform.Position,
                "The position was not the expected value before the target moved.");
        }
    }
}