using System.IO;
using System.Linq;
using UnitTestSharp;
using Vellum;

namespace Amphora.Vellum.UnitTests
{
    public class DynamicArrayConverterTests : TestFixture
    {
        public static SaveSession Session()
        {
            return SaveConverters.For(typeof(DynamicArrayConverterTests).Assembly).CreateSession();
        }

        public static DynamicArray<ItemType> Holding<ItemType>(params ItemType[] items)
        {
            var returnMe = new DynamicArray<ItemType>();
            foreach (ItemType item in items)
            {
                returnMe.Add(item);
            }

            return returnMe;
        }

        public class WriteTests : TestFixture
        {
            public void Array_IsAListOfItsItems()
            {
                SaveNode node = Session().ToNode(Holding(3, 1, 2), typeof(DynamicArray<int>));

                CheckEqual(SaveNode.Kinds.List, node.Kind);
                CheckEqual(new[] { "3", "1", "2" }, node.Items.Select(item => item.Text).ToArray());
            }

            public void SpareCapacity_IsNotSaved()
            {
                var value = new DynamicArray<int>(100);
                value.Add(5);
                SaveNode node = Session().ToNode(value, typeof(DynamicArray<int>));

                CheckEqual(1, node.Items.Count);
            }

            public void NullArray_IsNull()
            {
                CheckEqual(SaveNode.Kinds.Null, Session().ToNode(null, typeof(DynamicArray<int>)).Kind);
            }

            public void ItemTypeNothingSaves_Throws()
            {
                CheckThrow(typeof(System.InvalidOperationException));
                Session().ToNode(new DynamicArray<Stream>(), typeof(DynamicArray<Stream>));
            }
        }

        public class ReadTests : TestFixture
        {
            public void ArrayHoldingItself_ReadsAsAnArrayHoldingItself()
            {
                SaveNode node = SaveNode.NewList();
                node.Items.Add(node);
                var loaded = (DynamicArray<object>)Session().FromNode(node, typeof(DynamicArray<object>));

                CheckTrue(ReferenceEquals(loaded, loaded[0]));
            }

            public void Array_RoundTripsInTheSameOrder()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(Holding("b", "a", null), typeof(DynamicArray<string>));
                var loaded = (DynamicArray<string>)session.FromNode(node, typeof(DynamicArray<string>));

                CheckEqual(3, loaded.Count);
                CheckEqual("b", loaded[0]);
                CheckEqual("a", loaded[1]);
                CheckNull(loaded[2]);
            }

            public void ArrayOfSaveableValuesThroughLuaText_RoundTrips()
            {
                SaveSession session = Session();
                SaveNode saved = session.ToNode(Holding(new Vector { X = 1.5 }, new Vector { Y = -2 }),
                    typeof(DynamicArray<Vector>));
                SaveNode node = SaveConverterTests.ThroughLuaText(saved);
                var loaded = (DynamicArray<Vector>)session.FromNode(node, typeof(DynamicArray<Vector>));

                CheckEqual(1.5, loaded[0].X);
                CheckEqual(-2.0, loaded[1].Y);
            }

            public void EmptyArrayThroughLuaText_RoundTrips()
            {
                SaveSession session = Session();
                SaveNode node = SaveConverterTests.ThroughLuaText(
                    session.ToNode(new DynamicArray<int>(), typeof(DynamicArray<int>)));

                CheckEqual(0, ((DynamicArray<int>)session.FromNode(node, typeof(DynamicArray<int>))).Count);
            }

            public void NullForAnArray_IsNull()
            {
                CheckNull(Session().FromNode(SaveNode.Null, typeof(DynamicArray<int>)));
            }

            public void NodeThatIsNotAList_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Session().FromNode(SaveNode.OfText("3"), typeof(DynamicArray<int>));
            }
        }

        public class TryListChildrenTests : TestFixture
        {
            public void EachItem_IsListedAsTheItemType()
            {
                SaveNode node = Session().ToNode(Holding("a", null), typeof(DynamicArray<string>));
                var children = new ChildList();

                CheckTrue(new DynamicArrayConverter<string>().TryListChildren(node, children));
                CheckEqual(2, children.Count);
                CheckTrue(ReferenceEquals(node.Items[0], children.NodeAt(0)));
                CheckTrue(ReferenceEquals(node.Items[1], children.NodeAt(1)));
                CheckEqual(typeof(string), children.TypeAt(0));
            }

            public void EmptyArray_ListsNothingAndSucceeds()
            {
                var children = new ChildList();

                CheckTrue(new DynamicArrayConverter<int>().TryListChildren(SaveNode.NewList(), children));
                CheckEqual(0, children.Count);
            }

            public void NodeThatIsNotAList_ReturnsFalse()
            {
                CheckFalse(new DynamicArrayConverter<int>().TryListChildren(SaveNode.OfText("3"), new ChildList()));
            }
        }

        public class AllocateTests : TestFixture
        {
            public void SavedValue_GivesAnEmptyArray()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(Holding(3, 1, 2), typeof(DynamicArray<int>));

                CheckEqual(0, new DynamicArrayConverter<int>().Allocate(node, session).Count);
            }

            public void NodeThatIsNotAList_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                new DynamicArrayConverter<int>().Allocate(SaveNode.OfText("3"), Session());
            }
        }

        public class FillTests : TestFixture
        {
            public void SavedValue_AddsTheSavedItemsInOrder()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(Holding(3, 1, 2), typeof(DynamicArray<int>));
                var converter = new DynamicArrayConverter<int>();
                DynamicArray<int> filled = converter.Allocate(node, session);
                converter.Fill(filled, node, session);

                CheckEqual(new[] { 3, 1, 2 }, filled.ToArray());
            }
        }

        public class FillNeedsFilledPartTests : TestFixture
        {
            public void AnyType_IsFalse()
            {
                CheckFalse(new DynamicArrayConverter<int>().FillNeedsFilledPart(typeof(int)));
            }
        }
    }
}