Timer.cs

using System.Collections.Concurrent;
 
namespace Gondwana.Timers;

public sealed class Timer : IDisposable
{
    public event Action? Tick;

    public TimerType Type { get; }

    public TimerCycles Cycles { get; }

    public long Length { get; }

    public string TimerID { get; internal set; } = string.Empty;

    public bool Paused { get; set; }
 
    private long _lastEventTick { get; set; }
    private bool _disposed;
 
    private Timer(TimerType type, TimerCycles cycles, long startTick, double length)
    {
        if (!double.IsFinite(length) || length <= 0)
            throw new ArgumentOutOfRangeException(
                nameof(length),
                length,
                "Timer length must be finite and greater than zero.");
 
        double lengthInTicks = length * HighResTimer.TicksPerSecond;
        if (lengthInTicks < 1 || lengthInTicks >= long.MaxValue)
            throw new ArgumentOutOfRangeException(
                nameof(length),
                length,
                "Timer length must convert to at least one high-resolution tick and fit in a positive Int64.");
 
        Type = type;
        Cycles = cycles;
        _lastEventTick = startTick;
        Length = (long)lengthInTicks;
        Paused = false;
    }
 
    internal void RaiseTickEvent() => Tick?.Invoke();

    public void Dispose()
    {
        if (_disposed) return;
        GC.SuppressFinalize(this);
        _timers.TryRemove(TimerID, out _);
        Tick = null;
        _disposed = true;
    }

    ~Timer() => Dispose();
 
    #region static members
 
    private static readonly ConcurrentDictionary<string, Timer> _timers = new();

    public static bool PausedAll { get; set; }

    public static Timer Add(string timerID, TimerType type, TimerCycles cycles, double length)
    {
        long startTick = type == TimerType.PreCycle
            ? EngineSimulationClock.GetCurrentTick()
            : HighResTimer.GetCurrentTick();
 
        var timer = new Timer(type, cycles, startTick, length)
        {
            TimerID = timerID
        };
        _timers[timerID] = timer;
        return timer;
    }

    public static Timer Add(TimerType type, TimerCycles cycles, double length)
    {
        string timerID = Guid.NewGuid().ToString();
        return Add(timerID, type, cycles, length);
    }

    public static void Remove(string timerID)
    {
        if (_timers.TryRemove(timerID, out var timer))
            timer.Dispose();
    }

    public static Timer Get(string timerID) => _timers[timerID];

    public static int Count => _timers.Count;

    public static string[] TimerIDs => _timers.Keys.ToArray();

    public static void ClearAll()
    {
        foreach (var key in _timers.Keys.ToArray())
            Remove(key);
    }
 
    internal static void RaiseTimerEvents(TimerType type, long engineTick)
    {
        var expired = new List<string>();
 
        foreach (var (key, timer) in _timers.ToArray())
        {
            // checking this TimerType (i.e., PreCycle or PostCycle)
            if (timer.Type != type) continue;
 
            // "push" time forward for Paused Timer instances
            if (PausedAll || timer.Paused)
            {
                timer._lastEventTick += (engineTick - timer._lastEventTick);
                continue;
            }
 
            // check if Timer.Length time has passed
            while (engineTick - timer._lastEventTick >= timer.Length)
            {
                // save the time this event was scheduled to run
                // might be different from current system tick, but storing this value
                // will ensure that a lag in repeating timer events does not
                // accumulate over time
                timer._lastEventTick += timer.Length;
                timer.RaiseTickEvent();
 
                // check for any expired timers
                if (timer.Cycles == TimerCycles.Once)
                {
                    expired.Add(key);
                    break;
                }
            }
        }
 
        foreach (var key in expired)
            _timers.TryRemove(key, out _);
    }
 
    #endregion static members
}