using System;
using System.Collections.Generic;
using System.Linq;
using UnitTestSharp;

namespace Ariadne.UnitTests
{
    /// <summary>
    /// Runs scripts next to a twin that is saved and reloaded before every tick, to show a save never changes what a
    /// script does.
    /// </summary>
    public class ReloadEquivalenceTests : TestFixture
    {
        public const string RestartStep = "restart";

        /// <summary>
        /// Starts a step that sets the game time, in seconds, for the ticks after it, eg: "@2.5".
        /// </summary>
        public const string ClockStep = "@";

        public static void ApplyChange(string change, ArcTests.Gates gates)
        {
            if (change.StartsWith("+", StringComparison.Ordinal))
            {
                gates.Open.Add(change.Substring(1));
            }
            else if (change.StartsWith("-", StringComparison.Ordinal))
            {
                gates.Open.Remove(change.Substring(1));
            }
        }

        public static string[] SavedValuesOf(ArcRecord record)
        {
            var returnMe = new List<string>();
            foreach (KeyValuePair<string, object> field in
                record.Fields.OrderBy(pair => pair.Key, StringComparer.Ordinal))
            {
                returnMe.Add("field " + field.Key + "=" + field.Value);
            }

            foreach (KeyValuePair<string, object> local in
                record.AllLocals().OrderBy(pair => pair.Key, StringComparer.Ordinal))
            {
                returnMe.Add("local " + local.Key + "=" + local.Value);
            }

            return returnMe.ToArray();
        }

        public class ReloadedBeforeEveryTickTests : TestFixture
        {
            /// <summary>
            /// Ticks a script once per entry of <paramref name="schedule"/>, which opens ("+gate") or closes ("-gate")
            /// a gate or changes nothing (""), and returns what the script observed.  Before each tick a twin is
            /// loaded from the script's save and given the same tick, and the two must end it identically.
            /// </summary>
            [IgnoreTest]
            public string[] TickWithATwinReloadedEachTime<ScriptType>(string[] schedule,
                Func<ScriptType, IEnumerable<string>> observe)
                where ScriptType : Arc<ArcTests.Gates>, new()
            {
                var live = new ScriptType();
                var liveGates = new ArcTests.Gates();
                TimeSpan gameTime = TimeSpan.Zero;
                for (int i = 0; i < schedule.Length; ++i)
                {
                    // Not a tick, so the next step saves the arc just as the restart left it.
                    if (schedule[i] == RestartStep)
                    {
                        live.Restart();
                        continue;
                    }

                    if (schedule[i].StartsWith(ClockStep, StringComparison.Ordinal))
                    {
                        gameTime = TimeSpan.FromSeconds(double.Parse(schedule[i].Substring(ClockStep.Length),
                            System.Globalization.CultureInfo.InvariantCulture));
                        continue;
                    }

                    ArcRecord saved = ArcRecord.Of<ArcTests.Gates>(live);
                    ScriptType twin = LoadedArc.From<ScriptType>(saved);
                    twin.VerifyLoaded(saved);
                    var twinGates = new ArcTests.Gates();
                    twinGates.Open.UnionWith(liveGates.Open);
                    int observedBefore = observe(live).Count();

                    ApplyChange(schedule[i], liveGates);
                    ApplyChange(schedule[i], twinGates);
                    live.Tick(liveGates, TestTicks.At(TestTicks.NewSandbox(), TimeSpan.Zero, gameTime));
                    twin.Tick(twinGates, TestTicks.At(TestTicks.NewSandbox(), TimeSpan.Zero, gameTime));

                    CheckEqual(observe(live).Skip(observedBefore).ToArray(), observe(twin).ToArray());
                    CheckEqual(live.Cursor.ToArray(), twin.Cursor.ToArray());
                    CheckEqual(live.Finished, twin.Finished);
                    CheckTrue(liveGates.Open.SetEquals(twinGates.Open));
                    CheckEqual(SavedValuesOf(ArcRecord.Of<ArcTests.Gates>(live)),
                        SavedValuesOf(ArcRecord.Of<ArcTests.Gates>(twin)));
                }

                return observe(live).ToArray();
            }

