using System;
using System.Collections.Generic;

namespace Ariadne.UnitTests
{
    /// <summary>
    /// Offers a passage that pauses until its gate opens, then hands back a span.
    /// </summary>
    public partial class DelayWorkerScript : Arc<ArcTests.Gates>
    {
        public TimeSpan Ask(ArcTests.Gates gates)
        {
        ask:
            while (!gates.Open.Contains("answer"))
            {
                Yield();
            }

            return TimeSpan.FromSeconds(2);
        }

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

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

        public DelayWorkerScript Delay = new DelayWorkerScript();

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

    /// <summary>
    /// Uses what a passage of another arc hands back in a bigger statement, with a local read after the call.
    /// </summary>
    public partial class ForeignExpressionScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        public WorkerScript Worker = new WorkerScript();

        protected override void Run(ArcTests.Gates gates)
        {
            int before = 4;

        first:
            Log.Add("total " + (before + Worker.Add(gates, 5)));
        }
    }

    /// <summary>
    /// Offers a passage that pauses until a gate it is given opens.
    /// </summary>
    public partial class GatedWorkerScript : Arc<ArcTests.Gates>
    {
        public int Total;

        public int Add(ArcTests.Gates gates, string gate, int amount)
        {
        wait:
            while (!gates.Open.Contains(gate))
            {
                Yield();
            }

            Total += amount;
            return Total;
        }

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

    /// <summary>
    /// Adds what two passages of two arcs hand back, which wait on different gates.
    /// </summary>
    public partial class GatedSumScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        public GatedWorkerScript First = new GatedWorkerScript();

        public GatedWorkerScript Second = new GatedWorkerScript();

        protected override void Run(ArcTests.Gates gates)
        {
        sum:
            Log.Add("sum " + (First.Add(gates, "a", 5) + Second.Add(gates, "b", 7)));
        }
    }

    /// <summary>
    /// Adds what two passages of two arcs hand back.
    /// </summary>
    public partial class TwoForeignCallsScript : Arc<ArcTests.Gates>
    {
        [Scratch]
        public readonly List<string> Log = new List<string>();

        public WorkerScript First = new WorkerScript();

        public WorkerScript Second = new WorkerScript();

        protected override void Run(ArcTests.Gates gates)
        {
        sum:
            Log.Add("sum " + (First.Add(gates, 5) + Second.Add(gates, 7)));
        }
    }
}