using System;
using UnitTestSharp;

namespace Clave
{
    public class IdSetTests : TestFixture
    {
        public static IdSet Of(params int[] ids)
        {
            var returnMe = new IdSet();
            foreach (int id in ids)
            {
                returnMe.Add(id);
            }

            return returnMe;
        }

        public static int[] Members(IdSet set)
        {
            var returnMe = new System.Collections.Generic.List<int>();
            for (int id = set.NextAtOrAfter(0); id >= 0; id = set.NextAtOrAfter(id + 1))
            {
                returnMe.Add(id);
            }

            return returnMe.ToArray();
        }

        public class ContainsTests : TestFixture
        {
            public void EmptySet_HoldsNothing()
            {
                CheckFalse(new IdSet().Contains(0));
                CheckFalse(new IdSet().Contains(1000));
            }

            public void AddedIds_AreHeldAndOthersAreNot()
            {
                IdSet set = Of(3, 64, 200);

                Check(set.Contains(3));
                Check(set.Contains(64));
                Check(set.Contains(200));
                CheckFalse(set.Contains(2));
                CheckFalse(set.Contains(65));
                CheckFalse(set.Contains(199));
            }

            public void NegativeId_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new IdSet().Contains(-1);
            }
        }

        public class AddTests : TestFixture
        {
            public void AddingTwice_HoldsItOnce()
            {
                IdSet set = Of(5, 5);

                CheckEqual(new[] { 5 }, Members(set));
            }

            public void IdsOnEitherSideOfAWordBoundary_AreKeptApart()
            {
                IdSet set = Of(63, 64);

                CheckEqual(new[] { 63, 64 }, Members(set));
            }

            public void NegativeId_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new IdSet().Add(-1);
            }
        }

        public class RemoveTests : TestFixture
        {
            public void RemovesOnlyThatId()
            {
                IdSet set = Of(1, 2, 3);

                set.Remove(2);

                CheckEqual(new[] { 1, 3 }, Members(set));
            }

            public void IdBeyondTheSet_ChangesNothing()
            {
                IdSet set = Of(1);

                set.Remove(500);

                CheckEqual(new[] { 1 }, Members(set));
            }

            public void NegativeId_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new IdSet().Remove(-1);
            }
        }

        public class ClearTests : TestFixture
        {
            public void EmptiesTheSet()
            {
                IdSet set = Of(1, 100);

                set.Clear();

                CheckEqual(0, Members(set).Length);
            }
        }

        public class CopyFromTests : TestFixture
        {
            public void HoldsExactlyWhatTheOtherHolds()
            {
                IdSet set = Of(1, 2);

                set.CopyFrom(Of(2, 70));

                CheckEqual(new[] { 2, 70 }, Members(set));
            }

            public void ACopyOfASmallerSet_DropsTheHigherMembers()
            {
                IdSet set = Of(1, 200);

                set.CopyFrom(Of(1));

                CheckEqual(new[] { 1 }, Members(set));
            }

            public void ChangingTheCopy_LeavesTheSourceAlone()
            {
                IdSet source = Of(4);
                IdSet copy = new IdSet();
                copy.CopyFrom(source);

                copy.Add(9);

                CheckEqual(new[] { 4 }, Members(source));
            }
        }

        public class UnionWithTests : TestFixture
        {
            public void HoldsEverythingFromBoth()
            {
                IdSet set = Of(1, 2);

                set.UnionWith(Of(2, 130));

                CheckEqual(new[] { 1, 2, 130 }, Members(set));
            }

            public void UnionWithASmallerSet_KeepsTheHigherMembers()
            {
                IdSet set = Of(1, 200);

                set.UnionWith(Of(2));

                CheckEqual(new[] { 1, 2, 200 }, Members(set));
            }
        }

        public class IntersectWithTests : TestFixture
        {
            public void KeepsOnlyWhatBothHold()
            {
                IdSet set = Of(1, 2, 3, 100);

                set.IntersectWith(Of(2, 3, 4, 100));

                CheckEqual(new[] { 2, 3, 100 }, Members(set));
            }

            public void IntersectingWithASmallerSet_DropsTheHigherMembers()
            {
                IdSet set = Of(1, 200);

                set.IntersectWith(Of(1, 2));

                CheckEqual(new[] { 1 }, Members(set));
            }

            public void IntersectingWithTheEmptySet_EmptiesIt()
            {
                IdSet set = Of(1, 200);

                set.IntersectWith(new IdSet());

                CheckEqual(0, Members(set).Length);
            }
        }

        public class NextAtOrAfterTests : TestFixture
        {
            public void EmptySet_FindsNone()
            {
                CheckEqual(-1, new IdSet().NextAtOrAfter(0));
            }

            public void FindsTheIdItself()
            {
                CheckEqual(7, Of(7, 9).NextAtOrAfter(7));
            }

            public void FindsTheNextOneInTheSameWord()
            {
                CheckEqual(9, Of(7, 9).NextAtOrAfter(8));
            }

            public void FindsTheNextOneInALaterWord()
            {
                CheckEqual(200, Of(7, 200).NextAtOrAfter(8));
            }

            public void PastTheLastMember_FindsNone()
            {
                CheckEqual(-1, Of(7, 200).NextAtOrAfter(201));
            }

            public void StartingBeyondTheStoredWords_FindsNone()
            {
                CheckEqual(-1, Of(7).NextAtOrAfter(1000));
            }

            public void TheTopBitOfAWord_IsFound()
            {
                CheckEqual(63, Of(63).NextAtOrAfter(0));
            }

            public void TheLowBitOfALaterWord_IsFound()
            {
                CheckEqual(128, Of(128).NextAtOrAfter(0));
            }

            public void NegativeId_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new IdSet().NextAtOrAfter(-1);
            }
        }
    }
}