using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnitTestSharp;

namespace Vellum.UnitTests
{
    public class ListConverterTests : TestFixture
    {
        public static SaveSession Session()
        {
            return SaveConvertersTests.TestConverters().CreateSession();
        }

        public class WriteTests : TestFixture
        {
            public void List_IsAListOfItsItems()
            {
                SaveNode node = Session().ToNode(new List<int> { 3, 1, 2 }, typeof(List<int>));

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

            public void ListOfLists_IsAListOfLists()
            {
                var value = new List<List<string>> { new List<string> { "a" }, new List<string> { "b", "c" } };
                SaveNode node = Session().ToNode(value, typeof(List<List<string>>));

                CheckEqual("c", node.Items[1].Items[1].Text);
            }

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

        public class ReadTests : TestFixture
        {
            public void ListHoldingItself_ReadsAsAListHoldingItself()
            {
                SaveNode node = SaveNode.NewList();
                node.Items.Add(node);
                var loaded = (List<object>)new SaveConverters(new SaveConverter[0]).CreateSession()
                    .FromNode(node, typeof(List<object>));

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

            public void ListHoldingItselfThroughLuaText_ReadsAsAListHoldingItself()
            {
                SaveNode list = SaveNode.NewList();
                list.Items.Add(list);
                SaveNode save = SaveNode.NewTable();
                save.Entries["list"] = list;
                SaveNode read = LuaSaveFormat.Parse(LuaSaveFormat.Format(save));
                var loaded = (List<object>)new SaveConverters(new SaveConverter[0]).CreateSession()
                    .FromNode(read.RequireEntry("list"), typeof(List<object>));

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

            public void List_RoundTrips()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(new List<int> { 3, 1, 2 }, typeof(List<int>));

                CheckEqual(new[] { 3, 1, 2 }, (List<int>)session.FromNode(node, typeof(List<int>)));
            }

            public void ListOfConvertedValues_RoundTrips()
            {
                SaveSession session = Session();
                var value = new List<Waypoint> { new Waypoint { Name = "end", At = new Point(1.5, -2) }, null };
                SaveNode node = session.ToNode(value, typeof(List<Waypoint>));
                var loaded = (List<Waypoint>)session.FromNode(node, typeof(List<Waypoint>));

                CheckEqual("end", loaded[0].Name);
                CheckEqual(-2.0, loaded[0].At.Y);
                CheckNull(loaded[1]);
            }

            public void ListThroughLuaText_RoundTrips()
            {
                SaveSession session = Session();
                var value = new List<string> { "a", null, "c d" };
                SaveNode node = SaveConvertersTests.ThroughLuaText(session.ToNode(value, typeof(List<string>)));

                CheckEqual(value, (List<string>)session.FromNode(node, typeof(List<string>)));
            }

            public void EmptyListThroughLuaText_RoundTrips()
            {
                SaveSession session = Session();
                SaveNode node = SaveConvertersTests.ThroughLuaText(
                    session.ToNode(new List<int>(), typeof(List<int>)));

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

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

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

        public class TryListChildrenTests : TestFixture
        {
            public void EachItem_IsListedAsTheItemType()
            {
                var value = new List<Waypoint> { new Waypoint { Name = "a" }, null };
                SaveNode node = Session().ToNode(value, typeof(List<Waypoint>));
                var children = new ChildList();

                CheckTrue(new ListConverter<Waypoint>().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(Waypoint), children.TypeAt(0));
                CheckEqual(typeof(Waypoint), children.TypeAt(1));
            }

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

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

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

        public class AllocateTests : TestFixture
        {
            public void SavedValue_GivesAnEmptyCollection()
            {
                SaveSession session = SaveConvertersTests.Session();
                SaveNode node = session.ToNode(new List<int> { 3, 1, 2 });

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

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

        public class FillTests : TestFixture
        {
            public void SavedValue_AddsWhatReadLoads()
            {
                SaveSession session = SaveConvertersTests.Session();
                SaveNode node = session.ToNode(new List<int> { 3, 1, 2 });
                var converter = new ListConverter<int>();
                List<int> filled = converter.Allocate(node, session);
                converter.Fill(filled, node, session);

                CheckTrue(converter.Read(node, SaveConvertersTests.Session()).SequenceEqual(filled));
            }
        }

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