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

namespace Vellum.UnitTests
{
    public class SetConverterTests : TestFixture
    {
        public class Roster<ItemType> : HashSet<ItemType>
        {
            public string Stamp;
        }

        public class RosterConverter<ItemType> : SetConverter<Roster<ItemType>, ItemType>
        {
            public const string StampKey = "stamp";

            public override void WriteComparison(SaveNode table, Roster<ItemType> value)
            {
                if (value.Stamp != null)
                {
                    table.Entries[StampKey] = SaveNode.OfText(value.Stamp);
                }
            }

            public override Roster<ItemType> CreateEmpty(SaveNode table)
            {
                SaveNode stamp;
                table.TryGetEntry(StampKey, out stamp);
                return new Roster<ItemType> { Stamp = stamp == null ? null : stamp.Text };
            }
        }

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

        private static SaveNode TableOf(params string[] texts)
        {
            SaveNode items = SaveNode.NewList();
            foreach (string text in texts)
            {
                items.Items.Add(SaveNode.OfText(text));
            }

            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries[RosterConverter<string>.ItemsKey] = items;
            return returnMe;
        }

        public class WriteTests : TestFixture
        {
            public void Items_AreAListUnderTheItemsKey()
            {
                var roster = new Roster<int> { 3 };

                SaveNode node = Session().ToNode(roster, typeof(Roster<int>));

                CheckEqual(SaveNode.Kinds.Table, node.Kind);
                SaveNode items = node.RequireEntry(RosterConverter<int>.ItemsKey);
                CheckEqual(SaveNode.Kinds.List, items.Kind);
                CheckEqual(new[] { "3" }, items.Items.Select(item => item.Text).ToArray());
            }

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

                CheckEqual(0, node.RequireEntry(RosterConverter<int>.ItemsKey).Items.Count);
            }

            public void Comparison_IsWrittenIntoTheSameTable()
            {
                var roster = new Roster<int> { Stamp = "checked" };

                SaveNode node = Session().ToNode(roster, typeof(Roster<int>));

                CheckEqual("checked", node.RequireEntry(RosterConverter<int>.StampKey).Text);
            }

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

        public class ReadTests : TestFixture
        {
            public void List_AddsEachItem()
            {
                var loaded = (Roster<string>)Session().FromNode(TableOf("a", "b"), typeof(Roster<string>));

                CheckEqual(2, loaded.Count);
                CheckTrue(loaded.Contains("a"));
                CheckTrue(loaded.Contains("b"));
            }

            public void Comparison_IsGivenToTheNewSet()
            {
                SaveNode node = TableOf();
                node.Entries[RosterConverter<string>.StampKey] = SaveNode.OfText("checked");

                var loaded = (Roster<string>)Session().FromNode(node, typeof(Roster<string>));

                CheckEqual("checked", loaded.Stamp);
            }

            public void SetHoldingItself_ReadsAsOneHoldingItself()
            {
                SaveNode node = TableOf();
                node.Entries[RosterConverter<object>.ItemsKey].Items.Add(node);

                var loaded = (Roster<object>)Session().FromNode(node, typeof(Roster<object>));

                CheckTrue(loaded.Contains(loaded));
            }

            public void NodeWithoutItems_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Session().FromNode(SaveNode.NewTable(), typeof(Roster<string>));
            }

            public void ItemsThatAreNotAList_Throws()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries[RosterConverter<string>.ItemsKey] = SaveNode.OfText("x");

                CheckThrow(typeof(InvalidDataException));
                Session().FromNode(node, typeof(Roster<string>));
            }

            public void RepeatedItem_IsRecordedAndOnlyOneIsKept()
            {
                SaveSession session = Session();
                var loaded = (Roster<string>)session.FromNode(TableOf("a", "a"), typeof(Roster<string>));

                CheckEqual(1, loaded.Count);
                CheckEqual(1, session.Sandbox.Issues.Count);
            }
        }

        public class FillNeedsFilledPartTests : TestFixture
        {
            public void TheItemType_IsTrue()
            {
                CheckTrue(new RosterConverter<string>().FillNeedsFilledPart(typeof(string)));
            }

            public void AnotherType_IsFalse()
            {
                CheckFalse(new RosterConverter<string>().FillNeedsFilledPart(typeof(int)));
            }
        }

        public class TryListChildrenTests : TestFixture
        {
            public void List_ListsEachItemAsTheItemType()
            {
                var children = new ChildList();

                bool listed = new RosterConverter<string>().TryListChildren(TableOf("a", "b"), children);

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

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

                CheckFalse(new RosterConverter<string>().TryListChildren(SaveNode.NewTable(), children));
                CheckEqual(0, children.Count);
            }

            public void ItemsThatAreNotAList_ReturnsFalseAndListsNothing()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries[RosterConverter<string>.ItemsKey] = SaveNode.OfText("x");
                var children = new ChildList();

                CheckFalse(new RosterConverter<string>().TryListChildren(node, children));
                CheckEqual(0, children.Count);
            }
        }
    }
}