using System.Collections.Generic;
using Ariadne.UnitTests;

namespace Ariadne.Vellum.UnitTests
{
    /// <summary>
    /// Counts in a field, and in a local kept across a pause.
    /// </summary>
    public partial class CountingScript : Arc<Gates>
    {
        public int Count = 0;

        public string Note = "initial";

        protected override void Run(Gates gates)
        {
            int waits = 0;

        wait:
            while (!gates.Open.Contains("go"))
            {
                Count++;
                waits++;
                Yield();
            }

            Note = "waited " + waits;
        }
    }

    /// <summary>
    /// Keeps the list its field holds in a local across a pause, and hands it back in another field afterwards.
    /// </summary>
    public partial class SharingScript : Arc<Gates>
    {
        public List<Waypoint> Route = new List<Waypoint>();

        public List<Waypoint> Remembered;

        protected override void Run(Gates gates)
        {
            List<Waypoint> kept = Route;

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

            Remembered = kept;
        }
    }

    /// <summary>
    /// Keeps a converted value in a local across a pause, and another in a field.
    /// </summary>
    public partial class ConvertedScript : Arc<Gates>
    {
        public Waypoint Destination;

        protected override void Run(Gates gates)
        {
            var start = new Point(1.5, -2);

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

            Destination = new Waypoint { Name = "back to start", At = start };
        }
    }

    /// <summary>
    /// Holds the next arc of a chain.
    /// </summary>
    public sealed partial class ChainScript : Arc<Gates>
    {
        public ChainScript Next;

        public int Depth;

        protected override void Run(Gates gates)
        {
        }
    }

    public abstract partial class MissionScript : Arc<Gates>
    {
        public int Stage;
    }

    public sealed partial class ReliefScript : MissionScript
    {
        public int Crates;

        protected override void Run(Gates gates)
        {
        }
    }

    /// <summary>
    /// Saves and loads its one field by hand, so Ariadne.Generator writes nothing for it.
    /// </summary>
    public class HandBuiltScript : Arc<Gates>
    {
        public int Held;

        public HandBuiltScript()
        {
        }

        private HandBuiltScript(IArcReader reader)
            : base(reader)
        {
            int held;
            if (reader.TryField("Held", out held))
            {
                Held = held;
            }
        }

        protected override void __SaveFields(IArcWriter writer)
        {
            base.__SaveFields(writer);
            writer.Field("Held", Held);
        }

        protected override bool __Resume(Gates context, TickTime time)
        {
            return true;
        }

        protected override void Run(Gates context)
        {
        }
    }

    /// <summary>
    /// Derives from a generated class but saves itself by hand, so the chain has a class that lists nothing.
    /// </summary>
    public class HandBuiltUnderMission : MissionScript
    {
        protected override void __SaveFields(IArcWriter writer)
        {
            base.__SaveFields(writer);
        }

        protected override bool __Resume(Gates context, TickTime time)
        {
            return true;
        }

        protected override void Run(Gates context)
        {
        }
    }

    /// <summary>
    /// Refers back to the entity holding it.
    /// </summary>
    public partial class OwnedScript : Arc<Gates>
    {
        public Entity Owner;

        public int Progress;

        protected override void Run(Gates gates)
        {
        }
    }

    /// <summary>
    /// Holds a passage for the scripts that derive from it, which keeps a local across its pause.
    /// </summary>
    public abstract partial class StepsScript : Arc<Gates>
    {
        public string Note = "idle";

        protected void Hold(Gates gates)
        {
            int seen = 0;

        wait:
            while (!gates.Open.Contains("go"))
            {
                seen++;
                Yield();
            }

            Note = "held " + seen;
        }
    }

    /// <summary>
    /// Runs the passage of the class it derives from.
    /// </summary>
    public partial class SteppingScript : StepsScript
    {
        public int Stage;

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

