using System;
using System.IO;
using UnitTestSharp;

namespace Vellum.UnitTests
{
    public class SaveConverterTests : TestFixture
    {
        // Overrides nothing but what a converter has to.  Private, so it isn't found as a second converter of Knob.
        private sealed class BareConverter : SaveConverter
        {
            public override Type ValueType
            {
                get
                {
                    return typeof(Knob);
                }
            }

            public override SaveNode ToNode(object value, SaveSession session)
            {
                return SaveNode.Null;
            }

            public override object FromNode(SaveNode node, SaveSession session)
            {
                return null;
            }
        }

        public static SaveSession Session()
        {
            return SaveConvertersTests.Session();
        }

        public static SaveNode NameTable(string name)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries["Name"] = SaveNode.OfText(name);
            return returnMe;
        }

        public class TryListChildrenTests : TestFixture
        {
            public void ConverterThatDoesNotSayWhatItLoads_ReturnsFalseAndAddsNothing()
            {
                var children = new ChildList();
                SaveSession session = SaveConvertersTests.TestConverters().CreateSession();
                SaveNode node = session.ToNode(new Point(1.5, 2), typeof(Point));

                CheckFalse(new PointConverter().TryListChildren(node, children));
                CheckEqual(0, children.Count);
            }

            public void WithConverters_AsksTheOverloadWithoutThem()
            {
                var children = new ChildList();
                SaveConverters converters = SaveConvertersTests.TestConverters();
                SaveNode node = converters.CreateSession().ToNode(new Point(1.5, 2), typeof(Point));

                CheckFalse(new PointConverter().TryListChildren(node, children, converters));
                CheckEqual(0, children.Count);
            }
        }

        public class CanAllocateTests : TestFixture
        {
            public void ClassWithAReaderConstructor_IsTrue()
            {
                CheckTrue(new Ring.__Converter().CanAllocate);
            }

            public void ClassWhoseConverterCompletesIt_IsTrue()
            {
                CheckTrue(new PlateConverter().CanAllocate);
            }

            public void ClassBuiltInOneGo_IsFalse()
            {
                CheckFalse(new KnobConverter().CanAllocate);
            }

            public void Struct_IsFalse()
            {
                CheckFalse(new PointConverter().CanAllocate);
            }

            public void AbstractClass_IsFalse()
            {
                CheckFalse(new BlueprintConverter().CanAllocate);
            }

            public void AskedTwice_AnswersTheSame()
            {
                var converter = new PlateConverter();
                bool first = converter.CanAllocate;

                CheckEqual(first, converter.CanAllocate);
            }

            public void ConverterThatDoesntSay_IsFalse()
            {
                CheckFalse(new BareConverter().CanAllocate);
            }

            public void Container_IsTrue()
            {
                CheckTrue(new ListConverter<int>().CanAllocate);
            }
        }

        public class HasFillTests : TestFixture
        {
            public void ConverterThatFills_IsTrue()
            {
                CheckTrue(new PlateConverter().HasFill);
            }

            public void ConverterThatDoesntFill_IsFalse()
            {
                CheckFalse(new MoteConverter().HasFill);
            }

            public void GeneratedConverterOfAClass_IsTrue()
            {
                CheckTrue(new Ring.__Converter().HasFill);
            }

            public void ConverterThatDoesntSay_IsFalse()
            {
                CheckFalse(new BareConverter().HasFill);
            }

            public void AskedTwice_AnswersTheSame()
            {
                var converter = new PlateConverter();
                bool first = converter.HasFill;

                CheckEqual(first, converter.HasFill);
            }

            public void Container_IsTrue()
            {
                CheckTrue(new HashSetConverter<int>().HasFill);
            }
        }

        public class FillNeedsFilledPartTests : TestFixture
        {
            public void ConverterThatDoesntSay_IsFalseForAnyType()
            {
                CheckFalse(new BareConverter().FillNeedsFilledPart(typeof(int)));
                CheckFalse(new PlateConverter().FillNeedsFilledPart(typeof(Knob)));
            }
        }

        public class AllocateBlankTests : TestFixture
        {
            public void ClassWithAReaderConstructor_GivesAnObjectThatWasntConstructed()
            {
                object blank = new Vertex.__Converter().AllocateBlank(SaveNode.NewTable(), Session());

                CheckEqual(typeof(Vertex), blank.GetType());
                CheckNull(((Vertex)blank).Neighbors);
            }

