using System;
using System.Collections.Generic;

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

        public readonly Latch Alarm = new Latch();

        public readonly List<string> Log = new List<string>();

        public TimeSpan Limit = TimeSpan.FromSeconds(1);
    }

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

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

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

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

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

    /// <summary>
    /// Waits for the door, then sleeps for a long time.
    /// </summary>
    public partial class LatchThenSleepScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            Wait(world.Door);
            world.Log.Add("door");

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

    /// <summary>
    /// Waits for the door or the limit, and logs which came first.
    /// </summary>
    public partial class TimedLatchScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            Condition got = Wait(world.Door, timeout: world.Limit);
            world.Log.Add(got == world.Door ? "door" : "timeout");
        }
    }

    /// <summary>
    /// Waits for the door to be clear or the limit, and logs which came first.
    /// </summary>
    public partial class TimedClearScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            Condition got = Wait(!world.Door, timeout: world.Limit);
            world.Log.Add(got == null ? "timeout" : "clear");
        }
    }

    /// <summary>
    /// Waits for the door or the limit, then sleeps, so a late change to the door has to leave the sleep alone.
    /// </summary>
    public partial class TimedLatchThenSleepScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            Wait(world.Door, timeout: world.Limit);
            world.Log.Add("through");

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

    /// <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 RestartableLatchScript : Arc<LatchWorld>
    {
        public bool Skip;

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

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

    /// <summary>
    /// Waits for the door in a passage unless told to skip it, and then sleeps.
    /// </summary>
    public partial class RestartableLatchPassageScript : Arc<LatchWorld>
    {
        public bool Skip;

        private void Watch(LatchWorld world)
        {
        inner:
            Wait(world.Door);
            world.Log.Add("door");
        }

        protected override void Run(LatchWorld world)
        {
            if (!Skip)
            {
            call:
                Watch(world);
            }

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

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

        protected override void Run(LatchWorld world)
        {
        }
    }

    /// <summary>
    /// Runs the passage of another arc that waits for the door, unless told to skip it, and then sleeps.
    /// </summary>
    public partial class LatchRelayScript : Arc<LatchWorld>
    {
        public LatchLookoutScript Lookout;

        public bool Skip;

        protected override void Run(LatchWorld world)
        {
            if (!Skip)
            {
            relay:
                Lookout.Watch(world);
            }

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

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

    /// <summary>
    /// Waits for the door to be set or clear, which is always so.
    /// </summary>
    public partial class AnyOrInverseScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            WaitAny(world.Door, !world.Door);
            world.Log.Add("through");
        }
    }

    /// <summary>
    /// Waits for either latch, then sleeps, so a late change to either has to leave the sleep alone.
    /// </summary>
    public partial class AnyLatchThenSleepScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            WaitAny(world.Door, world.Alarm);
            world.Log.Add("through");

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

    /// <summary>
    /// Waits for both latches, and logs what the wait returned.
    /// </summary>
    public partial class AllLatchesScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            Condition last = WaitAll(world.Door, world.Alarm);
            world.Log.Add(last == world.Alarm ? "all set" : "other");
        }
    }

    /// <summary>
    /// Waits for the door to be set and the alarm to be clear.
    /// </summary>
    public partial class DoorOpenAlarmClearScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            WaitAll(world.Door, !world.Alarm);
            world.Log.Add("ready");
        }
    }

    /// <summary>
    /// Waits for the door to be both set and clear, which can't happen.
    /// </summary>
    public partial class ContradictoryAllScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            WaitAll(world.Door, !world.Door);
            world.Log.Add("never");
        }
    }

    /// <summary>
    /// Waits for either latch or the limit, and logs which came first.
    /// </summary>
    public partial class TimedAnyLatchScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            Condition got = WaitAny(timeout: world.Limit, world.Door, world.Alarm);
            world.Log.Add(got == null ? "timeout" : got == world.Alarm ? "alarm" : "door");
        }
    }

    /// <summary>
    /// Waits for both latches or the limit, and logs which came first.
    /// </summary>
    public partial class TimedAllLatchesScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        first:
            Condition got = WaitAll(world.Limit, world.Door, world.Alarm);
            world.Log.Add(got == null ? "timeout" : "all set");
        }
    }

    /// <summary>
    /// Takes the condition a wait ended on into a field it assigned earlier.
    /// </summary>
    public partial class AssignedLatchScript : Arc<LatchWorld>
    {
        public Condition Last;

        protected override void Run(LatchWorld world)
        {
        first:
            Last = Wait(world.Door, timeout: world.Limit);
            world.Log.Add(Last == null ? "timeout" : "door");
        }
    }

    /// <summary>
    /// Returns the condition a wait ended on from a passage.
    /// </summary>
    public partial class ReturnedLatchScript : Arc<LatchWorld>
    {
        protected override void Run(LatchWorld world)
        {
        call:
            Condition got = Pick(world);
            world.Log.Add(got == null ? "timeout" : "door");
        }

        private Condition Pick(LatchWorld world)
        {
        inner:
            return Wait(world.Door, timeout: world.Limit);
        }
    }
}