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

namespace Annulus.UnitTests
{
    class AABBTests : UnitTestSharp.TestFixture
    {
        #region Equals
        public void EqualsMethod_ScalarTest()
        {
            AABB<Scalar> i = new AABB<Scalar>(402, 1.9879876);
            AABB<Scalar> j = new AABB<Scalar>(402, 1.9879876);

            Check(i.Equals(j));
            Check(j.Equals(i));
        }

        public void EqualsMethod_ScalarTest_NotEqual()
        {
            AABB<Scalar> i = new AABB<Scalar>(5.68261, 12346932);
            AABB<Scalar> j = new AABB<Scalar>(402, 1.9879876);

            CheckFalse(i.Equals(j));
            CheckFalse(j.Equals(i));
        }

        public void EqualsOperator_ScalarTest()
        {
            AABB<Scalar> i = new AABB<Scalar>(402, 1.9879876);
            AABB<Scalar> j = new AABB<Scalar>(402, 1.9879876);

            Check(i == j);
            Check(j == i);
        }

        public void EqualsOperator_ScalarTest_NotEqual()
        {
            AABB<Scalar> i = new AABB<Scalar>(5.68261, 12346932);
            AABB<Scalar> j = new AABB<Scalar>(402, 1.9879876);

            CheckFalse(i == j);
            CheckFalse(j == i);
        }

        ///////////////////////////////////
        ///////////////////////////////////

        public void EqualsMethod_VectorTest()
        {
            AABB<Vector> i = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));
            AABB<Vector> j = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));

            Check(i.Equals(j));
            Check(j.Equals(i));
        }

        public void EqualsMethod_VectorTest_NotEqual()
        {
            AABB<Vector> i = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));
            AABB<Vector> j = new AABB<Vector>(new Vector(29, 1), new Vector(62, 4));

            CheckFalse(i.Equals(j));
            CheckFalse(j.Equals(i));
        }

        public void EqualsOperator_VectorTest()
        {
            AABB<Vector> i = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));
            AABB<Vector> j = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));

            Check(i == j);
            Check(j == i);
        }

        public void EqualsOperator_VectorTest_NotEqual()
        {
            AABB<Vector> i = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));
            AABB<Vector> j = new AABB<Vector>(new Vector(29, 1), new Vector(62, 4));

            CheckFalse(i == j);
            CheckFalse(j == i);
        }
        #endregion

        #region NotEquals
        public void NotEqualsOperator_ScalarTest_Equal()
        {
            AABB<Scalar> i = new AABB<Scalar>(402, 1.9879876);
            AABB<Scalar> j = new AABB<Scalar>(402, 1.9879876);

            CheckFalse(i != j);
            CheckFalse(j != i);
        }

        public void NotEqualsOperator_ScalarTest()
        {
            AABB<Scalar> i = new AABB<Scalar>(5.68261, 12346932);
            AABB<Scalar> j = new AABB<Scalar>(402, 1.9879876);

            Check(i != j);
            Check(j != i);
        }

        ///////////////////////////////////
        ///////////////////////////////////

        public void NotEqualsOperator_VectorTest_Equal()
        {
            AABB<Vector> i = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));
            AABB<Vector> j = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));

            CheckFalse(i != j);
            CheckFalse(j != i);
        }

        public void NotEqualsOperator_VectorTest()
        {
            AABB<Vector> i = new AABB<Vector>(new Vector(10, 23), new Vector(62, -5));
            AABB<Vector> j = new AABB<Vector>(new Vector(29, 1), new Vector(62, 4));

            Check(i != j);
            Check(j != i);
        }
        #endregion

        public void Union_ScalarTest()
        {
            var a = new AABB<Scalar>(-4, 8);
            var b = new AABB<Scalar>(-12, 3);
            var expected = new AABB<Scalar>(-12, 8);
            var observed = AABB<Scalar>.Union(a, b);

            CheckEqual(expected, observed);
        }

        public void ToString_VectorTest()
        {
            AABB<Vector> a = new AABB<Vector>(new Vector(1, 1), new Vector(9, 9));
            CheckEqual("[<1 : 1> : <9 : 9>]", a.ToString());
        }

        public void ToString_ScalarTest()
        {
            AABB<Scalar> a = new AABB<Scalar>(5, 10);
            CheckEqual("[5 : 10]", a.ToString());
        }

        public class AddPointTests : UnitTestSharp.TestFixture
        {
            public void PointIsAlreadyInside()
            {
                var aabb = new AABB<Scalar>(-1, 1);
                var expected = new AABB<Scalar>(-1, 1);

                aabb.AddPoint(0);

                CheckEqual(expected, aabb);
            }

            public void PointOutside()
            {
                var aabb = new AABB<Scalar>(-1, 1);
                var expected = new AABB<Scalar>(-1, 10);

                aabb.AddPoint(10);

                CheckEqual(expected, aabb);
            }

            public void PointOnEdge()
            {
                var aabb = new AABB<Scalar>(-1, 1);
                var expected = new AABB<Scalar>(-1, 1);

                aabb.AddPoint(1);

                CheckEqual(expected, aabb);
            }
        }

        public class ContainsTests : UnitTestSharp.TestFixture
        {
            public void Flush()
            {
                var aabbA = new AABB<Scalar>(-1, 1);
                var aabbB = new AABB<Scalar>(1, 2);

                CheckFalse(aabbA.Contains(aabbB));
                CheckFalse(aabbB.Contains(aabbA));
            }

            public void Disjoint()
            {
                var aabbA = new AABB<Scalar>(-1, 1);
                var aabbB = new AABB<Scalar>(2, 3);

                CheckFalse(aabbA.Contains(aabbB));
                CheckFalse(aabbB.Contains(aabbA));
            }

            public void Intersect()
            {
                var aabbA = new AABB<Scalar>(-1, 1);
                var aabbB = new AABB<Scalar>(0, 2);

                CheckFalse(aabbA.Contains(aabbB));
                CheckFalse(aabbB.Contains(aabbA));
            }

            public void Contained()
            {
                var aabbA = new AABB<Scalar>(-1, 1);
                var aabbB = new AABB<Scalar>(0, 0.5);

                CheckTrue(aabbA.Contains(aabbB));
                CheckFalse(aabbB.Contains(aabbA));
            }
        }
    }
}