using Microsoft.CodeAnalysis;
using UnitTestSharp;

namespace Ariadne.Generator.UnitTests
{
    /// <summary>
    /// Calls from a derived class's Run to the Run it overrides.
    /// </summary>
    public class BaseRunTests : TestFixture
    {
        public const string Basis = @"
public abstract partial class Basis : Arc<string>
{
    protected override void Run(string context)
    {
        int count = 1;

    first:
        while (context.Length == 0)
        {
            Yield();
        }

        count++;
    }
}
";

        public const string Derived = @"
public partial class Derived : Basis
{
    protected override void Run(string context)
    {
        string count = ""a"";

    second:
        while (context.Length == 0)
        {
            Yield();
        }

        base.Run(context);
        count += ""b"";
    }
}
";

        public class CallTests : TestFixture
        {
            public void BaseRun_CompilesWithoutComplaint()
            {
                GeneratorRun run = GeneratorRun.Of(Basis + Derived);

                CheckEqual(0, run.Reported.Count);
                CheckEqual(0, run.Compiled.Count);
            }

            public void BaseRun_RunsTheBasesCopyOnAFrameOfTheBase()
            {
                GeneratorRun run = GeneratorRun.Of(Basis + Derived);

                CheckTrue(run.CodeBehind.Contains("base.Run__Passage("));
                CheckTrue(run.CodeBehind.Contains("new global::Basis.__Frame()"));
            }

            public void BaseRun_SavesItsLocalsThroughTheBasesCopy()
            {
                GeneratorRun run = GeneratorRun.Of(Basis + Derived);

                CheckTrue(run.CodeBehind.Contains("base.Run__LocalsToSave("));
            }

            public void BaseRun_NeverCallsTheDerivedCopyFromItself()
            {
                GeneratorRun run = GeneratorRun.Of(Basis + Derived);

                CheckFalse(run.CodeBehind.Contains("if (!Run__Passage(__frame"));
            }

            public void BaseRunThatSavesNothing_LeavesNoTableToSave()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public abstract partial class Basis : Arc<string>
{
    protected override void Run(string context)
    {
    first:
        while (context.Length == 0)
        {
            Yield();
        }
    }
}" + Derived);

                CheckEqual(0, run.Compiled.Count);
                CheckFalse(run.CodeBehind.Contains("base.Run__LocalsToSave("));
            }

            public void BaseRunOfAnotherAssembly_CompilesWithoutComplaint()
            {
                MetadataReference library = GeneratorRun.CompileGeneratedLibrary("Bases", Basis);
                GeneratorRun run = GeneratorRun.Of(library, Derived);

                CheckEqual(0, run.Reported.Count);
                CheckEqual(0, run.Compiled.Count);
                CheckTrue(run.CodeBehind.Contains("base.Run__Passage("));
                CheckTrue(run.CodeBehind.Contains("base.Run__LocalsToSave("));
            }

            public void BaseRunInAChainOfThree_CompilesWithoutComplaint()
            {
                GeneratorRun run = GeneratorRun.Of(Basis + Derived + @"
public partial class Leaf : Derived
{
    protected override void Run(string context)
    {
        base.Run(context);
    }
}");

                CheckEqual(0, run.Reported.Count);
                CheckEqual(0, run.Compiled.Count);
            }
        }
    }
}