using Ariadne.Vellum.UnitTests.Library;

namespace Ariadne.Vellum.UnitTests
{
    /// <summary>
    /// Runs a passage of the class it derives from, which is built into another assembly.
    /// </summary>
    public partial class VaultSteppingScript : VaultHost
    {
        public int Stage;

        protected override void Run(Vault vault)
        {
            Stage = 1;

        first:
            Hold(vault, bonus: 10);
            Stage = 2;
        }
    }

    /// <summary>
    /// Uses the value a passage of its base class returns, from another assembly, inside a bigger expression.
    /// </summary>
    public partial class VaultCountingScript : VaultHost
    {
        public int Total;

        protected override void Run(Vault vault)
        {
        count:
            Total = 100 + Count(vault);
        }
    }

    /// <summary>
    /// Runs a generic passage of the class it derives from, which is built into another assembly.
    /// </summary>
    public partial class VaultWeighingScript : VaultHost
    {
        protected override void Run(Vault vault)
        {
        weigh:
            Weigh(vault, "ore");
        }
    }

    /// <summary>
    /// Runs a passage of the class it derives from, built into another assembly, that calls itself.
    /// </summary>
    public partial class VaultDescendingScript : VaultHost
    {
        protected override void Run(Vault vault)
        {
        descend:
            Descend(vault, 2);
        }
    }

    /// <summary>
    /// Runs the passages of a generic class that is built into another assembly, one of them generic too.
    /// </summary>
    public partial class VaultTaggedScript : VaultTagged<int>
    {
        protected override void Run(Vault vault)
        {
        first:
            Settle(vault, 3);

        second:
            Hold(vault, 4, "a");
        }
    }

    /// <summary>
    /// Extends the Run of a class that is built into another assembly, with a local named like the base's.
    /// </summary>
    public partial class VaultTemplateScript : VaultTemplate
    {
        public string Note = "idle";

        protected override void Run(Vault vault)
        {
            string count = "a";

            base.Run(vault);
            Note = "derived " + count;
        }
    }

    /// <summary>
    /// Runs a passage of an arc that is built into another assembly.
    /// </summary>
    public partial class VaultOperator : Arc<Vault>
    {
        public VaultPlant Plant;

        public string Result;

        protected override void Run(Vault vault)
        {
            int before = 7;

        update:
            Plant.Update(vault, bonus: 5);
            Result = "done " + before;
        }
    }

    /// <summary>
    /// Runs a generic passage of an arc that is built into another assembly.
    /// </summary>
    public partial class VaultPonderer : Arc<Vault>
    {
        public VaultPlant Plant;

        protected override void Run(Vault vault)
        {
        ponder:
            Plant.Ponder<string>(vault, "stone");
        }
    }

    /// <summary>
    /// Runs a passage of an arc that is built into another assembly, which calls itself.
    /// </summary>
    public partial class VaultDigger : Arc<Vault>
    {
        public VaultPlant Plant;

        protected override void Run(Vault vault)
        {
        dig:
            Plant.Dig(vault, 2);
        }
    }

    /// <summary>
    /// Runs passages of a generic arc class that is built into another assembly, one of them generic too.
    /// </summary>
    public partial class VaultShopkeeper : Arc<Vault>
    {
        public VaultShelf<string> Shelf;

        protected override void Run(Vault vault)
        {
        stock:
            Shelf.Stock(vault, "jar");

        label:
            Shelf.Label(vault, "lid", 5);
        }
    }

    /// <summary>
    /// Uses the value a passage of an arc built into another assembly returns, inside a bigger expression.
    /// </summary>
    public partial class VaultMeasurer : Arc<Vault>
    {
        public VaultPlant Plant;

        public int Total;

        protected override void Run(Vault vault)
        {
            int before = 7;

        measure:
            Total = before + Plant.Measure(vault);
        }
    }
}