Threadling.cs

using System.Collections.Concurrent;
using System.Diagnostics;

namespace Scopie;

internal readonly struct IdleActionResult
{
    public readonly int Kind;
    public readonly TimeSpan TimeSpan;

    private IdleActionResult(int kind, TimeSpan timeSpan)
    {
        Kind = kind;
        TimeSpan = timeSpan;
    }

    public static IdleActionResult LoopImmediately => new(0, TimeSpan.Zero);
    public static IdleActionResult WaitForNextEvent => new(1, TimeSpan.Zero);
    public static IdleActionResult WaitWithTimeout(TimeSpan timeSpan) => new(2, timeSpan);
}

internal sealed class Threadling : IDisposable
{
    private readonly Thread _thread;
    private readonly BlockingCollection<Action> _sendToThread = [];
    private Func<IdleActionResult>? _idleAction;

    public Threadling(Func<IdleActionResult>? idleAction)
    {
        _idleAction = idleAction;
        _thread = new Thread(RunThread);
        _thread.Start();
    }

    public Func<IdleActionResult>? IdleAction
    {
        set
        {
            _idleAction = value;
            _sendToThread.Add(() => { });
        }
    }

    public void Dispose()
    {
        _sendToThread.CompleteAdding();
        _sendToThread.Dispose();
    }

    public Task<T> Do<T>(Func<T> action)
    {
        if (_thread == Thread.CurrentThread)
        {
            try
            {
                return Task.FromResult(action());
            }
            catch (Exception e)
            {
                return Task.FromException<T>(e);
            }
        }

        TaskCompletionSource<T> tcs = new();
        _sendToThread.Add(() =>
        {
            try
            {
                tcs.SetResult(action());
            }
            catch (Exception e)
            {
                tcs.SetException(e);
            }
        });
        return tcs.Task;
    }

    public Task Do(Action action)
    {
        if (_thread == Thread.CurrentThread)
        {
            try
            {
                action();
                return Task.CompletedTask;
            }
            catch (Exception e)
            {
                return Task.FromException<int>(e);
            }
        }

        TaskCompletionSource<int> tcs = new();
        _sendToThread.Add(() =>
        {
            try
            {
                action();
                tcs.SetResult(0);
            }
            catch (Exception e)
            {
                tcs.SetException(e);
            }
        });
        return tcs.Task;
    }

    private void RunThread()
    {
        var idleActionResult = IdleActionResult.WaitForNextEvent;
        var stopwatch = new Stopwatch();
        while (true)
        {
            var first = true;
            while (true)
            {
                Action action;
                try
                {
                    if (first && idleActionResult.Kind == 1)
                        action = _sendToThread.Take();
                    else
                    {
                        if (idleActionResult.Kind == 2)
                        {
                            TimeSpan elapsed;
                            if (first)
                            {
                                stopwatch.Restart();
                                elapsed = TimeSpan.Zero;
                            }
                            else
                                elapsed = stopwatch.Elapsed;

                            if (elapsed > idleActionResult.TimeSpan)
                                break;

                            var toWait = idleActionResult.TimeSpan - elapsed;
                            if (!_sendToThread.TryTake(out action!, toWait))
                                break;
                        }
                        else if (!_sendToThread.TryTake(out action!))
                            break;
                    }
                }
                catch
                {
                    return;
                }

                action();

                first = false;
            }

            try
            {
                idleActionResult = _idleAction?.Invoke() ?? IdleActionResult.WaitForNextEvent;
            }
            catch (Exception e)
            {
                ExceptionReporter.Report(e);
                idleActionResult = IdleActionResult.WaitForNextEvent;
            }
        }
    }
}