            public void EachCall_GivesANewObject()
            {
                var converter = new Vertex.__Converter();
                SaveSession session = Session();

                CheckFalse(ReferenceEquals(converter.AllocateBlank(SaveNode.NewTable(), session),
                    converter.AllocateBlank(SaveNode.NewTable(), session)));
            }

            public void ClassBuiltInOneGo_Throws()
            {
                CheckThrow(typeof(NotSupportedException));
                new KnobConverter().AllocateBlank(SaveNode.NewTable(), Session());
            }

            public void ConverterThatDoesntSay_Throws()
            {
                CheckThrow(typeof(NotSupportedException));
                new BareConverter().AllocateBlank(SaveNode.NewTable(), Session());
            }
        }

        public class AllocateTests : TestFixture
        {
            public void ClassWithAReaderConstructor_GivesAnObjectThatWasntConstructed()
            {
                Vertex blank = new Vertex.__Converter().Allocate(SaveNode.NewTable(), Session());

                CheckNull(blank.Neighbors);
            }

            public void ClassBuiltInOneGo_Throws()
            {
                CheckThrow(typeof(NotSupportedException));
                new KnobConverter().Allocate(SaveNode.NewTable(), Session());
            }
        }

        public class FillBlankTests : TestFixture
        {
            public void ConverterThatDoesntFill_ChangesNothing()
            {
                var converter = new MoteConverter();
                SaveSession session = Session();
                SaveNode node = session.ToNode(new Mote("m", new System.Collections.Generic.HashSet<Mote>()));
                Mote blank = converter.Allocate(node, session);
                converter.FillBlank(blank, node, session);

                CheckNull(blank.Name);
            }

            public void GeneratedConverter_WritesTheSavedMembersWithoutRunningTheConstructor()
            {
                var converter = new Vertex.__Converter();
                SaveSession session = Session();
                Vertex blank = converter.Allocate(SaveNode.NewTable(), session);
                converter.FillBlank(blank, NameTable("v"), session);

                CheckEqual("v", blank.Name);
                CheckNull(blank.Neighbors);
            }

            public void ConverterThatFills_WritesTheDataWithoutRunningTheConstructor()
            {
                SaveSession session = Session();
                var node = SaveNode.NewTable();
                node.Entries["knob"] = SaveNode.Null;
                node.Entries["label"] = SaveNode.OfText("brass");
                var converter = new PlateConverter();
                Plate blank = converter.Allocate(node, session);
                converter.FillBlank(blank, node, session);

                CheckEqual("brass", blank.Label);
            }

            public void ConverterThatDoesntSay_ChangesNothing()
            {
                new BareConverter().FillBlank(new object(), SaveNode.NewTable(), Session());
            }
        }

        public class CompleteBlankTests : TestFixture
        {
            public void ConverterThatDoesntOverride_RunsTheReaderConstructor()
            {
                var converter = new Vertex.__Converter();
                SaveSession session = Session();
                Vertex blank = converter.Allocate(SaveNode.NewTable(), session);
                converter.CompleteBlank(blank, NameTable("v"), session);

                CheckEqual("v", blank.Name);
                CheckNotNull(blank.Neighbors);
            }

            public void ConverterThatOverrides_RunsWhatItDoes()
            {
                SaveSession session = Session();
                var node = SaveNode.NewTable();
                node.Entries["knob"] = SaveNode.Null;
                node.Entries["label"] = SaveNode.OfText("brass");
                var converter = new PlateConverter();
                Plate blank = converter.Allocate(node, session);
                converter.CompleteBlank(blank, node, session);

                CheckEqual("brass", blank.Label);
                CheckNull(blank.Knob);
            }

            public void ConverterThatDoesntSay_DoesNothing()
            {
                new BareConverter().CompleteBlank(new object(), SaveNode.NewTable(), Session());
            }

            public void ClassWithNoReaderConstructor_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new KnobConverter().CompleteBlank(FieldWriterTests.Blank<Knob>(), SaveNode.NewTable(), Session());
            }

            public void NodeThatIsntATable_Throws()
            {
                var converter = new Vertex.__Converter();
                SaveSession session = Session();
                Vertex blank = converter.Allocate(SaveNode.NewTable(), session);

                CheckThrow(typeof(InvalidDataException));
                converter.CompleteBlank(blank, SaveNode.OfText("3"), session);
            }
        }
    }
}