using System.IO;
using UnitTestSharp;
using Vellum;

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

        public static HexIndex ThroughLuaText(HexIndex value)
        {
            SaveSession session = Session();
            SaveNode save = SaveNode.NewTable();
            save.Entries["value"] = session.ToNode(value, typeof(HexIndex));
            SaveNode read = LuaSaveFormat.Parse(LuaSaveFormat.Format(save));

            return (HexIndex)Session().FromNode(read.RequireEntry("value"), typeof(HexIndex));
        }

        public class WriteTests : TestFixture
        {
            public void SavesBothCoordinates()
            {
                SaveNode node = Session().ToNode(new HexIndex(3, -4), typeof(HexIndex));

                CheckEqual(SaveNode.Kinds.Table, node.Kind);
                CheckEqual("3", node.RequireEntry(HexIndexConverter.QKey).Text);
                CheckEqual("-4", node.RequireEntry(HexIndexConverter.RKey).Text);
            }
        }

        public class ReadTests : TestFixture
        {
            public void RoundTripsEachCoordinate()
            {
                SaveSession session = Session();
                SaveNode node = session.ToNode(new HexIndex(-7, 12), typeof(HexIndex));

                CheckEqual(new HexIndex(-7, 12), (HexIndex)Session().FromNode(node, typeof(HexIndex)));
            }

            public void RoundTripsThroughLuaText()
            {
                var extreme = new HexIndex(-int.MaxValue, int.MaxValue);

                CheckEqual(extreme, ThroughLuaText(extreme));
            }

            public void MissingEntry_Throws()
            {
                SaveNode node = Session().ToNode(new HexIndex(1, 2), typeof(HexIndex));
                node.Entries.Remove(HexIndexConverter.RKey);

                CheckThrow(typeof(InvalidDataException));
                Session().FromNode(node, typeof(HexIndex));
            }

            public void NodeThatIsNotATable_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Session().FromNode(SaveNode.OfText("1"), typeof(HexIndex));
            }

            public void BadCoordinate_ThrowsNamingTheCoordinate()
            {
                SaveNode node = Session().ToNode(new HexIndex(1, 2), typeof(HexIndex));
                node.Entries[HexIndexConverter.QKey] = SaveNode.OfText("not a number");

                string message = "";

                try
                {
                    Session().FromNode(node, typeof(HexIndex));
                }
                catch (InvalidDataException exception)
                {
                    message = exception.Message;
                }

                CheckTrue(message.StartsWith("q: ", System.StringComparison.Ordinal));
            }
        }

        public class TryListChildrenTests : TestFixture
        {
            public void ListsNothingAndSucceeds()
            {
                SaveNode node = Session().ToNode(new HexIndex(1, 2), typeof(HexIndex));
                var children = new ChildList();

                CheckTrue(new HexIndexConverter().TryListChildren(node, children));
                CheckEqual(0, children.Count);
            }

            public void NodeWithoutR_ReturnsFalse()
            {
                SaveNode node = Session().ToNode(new HexIndex(1, 2), typeof(HexIndex));
                node.Entries.Remove(HexIndexConverter.RKey);

                CheckFalse(new HexIndexConverter().TryListChildren(node, new ChildList()));
            }

            public void NodeWithoutQ_ReturnsFalse()
            {
                SaveNode node = Session().ToNode(new HexIndex(1, 2), typeof(HexIndex));
                node.Entries.Remove(HexIndexConverter.QKey);

                CheckFalse(new HexIndexConverter().TryListChildren(node, new ChildList()));
            }

            public void NodeThatIsNotATable_ReturnsFalse()
            {
                CheckFalse(new HexIndexConverter().TryListChildren(SaveNode.OfText("3"), new ChildList()));
            }
        }
    }
}