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

namespace Vellum.UnitTests
{
    public class MapConverterTests : TestFixture
    {
        public class Ledger<KeyType, ValueType> : Dictionary<KeyType, ValueType>
        {
            public string Stamp;
        }

        public class LedgerConverter<KeyType, ValueType>
            : MapConverter<Ledger<KeyType, ValueType>, KeyType, ValueType>
        {
            public const string StampKey = "stamp";

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

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

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

        private static SaveNode Pair(string key, string value, SaveNode map)
        {
            map.Pairs.Add(new KeyValuePair<SaveNode, SaveNode>(SaveNode.OfText(key), SaveNode.OfText(value)));
            return map;
        }

        private static SaveNode TableOf(SaveNode entries)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries[LedgerConverter<string, string>.EntriesKey] = entries;
            return returnMe;
        }

        public class WriteTests : TestFixture
        {
            public void Entries_AreAMapUnderTheEntriesKey()
            {
                var ledger = new Ledger<string, int> { { "a", 1 }, { "b", 2 } };

                SaveNode node = Session().ToNode(ledger, typeof(Ledger<string, int>));

                CheckEqual(SaveNode.Kinds.Table, node.Kind);
                SaveNode entries = node.RequireEntry(LedgerConverter<string, int>.EntriesKey);
                CheckEqual(SaveNode.Kinds.Map, entries.Kind);
                CheckEqual(2, entries.Pairs.Count);
            }

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

                CheckEqual(0, node.RequireEntry(LedgerConverter<string, int>.EntriesKey).Pairs.Count);
            }

            public void Comparison_IsWrittenIntoTheSameTable()
            {
                var ledger = new Ledger<string, int> { Stamp = "checked" };

                SaveNode node = Session().ToNode(ledger, typeof(Ledger<string, int>));

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

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

        public class ReadTests : TestFixture
        {
            public void Map_AddsEachEntry()
            {
                SaveNode node = TableOf(Pair("b", "2", Pair("a", "1", SaveNode.NewMap())));

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

                CheckEqual(2, loaded.Count);
                CheckEqual("1", loaded["a"]);
                CheckEqual("2", loaded["b"]);
            }

            public void Comparison_IsGivenToTheNewCollection()
            {
                SaveNode node = TableOf(SaveNode.NewMap());
                node.Entries[LedgerConverter<string, string>.StampKey] = SaveNode.OfText("checked");

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

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

            public void CollectionHoldingItself_ReadsAsOneHoldingItself()
            {
                SaveNode node = TableOf(SaveNode.NewMap());
                node.Entries[LedgerConverter<string, object>.EntriesKey].Pairs.Add(
                    new KeyValuePair<SaveNode, SaveNode>(SaveNode.OfText("self"), node));

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

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

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

            public void EntriesThatAreNotAMap_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Session().FromNode(TableOf(SaveNode.OfText("x")), typeof(Ledger<string, string>));
            }

            public void RepeatedKey_IsRecordedAndOnlyOneIsKept()
            {
                SaveNode node = TableOf(Pair("a", "2", Pair("a", "1", SaveNode.NewMap())));
                SaveSession session = Session();
                var loaded = (Ledger<string, string>)session.FromNode(node, typeof(Ledger<string, string>));

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

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

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

        public class TryListChildrenTests : TestFixture
        {
            public void Map_ListsEachKeyThenItsValueWithTheirTypes()
            {
                SaveNode node = TableOf(Pair("a", "1", SaveNode.NewMap()));
                var children = new ChildList();

                bool listed = new LedgerConverter<string, int>().TryListChildren(node, children);

                CheckTrue(listed);
                CheckEqual(2, children.Count);
                CheckEqual(typeof(string), children.TypeAt(0));
                CheckEqual(typeof(int), children.TypeAt(1));
            }

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

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

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

                CheckFalse(new LedgerConverter<string, int>().TryListChildren(TableOf(SaveNode.NewList()), children));
                CheckEqual(0, children.Count);
            }
        }
    }
}