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

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

        public static SortedDictionary<KeyType, ValueType> ThroughLuaText<KeyType, ValueType>(
            SortedDictionary<KeyType, ValueType> value)
        {
            SaveSession session = Session();
            Type type = typeof(SortedDictionary<KeyType, ValueType>);
            SaveNode node = SaveConvertersTests.ThroughLuaText(session.ToNode(value, type));
            return (SortedDictionary<KeyType, ValueType>)session.FromNode(node, type);
        }

        public class WriteTests : TestFixture
        {
            public void Entries_AreAMapUnderEntries()
            {
                var value = new SortedDictionary<string, int> { { "b", 2 }, { "a", 1 } };
                SaveNode node = Session().ToNode(value, typeof(SortedDictionary<string, int>));

                CheckEqual(new[] { "a", "b" },
                    node.RequireEntry("entries").RequireMap().Select(entry => entry.Key.Text).ToArray());
            }

            public void DefaultOrdering_IsLeftOut()
            {
                SaveNode node = Session().ToNode(new SortedDictionary<string, int>(),
                    typeof(SortedDictionary<string, int>));

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

            public void NamedOrdering_IsSavedBesideTheEntries()
            {
                var value = new SortedDictionary<string, int>(StringComparer.Ordinal);
                SaveNode node = Session().ToNode(value, typeof(SortedDictionary<string, int>));

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

            public void OrderingThatCantBeSaved_Throws()
            {
                var value = new SortedDictionary<string, int>(StringComparer.CurrentCulture);

                CheckThrow(typeof(NotSupportedException));
                Session().ToNode(value, typeof(SortedDictionary<string, int>));
            }

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

        public class ReadTests : TestFixture
        {
            public void DictionaryHoldingItself_ReadsAsADictionaryHoldingItself()
            {
                var loaded = (SortedDictionary<string, object>)new SaveConverters(new SaveConverter[0])
                    .CreateSession()
                    .FromNode(DictionaryConverterTests.ReadTests.NodeHoldingItself(),
                        typeof(SortedDictionary<string, object>));

                CheckTrue(ReferenceEquals(loaded, loaded["self"]));
            }

            public void TextKeys_RoundTrip()
            {
                var value = new SortedDictionary<string, int> { { "b", 2 }, { "a", 1 } };
                SortedDictionary<string, int> loaded = ThroughLuaText(value);

                CheckEqual(new[] { "a", "b" }, loaded.Keys.ToArray());
                CheckEqual(2, loaded["b"]);
            }

            public void ConvertedKeys_RoundTrip()
            {
                var value = new SortedDictionary<int, Point> { { 5, new Point(1.5, 0) }, { -3, new Point(0, 2) } };
                SortedDictionary<int, Point> loaded = ThroughLuaText(value);

                CheckEqual(new[] { -3, 5 }, loaded.Keys.ToArray());
                CheckEqual(1.5, loaded[5].X);
            }

            public void Ordering_RoundTrips()
            {
                var value = new SortedDictionary<string, int>(StringComparer.OrdinalIgnoreCase) { { "a", 1 } };
                SortedDictionary<string, int> loaded = ThroughLuaText(value);

                CheckTrue(loaded.Comparer == StringComparer.OrdinalIgnoreCase);
                CheckEqual(1, loaded["A"]);
            }

            public void EmptyDictionary_RoundTrips()
            {
                CheckEqual(0, ThroughLuaText(new SortedDictionary<string, int>()).Count);
            }

            public void NullForADictionary_IsNull()
            {
                CheckNull(Session().FromNode(SaveNode.Null, typeof(SortedDictionary<string, int>)));
            }

            public void KeysTheOrderingCallsEqual_RecordsTheSecond()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries["comparer"] = SaveNode.OfText("OrdinalIgnoreCase");
                node.Entries["entries"] = SaveNode.NewTable();
                node.Entries["entries"].Entries["a"] = SaveNode.OfText("1");
                node.Entries["entries"].Entries["A"] = SaveNode.OfText("2");

                SaveSession session = Session();
                var loaded = (SortedDictionary<string, int>)session.FromNode(node,
                    typeof(SortedDictionary<string, int>));

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

            public void MissingEntries_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Session().FromNode(SaveNode.NewTable(), typeof(SortedDictionary<string, int>));
            }
        }

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

                CheckTrue(new SortedDictionaryConverter<string, Waypoint>().TryListChildren(node, children));
                IReadOnlyList<KeyValuePair<SaveNode, SaveNode>> pairs = node.RequireEntry("entries").RequireMap();
                CheckEqual(2, children.Count);
                CheckTrue(ReferenceEquals(pairs[0].Key, children.NodeAt(0)));
                CheckTrue(ReferenceEquals(pairs[0].Value, children.NodeAt(1)));
                CheckEqual(typeof(Waypoint), children.TypeAt(1));
            }

            public void MissingEntries_ReturnsFalse()
            {
                CheckFalse(new SortedDictionaryConverter<string, int>().TryListChildren(
                    SaveNode.NewTable(), new ChildList()));
            }

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

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

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

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

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

        public class FillTests : TestFixture
        {
            public void SavedValue_AddsWhatReadLoads()
            {
                SaveSession session = SaveConvertersTests.Session();
                SaveNode node = session.ToNode(new SortedDictionary<int, string> { { 3, "c" }, { 1, "a" } });
                var converter = new SortedDictionaryConverter<int, string>();
                SortedDictionary<int, string> 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 SortedDictionaryConverter<int, string>().FillNeedsFilledPart(typeof(int)));
            }

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