            public void PassageCalledAgain_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<LoopedPassageScript>(
                    new[] { "", "", "+A", "", "+B", "" }, script => script.Log);

                CheckEqual(new[] { "step begins", "A seen", "step ends", "step begins", "A seen", "step ends" },
                    observed);
            }

            public void PassageCalledAgainAndReturningEarly_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<LoopedEarlyReturnScript>(
                    new[] { "", "+skip", "+A", "" }, script => script.Log);

                CheckEqual(new[] { "step begins", "step ends", "step begins" }, observed);
            }

            public void PassageCalledTwiceFromTwoSites_BehavesTheSame()
            {
                TickWithATwinReloadedEachTime<RepeatedPassageScript>(
                    new[] { "", "+read", "", "+read", "" }, script => new string[0]);
            }

            public void PassageKeepingALocal_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<HoldingScript>(
                    new[] { "", "", "+go", "" }, script => script.Log);

                CheckEqual(new[] { "first held 2", "second held 0" }, observed);
            }

            public void Wait_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<WaitingScript>(
                    new[] { "@10", "", "@10.5", "", "@11", "", "@12", "", "@13", "" }, script => script.Log);

                CheckEqual(new[] { "start", "after one second", "end" }, observed);
            }

            public void WaitForTheResultOfAPassage_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<AskWaitScript>(
                    new[] { "@10", "", "@11", "", "@12", "+answer", "@13", "", "@14", "" }, script => script.Log);

                CheckEqual(new[] { "done" }, observed);
            }

            public void WaitForTheSumOfTwoPassages_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<AskSumWaitScript>(
                    new[] { "@10", "", "@11", "+a", "@12", "+b", "@13", "", "@14.5", "" }, script => script.Log);

                CheckEqual(new[] { "done" }, observed);
            }

            public void WaitInOneBranch_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<BranchWaitScript>(
                    new[] { "@10", "+slow", "@10.5", "", "@11", "" }, script => script.Log);

                CheckEqual(new[] { "start", "slow", "end" }, observed);
            }

            public void WaitInALoopAcrossARestart_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<LoopWaitScript>(
                    new[] { "@10", "", "@11", "", RestartStep, "@12", "", "@13", "", "@14", "", "@15", "" },
                    script => script.Log);

                CheckEqual(new[] { "trip 0", "trip 0", "trip 1", "trip 2" }, observed);
            }

            public void PassageKeepingALocal_BehavesTheSameAfterARestart()
            {
                string[] observed = TickWithATwinReloadedEachTime<HoldingScript>(
                    new[] { "", "", RestartStep, "", "+go", "" }, script => script.Log);

                CheckEqual(new[] { "first held 1", "second held 0" }, observed);
            }

            public void RestartOfAFinishedScript_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<LocalsScript>(
                    new[] { "", "+go", "+crate", "+crate", "", RestartStep, "", "+crate", "+crate", "" },
                    script => script.Log);

                CheckEqual(new[] { "hello", "waited 1", "delivered", "hello", "waited 0", "delivered" }, observed);
            }

            public void LocalsAndAPassageArgument_BehaveTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<LocalsScript>(
                    new[] { "", "", "+go", "+crate", "", "+crate", "" }, script => script.Log);

                CheckEqual(new[] { "hello", "waited 2", "delivered" }, observed);
            }

            public void LocalDeclaredInALoopBody_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<LoopBodyLocalsScript>(
                    new[] { "", "+a", "+b", "", "", "" }, script => script.Log);

                CheckTrue(observed.Contains("end"));
            }

            public void ParamsPassage_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<ParamsScript>(
                    new[] { "", "", "+go", "" }, script => script.Log);

                CheckEqual(new[] { "a,n1" }, observed);
            }

            public void ScriptWithSeveralPassages_BehavesTheSame()
            {
                string[] observed = TickWithATwinReloadedEachTime<TutorialScript>(
                    new[] { "", "+intro", "+build", "+connect", "+act3 connect", "" }, script => script.Log);

                CheckEqual("end", observed.Last());
            }
        }
    }
}