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

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

        public static HashSet<string> Words(IEqualityComparer<string> comparer, params string[] words)
        {
            return new HashSet<string>(words, comparer);
        }

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

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

            public void DefaultComparer_IsLeftOut()
            {
                SaveNode node = Session().ToNode(new HashSet<string> { "a" }, typeof(HashSet<string>));

                CheckEqual(new[] { "items" }, node.Entries.Keys.ToArray());
            }

            public void NamedComparer_IsSavedBesideTheItems()
            {
                SaveNode node = Session().ToNode(Words(StringComparer.OrdinalIgnoreCase, "a"),
                    typeof(HashSet<string>));

                CheckEqual("OrdinalIgnoreCase", node.RequireEntry("comparer").Text);
            }

            public void ComparerThatCantBeSaved_Throws()
            {
                CheckThrow(typeof(NotSupportedException));
                Session().ToNode(Words(StringComparer.CurrentCulture, "a"), typeof(HashSet<string>));
            }

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

        public class ReadTests : TestFixture
        {
            public void SetHoldingItself_ReadsAsASetHoldingItself()
            {
                SaveNode node = SaveNode.NewTable();
                SaveNode items = SaveNode.NewList();
                items.Items.Add(node);
                node.Entries[HashSetConverter<object>.ItemsKey] = items;
                var loaded = (HashSet<object>)new SaveConverters(new SaveConverter[0]).CreateSession()
                    .FromNode(node, typeof(HashSet<object>));

                CheckTrue(loaded.Contains(loaded));
            }

            public void Set_RoundTripsInTheSameOrder()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(new HashSet<int> { 3, 1, 2 }, typeof(HashSet<int>));
                var loaded = (HashSet<int>)session.FromNode(node, typeof(HashSet<int>));

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

            public void Comparer_RoundTrips()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(Words(StringComparer.OrdinalIgnoreCase, "a"),
                    typeof(HashSet<string>));
                var loaded = (HashSet<string>)session.FromNode(node, typeof(HashSet<string>));

                CheckTrue(loaded.Comparer == StringComparer.OrdinalIgnoreCase);
                CheckTrue(loaded.Contains("A"));
            }

            public void NoComparer_LoadsWithTheDefault()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(new HashSet<string> { "a" }, typeof(HashSet<string>));
                var loaded = (HashSet<string>)session.FromNode(node, typeof(HashSet<string>));

                CheckFalse(loaded.Contains("A"));
            }

            public void SetThroughLuaText_RoundTrips()
            {
                SaveSession session = Session();
                var value = new HashSet<Point> { new Point(1.5, 0), new Point(0, -2) };
                SaveNode saved = session.ToNode(value, typeof(HashSet<Point>));
                SaveNode node = LuaSaveFormat.Parse(LuaSaveFormat.Format(saved));
                var loaded = (HashSet<Point>)session.FromNode(node, typeof(HashSet<Point>));

                CheckEqual(2, loaded.Count);
                CheckEqual(-2.0, loaded.Last().Y);
            }

            public void EmptySetThroughLuaText_RoundTrips()
            {
                SaveSession session = Session();
                SaveNode saved = session.ToNode(new HashSet<int>(), typeof(HashSet<int>));
                SaveNode node = LuaSaveFormat.Parse(LuaSaveFormat.Format(saved));

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

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

            public void SameItemTwice_KeepsTheFirstAndRecordsTheSecond()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries["items"] = SavedItems.ToNode(new[] { 1, 2, 1 }, Session());
                SaveSession session = Session();
                var loaded = (HashSet<int>)session.FromNode(node, typeof(HashSet<int>));

                CheckEqualCommutative(new[] { 1, 2 }, loaded);
                CheckEqual(new[] { "items: [2]" }, SaveConvertersTests.IssuePaths(session));
            }

            public void ItemsTheComparerCallsEqual_KeepsTheFirstAndRecordsTheSecond()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries["comparer"] = SaveNode.OfText("OrdinalIgnoreCase");
                node.Entries["items"] = SavedItems.ToNode(new[] { "a", "A" }, Session());
                SaveSession session = Session();
                var loaded = (HashSet<string>)session.FromNode(node, typeof(HashSet<string>));

                CheckEqual(new[] { "a" }, loaded.ToArray());
                CheckEqual(new[] { "items: [1]" }, SaveConvertersTests.IssuePaths(session));
            }

            public void MissingItems_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Session().FromNode(SaveNode.NewTable(), typeof(HashSet<int>));
            }

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

            public void UnknownComparer_Throws()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries["comparer"] = SaveNode.OfText("CurrentCulture");
                node.Entries["items"] = SaveNode.NewList();

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

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

                CheckTrue(new HashSetConverter<Waypoint>().TryListChildren(node, children));
                CheckEqual(2, children.Count);
                CheckTrue(ReferenceEquals(node.RequireEntry("items").Items[0], children.NodeAt(0)));
                CheckTrue(ReferenceEquals(node.RequireEntry("items").Items[1], children.NodeAt(1)));
                CheckEqual(typeof(Waypoint), children.TypeAt(0));
            }

            public void EmptySet_ListsNothingAndSucceeds()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries["items"] = SaveNode.NewList();
                var children = new ChildList();

                CheckTrue(new HashSetConverter<int>().TryListChildren(node, children));
                CheckEqual(0, children.Count);
            }

            public void MissingItems_ReturnsFalse()
            {
                CheckFalse(new HashSetConverter<int>().TryListChildren(SaveNode.NewTable(), new ChildList()));
            }

            public void ItemsThatAreNotAList_ReturnsFalse()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries["items"] = SaveNode.OfText("3");

                CheckFalse(new HashSetConverter<int>().TryListChildren(node, new ChildList()));
            }

            public void NodeThatIsNotATable_ReturnsFalse()
            {
                CheckFalse(new HashSetConverter<int>().TryListChildren(SaveNode.NewList(), new ChildList()));
            }
        }

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

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

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

        public class FillTests : TestFixture
        {
            public void SavedValue_AddsWhatReadLoads()
            {
                SaveSession session = SaveConvertersTests.Session();
                SaveNode node = session.ToNode(new HashSet<int> { 3, 1, 2 });
                var converter = new HashSetConverter<int>();
                HashSet<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 TheHashedOrSortedType_IsTrue()
            {
                CheckTrue(new HashSetConverter<int>().FillNeedsFilledPart(typeof(int)));
            }

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