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

namespace Azimuth.UnitTests
{
    public class IntervalTests : UnitTestSharp.TestFixture
    {
        #region Constructors
        public void IntervalConstructorTest_LessThenGreater()
		{
			Scalar valueA = 10;
			Scalar valueB = 20;
			Interval target = new Interval(valueA, valueB);
			CheckEqual(valueA, target.Min);
            CheckEqual(valueB, target.Max);
		}

		public void IntervalConstructorTest_GreaterThenLess()
		{
			Scalar valueA = 20;
			Scalar valueB = 10;
			Interval target = new Interval(valueA, valueB);
            CheckEqual(valueB, target.Min);
            CheckEqual(valueA, target.Max);
		}

		public void IntervalConstructorTest_BinaryEqual()
		{
			Scalar valueA = 20;
			Scalar valueB = 20;
			Interval target = new Interval(valueA, valueB);
            CheckEqual(valueA, target.Min);
            CheckEqual(valueB, target.Max);
		}

        public void IntervalConstructorTest_UnaryEquals()
        {
            Scalar value = 10;
            Interval target = new Interval(value);
            CheckEqual(value, target.Min);
            CheckEqual(value, target.Max);
        }
        #endregion

		public void ToStringTest()
		{
			Interval target = new Interval(10, 20);
			string expected = "[10, 20]";
			string actual = target.ToString();
            CheckEqual(expected, actual);
        }

        #region AddPoint
        public void AddPointTest_InRangeNoAdd()
		{
			Interval actual = new Interval(10, 20); // TODO: Initialize to an appropriate value
			Interval expected = actual;
			actual.AddPoint(15);
            CheckEqual(expected, actual);
		}

		public void AddPointTest_OutsideRangeHigh()
		{
			Interval actual = new Interval(10, 20); // TODO: Initialize to an appropriate value
			Interval expected = new Interval(10, 25);
			actual.AddPoint(25);
            CheckEqual(expected, actual);
		}

		public void AddPointTest_OutsideRangeLo()
		{
			Interval actual = new Interval(10, 20); // TODO: Initialize to an appropriate value
			Interval expected = new Interval(5, 20);
			actual.AddPoint(5);
            CheckEqual(expected, actual);
        }

        public void AddPointTest_OutsideRangeLoInfinity()
        {
            Interval actual = new Interval(10, 20);
            Interval expected = new Interval(Scalar.NegativeInfinity, 20);
            actual.AddPoint(Scalar.NegativeInfinity);
            CheckEqual(expected, actual);
        }

        public void AddPointTest_OutsideRangeHighInfinity()
        {
            Interval actual = new Interval(10, 20);
            Interval expected = new Interval(10, Scalar.PositiveInfinity);
            actual.AddPoint(Scalar.PositiveInfinity);
            CheckEqual(expected, actual);
        }
        #endregion

        #region Combination tests
        private static Scalar inf = Scalar.PositiveInfinity;
        private static Scalar lo = -10;
        private static Scalar med = 0;
        private static Scalar high = 10;

        /// <summary> Helps us describe the containment states two intervals can have </summary>
        public enum Containment
        {
            none,
            AInsideB,
            BInsideA,
            congruent,
        };

        private struct Configuration
        {
            public Interval A, B;
            public bool intersects;
            public bool touches;
            public Containment containment;
        }

        public void Disjoint()
        {
            // disjoint
            // <------)   
            //            [-------->
            var config = new Configuration { 
                A = new Interval(-inf, lo),
                B = new Interval(high, inf),
                intersects = false,
                touches = false,
                containment = Containment.none
            };

            CheckFalse(config.A.GetIntersection(config.B).HasValue);
            CheckFalse(config.B.GetIntersection(config.A).HasValue);

            CheckEqual(config.touches, config.A.IsTouching(config.B));
            CheckEqual(config.touches, config.B.IsTouching(config.A));

            CheckFalse(config.A.IsContaining(config.B));
            CheckFalse(config.B.IsContaining(config.A));
        }

