using System.Linq;
using UnitTestSharp;

namespace Ariadne.Generator.UnitTests
{
    public class GenericScriptTests : TestFixture
    {
        public static string ProblemsOf(GeneratorRun run)
        {
            return string.Join(" | ", run.Reported.Concat(run.CompiledAt));
        }

        public class ScriptTests : TestFixture
        {
            public void GenericScript_IsWrittenWithItsTypeParameters()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Counter<T, U> : Arc<World>
{
    protected override void Run(World world)
    {
    }
}");

                CheckEqual("", ProblemsOf(run));
                CheckTrue(run.CodeBehind.Contains("partial class Counter<T, U>"));
            }

            public void LocalOfTheTypeParameter_IsKeptAcrossAPause()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Holder<T> : Arc<World>
    where T : class, new()
{
    public T Kept;

    protected override void Run(World world)
    {
        T item = new T();
        List<T> seen = new List<T>();

    wait:
        while (!world.Open.Contains(""go""))
        {
            seen.Add(item);
            Yield();
        }

        Kept = item;
    }
}");

                CheckEqual("", ProblemsOf(run));
                CheckTrue(run.CodeBehind.Contains("public T Run__item;"));
                CheckTrue(run.CodeBehind.Contains("List<T> Run__seen;"));
            }

            public void ContextTypeUsingTheTypeParameter_Compiles()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Feed<T> : Arc<List<T>>
{
    public int Seen;

    protected override void Run(List<T> items)
    {
    wait:
        while (items.Count == 0)
        {
            Yield();
        }

        Seen = items.Count;
    }
}");

                CheckEqual("", ProblemsOf(run));
            }

            public void PassageWithParametersOfTheTypeParameter_Compiles()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Waiter<T> : Arc<World>
    where T : struct
{
    private T Wait(World world, T start, out T last)
    {
        T current = start;

    wait:
        while (!world.Open.Contains(""go""))
        {
            Yield();
        }

        last = current;
        return current;
    }

    protected override void Run(World world)
    {
        T back;

    first:
        T got = Wait(world, default(T), out back);
    }
}");

                CheckEqual("", ProblemsOf(run));
            }

            public void ScriptNestedInAGenericContainer_Compiles()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Outer<T>
{
    public partial class Inner : Arc<World>
    {
        private T held;

        protected override void Run(World world)
        {
            T item = held;

        wait:
            while (!world.Open.Contains(""go""))
            {
                Yield();
            }

            held = item;
        }
    }
}");

                CheckEqual("", ProblemsOf(run));
                CheckTrue(run.CodeBehind.Contains("partial class Outer<T>"));
            }

            public void ScriptWithTheNameOfAGenericOfAnotherArity_Compiles()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Same : Arc<World>
{
    protected override void Run(World world)
    {
    }
}

public partial class Same<T> : Arc<World>
{
    protected override void Run(World world)
    {
    }
}");

                CheckEqual("", ProblemsOf(run));
            }
        }

        public class BaseClassTests : TestFixture
        {
            public void FieldsOnlyGenericBase_SavesItsFields()
            {
                GeneratorRun run = GeneratorRun.Of(
                    "public abstract partial class Mission<T> : Arc<World> { public T Stage; }");

                CheckEqual("", ProblemsOf(run));
                CheckTrue(run.CodeBehind.Contains("writer.Field<T>(\"Stage\", this.Stage);"));
            }

            public void ScriptDerivedFromAConstructedGenericBase_RunsTheBasesPassage()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public abstract partial class Steps<T> : Arc<World>
{
    protected T Last;

    protected void Hold(World world, T value)
    {
        T held = value;

    hold:
        while (!world.Open.Contains(""go""))
        {
            Yield();
        }

        Last = held;
    }
}

public partial class IntSteps : Steps<int>
{
    protected override void Run(World world)
    {
        int local = 3;

    first:
        Hold(world, local);
    }
}");

                CheckEqual("", ProblemsOf(run));
            }

            public void ScriptDerivedFromAGenericScript_Compiles()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Base<T> : Arc<World>
{
    protected override void Run(World world)
    {
        T value = default(T);

    wait:
        while (!world.Open.Contains(""go""))
        {
            Yield();
        }

        value.ToString();
    }
}

public partial class Derived : Base<string>
{
    public int Stage;
}");

                CheckEqual("", ProblemsOf(run));
            }

            public void GenericScriptDerivedFromAGenericBase_Compiles()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public abstract partial class Steps<T> : Arc<World>
{
    protected void Hold(World world, T value)
    {
        T held = value;

    hold:
        while (!world.Open.Contains(""go""))
        {
            Yield();
        }
    }
}

public partial class Stepper<U> : Steps<List<U>>
{
    protected override void Run(World world)
    {
        List<U> local = new List<U>();

    first:
        Hold(world, local);
    }
}");

                CheckEqual("", ProblemsOf(run));
            }
        }

        public class ForeignCallTests : TestFixture
        {
            public void CallOnAConstructedGenericArc_Compiles()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Plant<T> : Arc<World>
{
    public int Updates;

    public void Update(World world, T seed)
    {
        T kept = seed;

    wait:
        while (!world.Open.Contains(""go""))
        {
            Yield();
        }

        ++Updates;
    }

    protected override void Run(World world)
    {
    }
}

public partial class Tender : Arc<World>
{
    public Plant<string> Plant;

    protected override void Run(World world)
    {
        string seed = ""x"";

    update:
        Plant.Update(world, seed);
    }
}");

                CheckEqual("", ProblemsOf(run));
                CheckTrue(run.CodeBehind.Contains("global::Plant<string>.__Frame"));
            }

            public void CallOnGenericArcsOfTwoInstantiations_KeepsEachFrameApart()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Plant<T> : Arc<World>
{
    public void Update(World world, T seed)
    {
        T kept = seed;

    wait:
        while (!world.Open.Contains(""go""))
        {
            Yield();
        }
    }

    protected override void Run(World world)
    {
    }
}

public partial class Tender : Arc<World>
{
    public Plant<string> Words;
    public Plant<int> Numbers;

    protected override void Run(World world)
    {
    first:
        Words.Update(world, ""x"");
    second:
        Numbers.Update(world, 3);
    }
}");

                CheckEqual("", ProblemsOf(run));
                CheckTrue(run.CodeBehind.Contains("global::Plant<string>.__Frame"));
                CheckTrue(run.CodeBehind.Contains("global::Plant<int>.__Frame"));
            }

            public void CallOnAnArcOfTheCallersOwnTypeParameter_Compiles()
            {
                GeneratorRun run = GeneratorRun.Of(@"
public partial class Plant<T> : Arc<World>
{
    public void Update(World world, T seed)
    {
        T kept = seed;

    wait:
        while (!world.Open.Contains(""go""))
        {
            Yield();
        }
    }

    protected override void Run(World world)
    {
    }
}

public partial class Tender<U> : Arc<World>
{
    public Plant<U> Plant;

    protected override void Run(World world)
    {
        U seed = default(U);

    update:
        Plant.Update(world, seed);
    }
}");

                CheckEqual("", ProblemsOf(run));
            }
        }
    }
}