using System;
using System.Collections.Generic;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class PermutedListTests : TestFixture
    {
        public class CtorTests : TestFixture
        {
            public void NullSource_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new PermutedList<string>(null, new int[0]);
            }

            public void NullOrder_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new PermutedList<string>(new[] { "a" }, null);
            }

            public void AnOrderOfTheWrongLength_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new PermutedList<string>(new[] { "a", "b" }, new[] { 0 });
            }

            public void ARepeatedPosition_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new PermutedList<string>(new[] { "a", "b" }, new[] { 1, 1 });
            }

            public void APositionPastTheEnd_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new PermutedList<string>(new[] { "a", "b" }, new[] { 0, 2 });
            }

            public void ANegativePosition_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new PermutedList<string>(new[] { "a", "b" }, new[] { 0, -1 });
            }

            public void ChangingTheOrderAfterwards_ChangesNothing()
            {
                var order = new[] { 1, 0 };
                var view = new PermutedList<string>(new[] { "a", "b" }, order);

                order[0] = 0;
                order[1] = 1;

                CheckEqual("b", view[0]);
            }
        }

        public class CountTests : TestFixture
        {
            public void Always_IsTheSourcesCount()
            {
                CheckEqual(3, new PermutedList<string>(new[] { "a", "b", "c" }, new[] { 2, 0, 1 }).Count);
            }

            public void Empty_IsZero()
            {
                CheckEqual(0, new PermutedList<string>(new string[0], new int[0]).Count);
            }
        }

        public class IndexerTests : TestFixture
        {
            public void Always_ReadsTheSourceThroughTheOrder()
            {
                var view = new PermutedList<string>(new[] { "a", "b", "c" }, new[] { 2, 0, 1 });

                CheckEqual("c", view[0]);
                CheckEqual("a", view[1]);
                CheckEqual("b", view[2]);
            }

            public void Always_LeavesTheSourceAlone()
            {
                var source = new[] { "a", "b", "c" };

                var view = new PermutedList<string>(source, new[] { 2, 1, 0 });

                CheckEqual("c", view[0]);
                CheckEqual(new[] { "a", "b", "c" }, source);
            }

            public void ThroughTheOrder_FollowsASourceThatIsAList()
            {
                var source = new List<string> { "a", "b" };
                var view = new PermutedList<string>(source, new[] { 1, 0 });

                source[0] = "changed";

                CheckEqual("changed", view[1]);
            }

            public void PastTheEnd_Throws()
            {
                var view = new PermutedList<string>(new[] { "a" }, new[] { 0 });

                CheckThrow(typeof(ArgumentOutOfRangeException));
                string unused = view[1];
            }

            public void Negative_Throws()
            {
                var view = new PermutedList<string>(new[] { "a" }, new[] { 0 });

                CheckThrow(typeof(ArgumentOutOfRangeException));
                string unused = view[-1];
            }
        }

        public class GetEnumeratorTests : TestFixture
        {
            public void Always_WalksTheViewInOrder()
            {
                var view = new PermutedList<string>(new[] { "a", "b", "c" }, new[] { 1, 2, 0 });
                var seen = new List<string>();

                foreach (string item in view)
                {
                    seen.Add(item);
                }

                CheckEqual(new List<string> { "b", "c", "a" }, seen);
            }

            public void ThroughTheNonGenericInterface_WalksTheViewInOrder()
            {
                var view = new PermutedList<string>(new[] { "a", "b" }, new[] { 1, 0 });
                var seen = new List<object>();

                foreach (object item in (System.Collections.IEnumerable)view)
                {
                    seen.Add(item);
                }

                CheckEqual(new List<object> { "b", "a" }, seen);
            }
        }
    }
}