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

namespace Vellum.UnitTests
{
    public class ItemsConverterTests : TestFixture
    {
        public class Tray<ItemType> : List<ItemType>
        {
            public int Reserved;
        }

        public class TrayConverter<ItemType> : ItemsConverter<Tray<ItemType>, ItemType>
        {
            public override Tray<ItemType> CreateEmpty(int capacity)
            {
                return new Tray<ItemType> { Reserved = capacity };
            }

            public override void AddItem(Tray<ItemType> collection, ItemType item)
            {
                collection.Add(item);
            }
        }

        public class BackwardTray<ItemType> : List<ItemType>
        {
        }

        public class BackwardTrayConverter<ItemType> : ItemsConverter<BackwardTray<ItemType>, ItemType>
        {
            public override BackwardTray<ItemType> CreateEmpty(int capacity)
            {
                return new BackwardTray<ItemType>();
            }

            public override void AddItem(BackwardTray<ItemType> collection, ItemType item)
            {
                collection.Add(item);
            }

            public override IEnumerable<ItemType> ItemsInSaveOrder(BackwardTray<ItemType> value)
            {
                return value.AsEnumerable().Reverse();
            }
        }

        public static SaveSession Session()
        {
            return SaveConvertersTests.SessionWith(typeof(TrayConverter<>));
        }

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

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

            public void NoItems_IsAnEmptyList()
            {
                SaveNode node = Session().ToNode(new Tray<int>(), typeof(Tray<int>));

                CheckEqual(SaveNode.Kinds.List, node.Kind);
                CheckEqual(0, node.Items.Count);
            }

            public void ConverterThatChoosesTheOrder_IsFollowed()
            {
                SaveNode node = SaveConvertersTests.SessionWith(typeof(BackwardTrayConverter<>))
                    .ToNode(new BackwardTray<int> { 3, 1, 2 }, typeof(BackwardTray<int>));

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

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

        public class ReadTests : TestFixture
        {
            private static SaveNode ListOf(params string[] texts)
            {
                SaveNode returnMe = SaveNode.NewList();
                foreach (string text in texts)
                {
                    returnMe.Items.Add(SaveNode.OfText(text));
                }

                return returnMe;
            }

            public void List_IsAddedItemByItemInOrder()
            {
                var loaded = (Tray<int>)Session().FromNode(ListOf("3", "1", "2"), typeof(Tray<int>));

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

            public void List_MakesTheCollectionWithRoomForEveryItem()
            {
                var loaded = (Tray<int>)Session().FromNode(ListOf("3", "1", "2"), typeof(Tray<int>));

                CheckEqual(3, loaded.Reserved);
            }

            public void EmptyList_IsAnEmptyCollection()
            {
                var loaded = (Tray<int>)Session().FromNode(ListOf(), typeof(Tray<int>));

                CheckEqual(0, loaded.Count);
            }

            public void CollectionHoldingItself_ReadsAsOneHoldingItself()
            {
                SaveNode node = SaveNode.NewList();
                node.Items.Add(node);

                var loaded = (Tray<object>)SaveConvertersTests.SessionWith(typeof(TrayConverter<>))
                    .FromNode(node, typeof(Tray<object>));

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

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

            public void ItemOfTheWrongKind_IsLeftOutAndRecordedAtItsIndex()
            {
                SaveNode node = SaveNode.NewList();
                node.Items.Add(SaveNode.OfText("1"));
                node.Items.Add(SaveNode.NewList());
                node.Items.Add(SaveNode.OfText("3"));
                SaveSession session = Session();

                CheckEqual(new[] { 1, 3 }, ((Tray<int>)session.FromNode(node, typeof(Tray<int>))).ToArray());
                CheckEqual(new[] { "[1]" }, SaveConvertersTests.IssuePaths(session));
            }
        }

        public class TryListChildrenTests : TestFixture
        {
            public void List_ListsEachItemAsTheItemType()
            {
                SaveNode node = SaveNode.NewList();
                node.Items.Add(SaveNode.OfText("a"));
                node.Items.Add(SaveNode.OfText("b"));
                var children = new ChildList();

                bool listed = new TrayConverter<string>().TryListChildren(node, children);

                CheckTrue(listed);
                CheckEqual(2, children.Count);
                CheckEqual("b", children.NodeAt(1).Text);
                CheckEqual(typeof(string), children.TypeAt(1));
            }

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

                CheckFalse(new TrayConverter<string>().TryListChildren(SaveNode.OfText("a"), children));
                CheckEqual(0, children.Count);
            }
        }
    }
}