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

namespace Amphora.Vellum.UnitTests
{
    public class OrderedDictionaryConverterTests : TestFixture
    {
        public static SaveSession Session()
        {
            return SaveConverters.For(typeof(OrderedDictionaryConverterTests).Assembly).CreateSession();
        }

        public static OrderedDictionary<string, int> Ordered(IEqualityComparer<string> comparer,
            params string[] keys)
        {
            var returnMe = new OrderedDictionary<string, int>(comparer);
            foreach (string key in keys)
            {
                returnMe.Add(key, returnMe.Count);
            }

            return returnMe;
        }

        public static OrderedDictionary<string, int> ThroughLuaText(OrderedDictionary<string, int> value)
        {
            SaveSession session = Session();
            SaveNode node = SaveConverterTests.ThroughLuaText(
                session.ToNode(value, typeof(OrderedDictionary<string, int>)));
            return (OrderedDictionary<string, int>)session.FromNode(node, typeof(OrderedDictionary<string, int>));
        }

        public class WriteTests : TestFixture
        {
            public void Entries_AreAListOfKeyAndValuePairsInOrder()
            {
                SaveNode node = Session().ToNode(Ordered(null, "z", "a", "m"),
                    typeof(OrderedDictionary<string, int>));
                List<SaveNode> pairs = node.RequireEntry("entries").Items;

                CheckEqual(new[] { "z", "a", "m" }, pairs.Select(pair => pair.RequireEntry("key").Text).ToArray());
                CheckEqual(new[] { "0", "1", "2" }, pairs.Select(pair => pair.RequireEntry("value").Text).ToArray());
            }

