using System;
using System.IO;
using UnitTestSharp;

namespace Vellum.UnitTests
{
    public class SaveReaderTests : TestFixture
    {
        public static SaveReader Sample()
        {
            SaveNode node = SaveNode.NewTable();
            node.Entries["Count"] = SaveNode.OfText("3");
            return new SaveReader(node, SaveConverters.For(typeof(SaveReaderTests).Assembly).CreateSession());
        }

        public class CtorTests : TestFixture
        {
            public void KeepsTheNodeAndSession()
            {
                SaveNode node = SaveNode.NewTable();
                SaveSession session = new SaveConverters(new SaveConverter[0]).CreateSession();
                var reader = new SaveReader(node, session);

                CheckEqual(node, reader.Node);
                CheckEqual(session, reader.Session);
            }

            public void NonTable_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                new SaveReader(SaveNode.Null, new SaveConverters(new SaveConverter[0]).CreateSession());
            }

            [AllocationTest]
            public void Reader_AllocatesNothing()
            {
                var reader = new SaveReader(Table, Session);
                CheckNoAllocations();
                CheckTrue(ReferenceEquals(Table, reader.Node));
            }

            public static readonly SaveNode Table = Sample().Node;

            public static readonly SaveSession Session = new SaveConverters(new SaveConverter[0]).CreateSession();
        }

        public class DefaultReaderTests : TestFixture
        {
            public void HasNoNodeOrSession()
            {
                SaveReader reader = default(SaveReader);

                CheckNull(reader.Node);
                CheckNull(reader.Session);
            }

            public void Publish_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                default(SaveReader).Publish(new Stamp());
            }

            public void TryRead_Throws()
            {
                int count;

                CheckThrow(typeof(InvalidOperationException));
                default(SaveReader).TryRead("Count", out count);
            }

            public void Require_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                default(SaveReader).Require<int>("Count");
            }
        }

        public class PublishTests : TestFixture
        {
            public void Object_IsHandedToAnythingThatReadsThisNodeBeforeItIsBuilt()
            {
                SaveReader reader = Sample();
                var half = new Stamp();
                reader.Publish(half);

                CheckTrue(ReferenceEquals(half, reader.Session.FromNode(reader.Node, typeof(object))));
            }

            public void Null_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                Sample().Publish(null);
            }
        }

        public class RequireTests : TestFixture
        {
            public void SavedValue_IsRead()
            {
                CheckEqual(3, Sample().Require<int>("Count"));
            }

            public void MissingValue_ThrowsNamingTheKey()
            {
                string message = "";
                try
                {
                    Sample().Require<int>("Removed");
                }
                catch (InvalidDataException exception)
                {
                    message = exception.Message;
                }

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

            public void ValueOfTheWrongShape_IsReportedUnderItsKey()
            {
                string message = "";
                try
                {
                    Sample().Require<Vector>("Count");
                }
                catch (InvalidDataException exception)
                {
                    message = exception.Message;
                }

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

            public void ValueOfTheWrongShape_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                Sample().Require<Vector>("Count");
            }

            public void PartThatFailedWhileTheLoadReadAhead_IsReportedUnderItsKey()
            {
                SaveSession session = new SaveConverters(new SaveConverter[]
                {
                    new CarrierConverter(), new BeadConverter(),
                }).CreateSession();
                SaveNode node = session.ToNode(new Carrier { Load = new Bead { Next = new Bead() } },
                    typeof(Carrier));
                node.Entries["load"].Entries["next"].Entries.Remove("next");
                string message = "";
                try
                {
                    session.FromNode<Carrier>(node);
                }
                catch (InvalidDataException exception)
                {
                    message = exception.Message;
                }

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

            public static readonly SaveReader Reader = Sample();

            [AllocationTest]
            public void SavedValue_AllocatesNothing()
            {
                int count = Reader.Require<int>("Count");
                CheckNoAllocations();
                CheckEqual(3, count);
            }
        }

        public class TryReadTests : TestFixture
        {
            public void SavedValue_IsRead()
            {
                int count;

                CheckTrue(Sample().TryRead("Count", out count));
                CheckEqual(3, count);
            }

            public void MissingValue_IsFalse()
            {
                int count;

                CheckFalse(Sample().TryRead("Removed", out count));
                CheckEqual(0, count);
            }

            public void ValueOfTheWrongShape_IsFalseAndRecordedUnderItsKey()
            {
                SaveReader reader = Sample();
                Vector vector;

                CheckFalse(reader.TryRead("Count", out vector));
                CheckEqual(new[] { "Count" }, SaveConvertersTests.IssuePaths(reader.Session));
            }

            public static readonly SaveReader Reader = Sample();

            [AllocationTest]
            public void SavedValue_AllocatesNothing()
            {
                int count;
                bool found = Reader.TryRead("Count", out count);
                CheckNoAllocations();
                CheckTrue(found);
                CheckEqual(3, count);
            }

            [AllocationTest]
            public void MissingValue_AllocatesNothing()
            {
                int count;
                bool found = Reader.TryRead("Removed", out count);
                CheckNoAllocations();
                CheckFalse(found);
            }
        }
    }
}