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

namespace Annulus.UnitTests.Broadphase
{
    public class SortAndSweepTests : UnitTestSharp.TestFixture
    {
        public void Basic()
        {
            var list = new List<int>() {
                0,
                1,
                2,
                3,
            };

            var minMax = new List<Interval> {
                new Interval(-10, 10),
                new Interval(0, 20),
                new Interval(11, 30),
                new Interval(21, 40),
            };

            var sortNsweep = new SortAndSweep<int>(list, minMax);

            var pairs = new List<KeyValuePair<int, int>>(sortNsweep.FindPotentialCollisions());

            CheckEqual(3, pairs.Count());

            CheckEqual(new KeyValuePair<int, int>(0, 1), pairs[0]);
            CheckEqual(new KeyValuePair<int, int>(1, 2), pairs[1]);
            CheckEqual(new KeyValuePair<int, int>(2, 3), pairs[2]);
        }

        public void Empty()
        {
            var list = new List<int>()
            {

            };

            var minMax = new List<Interval>()
            {

            };

            var sortNsweep = new SortAndSweep<int>(list, minMax);

            var pairs = new List<KeyValuePair<int, int>>(sortNsweep.FindPotentialCollisions());

            CheckEqual(0, pairs.Count());
        }

        public void SingleElement()
        {
            var list = new List<int>()
            {
                0,
            };

            var minMax = new List<Interval>()
            {
                new Interval(0, 10),
            };

            var sortNsweep = new SortAndSweep<int>(list, minMax);

            var pairs = new List<KeyValuePair<int, int>>(sortNsweep.FindPotentialCollisions());

            CheckEqual(0, pairs.Count());
        }

        public void DuplicateKeys()
        {
            var list = new List<int>() {
                0,
                1,
                1,
                3,
            };

            var minMax = new List<Interval> {
                new Interval(-10, 10),
                new Interval(0, 20),
                new Interval(11, 30),
                new Interval(21, 40),
            };

            var sortNsweep = new SortAndSweep<int>(list, minMax);

            var pairs = new List<KeyValuePair<int, int>>(sortNsweep.FindPotentialCollisions());

            CheckEqual(3, pairs.Count());

            CheckEqual(new KeyValuePair<int, int>(0, 1), pairs[0]);
            CheckEqual(new KeyValuePair<int, int>(1, 1), pairs[1]);
            CheckEqual(new KeyValuePair<int, int>(1, 3), pairs[2]);
        }

        public void Overlapping()
        {
            var list = new List<int>() {
                0,
                1,
                2,
            };

            var minMax = new List<Interval> {
                new Interval(-10, 10),
                new Interval(-10, 20),
                new Interval(-10, 4),
            };

            var sortNsweep = new SortAndSweep<int>(list, minMax);

            var pairs = new List<KeyValuePair<int, int>>(sortNsweep.FindPotentialCollisions());

            CheckEqual(3, pairs.Count());

            CheckEqualCommutative(new KeyValuePair<int, int>[] 
            {
                new KeyValuePair<int, int>(0, 1),
                new KeyValuePair<int, int>(0, 2),
                new KeyValuePair<int, int>(1, 2),
            }, pairs);
        }

        public void EndToEnd()
        {
            var list = new List<int>() {
                0,
                1,
                2,
            };

            var minMax = new List<Interval> {
                new Interval(-10, 10),
                new Interval(10, 20),
                new Interval(20, 30),
            };

            var sortNsweep = new SortAndSweep<int>(list, minMax);

            var pairs = new List<KeyValuePair<int, int>>(sortNsweep.FindPotentialCollisions());

            CheckEqualCommutative(new KeyValuePair<int, int>[] 
            {
                new KeyValuePair<int, int>(0, 1),
                new KeyValuePair<int, int>(1, 2),
            }, pairs);
        }

