using System;
using System.Linq;
using Ariadne.Vellum.UnitTests.Library;
using UnitTestSharp;
using Vellum;

namespace Ariadne.Vellum.UnitTests
{
    /// <summary>
    /// Saves arcs paused inside passages that were built into another assembly.
    /// </summary>
    public class LibrarySaveTests : TestFixture
    {
        public static ArcType Tick<ArcType>(ArcType arc, Vault vault, int ticks) where ArcType : Arc<Vault>
        {
            for (int i = 0; i < ticks; ++i)
            {
                arc.Tick(vault, 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 BasePassageTests : TestFixture
        {
            public void PausedInside_SavesItsLocalsUnderThePassagesKeys()
            {
                SaveSession session = ArcConverterTests.Session();
                var script = Tick(new VaultSteppingScript(), new Vault(), ticks: 2);

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

                CheckEqual(new[] { "Hold.bonus", "Hold.seen" },
                    locals.Entries.Keys.OrderBy(key => key, StringComparer.Ordinal).ToArray());
                CheckEqual("2", locals.RequireEntry("Hold.seen").Text);
                CheckEqual("10", locals.RequireEntry("Hold.bonus").Text);
            }

            public void Reloaded_ResumesThePassageWithItsLocals()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultSteppingScript(), vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual("held 12", loaded.Note);
                CheckEqual(2, loaded.Stage);
                CheckTrue(loaded.Finished);
            }

            public void ReturnedValueInsideAnExpression_SurvivesAReload()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultCountingScript(), vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual(102, loaded.Total);
                CheckTrue(loaded.Finished);
            }
        }

        public class GenericAndRecursiveBasePassageTests : TestFixture
        {
            public void InheritedGenericPassage_ResumesWithItsTypedLocalAfterAReload()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultWeighingScript(), vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual("weighed ore", loaded.Note);
                CheckTrue(loaded.Finished);
            }

            public void InheritedRecursivePassage_ResumesEveryLevelAfterAReload()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultDescendingScript(), vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual("idlelevel0;level1;level2;", loaded.Note);
                CheckTrue(loaded.Finished);
            }

            public void PassagesOfAGenericBase_ResumeAfterAReloadAtEachPause()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultTaggedScript(), vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);
                loaded = Reloaded(loaded);
                vault.Open.Add("held");
                Tick(loaded, vault, ticks: 1);

                CheckEqual(4, loaded.Last);
                CheckEqual("a;", loaded.Log);
                CheckTrue(loaded.Finished);
            }
        }

        public class BaseRunTests : TestFixture
        {
            public void BaseRunOfAnotherAssembly_ResumesBothRunsLocalsAfterAReload()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultTemplateScript(), vault, ticks: 1));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual("template 1", loaded.TemplateNote);
                CheckEqual("derived a", loaded.Note);
                CheckTrue(loaded.Finished);
            }
        }

        public class OtherArcPassageTests : TestFixture
        {
            public void PausedInside_SavesTheCalleesLocalsInATableNamedForTheCall()
            {
                SaveSession session = ArcConverterTests.Session();
                var script = Tick(new VaultOperator { Plant = new VaultPlant() }, new Vault(), ticks: 2);

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

                CheckEqual(new[] { "Run.before", "Run.update/" },
                    locals.Entries.Keys.OrderBy(key => key, StringComparer.Ordinal).ToArray());
                SaveNode call = locals.RequireEntry("Run.update/");
                CheckEqual(new[] { "Update.bonus", "Update.waited", "receiver" },
                    call.Entries.Keys.OrderBy(key => key, StringComparer.Ordinal).ToArray());
                CheckEqual("2", call.RequireEntry("Update.waited").Text);
            }

            public void Reloaded_ResumesTheCallOnTheSameArc()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultOperator { Plant = new VaultPlant() }, vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual("done 7", loaded.Result);
                CheckEqual("updated after 2", loaded.Plant.Note);
                CheckEqual(7, loaded.Plant.Updates);
                CheckTrue(loaded.Finished);
            }

            public void GenericPassage_ResumesWithItsTypedLocalAfterAReload()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultPonderer { Plant = new VaultPlant() }, vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual("pondered stone", loaded.Plant.Note);
                CheckTrue(loaded.Finished);
            }

            public void PassagesOfAGenericArcClass_ResumeAfterAReloadAtEachPause()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultShopkeeper { Shelf = new VaultShelf<string>() }, vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);
                CheckEqual("stocked jar", loaded.Shelf.Note);
                loaded = Reloaded(loaded);
                vault.Open.Add("labeled");
                Tick(loaded, vault, ticks: 1);

                CheckEqual("labeled lid5", loaded.Shelf.Note);
                CheckTrue(loaded.Finished);
            }

            public void RecursivePassage_ResumesEveryLevelAfterAReload()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultDigger { Plant = new VaultPlant() }, vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual(3, loaded.Plant.Updates);
                CheckTrue(loaded.Finished);
            }

            public void ReturnedValueInsideAnExpression_SurvivesAReload()
            {
                var vault = new Vault();
                var loaded = Reloaded(Tick(new VaultMeasurer { Plant = new VaultPlant() }, vault, ticks: 2));

                vault.Open.Add("go");
                Tick(loaded, vault, ticks: 1);

                CheckEqual(9, loaded.Total);
                CheckTrue(loaded.Finished);
            }
        }
    }
}