using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnitTestSharp;

namespace Azimuth.UnitTests
{
    public class VectorTests : TestFixture
    {
		public class IVectorSpaceTests : TestFixture
		{
            public void Dimension()
            {
                IVectorSpace<Vector> v1 = new Vector(4, 14);
                CheckEqual(2, v1.Dimension);
            }

            public void GetDimension()
            {
                IVectorSpace<Vector> v1 = new Vector(4, 14);
                CheckEqual(4, v1[0]);
                CheckEqual(14, v1[1]);
            }

            public void GetDimension_OutOfBounds_Hi()
            {
                IVectorSpace<Vector> v1 = new Vector(4, 14);
                CheckThrow(typeof(System.Exception));
                Scalar dummy = v1[2];
                CheckFalse(dummy == 0); //dummy
            }

            public void GetDimension_OutOfBounds_Lo()
            {
                IVectorSpace<Vector> v1 = new Vector(4, 14);
                CheckThrow(typeof(System.Exception));
                Scalar dummy = v1[-1];
                CheckFalse(dummy == 0); //dummy
            }

			public void AssignmentAdd()
			{
				IVectorSpace<Vector> a = new Vector(-10, 10);
				Vector b = new Vector(5, -5);

                a.AddAssignment(b);

				CheckEqual(new Vector(-5, 5), a);
			}

			public void AssignmentSubtract()
			{
                IVectorSpace<Vector> a = new Vector(-10, 10);
				Vector b = new Vector(5, -5);

                a.SubtractAssignment(b);

				CheckEqual(new Vector(-15, 15), a);
			}

			public void AssignmentScale()
			{
                IVectorSpace<Vector> a = new Vector(-10, 10);
				Scalar b = -2;

                a.ScaleAssignment(b);

				CheckEqual(new Vector(20, -20), a);
			}

            public void AssignmentScaleThenAdd()
            {
                IVectorSpace<Vector> a = new Vector(10, 20);
                Scalar scale = 10;
                Vector b = new Vector(1, -1);

                a.ScaleThenAddAssignment(scale, b);

                CheckEqual(new Vector(20, 10), a);
                CheckEqual(new Vector(1, -1), b);
            }

            public void InnerProduct()
            {
                Vector a = new Vector(-10, 10);
                Vector b = new Vector(10, -10);

                CheckEqual(-200, a.InnerProduct(b));
                CheckEqual(new Vector(-10, 10), a);
                CheckEqual(new Vector(10, -10), b);
            }

            public void IsOrigin_False()
            {
                IVectorSpace<Vector> a = new Vector(0, 10);

                CheckFalse(a.IsOrigin());
            }

            public void IsOrigin_True()
            {
                IVectorSpace<Vector> a = new Vector(Scalar.Epsilon / 2, -Scalar.Epsilon / 2);

                CheckTrue(a.IsOrigin());
            }

            public void Clone()
            {
                Vector a = new Vector(10, 20);
                
                Vector b = ((IVectorSpace<Vector>)a).Clone();
                a += new Vector(1, 1);

                CheckEqual(new Vector(10, 20), b);
                CheckEqual(new Vector(11, 21), a);
            }
		}

        public void Ctor()
        {
            Vector vec = new Vector(17, 23);

            CheckEqual(17, vec.X);
            CheckEqual(23, vec.Y);
        }

        public void StaticBuilder_AngleMag()
        {
            Vector vec = Vector.BuildFromAngleMagnitude(Math.PI / 2.0, 50);

            CheckEqual(0, vec.X);
            CheckEqual(50, vec.Y);
        }

        public void StaticBuilder_XY()
        {
            Vector vec = Vector.BuildFromXY(17, 23);

            CheckEqual(17, vec.X);
            CheckEqual(23, vec.Y);
        }

        public void StaticDotProduct()
        {
            Vector v1 = new Vector(17, 23);
            Vector v2 = new Vector(-23, 17);

            CheckEqual(0, Vector.DotProduct(v1, v2));
            CheckEqual(0, Vector.DotProduct(v2, v1));
        }

        public void DotProduct()
        {
            Vector v1 = new Vector(17, 23);
            Vector v2 = new Vector(-23, 17);

            CheckEqual(0, v1.DotProduct(v2));
            CheckEqual(0, v2.DotProduct(v1));
        }

        public void StaticCrossProduct()
        {
            Vector v1 = new Vector(5, 11);
            Vector v2 = new Vector(-11, 17);

            CheckEqual(206, Vector.CrossProduct(v1, v2));
            CheckEqual(-206, Vector.CrossProduct(v2, v1));
        }

        public void CrossProduct()
        {
            Vector v1 = new Vector(5, 11);
            Vector v2 = new Vector(-11, 17);

            CheckEqual(206, v1.CrossProduct(v2));
            CheckEqual(-206, v2.CrossProduct(v1));
        }

        public void LengthSquared()
        {
            Vector v1 = new Vector(17, 23);

            CheckEqual(818, v1.LengthSquared());
        }

