using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Azimuth;
using Annulus.Broadphase;

namespace Annulus.UnitTests.Broadphase
{
    public class PointSortAndSweepTests : UnitTestSharp.TestFixture
    {
        public class QueryAreaTests : UnitTestSharp.TestFixture
        {
            public void Empty()
            {
                var vertices = new Scalar[]
                {
                    
                };

                var payloads = new int[]
                {
                    
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                var actual = sortNsweep.QueryArea(new Interval(1.5, 4.5)).ToList();
                var expected = new int[] { };

                CheckEqual(expected, actual);
            }

            public void Basic()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                var actual = sortNsweep.QueryArea(new Interval(1.5, 4.5)).ToList();
                var expected = new int[] { 8, 7, 6, };

                CheckEqual(expected, actual);
            }

            public void LeftEdge()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                var actual = sortNsweep.QueryArea(new Interval(1, 4.5)).ToList();
                var expected = new int[] { 9, 8, 7, 6, };

                CheckEqual(expected, actual);
            }

            public void RightEdge()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                var actual = sortNsweep.QueryArea(new Interval(1.5, 5.0)).ToList();
                var expected = new int[] { 8, 7, 6, 5, };

                CheckEqual(expected, actual);
            }

            public void None()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                var actual = sortNsweep.QueryArea(new Interval(1.5, 1.75)).ToList();
                var expected = new int[] { };

                CheckEqual(expected, actual);
            }

            public void Wide()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                var actual = sortNsweep.QueryArea(new Interval(-10, 10)).ToList();
                var expected = new int[] { 9, 8, 7, 6, 5, };

                CheckEqual(expected, actual);
            }
        }

        public class FirstGreaterTests : UnitTestSharp.TestFixture
        {
            public void Empty()
            {
                var vertices = new Scalar[]
                {
                    
                };

                var payloads = new int[]
                {
                    
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FirstGreater(1.5));
            }

            public void Basic()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(1, sortNsweep.FirstGreater(1.5));
            }

            public void Zero()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FirstGreater(0));
            }

            public void EqualZero()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(1, sortNsweep.FirstGreater(1.0));
            }

            public void GreaterThanAll()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(5, sortNsweep.FirstGreater(6.0));
            }

            public void EqualGreatest()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(5, sortNsweep.FirstGreater(5.0));
            }

            public void DuplicateList_Less()
            {
                var vertices = new Scalar[]
                {
                    1, 1, 1, 1, 1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5, 1, 1, 1, 1,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FirstGreater(0.0));
            }

            public void DuplicateList_Equal()
            {
                var vertices = new Scalar[]
                {
                    1, 1, 1, 1, 1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5, 1, 1, 1, 1,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(5, sortNsweep.FirstGreater(1.0));
            }

            public void DuplicateList_Greater()
            {
                var vertices = new Scalar[]
                {
                    1, 1, 1, 1, 1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5, 1, 1, 1, 1,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(5, sortNsweep.FirstGreater(1.1));
            }
        }

        public class FirstGreaterOrEqualTests : UnitTestSharp.TestFixture
        {
            public void Empty()
            {
                var vertices = new Scalar[]
                {
                    
                };

                var payloads = new int[]
                {
                    
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FirstGreaterOrEqual(1.5));
            }

            public void Basic()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(1, sortNsweep.FirstGreaterOrEqual(1.5));
            }

            public void Zero()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FirstGreaterOrEqual(0));
            }

            public void EqualZero()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FirstGreaterOrEqual(1.0));
            }

            public void GreaterThanAll()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(5, sortNsweep.FirstGreaterOrEqual(6.0));
            }

            public void EqualGreatest()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(4, sortNsweep.FirstGreaterOrEqual(5.0));
            }

            public void DuplicateList_Less()
            {
                var vertices = new Scalar[]
                {
                    1, 1, 1, 1, 1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5, 1, 1, 1, 1,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FirstGreaterOrEqual(0.0));
            }

            public void DuplicateList_Equal()
            {
                var vertices = new Scalar[]
                {
                    1, 1, 1, 1, 1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5, 1, 1, 1, 1,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FirstGreaterOrEqual(1.0));
            }

            public void DuplicateList_Greater()
            {
                var vertices = new Scalar[]
                {
                    1, 1, 1, 1, 1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5, 1, 1, 1, 1,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(5, sortNsweep.FirstGreaterOrEqual(1.1));
            }
        }

        public class AddTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                sortNsweep.Add(10, 1.5);
                var actual = sortNsweep.QueryArea(new Interval(1, 2));
                var expected = new int[] { 9, 10, 8, };

                CheckEqual(expected, actual);
            }

            public void First()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                sortNsweep.Add(10, -1.5);
                var actual = sortNsweep.QueryArea(new Interval(-2, 0));
                var expected = new int[] { 10, };

                CheckEqual(expected, actual);
            }

            public void Last()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                sortNsweep.Add(10, 10);
                var actual = sortNsweep.QueryArea(new Interval(9, 11));
                var expected = new int[] { 10, };

                CheckEqual(expected, actual);
            }

            public void Overlap()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                sortNsweep.Add(10, 1);
                var actual = sortNsweep.QueryArea(new Interval(1, 1));
                var expected = new int[] { 9, 10, };

                CheckEqual(expected, actual);
            }

            public void AllTheSame()
            {
                var vertices = new Scalar[]
                {
                    1, 1, 1, 1, 1,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                sortNsweep.Add(10, 1);
                var actual = sortNsweep.QueryArea(new Interval(1, 1));
                var expected = new int[] { 9, 8, 7, 6, 5, 10, };

                CheckEqual(expected, actual);
            }

            public void Empty()
            {
                var vertices = new Scalar[]
                {
                    
                };

                var payloads = new int[]
                {
                    
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                sortNsweep.Add(10, 1);
                var actual = sortNsweep.QueryArea(new Interval(1, 1));
                var expected = new int[] { 10, };

                CheckEqual(expected, actual);
            }
        }

        public class FindPotentialCollisionsTests : UnitTestSharp.TestFixture
        {
            public void Empty()
            {
                var vertices = new Scalar[]
                {
                    
                };

                var payloads = new int[]
                {
                    
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FindPotentialCollisions().ToList().Count);
            }

            public void NoOverlaps()
            {
                var vertices = new Scalar[]
                {
                    1, 2, 3, 4, 5,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                CheckEqual(0, sortNsweep.FindPotentialCollisions().ToList().Count);
            }

            public void AllOverlap()
            {
                var vertices = new Scalar[]
                {
                    1, 1, 1, 1, 1,
                };

                var payloads = new int[]
                {
                    9, 8, 7, 6, 5,
                };

                var sortNsweep = new PointSortAndSweep<int>(payloads, vertices);

                var expected = new Tuple<int, int>[]
                {
                    new Tuple<int, int>(9, 8),
                    new Tuple<int, int>(9, 7),
                    new Tuple<int, int>(9, 6),
                    new Tuple<int, int>(9, 5),

                    new Tuple<int, int>(8, 7),
                    new Tuple<int, int>(8, 6),
                    new Tuple<int, int>(8, 5),

                    new Tuple<int, int>(7, 6),
                    new Tuple<int, int>(7, 5),

                    new Tuple<int, int>(6, 5),
                };

                CheckEqualCommutative(expected, sortNsweep.FindPotentialCollisions());
            }
        }
    }
}