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

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

        public class ToNodeTests : TestFixture
        {
            public void Entries_AreSavedInOrderAsAMapOfKeyAndValueTypes()
            {
                var entries = new List<KeyValuePair<int, int>>
                {
                    new KeyValuePair<int, int>(3, 30),
                    new KeyValuePair<int, int>(1, 10),
                };

                SaveNode node = SavedEntries.ToNode(entries, Session());

                CheckEqual(SaveNode.Kinds.Map, node.Kind);
                CheckEqual(new[] { "3", "1" }, node.Pairs.Select(pair => pair.Key.Text).ToArray());
                CheckEqual(new[] { "30", "10" }, node.Pairs.Select(pair => pair.Value.Text).ToArray());
            }

            public void NoEntries_IsAnEmptyMap()
            {
                SaveNode node = SavedEntries.ToNode(new List<KeyValuePair<int, int>>(), Session());

                CheckEqual(SaveNode.Kinds.Map, node.Kind);
                CheckEqual(0, node.Pairs.Count);
            }

            public void NullValue_IsANullNode()
            {
                var entries = new List<KeyValuePair<int, string>> { new KeyValuePair<int, string>(1, null) };

                SaveNode node = SavedEntries.ToNode(entries, Session());

                CheckEqual(SaveNode.Kinds.Null, node.Pairs[0].Value.Kind);
            }

            public void ConvertedKeyAndValue_AreSavedByTheirConverters()
            {
                var entries = new List<KeyValuePair<Point, Point>>
                {
                    new KeyValuePair<Point, Point>(new Point(1.5, 0), new Point(2.5, 0)),
                };

                SaveNode node = SavedEntries.ToNode(entries, Session());

                CheckEqual("0x3FF8000000000000", node.Pairs[0].Key.RequireEntry("x").Text);
                CheckEqual("0x4004000000000000", node.Pairs[0].Value.RequireEntry("x").Text);
            }
        }

        public class ListChildrenTests : TestFixture
        {
            public void Map_ListsEachKeyThenItsValueWithTheirTypes()
            {
                SaveNode node = SaveNode.NewMap();
                node.Pairs.Add(new KeyValuePair<SaveNode, SaveNode>(SaveNode.OfText("1"), SaveNode.OfText("a")));
                node.Pairs.Add(new KeyValuePair<SaveNode, SaveNode>(SaveNode.OfText("2"), SaveNode.OfText("b")));
                var children = new ChildList();

                bool listed = SavedEntries.ListChildren(node, typeof(int), typeof(string), children);

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

            public void TableOfTextKeys_ListsThemSortedByKey()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries["b"] = SaveNode.OfText("2");
                node.Entries["a"] = SaveNode.OfText("1");
                var children = new ChildList();

                bool listed = SavedEntries.ListChildren(node, typeof(string), typeof(int), children);

                CheckTrue(listed);
                CheckEqual(new[] { "a", "1", "b", "2" },
                    Enumerable.Range(0, children.Count).Select(index => children.NodeAt(index).Text).ToArray());
            }

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

                CheckTrue(SavedEntries.ListChildren(SaveNode.NewMap(), typeof(int), typeof(int), children));
                CheckEqual(0, children.Count);
            }

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

                CheckFalse(SavedEntries.ListChildren(SaveNode.NewList(), typeof(int), typeof(int), children));
                CheckEqual(0, children.Count);
            }
        }

        public class RejectRepeatedKeyTests : TestFixture
        {
            public void KeyNotThereYet_ChangesNothing()
            {
                var target = new Dictionary<string, int> { { "a", 1 } };

                SavedEntries.RejectRepeatedKey(target, "b", SaveNode.OfText("b"));

                CheckEqual(1, target.Count);
            }

            public void KeyAlreadyThere_Throws()
            {
                var target = new Dictionary<string, int> { { "a", 1 } };

                CheckThrow(typeof(InvalidDataException));
                SavedEntries.RejectRepeatedKey(target, "a", SaveNode.OfText("a"));
            }

            public void KeyAlreadyThere_NamesTheSavedKey()
            {
                var target = new Dictionary<string, int> { { "a", 1 } };
                string message = "";
                try
                {
                    SavedEntries.RejectRepeatedKey(target, "a", SaveNode.OfText("a"));
                }
                catch (InvalidDataException exception)
                {
                    message = exception.Message;
                }

                CheckTrue(message.Contains("\"a\""));
            }
        }

        public class ReadIntoTests : TestFixture
        {
            private static void AddPair(SaveNode map, string key, string value)
            {
                map.Pairs.Add(new KeyValuePair<SaveNode, SaveNode>(SaveNode.OfText(key), SaveNode.OfText(value)));
            }

            public void Map_AddsEachEntry()
            {
                SaveNode node = SaveNode.NewMap();
                AddPair(node, "1", "10");
                AddPair(node, "2", "20");
                var target = new Dictionary<int, int>();

                SavedEntries.ReadInto(node, target, Session());

                CheckEqual(2, target.Count);
                CheckEqual(10, target[1]);
                CheckEqual(20, target[2]);
            }

            public void TableOfTextKeys_AddsEachEntry()
            {
                SaveNode node = SaveNode.NewTable();
                node.Entries["a"] = SaveNode.OfText("1");
                var target = new Dictionary<string, int>();

                SavedEntries.ReadInto(node, target, Session());

                CheckEqual(1, target["a"]);
            }

            public void EmptyMap_AddsNothing()
            {
                var target = new Dictionary<int, int>();

                SavedEntries.ReadInto(SaveNode.NewMap(), target, Session());

                CheckEqual(0, target.Count);
            }

            public void NullValue_IsNullForAReferenceType()
            {
                SaveNode node = SaveNode.NewMap();
                node.Pairs.Add(new KeyValuePair<SaveNode, SaveNode>(SaveNode.OfText("1"), SaveNode.Null));
                var target = new Dictionary<int, string>();

                SavedEntries.ReadInto(node, target, Session());

                CheckNull(target[1]);
            }

            public void RepeatedKey_KeepsTheFirstAndRecordsTheSecond()
            {
                SaveNode node = SaveNode.NewMap();
                AddPair(node, "1", "10");
                AddPair(node, "1", "20");
                SaveSession session = Session();
                var target = new Dictionary<int, int>();
                SavedEntries.ReadInto(node, target, session);

                CheckEqual(10, target[1]);
                CheckEqual(new[] { "[1]" }, SaveConvertersTests.IssuePaths(session));
            }

            public void KeyOfTheWrongKind_LeavesTheEntryOutAndRecordsIt()
            {
                SaveNode node = SaveNode.NewMap();
                node.Pairs.Add(new KeyValuePair<SaveNode, SaveNode>(SaveNode.NewList(), SaveNode.OfText("1")));
                SaveSession session = Session();
                var target = new Dictionary<int, int>();
                SavedEntries.ReadInto(node, target, session);

                CheckEqual(0, target.Count);
                CheckEqual(new[] { "[0]" }, SaveConvertersTests.IssuePaths(session));
            }

            public void ValueOfTheWrongKind_LeavesTheEntryOutAndRecordsIt()
            {
                SaveNode node = SaveNode.NewMap();
                node.Pairs.Add(new KeyValuePair<SaveNode, SaveNode>(SaveNode.OfText("1"), SaveNode.NewList()));
                SaveSession session = Session();
                var target = new Dictionary<int, int>();
                SavedEntries.ReadInto(node, target, session);

                CheckEqual(0, target.Count);
                CheckEqual(new[] { "[0]" }, SaveConvertersTests.IssuePaths(session));
            }

            public void NodeThatIsNotAMap_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                SavedEntries.ReadInto(SaveNode.OfText("3"), new Dictionary<int, int>(), Session());
            }
        }
    }
}