        public void Length()
        {
            Vector v1 = new Vector(3, 4);

            CheckEqual(5, v1.Length());
        }

        public void Length_Negative_Low()
        {
            Vector v1 = new Vector(-3, 4);

            CheckEqual(5, v1.Length());
        }

        public void Length_Negative_High()
        {
            Vector v1 = new Vector(3, -4);

            CheckEqual(5, v1.Length());
        }

        public void Length_AllNegative()
        {
            Vector v1 = new Vector(-3, -4);

            CheckEqual(5, v1.Length());
        }

        public void Length_XCancellation()
        {
            Vector v1 = new Vector(0, -4);

            CheckEqual(4, v1.Length());
        }

        public void Length_YCancellation()
        {
            Vector v1 = new Vector(-3, 0);

            CheckEqual(3, v1.Length());
        }

        public void DistanceSquared()
        {
            Vector v1 = new Vector(11, 13);
            Vector v2 = new Vector(28, 36);

            CheckEqual(818, Vector.DistanceSquared(v1, v2));
            CheckEqual(818, Vector.DistanceSquared(v2, v1));
        }

        public void Distance()
        {
            Vector v1 = new Vector(11, 13);
            Vector v2 = new Vector(15, 16);

            CheckEqual(5, Vector.Distance(v2, v1));
        }

        public void Equality()
        {
            Vector v1 = new Vector(3, 4);
            Vector v2 = new Vector(3, 4);

            CheckEqual(v1, v2);
        }

        public void FuzzyEquality()
        {
            Vector v1 = new Vector(3, 4);
            Vector v2 = new Vector(3 + 1e-11, 4 - 1e-11);

            CheckEqual(v1, v2);
        }

        public void IsSameDirection()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI, 1);
            Vector v2 = Vector.BuildFromAngleMagnitude(Math.PI, 100);

