BadConsoleApi.cs

Go to the documentation of this file.

using BadScript2.ConsoleAbstraction;
using BadScript2.Interop.Common.Task;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Native;
 
namespace BadScript2.Interop.Common.Apis;
 
[BadInteropApi("Console", true)]
internal partial class BadConsoleApi
{
    private readonly IBadConsole? m_Console;
 
 
    public BadConsoleApi(IBadConsole console) : this()
    {
        m_Console = console;
        OnWrite = Write;
        OnWriteLine = WriteLine;
        OnClear = Clear;
        OnReadLine = ReadLine;
        OnReadLineAsync = ReadLineAsync;
    }
 
    private IBadConsole Console => m_Console ?? BadConsole.GetConsole();
 
    public Action<BadObject> OnWrite { get; set; } = delegate { };
 
    public Action<BadObject> OnWriteLine { get; set; } = delegate { };
 
    public Action OnClear { get; set; } = delegate { };
 
    public Func<string> OnReadLine { get; set; } = () => string.Empty;
 
    public Func<Task<string>> OnReadLineAsync { get; set; } = () => System.Threading.Tasks.Task.FromResult(string.Empty);
 
    public bool AllowInput { get; set; } = true;
 
    private Task<string> ReadLineAsync()
    {
        return System.Threading.Tasks.Task.Run(Console.ReadLine);
    }
 
 
    [BadMethod("WriteLine", "Writes a line to the Console")]
    private void InvokeWriteLine([BadParameter(description: "The Object to Write")] BadObject obj)
    {
        OnWriteLine(obj);
    }
 
    [BadMethod("Write", "Writes to the Console")]
    private void InvokeWrite([BadParameter(description: "The Object to Write")] BadObject obj)
    {
        OnWrite(obj);
    }
 
    [BadMethod("Clear", "Clears the Console")]
    private void InvokeClear()
    {
        OnClear();
    }
 
    [BadMethod("ReadLine", "Reads a line from the Console")]
    [return: BadReturn("The Console Input")]
    private string InvokeReadLine()
    {
        return OnReadLine();
    }
 
    [BadMethod("ReadLineAsync", "Reads a line from the Console asynchronously")]
    [return: BadReturn("The Console Input")]
    private BadTask InvokeReadLineAsync()
    {
        return new BadTask(
            new BadReadLineAsyncRunnable(ReadLineAsyncBlocking().GetEnumerator()),
            "Console.ReadLineAsync"
        );
    }
 
    private IEnumerable<BadObject> ReadLineAsyncBlocking()
    {
        Task<string>? t = OnReadLineAsync();
 
        while (!t.IsCompleted)
        {
            yield return BadObject.Null;
        }
 
        yield return t.Result;
    }
 
    private void Write(BadObject obj)
    {
        if (obj is IBadString str)
        {
            Console.Write(str.Value);
        }
        else
        {
            Console.Write(obj.ToString());
        }
    }
 
    private void WriteLine(BadObject obj)
    {
        if (obj is IBadString str)
        {
            Console.WriteLine(str.Value);
        }
        else
        {
            Console.WriteLine(obj.ToString());
        }
    }
 
    public void Clear()
    {
        Console.Clear();
    }
 
    public string ReadLine()
    {
        if (!AllowInput)
        {
            throw new NotSupportedException("Input is not allowed");
        }
 
        return Console.ReadLine();
    }
 
    private class BadReadLineAsyncRunnable : BadRunnable
    {
        private readonly IEnumerator<BadObject> m_Task;
 
        private BadObject m_Return = BadObject.Null;
 
        public BadReadLineAsyncRunnable(IEnumerator<BadObject> task)
        {
            m_Task = task;
        }
 
        public override IEnumerator<BadObject> Enumerator
        {
            get
            {
                while (m_Task.MoveNext())
                {
                    m_Return = m_Task.Current!;
 
                    yield return m_Return;
                }
            }
        }
 
        public override BadObject GetReturn()
        {
            return m_Return;
        }
    }
}