        first:
            Hold(gates);
            Stage = 2;
        }
    }

    /// <summary>
    /// Offers a passage for other arcs to run, which keeps a local across its pause.
    /// </summary>
    public partial class PlantScript : Arc<Gates>
    {
        public int Updates;

        public string Note = "idle";

        public void Update(Gates gates)
        {
            int waited = 0;

        wait:
            while (!gates.Open.Contains("go"))
            {
                waited++;
                Yield();
            }

            Updates += waited;
            Note = "updated after " + waited;
        }

        protected override void Run(Gates gates)
        {
        }
    }

    /// <summary>
    /// Runs the passage of another arc, and keeps a local of its own across the call.
    /// </summary>
    public partial class OperatorScript : Arc<Gates>
    {
        public PlantScript Plant;

        public string Result;

        protected override void Run(Gates gates)
        {
            int before = 7;

        update:
            Plant.Update(gates);
            Result = "done " + before + " " + Plant.Updates;
        }
    }

    /// <summary>
    /// Sits inside a static class, with a local kept across its pause.
    /// </summary>
    public static partial class Squad
    {
        public partial class Scout : Arc<Gates>
        {
            public int Reported;

            protected override void Run(Gates gates)
            {
                int waited = 0;

            look:
                while (!gates.Open.Contains("go"))
                {
                    waited++;
                    Yield();
                }

                Reported = waited;
            }
        }
    }

    /// <summary>
    /// Has a type parameter, with a field and a local kept across a pause of its type.
    /// </summary>
    public partial class Relay<T> : Arc<Gates>
    {
        public T Source;

        public T Delivered;

        public void Deliver(Gates gates, T item)
        {
            T carried = item;

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

            Delivered = carried;
        }

        protected override void Run(Gates gates)
        {
            T held = Source;

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

            Delivered = held;
        }
    }

    /// <summary>
    /// Runs a passage of an arc whose class has a type parameter.
    /// </summary>
    public partial class RelayTender : Arc<Gates>
    {
        public Relay<string> Relay;

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

        deliver:
            Relay.Deliver(gates, mail);
        }
    }

    /// <summary>
    /// Calls a generic passage with two type arguments, which keeps a local of each across its pause.
    /// </summary>
    public partial class PassageHolder : Arc<Gates>
    {
        public string Report = "";

        private void Hold<X>(Gates gates, X item, string gate)
        {
            X held = item;

        hold:
            while (!gates.Open.Contains(gate))
            {
                Yield();
            }

            Report += held + ";";
        }

        protected override void Run(Gates gates)
        {
        first:
            Hold(gates, 5, "go1");

        second:
            Hold(gates, "five", "go2");
        }
    }

    /// <summary>
    /// Has a generic passage that calls an ordinary passage and a generic passage, each keeping a local across its
    /// pause.
    /// </summary>
    public partial class NestedRelay : Arc<Gates>
    {
        public string Report = "";

        private void Step(Gates gates, string gate)
        {
            int spins = 0;

        step:
            while (!gates.Open.Contains(gate))
            {
                ++spins;
                Yield();
            }

            Report += "step" + spins + ";";
        }

        private void Inner<Y>(Gates gates, Y item, string gate)
        {
            Y deep = item;

        inner:
            while (!gates.Open.Contains(gate))
            {
                Yield();
            }

            Report += "inner" + deep + ";";
        }

        private void Outer<X>(Gates gates, X item)
        {
            X held = item;

        first:
            Step(gates, "a");

        second:
            Inner(gates, held, "b");
        }

        protected override void Run(Gates gates)
        {
        start:
            Outer(gates, 9);
        }
    }

    /// <summary>
    /// Offers a generic passage for other arcs to run, which calls an ordinary passage of its own arc.
    /// </summary>
    public partial class Greenhouse : Arc<Gates>
    {
        public string Note = "";

        private void Step(Gates gates, string gate)
        {
            int spins = 0;

        step:
            while (!gates.Open.Contains(gate))
            {
                ++spins;
                Yield();
            }

            Note += "step" + spins + ";";
        }

        public void Grow<X>(Gates gates, X seed, string gate)
        {
            X kept = seed;

        grow:
            Step(gates, "s");

        wait:
            while (!gates.Open.Contains(gate))
            {
                Yield();
            }

            Note += "grew" + kept + ";";
        }

        protected override void Run(Gates gates)
        {
        }
    }

    /// <summary>
    /// Runs a generic passage of another arc.
    /// </summary>
    public partial class Farmer : Arc<Gates>
    {
        public Greenhouse House;

        protected override void Run(Gates gates)
        {
        first:
            House.Grow(gates, 4, "g1");
        }
    }

    /// <summary>
    /// Counts its ticks in a field until a gate opens.
    /// </summary>
    public partial class CounterScript : Arc<Gates>
    {
        public int Counted;

        protected override void Run(Gates gates)
        {
        count:
            while (!gates.Open.Contains("stop"))
            {
                Counted++;
                Yield();
            }
        }
    }

    /// <summary>
    /// Ticks the arc it holds before its own script, which waits for that arc to finish.
    /// </summary>
    public partial class SupervisorScript : Arc<Gates>
    {
        public CounterScript Child = new CounterScript();

        public string Result = "none";

        protected override bool TickSelf(Gates gates, TickContext tick)
        {
            Child.Tick(gates, tick);
            return base.TickSelf(gates, tick);
        }

        protected override void Run(Gates gates)
        {
        wait:
            while (!Child.Finished)
            {
                Yield();
            }

            Result = "child counted " + Child.Counted;
        }
    }
}