        public class PostCtor : UnitTestSharp.TestFixture
        {
            public void Add_Basic()
            {
                var list = new List<int>() {
                    0,
                    1,
                    2,
                    3,
                };

                var minMax = new List<Interval> {
                    new Interval(-10, 10),
                    new Interval(0, 20),
                    new Interval(11, 30),
                    new Interval(21, 40),
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Add(4, new Interval(12, 20));

                var pairs = new List<KeyValuePair<int, int>>(sortNsweep.FindPotentialCollisions());

                CheckEqual(5, pairs.Count());

                if (pairs.Count() == 5)
                {
                    CheckEqual(new KeyValuePair<int, int>(0, 1), pairs[0]);
                    CheckEqual(new KeyValuePair<int, int>(1, 2), pairs[1]);
                    CheckEqual(new KeyValuePair<int, int>(1, 4), pairs[2]);
                    CheckEqual(new KeyValuePair<int, int>(2, 4), pairs[3]);
                    CheckEqual(new KeyValuePair<int, int>(2, 3), pairs[4]);                    
                }
            }

            public void Add_Empty()
            {
                var list = new List<int>() {
                    
                };

                var minMax = new List<Interval> {
                    
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Add(4, new Interval(12, 20));

                var element = sortNsweep.QueryArea(new Interval(0, 40));
                CheckEqualCommutative(new[] { 4 }, element);
            }

            public void Add_Overlaps()
            {
                var list = new List<int>()
                {
                    1
                };

                var minMax = new List<Interval>
                {
                    new Interval(2, 3),
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Add(4, new Interval(2, 3));

                var overlaps = sortNsweep.QueryArea(new Interval(2, 3));
                CheckEqualCommutative(new[] { 1, 4, }, overlaps);
            }

            public void Add_Touching_Low()
            {
                var list = new List<int>()
                {
                    1
                };

                var minMax = new List<Interval>
                {
                    new Interval(2, 2),
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Add(4, new Interval(2, 3));

                var overlaps = new HashSet<int>(sortNsweep.QueryArea(new Interval(2, 3)));
                CheckEqualCommutative(new[] { 1, 4, }, overlaps);
            }

            public void Add_Touching_High()
            {
                var list = new List<int>()
                {
                    1
                };

                var minMax = new List<Interval>
                {
                    new Interval(3, 3),
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Add(4, new Interval(2, 3));

                var overlaps = new HashSet<int>(sortNsweep.QueryArea(new Interval(2, 3)));
                CheckEqualCommutative(new[] { 1, 4, }, overlaps);
            }

            public void Add_Disjoint()
            {
                var list = new List<int>()
                {
                    1
                };

                var minMax = new List<Interval>
                {
                    new Interval(7, 10),
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Add(4, new Interval(2, 3));

                var overlaps = new HashSet<int>(sortNsweep.QueryArea(new Interval(2, 3)));
                CheckEqualCommutative(new[] { 4, }, overlaps);
            }
        }

        public class Remove : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var list = new List<int>() {
                    0,
                    1,
                    2,
                    3,
                };

                var minMax = new List<Interval> {
                    new Interval(-10, 10),
                    new Interval(0, 20),
                    new Interval(11, 30),
                    new Interval(21, 40),
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Remove(2);

                var pairs = sortNsweep.FindPotentialCollisions().ToList();

                CheckEqual(1, pairs.Count);
                if (pairs.Count() == 1)
                {
                    CheckEqual(new KeyValuePair<int, int>(0, 1), pairs[0]);
                }
            }

            public void NoSuchEntry()
            {
                var list = new List<int>() {
                    0,
                    1,
                    3,
                };

                var minMax = new List<Interval> {
                    new Interval(-10, 10),
                    new Interval(0, 20),
                    new Interval(21, 40),
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Remove(7);

                var pairs = sortNsweep.FindPotentialCollisions().ToList();

                CheckEqual(1, pairs.Count);
                if (pairs.Count() == 1)
                {
                    CheckEqual(new KeyValuePair<int, int>(0, 1), pairs[0]);
                }
            }

            public void Duplicate()
            {
                var list = new List<int>() {
                    1,
                    1,
                    3,
                };

                var minMax = new List<Interval> {
                    new Interval(-10, 10),
                    new Interval(0, 20),
                    new Interval(21, 40),
                };

                var sortNsweep = new SortAndSweep<int>(list, minMax);

                sortNsweep.Remove(1);

                var pairs = sortNsweep.FindPotentialCollisions().ToList();

                CheckEqual(0, pairs.Count);
            }
        }
    }
}