using System;
using System.IO;
using UnitTestSharp;
using Vellum;

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

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

        public static Duration Loaded(string ticks)
        {
            return (Duration)Session().FromNode(SaveNode.OfText(ticks), typeof(Duration));
        }

        public class WriteTests : TestFixture
        {
            public void SavesTheTickCount()
            {
                SaveNode node = Session().ToNode(Duration.FromSeconds(1.5), typeof(Duration));

                CheckEqual("15000000", node.Text);
            }

            public void SavesTheLengthInWordsAsAComment()
            {
                SaveNode node = Session().ToNode(Duration.FromSeconds(1.5), typeof(Duration));

                CheckEqual("00:00:01.5000000", node.Comment);
            }

            public void SavesANegativeLength()
            {
                SaveNode node = Session().ToNode(Duration.FromSeconds(-1.5), typeof(Duration));

                CheckEqual("-15000000", node.Text);
                CheckEqual("-00:00:01.5000000", node.Comment);
            }

            public void SavesZero()
            {
                SaveNode node = Session().ToNode(Duration.Zero, typeof(Duration));

                CheckEqual("0", node.Text);
                CheckEqual("00:00:00", node.Comment);
            }

            public void SavesDaysInTheComment()
            {
                SaveNode node = Session().ToNode(Duration.FromDays(12.5), typeof(Duration));

                CheckEqual("12.12:00:00", node.Comment);
            }

            public void SavesForeverAsTheLargestCountWithItsNameAsTheComment()
            {
                SaveNode node = Session().ToNode(Duration.Forever, typeof(Duration));

                CheckEqual("9223372036854775807", node.Text);
                CheckEqual("Forever", node.Comment);
            }

            public void SavesNegativeForeverAsTheSmallestCountWithItsNameAsTheComment()
            {
                SaveNode node = Session().ToNode(-Duration.Forever, typeof(Duration));

                CheckEqual("-9223372036854775808", node.Text);
                CheckEqual("-Forever", node.Comment);
            }

            public void SavesTheFiniteExtremesJustInsideTheInfinities()
            {
                CheckEqual("9223372036854775806", Session().ToNode(Duration.MaxValue, typeof(Duration)).Text);
                CheckEqual("-9223372036854775806", Session().ToNode(Duration.MinValue, typeof(Duration)).Text);
            }

            public void SavesTheSameNumberAsATimeSpanOfThatLength()
            {
                SaveSession session = Session();
                foreach (double seconds in new[] { 0.0, 1.5, -90.0, 86400.0 * 12.5 })
                {
                    SaveNode asDuration = session.ToNode(Duration.FromSeconds(seconds), typeof(Duration));
                    SaveNode asTimeSpan = session.ToNode(TimeSpan.FromSeconds(seconds), typeof(TimeSpan));

                    CheckEqual(asTimeSpan.Text, asDuration.Text);
                    CheckEqual(asTimeSpan.Comment, asDuration.Comment);
                }
            }

            public void WritesTheCommentIntoTheLuaText()
            {
                SaveNode save = SaveNode.NewTable();
                save.Entries["wait"] = Session().ToNode(Duration.FromDays(12.5), typeof(Duration));

                string text = LuaSaveFormat.Format(save);

                CheckTrue(text.Contains("12.12:00:00"));
                CheckTrue(text.Contains("10800000000000"));
            }
        }

        public class ReadTests : TestFixture
        {
            public void ReadsTheTickCount()
            {
                CheckEqual(Duration.FromSeconds(1.5), Loaded("15000000"));
                CheckEqual(Duration.FromSeconds(-1.5), Loaded("-15000000"));
                CheckEqual(Duration.Zero, Loaded("0"));
            }

            public void LargestCount_IsForever()
            {
                CheckEqual(Duration.Forever, Loaded("9223372036854775807"));
            }

            public void SmallestCount_IsNegativeForever()
            {
                CheckEqual(-Duration.Forever, Loaded("-9223372036854775808"));
            }

            public void TheFiniteExtremes_AreFinite()
            {
                CheckEqual(Duration.MaxValue, Loaded("9223372036854775806"));
                CheckEqual(Duration.MinValue, Loaded("-9223372036854775806"));
            }

            public void TheCountJustAboveNegativeForever_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Loaded("-9223372036854775807");
            }

            public void TextThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Loaded("soon");
            }

            public void ReadsWhatATimeSpanSavedAs()
            {
                SaveSession session = Session();
                SaveNode saved = session.ToNode(TimeSpan.FromMinutes(90.0), typeof(TimeSpan));

                CheckEqual(Duration.FromMinutes(90.0), (Duration)session.FromNode(saved, typeof(Duration)));
            }
        }

        public class RoundTripTests : TestFixture
        {
            public void EveryKindOfLength_SurvivesLuaText()
            {
                Duration[] lengths =
                {
                    Duration.Zero, Duration.FromTicks(1L), Duration.FromTicks(-1L), Duration.FromSeconds(1.5),
                    Duration.FromDays(-12.5), Duration.MaxValue, Duration.MinValue, Duration.Forever,
                    -Duration.Forever,
                };
                foreach (Duration length in lengths)
                {
                    CheckEqual(length, ThroughLuaText(length));
                }
            }
        }
    }
}