using System;
using UnitTestSharp;

namespace Vellum.UnitTests
{
    public class ChildListTests : TestFixture
    {
        public class CountTests : TestFixture
        {
            public void NewList_IsEmpty()
            {
                CheckEqual(0, new ChildList().Count);
            }

            public void AfterEachAdd_IsOneMore()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));
                children.Add(SaveNode.Null, typeof(int));

                CheckEqual(2, children.Count);
            }
        }

        public class AddTests : TestFixture
        {
            public void NodeAndType_AreKeptTogetherInOrder()
            {
                var first = SaveNode.NewTable();
                var second = SaveNode.NewList();
                var children = new ChildList();
                children.Add(first, typeof(string));
                children.Add(second, typeof(double));

                CheckTrue(ReferenceEquals(first, children.NodeAt(0)));
                CheckEqual(typeof(string), children.TypeAt(0));
                CheckTrue(ReferenceEquals(second, children.NodeAt(1)));
                CheckEqual(typeof(double), children.TypeAt(1));
            }

            public void SameNodeTwice_IsListedTwice()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));
                children.Add(SaveNode.Null, typeof(long));

                CheckEqual(2, children.Count);
            }

            public void NullNode_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new ChildList().Add(null, typeof(int));
            }

            public void NullType_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new ChildList().Add(SaveNode.Null, null);
            }
        }

        /// <summary>
        /// A list that takes every null part instead of keeping it.
        /// </summary>
        public class NullDroppingList : ChildList
        {
            protected override bool TrySubstitute(SaveNode node, Type type)
            {
                return node.Kind == SaveNode.Kinds.Null;
            }
        }

        public class TrySubstituteTests : TestFixture
        {
            public void PartTheDerivedListTakes_IsNotKept()
            {
                var children = new NullDroppingList();
                children.Add(SaveNode.Null, typeof(int));

                CheckEqual(0, children.Count);
            }

            public void PartTheDerivedListLeaves_IsKept()
            {
                var children = new NullDroppingList();
                children.Add(SaveNode.NewTable(), typeof(int));

                CheckEqual(1, children.Count);
            }

            public void BaseList_KeepsEveryPart()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));

                CheckEqual(1, children.Count);
            }

            public void NullNode_StillThrowsInADerivedList()
            {
                CheckThrow(typeof(ArgumentNullException));
                new NullDroppingList().Add(null, typeof(int));
            }
        }

        public class TruncateTests : TestFixture
        {
            public void KeepsTheFirstParts()
            {
                var first = SaveNode.NewTable();
                var children = new ChildList();
                children.Add(first, typeof(int));
                children.Add(SaveNode.NewList(), typeof(long));
                children.Truncate(1);

                CheckEqual(1, children.Count);
                CheckTrue(ReferenceEquals(first, children.NodeAt(0)));
                CheckEqual(typeof(int), children.TypeAt(0));
            }

            public void ToTheCount_KeepsEverything()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));
                children.Truncate(1);

                CheckEqual(1, children.Count);
            }

            public void ToZero_EmptiesTheList()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));
                children.Truncate(0);

                CheckEqual(0, children.Count);
            }

            public void ListCanBeFilledAgain()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));
                children.Add(SaveNode.Null, typeof(int));
                children.Truncate(1);
                children.Add(SaveNode.Null, typeof(string));

                CheckEqual(typeof(string), children.TypeAt(1));
            }

            public void PastTheCount_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new ChildList().Truncate(1);
            }

            public void Negative_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new ChildList().Truncate(-1);
            }
        }

        public class NodeAtTests : TestFixture
        {
            public void OutOfRange_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new ChildList().NodeAt(0);
            }
        }

        public class TypeAtTests : TestFixture
        {
            public void OutOfRange_Throws()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));

                CheckThrow(typeof(ArgumentOutOfRangeException));
                children.TypeAt(1);
            }
        }

        public class ClearTests : TestFixture
        {
            public void EmptiesTheList()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));
                children.Clear();

                CheckEqual(0, children.Count);
            }

            public void ListCanBeFilledAgain()
            {
                var children = new ChildList();
                children.Add(SaveNode.Null, typeof(int));
                children.Clear();
                children.Add(SaveNode.Null, typeof(string));

                CheckEqual(typeof(string), children.TypeAt(0));
            }
        }
    }
}