            Check(Vector.IsSameDirection(v1, v2));
        }

        public void IsSameDirection_Fuzzy()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI, 1);
            Vector v2 = Vector.BuildFromAngleMagnitude(Math.PI + 1e-20, 100);

            Check(Vector.IsSameDirection(v1, v2));
        }

        public void IsSameMagnitude()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 1000);
            Vector v2 = new Vector(1000, 0);

            Check(Vector.IsSameMagnitude(v1, v2));
        }

        public void IsSameMagnitude_Fuzzy()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 1000 + 1e-11);
            Vector v2 = new Vector(1000, 0);

            Check(Vector.IsSameMagnitude(v1, v2));
        }

        public void IsSameDirectionAndMagnitude_Fuzzy()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 1000 + 1e-11);
            Vector v2 = Vector.BuildFromAngleMagnitude(Math.PI / 4 + 1e-20, 1000);
            
            Check(Vector.IsSameDirectionAndMagnitude(v1, v2));
        }

        public void Negation()
        {
            Vector v1 = new Vector(-17, 23);

            CheckEqual(17, (-v1).X);
            CheckEqual(-23, (-v1).Y);
        }

        public void Scaling_InPlace()
        {
            Vector v1 = new Vector(1, 2);

            v1 *= 3;

            CheckEqual(3, v1.X);
            CheckEqual(6, v1.Y);
        }

        public void Scaling_Left()
        {
            Vector v1 = new Vector(1, 2);

            v1 = 3 * v1;

            CheckEqual(3, v1.X);
            CheckEqual(6, v1.Y);
        }

        public void Scaling_Right()
        {
            Vector v1 = new Vector(1, 2);

            v1 = v1 * 3;

            CheckEqual(3, v1.X);
            CheckEqual(6, v1.Y);
        }

        public void Addition()
        {
            Vector v1 = new Vector(3, 4);
            Vector v2 = new Vector(-7, -11);
            Vector expected = new Vector(-4, -7);

            CheckEqual(expected, v1 + v2);
            CheckEqual(expected, v2 + v1);
        }

        public void Addition_InPlace()
        {
            Vector v1 = new Vector(3, 4);
            Vector v2 = new Vector(-7, -11);
            Vector v3 = v1;
            Vector expected = new Vector(-4, -7);

            v1 += v2;
            v2 += v3;

            CheckEqual(expected, v1);
            CheckEqual(expected, v2);
        }


        public void Subtraction()
        {
            Vector v1 = new Vector(3, 4);
            Vector v2 = new Vector(-7, -11);
            Vector expected = new Vector(10, 15);

            CheckEqual(expected, v1 - v2);
            CheckEqual(-expected, v2 - v1);
        }

        public void Subtraction_InPlace()
        {
            Vector v1 = new Vector(3, 4);
            Vector v2 = new Vector(-7, -11);
            Vector v3 = v1;
            Vector expected = new Vector(10, 15);

            v1 -= v2;
            v2 -= v3;

            CheckEqual(expected, v1);
            CheckEqual(-expected, v2);
        }

        public void ScalarDivision_InPlace()
        {
            Vector v1 = new Vector(16, 32);
            Vector expected = new Vector(2, 4);

            v1 /= 8;

            CheckEqual(expected, v1);
        }

        public void ScalarDivision_Reverse()
        {
            Vector v1 = new Vector(16, 32);
            Vector expected = new Vector(8.0/16.0, 8.0/32.0);

            v1 = 8 / v1;

            CheckEqual(expected, v1);
        }

        public void ScalarDivision_Right()
        {
            Vector v1 = new Vector(16, 32);
            Vector expected = new Vector(2, 4);

            v1 = v1 / 8;

            CheckEqual(expected, v1);
        }

        public void Normalization()
        {
            Vector v1 = new Vector(3, 4);

            v1.Normalize();

            CheckEqual(new Vector(3.0/5.0, 4.0/5.0), v1);
        }

        public void Normalization_ZeroLength()
        {
            Vector v1 = new Vector(0, 0);
            v1.Normalize();
            Check(Vector.IsNaN(v1));
        }

        public void NormalizedCopy()
        {
            Vector v1 = new Vector(3, 4);            

            CheckEqual(new Vector(3.0/5.0, 4.0/5.0), v1.NormalizedCopy());
            CheckEqual(new Vector(3, 4), v1);
        }

        public void NormalizedCopy_ZeroLength()
        {
            Vector v1 = new Vector(0, 0);

            Check(Vector.IsNaN(v1.NormalizedCopy()));
        }

        public void PerpCCW()
        {
            Vector v1 = Vector.UnitX;

            CheckEqual(Vector.UnitY, v1.PerpCCW());
        }

        public void PerpCW()
        {
            Vector v1 = Vector.UnitY;

            CheckEqual(Vector.UnitX, v1.PerpCW());
        }

        public void IsUnitLength_True()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 1);

            Check(v1.IsUnitLength());
        }

        public void IsUnitLength_False()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 2);

            CheckFalse(v1.IsUnitLength());
        }

        public void StaticRotate_Angle()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 2);
            Vector v2 = Vector.UnitX * 2;
            v2 = Vector.Rotate(v2, Math.PI / 4);

            CheckEqual(v1, v2);
        }

        public void StaticRotate_Vector()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 2);
            Vector v2 = Vector.UnitX;
            v2 = Vector.Rotate(v2, v1);

            CheckEqual(v1, v2);
        }

        public void Rotate_Angle()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 2);
            Vector v2 = Vector.UnitX * 2;
            v2.Rotate(Math.PI / 4);

            CheckEqual(v1, v2);
        }

        public void Rotate_Vector()
        {
            Vector v1 = Vector.BuildFromAngleMagnitude(Math.PI / 4, 2);
            Vector v2 = Vector.UnitX;
            v2.Rotate(v1);

            CheckEqual(v1, v2);
        }

        public void Vector_IsNotNaN()
        {
            Vector v1 = new Vector(1, 2);

            CheckFalse(Vector.IsNaN(v1));
        }

        public void Vector_IsNan_JustX()
        {
            Vector v1 = new Vector(Scalar.NaN, 2);

            Check(Vector.IsNaN(v1));
        }

        public void Vector_IsNan_JustY()
        {
            Vector v1 = new Vector(1, Scalar.NaN);

            Check(Vector.IsNaN(v1));
        }

        public void Vector_IsNan_XY()
        {
            Vector v1 = new Vector(Scalar.NaN, Scalar.NaN);

            Check(Vector.IsNaN(v1));
        }

        public void Vector_ToString()
        {
            Vector v1 = new Vector(1, 2);

            CheckEqual("<1 : 2>", v1.ToString());
        }

        public void Vector_ToString_Fuzzy()
        {
            Vector v1 = new Vector(1.0/3.0, 2.0/3.0);

            CheckEqual("<0.3333333333 : 0.6666666667>", v1.ToString());
        }

        public void MinMax()
        {
            Vector v1 = new Vector(8, 1);
            Vector v2 = new Vector(3, 24);
            Vector v3, v4;

            v1.MinMax(v2, out v3, out v4);

            Check(v3.X == 3 && v3.Y == 1);
            Check(v4.X == 8 && v4.Y == 24);
        }

        public class ToStringTests : TestFixture
        {
            public void Basic()
            {
                var vector = new Vector(1, 5);

                CheckEqual("<1 : 5>", vector.ToString());
            }

            public void Infinity()
            {
                var vector = new Vector(Scalar.PositiveInfinity, Scalar.PositiveInfinity);

                CheckEqual("<Infinity : Infinity>", vector.ToString());
            }

            public void NegativeInfinity()
            {
                var vector = new Vector(Scalar.NegativeInfinity, Scalar.NegativeInfinity);

                CheckEqual("<-Infinity : -Infinity>", vector.ToString());
            }
        }

        public class Parse : TestFixture
        {
            public void TODO()
            {
                TODO("Parse and TryParse needs to be written.");
            }
        }
    }
}