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

namespace Ariadne.Vellum.UnitTests
{
    /// <summary>
    /// Saves a script declared inside another type.
    /// </summary>
    public class NestedScriptSaveTests : TestFixture
    {
        public void Reloaded_ResumesWithItsLocal()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var paused = new Squad.Scout();
            paused.Tick(gates, TestTicks.Fresh());
            paused.Tick(gates, TestTicks.Fresh());

            var loaded = (Squad.Scout)session.FromNode(
                session.ToNode(paused, typeof(Squad.Scout)), typeof(Squad.Scout));
            gates.Open.Add("go");
            loaded.Tick(gates, TestTicks.Fresh());

            CheckEqual(2, loaded.Reported);
            CheckTrue(loaded.Finished);
        }
    }

    /// <summary>
    /// Saves scripts whose classes have type parameters.
    /// </summary>
    public class GenericScriptSaveTests : TestFixture
    {
        public void EachInstantiation_ReloadsWithItsOwnTypedLocal()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var numbers = new Relay<int> { Source = 4 };
            var words = new Relay<string> { Source = "four" };
            numbers.Tick(gates, TestTicks.Fresh());
            words.Tick(gates, TestTicks.Fresh());

            var loadedNumbers = (Relay<int>)session.FromNode(
                session.ToNode(numbers, typeof(Relay<int>)), typeof(Relay<int>));
            var loadedWords = (Relay<string>)session.FromNode(
                session.ToNode(words, typeof(Relay<string>)), typeof(Relay<string>));
            gates.Open.Add("go");
            loadedNumbers.Tick(gates, TestTicks.Fresh());
            loadedWords.Tick(gates, TestTicks.Fresh());

            CheckEqual(4, loadedNumbers.Delivered);
            CheckEqual("four", loadedWords.Delivered);
        }

        public void PassageRunOnAnArcOfAGenericClass_ReloadsWithTheCallersFrame()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var paused = new RelayTender { Relay = new Relay<string>() };
            paused.Tick(gates, TestTicks.Fresh());

            var loaded = (RelayTender)session.FromNode(
                session.ToNode(paused, typeof(RelayTender)), typeof(RelayTender));
            gates.Open.Add("go");
            loaded.Tick(gates, TestTicks.Fresh());

            CheckEqual("mail", loaded.Relay.Delivered);
            CheckTrue(loaded.Finished);
        }
    }

    /// <summary>
    /// Saves an arc paused inside a generic passage, whose locals live in a frame made for the call.
    /// </summary>
    public class GenericPassageSaveTests : TestFixture
    {
        public void Locals_AreSavedBehindTheCallSiteWithTheirOwnTypes()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var paused = new PassageHolder();
            paused.Tick(gates, TestTicks.Fresh());
            gates.Open.Add("go1");
            paused.Tick(gates, TestTicks.Fresh());

            SaveNode locals = session.ToNode(paused, typeof(PassageHolder)).RequireEntry(ArcRecord.LocalsKey);

            CheckEqual("five", locals.RequireEntry("Run.second/").RequireEntry("Hold.held").Text);
        }

        public void ReloadedInEachInstantiation_ResumesWithItsLocal()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var first = new PassageHolder();
            first.Tick(gates, TestTicks.Fresh());
            var loadedFirst = (PassageHolder)session.FromNode(
                session.ToNode(first, typeof(PassageHolder)), typeof(PassageHolder));
            gates.Open.Add("go1");
            loadedFirst.Tick(gates, TestTicks.Fresh());

            var loadedSecond = (PassageHolder)session.FromNode(
                session.ToNode(loadedFirst, typeof(PassageHolder)), typeof(PassageHolder));
            gates.Open.Add("go2");
            loadedSecond.Tick(gates, TestTicks.Fresh());

            CheckEqual("5;five;", loadedSecond.Report);
            CheckTrue(loadedSecond.Finished);
        }

        public void CallsMadeInsideAGenericPassage_SaveTheirLocalsWhereTheyLive()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var paused = new NestedRelay();
            paused.Tick(gates, TestTicks.Fresh());

            SaveNode locals = session.ToNode(paused, typeof(NestedRelay)).RequireEntry(ArcRecord.LocalsKey);

            CheckEqual(new[] { "Run.start/", "Step.gate", "Step.spins" },
                locals.Entries.Keys.OrderBy(key => key, StringComparer.Ordinal).ToArray());
            CheckEqual(new[] { "Outer.held" }, locals.RequireEntry("Run.start/").Entries.Keys.ToArray());
        }

        public void ReloadedAtEachPause_ResumesTheNestedCalls()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var relay = new NestedRelay();
            relay.Tick(gates, TestTicks.Fresh());
            foreach (string gate in new[] { "a", "b" })
            {
                relay = (NestedRelay)session.FromNode(session.ToNode(relay, typeof(NestedRelay)),
                    typeof(NestedRelay));
                gates.Open.Add(gate);
                relay.Tick(gates, TestTicks.Fresh());
            }

            CheckEqual("step1;inner9;", relay.Report);
            CheckTrue(relay.Finished);
        }

        public void PassageOfAnotherArc_SavesTheGenericFrameBesideTheArcFrame()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var paused = new Farmer { House = new Greenhouse() };
            paused.Tick(gates, TestTicks.Fresh());

            SaveNode locals = session.ToNode(paused, typeof(Farmer)).RequireEntry(ArcRecord.LocalsKey);

            CheckEqual(new[] { "Run.first/" }, locals.Entries.Keys.ToArray());
            CheckEqual(new[] { "Grow.gate", "Grow.kept", "Step.gate", "Step.spins", "receiver" },
                locals.RequireEntry("Run.first/").Entries.Keys.OrderBy(key => key, StringComparer.Ordinal).ToArray());
        }

        public void ReloadedAtEachPause_ResumesThePassageOfAnotherArc()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var farmer = new Farmer { House = new Greenhouse() };
            farmer.Tick(gates, TestTicks.Fresh());
            foreach (string gate in new[] { "s", "g1" })
            {
                farmer = (Farmer)session.FromNode(session.ToNode(farmer, typeof(Farmer)), typeof(Farmer));
                gates.Open.Add(gate);
                farmer.Tick(gates, TestTicks.Fresh());
            }

            CheckEqual("step1;grew4;", farmer.House.Note);
            CheckTrue(farmer.Finished);
        }

        public void InheritedGenericPassageOfAGenericBase_SurvivesAReload()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var steps = new IntSteps();
            steps.Tick(gates, TestTicks.Fresh());
            var loaded = (IntSteps)session.FromNode(session.ToNode(steps, typeof(IntSteps)), typeof(IntSteps));
            gates.Open.Add("go");
            loaded.Tick(gates, TestTicks.Fresh());

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

        public void RefAndOutArgumentsOfAGenericPassage_ComeBackAfterAReload()
        {
            SaveSession session = ArcConverterTests.Session();
            var gates = new Gates();
            var swapper = new Swapper();
            swapper.Tick(gates, TestTicks.Fresh());
            var loaded = (Swapper)session.FromNode(session.ToNode(swapper, typeof(Swapper)), typeof(Swapper));
            gates.Open.Add("go");
            loaded.Tick(gates, TestTicks.Fresh());

            CheckEqual(10, loaded.Total);
        }
    }
}