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());

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

        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());

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

        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);

                HashSet<int> overlaps;
                sortNsweep.Add(4, new Interval(12, 20), out overlaps);

                CheckEqual(2, overlaps.Count);
                if (overlaps.Count >= 2)
                {
                    Check(overlaps.Contains(1));
                    Check(overlaps.Contains(2));
                }

                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);

                HashSet<int> overlaps;
                sortNsweep.Add(4, new Interval(12, 20), out overlaps);

                CheckEqual(0, overlaps.Count);

                var element = sortNsweep.QueryArea(new Interval(0, 40)).First();
                CheckEqual(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);

                HashSet<int> overlaps;
                sortNsweep.Add(4, new Interval(2, 3), out overlaps);

                CheckEqual(1, overlaps.Count);
                CheckEqual(1, overlaps.First());

                overlaps = sortNsweep.QueryArea(new Interval(2, 3));
                CheckEqual(2, overlaps.Count);
                if (overlaps.Count == 2)
                {
                    Check(overlaps.Contains(1));
                    Check(overlaps.Contains(4));
                }
            }

            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);

                HashSet<int> overlaps;
                sortNsweep.Add(4, new Interval(2, 3), out overlaps);

                CheckEqual(0, overlaps.Count);

                overlaps = sortNsweep.QueryArea(new Interval(2, 3));
                CheckEqual(1, overlaps.Count);
                if (overlaps.Count == 1)
                {
                    Check(overlaps.Contains(4));
                }
            }

            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);

                HashSet<int> overlaps;
                sortNsweep.Add(4, new Interval(2, 3), out overlaps);

                CheckEqual(0, overlaps.Count);

                overlaps = sortNsweep.QueryArea(new Interval(2, 3));
                CheckEqual(1, overlaps.Count);
                if (overlaps.Count == 1)
                {
                    Check(overlaps.Contains(4));
                }
            }

            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);

                HashSet<int> overlaps;
                sortNsweep.Add(4, new Interval(2, 3), out overlaps);

                CheckEqual(0, overlaps.Count);

                overlaps = sortNsweep.QueryArea(new Interval(2, 3));
                CheckEqual(1, overlaps.Count);
                if (overlaps.Count == 1)
                {
                    Check(overlaps.Contains(4));
                }
            }
        }
    }
}