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

namespace Ariadne.Vellum.UnitTests
{
    public class ArcLoaderTests : TestFixture
    {
        /// <summary>
        /// Writes its own __Resume, so Ariadne.Generator leaves it alone and it has no loading constructor.
        /// </summary>
        public class LoaderlessArc : Arc<Gates>
        {
            protected override bool __Resume(Gates context, TickTime time)
            {
                return true;
            }

            protected override void Run(Gates context)
            {
            }
        }

        public static ArcRecord ReadRecord(SaveNode fields)
        {
            SaveNode root = SaveNode.NewTable();
            root.Entries[ArcRecord.FieldsKey] = fields;
            return ArcRecord.FromNode(root, ArcRecordTests.Session());
        }

        public class FindConstructorTests : TestFixture
        {
            public void GeneratedLoader_IsFound()
            {
                CheckNotNull(ArcLoader.FindConstructor(typeof(CountingScript)));
            }

            public void ClassWithoutOne_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                ArcLoader.FindConstructor(typeof(LoaderlessArc));
            }
        }

        public class TryListPartsTests : TestFixture
        {
            public void GeneratedClass_ListsItsFieldsThenItsLocals()
            {
                var parts = new ArcPartList();

                CheckTrue(ArcLoader.TryListParts(typeof(CountingScript), parts));
                CheckEqual(new[] { "Count", "Note", "Run.waits" }, parts.Keys);
                CheckEqual(new[] { typeof(int), typeof(string), typeof(int) }, parts.Types);
                CheckEqual(new[] { false, false, true }, parts.IsLocal);
            }

            public void DerivedClass_ListsItsBaseClassFirst()
            {
                var parts = new ArcPartList();

                CheckTrue(ArcLoader.TryListParts(typeof(ReliefScript), parts));
                CheckEqual(new[] { "Stage", "Crates" }, parts.Keys);
            }

            public void ClassWritingItsOwnSaveFields_ReturnsFalse()
            {
                CheckFalse(ArcLoader.TryListParts(typeof(HandBuiltScript), new ArcPartList()));
            }

            public void ClassWithoutAListing_ReturnsFalse()
            {
                CheckFalse(ArcLoader.TryListParts(typeof(LoaderlessArc), new ArcPartList()));
            }

            public void HandBuiltClassUnderAGeneratedOne_ReturnsFalse()
            {
                CheckFalse(ArcLoader.TryListParts(typeof(HandBuiltUnderMission), new ArcPartList()));
            }
        }

        public class CreateTests : TestFixture
        {
            public void BuildsTheArcFromTheRecord()
            {
                var record = ArcRecord.FromNode(ArcRecordTests.SampleRecord().ToNode(), ArcRecordTests.Session());
                var arc = (CountingScript)ArcLoader.Create(typeof(CountingScript), record);

                CheckEqual(new[] { "act2", "build" }, arc.Cursor);
                CheckTrue(arc.Finished);
            }

            public void ConstructorFoundEarlier_BuildsTheArcToo()
            {
                var record = ArcRecord.FromNode(ArcRecordTests.SampleRecord().ToNode(), ArcRecordTests.Session());
                var arc = (CountingScript)ArcLoader.Create(ArcLoader.FindConstructor(typeof(CountingScript)), record);

                CheckEqual(new[] { "act2", "build" }, arc.Cursor);
            }

            public void FieldThatCannotBeRead_KeepsItsInitialValue()
            {
                SaveNode fields = SaveNode.NewTable();
                fields.Entries["Count"] = SaveNode.OfText("many");
                var arc = (CountingScript)ArcLoader.Create(typeof(CountingScript), ReadRecord(fields));

                CheckEqual(0, arc.Count);
            }

            public void ClassWithoutALoader_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                ArcLoader.Create(typeof(LoaderlessArc), ReadRecord(SaveNode.NewTable()));
            }
        }
    }
}