namespace Ariadne.UnitTests
{
    /// <summary>
    /// Greets from a virtual passage that a derived class overrides, from a Run that only the base writes.
    /// </summary>
    public abstract partial class Greeter : Arc<ArcTests.Gates>
    {
        public string Log = "";

        protected virtual void Greet(ArcTests.Gates gates)
        {
            string word = "hello";

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

            Log += word + ";";
        }

        protected override void Run(ArcTests.Gates gates)
        {
            Greet(gates);
            Log += "done;";
        }
    }

    /// <summary>
    /// Takes the greeting from its base.
    /// </summary>
    public partial class PlainGreeter : Greeter
    {
    }

    /// <summary>
    /// Overrides the greeting with one that keeps a local of its own across the pause.
    /// </summary>
    public partial class LoudGreeter : Greeter
    {
        protected override void Greet(ArcTests.Gates gates)
        {
            int volume = 3;

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

            Log += "LOUD" + volume + ";";
        }
    }

    /// <summary>
    /// Overrides an override, and is itself the base of another override.
    /// </summary>
    public partial class LoudestGreeter : LoudGreeter
    {
        protected override void Greet(ArcTests.Gates gates)
        {
            string volume = "max";

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

            Log += "LOUDEST " + volume + ";";
        }
    }

    /// <summary>
    /// Runs the greeting it overrides between two pauses of its own, with a local named like the base's of another
    /// type.
    /// </summary>
    public partial class Escalator : Greeter
    {
        protected override void Greet(ArcTests.Gates gates)
        {
            int word = 5;

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

            base.Greet(gates);
            Log += "after " + word + ";";
        }
    }

    /// <summary>
    /// Overrides a virtual passage with a body that never pauses.
    /// </summary>
    public partial class SilentGreeter : Greeter
    {
        protected override void Greet(ArcTests.Gates gates)
        {
            Log += "silence;";
        }
    }

    /// <summary>
    /// Returns a value from a virtual passage.
    /// </summary>
    public abstract partial class Appraiser : Arc<ArcTests.Gates>
    {
        public int Total;

        protected virtual int Cost(ArcTests.Gates gates, int quantity)
        {
            return quantity;
        }

        protected override void Run(ArcTests.Gates gates)
        {
        one:
            int first = Cost(gates, 2);

        two:
            int second = Cost(gates, 3);
            Total = first * 100 + second;
        }
    }

    /// <summary>
    /// Takes the appraisal from its base.
    /// </summary>
    public partial class PlainAppraiser : Appraiser
    {
    }

    /// <summary>
    /// Appraises at a flat price, after waiting for a gate.
    /// </summary>
    public partial class Haggler : Appraiser
    {
        protected override int Cost(ArcTests.Gates gates, int quantity)
        {
            int price = 10;

        haggle:
            while (!gates.Open.Contains("haggle" + quantity))
            {
                Yield();
            }

            return price * quantity;
        }
    }

    /// <summary>
    /// Calls a passage that it leaves to the classes that derive from it.
    /// </summary>
    public abstract partial class Merchant : Arc<ArcTests.Gates>
    {
        public string Log = "";

        protected abstract void Barter(ArcTests.Gates gates, int offer);

        protected override void Run(ArcTests.Gates gates)
        {
            Barter(gates, 7);
            Log += "closed;";
        }
    }

    /// <summary>
    /// Asks double, and keeps what it asked across the pause.
    /// </summary>
    public partial class Stubborn : Merchant
    {
        protected override void Barter(ArcTests.Gates gates, int offer)
        {
            int asked = offer * 2;

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

            Log += "asked " + asked + ";";
        }
    }

    /// <summary>
    /// Goes down three levels with a passage of its own, calling a virtual hook at each.
    /// </summary>
    public abstract partial class Surveyor : Arc<ArcTests.Gates>
    {
        public string Log = "";

        protected abstract void Inspect(ArcTests.Gates gates, int depth);

        private void Descend(ArcTests.Gates gates, int depth)
        {
        inspect:
            Inspect(gates, depth);

            if (depth < 2)
            {
            deeper:
                Descend(gates, depth + 1);
            }
        }

        protected override void Run(ArcTests.Gates gates)
        {
        start:
            Descend(gates, 0);
        }
    }

    /// <summary>
    /// Pauses in the hook at each level, with a local across the pause.
    /// </summary>
    public partial class PausingSurveyor : Surveyor
    {
        protected override void Inspect(ArcTests.Gates gates, int depth)
        {
            int seen = depth * 10;

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

            Log += seen + ";";
        }
    }

    /// <summary>
    /// Visits through a virtual passage that calls on to another, which the base doesn't know the override of.
    /// </summary>
    public abstract partial class Walker : Arc<ArcTests.Gates>
    {
        public string Log = "";

        protected virtual void Next(ArcTests.Gates gates)
        {
        }

        protected virtual void Visit(ArcTests.Gates gates)
        {
            Log += "visit;";
            Next(gates);
        }

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

    /// <summary>
    /// Takes the walk from its base, which goes nowhere.
    /// </summary>
    public partial class PlainWalker : Walker
    {
    }

    /// <summary>
    /// Walks on from Next back into Visit, so Visit runs again before it has finished.
    /// </summary>
    public partial class LoopingWalker : Walker
    {
        protected override void Next(ArcTests.Gates gates)
        {
            Visit(gates);
        }
    }
}