using System;
using System.Collections.Generic;

namespace Ariadne.UnitTests
{
    /// <summary>
    /// The context the trigger wait scripts run in, with the triggers they wait on and a log they write to.
    /// </summary>
    public class TriggerWorld
    {
        public readonly Trigger Door = new Trigger();

        public readonly Trigger Alarm = new Trigger();

        [Scratch]
        public readonly List<string> Log = new List<string>();
    }

    /// <summary>
    /// Waits for the door, then logs.
    /// </summary>
    public partial class SingleTriggerScript : Arc<TriggerWorld>
    {
        protected override void Run(TriggerWorld world)
        {
            world.Log.Add("start");

        first:
            Wait(world.Door);
            world.Log.Add("door");
        }
    }

    /// <summary>
    /// Waits for the door, then for the alarm.
    /// </summary>
    public partial class TwoWaitsScript : Arc<TriggerWorld>
    {
        protected override void Run(TriggerWorld world)
        {
        first:
            Wait(world.Door);
            world.Log.Add("door");

        second:
            Wait(world.Alarm);
            world.Log.Add("alarm");
        }
    }

    /// <summary>
    /// Waits for either trigger, and logs which one it was.
    /// </summary>
    public partial class AnyTriggerScript : Arc<TriggerWorld>
    {
        protected override void Run(TriggerWorld world)
        {
        first:
            Trigger fired = WaitAny(world.Door, world.Alarm);
            world.Log.Add(fired == world.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Waits for both triggers, and logs which one came last.
    /// </summary>
    public partial class AllTriggersScript : Arc<TriggerWorld>
    {
        protected override void Run(TriggerWorld world)
        {
        first:
            Trigger last = WaitAll(world.Door, world.Alarm);
            world.Log.Add(last == world.Alarm ? "alarm last" : "door last");
        }
    }

    /// <summary>
    /// Waits for the same trigger twice in one wait.
    /// </summary>
    public partial class RepeatedTriggerScript : Arc<TriggerWorld>
    {
        protected override void Run(TriggerWorld world)
        {
        first:
            WaitAll(world.Door, world.Door);
            world.Log.Add("through");
        }
    }

    /// <summary>
    /// Waits for the door three times, with a local counting the trips.
    /// </summary>
    public partial class LoopedTriggerScript : Arc<TriggerWorld>
    {
        protected override void Run(TriggerWorld world)
        {
            int count = 0;
            while (count < 3)
            {
            spin:
                Wait(world.Door);
                ++count;
                world.Log.Add("door " + count);
            }
        }
    }

    /// <summary>
    /// Waits for the door unless told to skip it, and then sleeps, so a restart can send it past the wait.
    /// </summary>
    public partial class RestartableTriggerScript : Arc<TriggerWorld>
    {
        public bool Skip;

        protected override void Run(TriggerWorld world)
        {
            if (!Skip)
            {
            first:
                Wait(world.Door);
                world.Log.Add("door");
            }

        nap:
            Wait(TimeSpan.FromSeconds(100));
            world.Log.Add("rested");
        }
    }

    /// <summary>
    /// Takes the trigger a wait ended on into a local it declared earlier, and into a field.
    /// </summary>
    public partial class AssignedTriggerScript : Arc<TriggerWorld>
    {
        public Trigger Last;

        protected override void Run(TriggerWorld world)
        {
            Trigger first = null;

        pick:
            first = WaitAny(world.Door, world.Alarm);

        again:
            Last = WaitAny(world.Door, world.Alarm);
            world.Log.Add(first == world.Door ? "first door" : "first alarm");
            world.Log.Add(Last == world.Door ? "then door" : "then alarm");
        }
    }

    /// <summary>
    /// Keeps the trigger a wait ended on across a later pause.
    /// </summary>
    public partial class KeptTriggerScript : Arc<TriggerWorld>
    {
        protected override void Run(TriggerWorld world)
        {
        first:
            Trigger fired = WaitAny(world.Door, world.Alarm);

        second:
            Yield();
            world.Log.Add(fired == world.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Waits in a passage that hands the trigger back.
    /// </summary>
    public partial class PassageTriggerScript : Arc<TriggerWorld>
    {
        private Trigger Pick(TriggerWorld world)
        {
        inner:
            return WaitAny(world.Door, world.Alarm);
        }

        protected override void Run(TriggerWorld world)
        {
        outer:
            Trigger picked = Pick(world);
            world.Log.Add(picked == world.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Offers a passage for other arcs to run, which waits for the door.
    /// </summary>
    public partial class TriggerLookoutScript : Arc<TriggerWorld>
    {
        public void Watch(TriggerWorld world)
        {
        watch:
            Wait(world.Door);
            world.Log.Add("seen");
        }

        protected override void Run(TriggerWorld world)
        {
        }
    }

    /// <summary>
    /// Runs the passage of another arc that waits for the door.
    /// </summary>
    public partial class TriggerRelayScript : Arc<TriggerWorld>
    {
        public TriggerLookoutScript Lookout;

        protected override void Run(TriggerWorld world)
        {
        relay:
            Lookout.Watch(world);
            world.Log.Add("relayed");
        }
    }

    /// <summary>
    /// Waits in a generic passage, which keeps its locals in a frame of its own.
    /// </summary>
    public partial class GenericTriggerScript : Arc<TriggerWorld>
    {
        private Trigger Choose<ItemType>(TriggerWorld world, ItemType marker)
        {
        inner:
            return WaitAny(world.Door, world.Alarm);
        }

        protected override void Run(TriggerWorld world)
        {
        outer:
            Trigger picked = Choose(world, 5);
            world.Log.Add(picked == world.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Waits for the door with a time limit, and logs whether it came.
    /// </summary>
    public partial class TimedDoorScript : Arc<TriggerWorld>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        protected override void Run(TriggerWorld world)
        {
        first:
            Trigger got = Wait(world.Door, timeout: Limit);
            world.Log.Add(got == null ? "timed out" : "door");
        }
    }

    /// <summary>
    /// Waits for either trigger with a time limit, and logs which one came.
    /// </summary>
    public partial class TimedAnyScript : Arc<TriggerWorld>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        protected override void Run(TriggerWorld world)
        {
        first:
            Trigger fired = WaitAny(timeout: Limit, world.Door, world.Alarm);
            world.Log.Add(fired == null ? "timed out" : fired == world.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Waits for both triggers with a time limit, and logs which one came last.
    /// </summary>
    public partial class TimedAllScript : Arc<TriggerWorld>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        protected override void Run(TriggerWorld world)
        {
        first:
            Trigger last = WaitAll(timeout: Limit, world.Door, world.Alarm);
            world.Log.Add(last == null ? "timed out" : last == world.Alarm ? "alarm last" : "door last");
        }
    }

    /// <summary>
    /// Waits for the door with a time limit, and then sleeps for a long time.
    /// </summary>
    public partial class TimedThenNapScript : Arc<TriggerWorld>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        protected override void Run(TriggerWorld world)
        {
        first:
            Wait(world.Door, timeout: Limit);
            world.Log.Add("waited");

        second:
            Wait(TimeSpan.FromSeconds(100));
            world.Log.Add("rested");
        }
    }

    /// <summary>
    /// Waits for the door with a time limit three times, with the arguments named out of order.
    /// </summary>
    public partial class TimedLoopScript : Arc<TriggerWorld>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        protected override void Run(TriggerWorld world)
        {
            int count = 0;
            while (count < 3)
            {
            spin:
                Trigger got = Wait(timeout: Limit, trigger: world.Door);
                ++count;
                world.Log.Add((got == null ? "timed out " : "door ") + count);
            }
        }
    }

    /// <summary>
    /// Waits for either trigger with a time limit in a passage that hands the trigger back.
    /// </summary>
    public partial class TimedPassageScript : Arc<TriggerWorld>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        private Trigger Pick(TriggerWorld world)
        {
        inner:
            return WaitAny(timeout: Limit, world.Door, world.Alarm);
        }

        protected override void Run(TriggerWorld world)
        {
        outer:
            Trigger picked = Pick(world);
            world.Log.Add(picked == null ? "timed out" : picked == world.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Waits for the door with a time limit, ignoring the result.
    /// </summary>
    public partial class TimedDiscardScript : Arc<TriggerWorld>
    {
        public TimeSpan Limit = TimeSpan.FromSeconds(2);

        protected override void Run(TriggerWorld world)
        {
        first:
            Wait(world.Door, timeout: Limit);
            world.Log.Add("through");
        }
    }

    /// <summary>
    /// Waits for the door inside a branch and a loop that is only sometimes taken.
    /// </summary>
    public partial class BranchingTriggerScript : Arc<TriggerWorld>
    {
        public bool Skip;

        protected override void Run(TriggerWorld world)
        {
            if (!Skip)
            {
            inside:
                Wait(world.Door);
                world.Log.Add("waited");
            }

            world.Log.Add("done");
        }
    }
}