namespace Ariadne.Vellum.UnitTests
{
    /// <summary>
    /// Keeps a local across a pause in a Run that a derived class overrides.
    /// </summary>
    public abstract partial class CollisionBase : Arc<Gates>
    {
        public string BaseNote = "idle";

        protected override void Run(Gates gates)
        {
            int count = 1;

        basewait:
            while (!gates.Open.Contains("go"))
            {
                Yield();
            }

            BaseNote = "base " + count;
        }
    }

    /// <summary>
    /// Overrides Run with a local of the same name as the base's, but another type.
    /// </summary>
    public partial class CollisionDerived : CollisionBase
    {
        public string Note = "idle";

        protected override void Run(Gates gates)
        {
            string count = "a";

        derivedwait:
            while (!gates.Open.Contains("go"))
            {
                Yield();
            }

            Note = "derived " + count;
        }
    }

    /// <summary>
    /// Runs the base's Run between two pauses of its own, with a local named like the base's but of another type.
    /// </summary>
    public partial class CollisionCaller : CollisionBase
    {
        public string Note = "idle";

        protected override void Run(Gates gates)
        {
            string count = "a";

        before:
            while (!gates.Open.Contains("start"))
            {
                Yield();
            }

            base.Run(gates);
            Note = "derived " + count;
        }
    }

    /// <summary>
    /// Runs the base's Run from a call of its own, under a label.
    /// </summary>
    public partial class CollisionLabelled : CollisionBase
    {
        protected override void Run(Gates gates)
        {
        again:
            base.Run(gates);
        }
    }

    /// <summary>
    /// Runs the base's Run from a passage other than Run.
    /// </summary>
    public partial class CollisionHelper : CollisionBase
    {
        public string Note = "idle";

        protected void Prepare(Gates gates)
        {
            string count = "p";

        prepared:
            base.Run(gates);
            Note = "prepared " + count;
        }

        protected override void Run(Gates gates)
        {
            Prepare(gates);
        }
    }

    /// <summary>
    /// Holds a Run that waits for game time, with a local across the wait.
    /// </summary>
    public abstract partial class CollisionWaitBase : Arc<Gates>
    {
        public string WaitNote = "idle";

        protected override void Run(Gates gates)
        {
            int rounds = 3;

        rest:
            Wait(System.TimeSpan.FromSeconds(1));
            WaitNote = "rested " + rounds;
        }
    }

    /// <summary>
    /// Runs a base Run that waits for game time.
    /// </summary>
    public partial class CollisionWaitDerived : CollisionWaitBase
    {
        public string Note = "idle";

        protected override void Run(Gates gates)
        {
            string rounds = "x";

            base.Run(gates);
            Note = "derived " + rounds;
        }
    }

    /// <summary>
    /// Runs the base's Run, and is itself the base of a script that does the same.
    /// </summary>
    public partial class CollisionMiddle : CollisionBase
    {
        public string MiddleNote = "idle";

        protected override void Run(Gates gates)
        {
            double count = 2.5;

        middlewait:
            while (!gates.Open.Contains("middle"))
            {
                Yield();
            }

            base.Run(gates);
            MiddleNote = "middle " + count;
        }
    }

    /// <summary>
    /// Runs the Run of a class that runs the Run of its own base.
    /// </summary>
    public partial class CollisionLeaf : CollisionMiddle
    {
        public string Note = "idle";

        protected override void Run(Gates gates)
        {
            string count = "leaf";

        leafwait:
            while (!gates.Open.Contains("start"))
            {
                Yield();
            }

            base.Run(gates);
            Note = "leaf " + count;
        }
    }

    /// <summary>
    /// Overrides Run with a local of the same name and type as the base's, holding another value.
    /// </summary>
    public partial class CollisionSameType : CollisionBase
    {
        public string Note = "idle";

        protected override void Run(Gates gates)
        {
            int count = 5;

        derivedwait:
            while (!gates.Open.Contains("go"))
            {
                Yield();
            }

            Note = "derived " + count;
        }
    }
}