using System;
using UnitTestSharp;
using Vellum;

namespace Ariadne.Vellum.UnitTests
{
    /// <summary>
    /// Saves an arc whose Run overrides a base class's Run, and both keep a local of the same name across a pause.
    /// </summary>
    public class RunCollisionSaveTests : TestFixture
    {
        public static ArcType Ticked<ArcType>(ArcType arc, Gates gates, int ticks) where ArcType : Arc<Gates>
        {
            for (int i = 0; i < ticks; ++i)
            {
                arc.Tick(gates, TestTicks.Fresh());
            }

            return arc;
        }

        public static ArcType Reloaded<ArcType>(ArcType arc)
        {
            SaveSession session = ArcConverterTests.Session();
            return (ArcType)session.FromNode(session.ToNode(arc, typeof(ArcType)), typeof(ArcType));
        }

        public class BaseRunCallTests : TestFixture
        {
            public void PausedBeforeTheCall_RunsTheBaseRunAfterAReload()
            {
                var gates = new Gates();
                CollisionCaller loaded = Reloaded(Ticked(new CollisionCaller(), gates, ticks: 1));

                gates.Open.Add("start");
                gates.Open.Add("go");
                loaded.Tick(gates, TestTicks.Fresh());

                CheckEqual("base 1", loaded.BaseNote);
                CheckEqual("derived a", loaded.Note);
                CheckTrue(loaded.Finished);
            }

            public void PausedInsideTheCall_ResumesBothRunsLocalsAfterAReload()
            {
                var gates = new Gates();
                gates.Open.Add("start");
                CollisionCaller loaded = Reloaded(Ticked(new CollisionCaller(), gates, ticks: 1));

                gates.Open.Add("go");
                loaded.Tick(gates, TestTicks.Fresh());

                CheckEqual("base 1", loaded.BaseNote);
                CheckEqual("derived a", loaded.Note);
                CheckTrue(loaded.Finished);
            }

            public void PausedInsideTheCall_SavesTheBasesLocalsInATableNamedForTheCall()
            {
                SaveSession session = ArcConverterTests.Session();
                var gates = new Gates();
                gates.Open.Add("start");
                CollisionCaller script = Ticked(new CollisionCaller(), gates, ticks: 1);

                SaveNode locals = session.ToNode(script, typeof(CollisionCaller)).RequireEntry(ArcRecord.LocalsKey);

                CheckEqual("a", locals.RequireEntry("Run.count").Text);
                CheckEqual("1", locals.RequireEntry("Run.Run/").RequireEntry("Run.count").Text);
            }

            public void ReloadedAndSavedAgainBeforeTicking_KeepsBothRunsLocals()
            {
                var gates = new Gates();
                gates.Open.Add("start");
                CollisionCaller loaded = Reloaded(Reloaded(Ticked(new CollisionCaller(), gates, ticks: 1)));

                gates.Open.Add("go");
                loaded.Tick(gates, TestTicks.Fresh());

                CheckEqual("base 1", loaded.BaseNote);
                CheckEqual("derived a", loaded.Note);
            }

            public void LabelledCall_SavesTheBasesLocalsUnderTheLabel()
            {
                SaveSession session = ArcConverterTests.Session();
                var gates = new Gates();
                CollisionLabelled script = Ticked(new CollisionLabelled(), gates, ticks: 1);

                SaveNode locals = session.ToNode(script, typeof(CollisionLabelled)).RequireEntry(ArcRecord.LocalsKey);

                CheckEqual("1", locals.RequireEntry("Run.again/").RequireEntry("Run.count").Text);
            }

            public void CallFromAnotherPassage_ResumesBothLocalsAfterAReload()
            {
                var gates = new Gates();
                CollisionHelper loaded = Reloaded(Ticked(new CollisionHelper(), gates, ticks: 1));

                gates.Open.Add("go");
                loaded.Tick(gates, TestTicks.Fresh());

                CheckEqual("base 1", loaded.BaseNote);
                CheckEqual("prepared p", loaded.Note);
                CheckTrue(loaded.Finished);
            }

            public void WaitInTheBaseRun_KeepsItsDeadlineAcrossAReload()
            {
                var gates = new Gates();
                var script = new CollisionWaitDerived();
                script.Tick(gates, TestTicks.At(TimeSpan.Zero, TimeSpan.Zero));

                CollisionWaitDerived loaded = Reloaded(script);
                loaded.Tick(gates, TestTicks.At(TimeSpan.Zero, TimeSpan.FromSeconds(0.5)));
                CheckFalse(loaded.Finished);
                loaded.Tick(gates, TestTicks.At(TimeSpan.Zero, TimeSpan.FromSeconds(2)));

                CheckEqual("rested 3", loaded.WaitNote);
                CheckEqual("derived x", loaded.Note);
                CheckTrue(loaded.Finished);
            }

            public void ListedParts_IncludeTheBasesLocalsInTheCallsTable()
            {
                SaveSession session = ArcConverterTests.Session();
                var gates = new Gates();
                gates.Open.Add("start");
                SaveNode node = session.ToNode(Ticked(new CollisionCaller(), gates, ticks: 1),
                    typeof(CollisionCaller));
                var children = new ChildList();

                CheckTrue(new ArcConverter<CollisionCaller, Gates>().TryListChildren(node, children));
                CheckTrue(ArcConverterTests.IndexOfNode(children,
                    node.RequireEntry(ArcRecord.LocalsKey).RequireEntry("Run.Run/").RequireEntry("Run.count")) >= 0);
            }

            public void ChainOfThreeClasses_ResumesEachRunsLocalsAfterAReload()
            {
                var gates = new Gates();
                gates.Open.Add("start");
                gates.Open.Add("middle");
                CollisionLeaf loaded = Reloaded(Ticked(new CollisionLeaf(), gates, ticks: 1));

                gates.Open.Add("go");
                loaded.Tick(gates, TestTicks.Fresh());

                CheckEqual("base 1", loaded.BaseNote);
                CheckEqual("middle 2.5", loaded.MiddleNote);
                CheckEqual("leaf leaf", loaded.Note);
                CheckTrue(loaded.Finished);
            }
        }

        public class FromNodeTests : TestFixture
        {
            public void DerivedLocalOfAnotherType_SurvivesAReload()
            {
                var gates = new Gates();
                var script = new CollisionDerived();
                script.Tick(gates, TestTicks.Fresh());

                CollisionDerived loaded = Reloaded(script);
                gates.Open.Add("go");
                loaded.Tick(gates, TestTicks.Fresh());

                CheckEqual("derived a", loaded.Note);
            }

            public void DerivedLocalOfTheSameType_SurvivesAReload()
            {
                var gates = new Gates();
                var script = new CollisionSameType();
                script.Tick(gates, TestTicks.Fresh());

                CollisionSameType loaded = Reloaded(script);
                gates.Open.Add("go");
                loaded.Tick(gates, TestTicks.Fresh());

                CheckEqual("derived 5", loaded.Note);
            }
        }
    }
}