            public void DefaultComparer_IsLeftOut()
            {
                SaveNode node = Session().ToNode(Ordered(null, "a"), typeof(OrderedDictionary<string, int>));

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

            public void NamedComparer_IsSavedBesideTheEntries()
            {
                SaveNode node = Session().ToNode(Ordered(StringComparer.Ordinal, "a"),
                    typeof(OrderedDictionary<string, int>));

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

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

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

        public class ReadTests : TestFixture
        {
            public void DictionaryHoldingItself_ReadsAsADictionaryHoldingItself()
            {
                SaveNode node = SaveNode.NewTable();
                SaveNode pair = SaveNode.NewTable();
                pair.Entries[OrderedDictionaryConverter<string, object>.KeyKey] = SaveNode.OfText("self");
                pair.Entries[OrderedDictionaryConverter<string, object>.ValueKey] = node;
                SaveNode entries = SaveNode.NewList();
                entries.Items.Add(pair);
                node.Entries[OrderedDictionaryConverter<string, object>.EntriesKey] = entries;
                var loaded = (OrderedDictionary<string, object>)Session().FromNode(node,
                    typeof(OrderedDictionary<string, object>));

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

            public void Order_SurvivesLuaText()
            {
                OrderedDictionary<string, int> loaded = ThroughLuaText(Ordered(null, "z", "a", "m", "b"));

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

            public void KeysThatAreNotIdentifiers_RoundTrip()
            {
                OrderedDictionary<string, int> loaded = ThroughLuaText(Ordered(null, "end", "two words", ""));

                CheckEqual(new[] { "end", "two words", "" }, loaded.Keys.ToArray());
            }

            public void EmptyDictionary_RoundTrips()
            {
                CheckEqual(0, ThroughLuaText(Ordered(null)).Count);
            }

            public void Comparer_RoundTrips()
            {
                OrderedDictionary<string, int> loaded = ThroughLuaText(Ordered(StringComparer.OrdinalIgnoreCase, "a"));

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

            public void KeysAndValuesThatAreSaveableTypes_RoundTrip()
            {
                SaveSession session = Session();
                var value = new OrderedDictionary<Vector, string[]>();
                value.Add(new Vector { X = 1.5 }, new[] { "a", null });
                value.Add(new Vector { Y = 2 }, null);
                SaveNode node = SaveConverterTests.ThroughLuaText(
                    session.ToNode(value, typeof(OrderedDictionary<Vector, string[]>)));
                var loaded = (OrderedDictionary<Vector, string[]>)session.FromNode(node,
                    typeof(OrderedDictionary<Vector, string[]>));

                CheckEqual(2, loaded.Count);
                CheckNull(loaded[new Vector { Y = 2 }]);
                CheckNull(loaded[new Vector { X = 1.5 }][1]);
            }

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

            public void SameKeyTwice_KeepsTheFirstAndRecordsTheSecond()
            {
                SaveNode entries = SaveNode.NewList();
                for (int i = 0; i < 2; ++i)
                {
                    SaveNode pair = SaveNode.NewTable();
                    pair.Entries["key"] = SaveNode.OfText("a");
                    pair.Entries["value"] = SaveNode.OfText("1");
                    entries.Items.Add(pair);
                }

                SaveNode node = SaveNode.NewTable();
                node.Entries["entries"] = entries;

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

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

            public void PairMissingItsValue_IsLeftOutAndRecorded()
            {
                SaveNode pair = SaveNode.NewTable();
                pair.Entries["key"] = SaveNode.OfText("a");
                SaveNode entries = SaveNode.NewList();
                entries.Items.Add(pair);
                SaveNode node = SaveNode.NewTable();
                node.Entries["entries"] = entries;
                SaveSession session = Session();
                var loaded = (OrderedDictionary<string, int>)session.FromNode(node,
                    typeof(OrderedDictionary<string, int>));

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

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

        public class TryListChildrenTests : TestFixture
        {
            public void EachKeyAndValue_AreListedInPairsAsTheirTypes()
            {
                SaveNode node = Session().ToNode(Ordered(null, "b", "a"), typeof(OrderedDictionary<string, int>));
                var children = new ChildList();

                CheckTrue(new OrderedDictionaryConverter<string, int>().TryListChildren(node, children));
                IReadOnlyList<SaveNode> pairs = node.RequireEntry("entries").RequireItems();
                CheckEqual(4, children.Count);
                CheckTrue(ReferenceEquals(pairs[0].Entries["key"], children.NodeAt(0)));
                CheckTrue(ReferenceEquals(pairs[0].Entries["value"], children.NodeAt(1)));
                CheckTrue(ReferenceEquals(pairs[1].Entries["key"], children.NodeAt(2)));
                CheckEqual(typeof(string), children.TypeAt(0));
                CheckEqual(typeof(int), children.TypeAt(1));
            }

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

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

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

            public void PairMissingItsKeyOrValue_ReturnsFalse()
            {
                SaveNode pair = SaveNode.NewTable();
                pair.Entries["key"] = SaveNode.OfText("a");
                SaveNode entries = SaveNode.NewList();
                entries.Items.Add(pair);
                SaveNode node = SaveNode.NewTable();
                node.Entries["entries"] = entries;

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

            public void PairThatIsNotATable_ReturnsFalse()
            {
                SaveNode entries = SaveNode.NewList();
                entries.Items.Add(SaveNode.OfText("3"));
                SaveNode node = SaveNode.NewTable();
                node.Entries["entries"] = entries;

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

        public class AllocateTests : TestFixture
        {
            public void SavedValue_GivesAnEmptyDictionaryWithTheSavedComparer()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(Ordered(StringComparer.OrdinalIgnoreCase, "b", "a"),
                    typeof(OrderedDictionary<string, int>));
                OrderedDictionary<string, int> made = new OrderedDictionaryConverter<string, int>()
                    .Allocate(node, session);

                CheckEqual(0, made.Count);
                CheckEqual(StringComparer.OrdinalIgnoreCase, made.Comparer);
            }

            public void NodeWithoutEntries_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                new OrderedDictionaryConverter<string, int>().Allocate(SaveNode.NewTable(), Session());
            }
        }

        public class FillTests : TestFixture
        {
            public void SavedValue_AddsTheEntriesInOrder()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(Ordered(StringComparer.Ordinal, "b", "a"),
                    typeof(OrderedDictionary<string, int>));
                var converter = new OrderedDictionaryConverter<string, int>();
                OrderedDictionary<string, int> filled = converter.Allocate(node, session);
                converter.Fill(filled, node, session);

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

        public class FillNeedsFilledPartTests : TestFixture
        {
            public void TheKeyType_IsTrue()
            {
                CheckTrue(new OrderedDictionaryConverter<string, int>().FillNeedsFilledPart(typeof(string)));
            }

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