        public void JustTouching()
        {
            // touching
            // <------)
            //        (-------->
            var config = new Configuration {
                A = new Interval(-inf, med),
                B = new Interval(med, inf),
                intersects = false,
                touches = true,
                containment = Containment.none
            };

            CheckFalse(config.A.GetIntersection(config.B).HasValue);
            CheckFalse(config.B.GetIntersection(config.A).HasValue);

            CheckEqual(config.touches, config.A.IsTouching(config.B));
            CheckEqual(config.touches, config.B.IsTouching(config.A));

            CheckFalse(config.A.IsContaining(config.B));
            CheckFalse(config.B.IsContaining(config.A));
        }

        public void Intersecting()
        {
            // intersecting
            // <--------)
            //       (--------->
            var config = new Configuration { 
                A = new Interval(-inf, high),
                B = new Interval(lo, inf),
                intersects = true,
                touches = false,
                containment = Containment.none,
            };

            CheckEqual(new Interval(lo, high), config.A.GetIntersection(config.B).Value);
            CheckEqual(new Interval(lo, high), config.B.GetIntersection(config.A).Value);

            CheckEqual(config.touches, config.A.IsTouching(config.B));
            CheckEqual(config.touches, config.B.IsTouching(config.A));

            CheckFalse(config.A.IsContaining(config.B));
            CheckFalse(config.B.IsContaining(config.A));
        }

        public void ContainmentTest()
        {
            // containment
            //      (---)
            // <-------------->
            var config = new Configuration { 
                A = new Interval(lo, high),
                B = new Interval(-inf, inf),
                intersects = true,
                touches = false,
                containment = Containment.AInsideB
            };

            CheckEqual(new Interval(lo, high), config.A.GetIntersection(config.B).Value);
            CheckEqual(new Interval(lo, high), config.B.GetIntersection(config.A).Value);

            CheckEqual(config.touches, config.A.IsTouching(config.B));
            CheckEqual(config.touches, config.B.IsTouching(config.A));

            CheckFalse(config.A.IsContaining(config.B));
            CheckTrue(config.B.IsContaining(config.A));
        }

        public void TouchingContainment()
        {
            // touching containment
            //     (----)
            //     (----------)
            var config = new Configuration { 
                A = new Interval(lo, med),
                B = new Interval(lo, high),
                intersects = true,
                touches = true,
                containment = Containment.AInsideB
            };

            CheckEqual(new Interval(lo, med), config.A.GetIntersection(config.B).Value);
            CheckEqual(new Interval(lo, med), config.B.GetIntersection(config.A).Value);

            CheckEqual(config.touches, config.A.IsTouching(config.B));
            CheckEqual(config.touches, config.B.IsTouching(config.A));

            CheckFalse(config.A.IsContaining(config.B));
            CheckTrue(config.B.IsContaining(config.A));
        }
        
        public void Congruent()
        {
            // congruent
            //     (-----)
            //     (-----)
            var config = new Configuration { 
                A = new Interval(lo, high),
                B = new Interval(lo, high),
                intersects = true,
                touches = true,
                containment = Containment.congruent
            };

            CheckEqual(new Interval(lo, high), config.A.GetIntersection(config.B).Value);
            CheckEqual(new Interval(lo, high), config.B.GetIntersection(config.A).Value);

            CheckEqual(config.touches, config.A.IsTouching(config.B));
            CheckEqual(config.touches, config.B.IsTouching(config.A));

            CheckTrue(config.A.IsContaining(config.B));
            CheckTrue(config.B.IsContaining(config.A));
        }

        public void QuadrupleInfinity()
        {
            // quadruple infinity
            // <---->
            // <---->
            var config = new Configuration { 
                A = new Interval(-inf, inf),
                B = new Interval(-inf, inf),
                intersects = true,
                touches = true,
                containment = Containment.congruent
            };

            CheckEqual(new Interval(-inf, inf), config.A.GetIntersection(config.B).Value);
            CheckEqual(new Interval(-inf, inf), config.B.GetIntersection(config.A).Value);

            CheckEqual(config.touches, config.A.IsTouching(config.B));
            CheckEqual(config.touches, config.B.IsTouching(config.A));

            CheckTrue(config.A.IsContaining(config.B));
            CheckTrue(config.B.IsContaining(config.A));
        }

        #endregion
    }
}