using System;
using Amphora;
using System.Collections.Generic;

namespace Ariadne.UnitTests
{
    /// <summary>
    /// Waits a second, then two more, logging between.
    /// </summary>
    public partial class WaitingScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        protected override void Run(ArcTests.Gates gates)
        {
            Log.Add("start");

        first:
            Wait(TimeSpan.FromSeconds(1));
            Log.Add("after one second");

        second:
            Wait(TimeSpan.FromSeconds(2));
            Log.Add("end");
        }
    }

    /// <summary>
    /// Waits for no time at all, then for a negative time.
    /// </summary>
    public partial class NoTimeWaitScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        protected override void Run(ArcTests.Gates gates)
        {
        none:
            Wait(TimeSpan.Zero);
            Log.Add("through zero");

        behind:
            Wait(TimeSpan.FromSeconds(-5));
            Log.Add("through negative");
        }
    }

    /// <summary>
    /// Waits once each trip round a loop, with a local counting the trips.
    /// </summary>
    public partial class LoopWaitScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        protected override void Run(ArcTests.Gates gates)
        {
            for (int trip = 0; trip < 3; trip++)
            {
            rest:
                Wait(TimeSpan.FromSeconds(1));
                Log.Add("trip " + trip);
            }
        }
    }

    /// <summary>
    /// Waits for a span held in a local, which is only read on the way in.
    /// </summary>
    public partial class SpanLocalScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        protected override void Run(ArcTests.Gates gates)
        {
            TimeSpan span = TimeSpan.FromSeconds(1.5);

        rest:
            Wait(span);
            Log.Add("rested");
        }
    }

    /// <summary>
    /// Waits only on one side of an if, and in a nested block.
    /// </summary>
    public partial class BranchWaitScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        protected override void Run(ArcTests.Gates gates)
        {
            Log.Add("start");
            if (gates.Open.Contains("slow"))
            {
            slow:
                Wait(TimeSpan.FromSeconds(1));
                Log.Add("slow");
            }
            else
            {
                Log.Add("quick");
            }

            Log.Add("end");
        }
    }

    /// <summary>
    /// Waits for as long as a passage that pauses says.
    /// </summary>
    public partial class AskWaitScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        private TimeSpan Ask(ArcTests.Gates gates)
        {
        ask:
            while (!gates.Open.Contains("answer"))
            {
                Yield();
            }

            return TimeSpan.FromSeconds(2);
        }

        protected override void Run(ArcTests.Gates gates)
        {
        first:
            Wait(Ask(gates));
            Log.Add("done");
        }
    }

    /// <summary>
    /// Waits for the total of two answers and a local read after both.
    /// </summary>
    public partial class AskSumWaitScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        private TimeSpan Ask(ArcTests.Gates gates, string gate)
        {
        ask:
            while (!gates.Open.Contains(gate))
            {
                Yield();
            }

            return TimeSpan.FromSeconds(1);
        }

        protected override void Run(ArcTests.Gates gates)
        {
            TimeSpan extra = TimeSpan.FromSeconds(0.5);

        first:
            Wait(Ask(gates, "a") + Ask(gates, "b") + extra);
            Log.Add("done");
        }
    }

    /// <summary>
    /// Jumps back to a step that waits.
    /// </summary>
    public partial class JumpWaitScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        protected override void Run(ArcTests.Gates gates)
        {
            int laps = 0;

        again:
            Wait(TimeSpan.FromSeconds(1));
            laps++;
            Log.Add("lap " + laps);
            if (laps < 2)
            {
                goto again;
            }
        }
    }

    /// <summary>
    /// Waits for longer than the game time can count.
    /// </summary>
    public partial class ForeverWaitScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        protected override void Run(ArcTests.Gates gates)
        {
        forever:
            Wait(TimeSpan.MaxValue);
            Log.Add("never");
        }
    }

    /// <summary>
    /// Waits for a span it is given, then logs.
    /// </summary>
    public partial class SpanWaitScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        public Duration Span;

        protected override void Run(ArcTests.Gates gates)
        {
        rest:
            Wait(Span);
            Log.Add("woke");
        }
    }

    /// <summary>
    /// Offers a passage for other arcs to run, which waits a second.
    /// </summary>
    public partial class WaitWorkerScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        public void Pace(ArcTests.Gates gates)
        {
        rest:
            Wait(TimeSpan.FromSeconds(1));
            Log.Add("rested");
        }

        protected override void Run(ArcTests.Gates gates)
        {
        }
    }

    /// <summary>
    /// Runs the passage of another arc that waits, which is never ticked itself.
    /// </summary>
    public partial class WaitClientScript : Arc<ArcTests.Gates>
    {
        public WaitWorkerScript Worker = new WaitWorkerScript();

        protected override void Run(ArcTests.Gates gates)
        {
        pace:
            Worker.Pace(gates);
        }
    }
}