GamepadEventPoller.cs

namespace Gondwana.Input.Gamepad;

public sealed class GamepadEventPoller
{
    private readonly Dictionary<string, Dictionary<string, GamepadButtonEventConfiguration>> _configsByGamepadId = new();

    public static GamepadEventPoller? Instance { get; private set; } = new();
 
    private GamepadEventPoller()
    { }
 
    private GamepadEventPoller(IEnumerable<IGamepadAdapter>? adapters)
    {
        _configsByGamepadId.Clear();
 
        RefreshAdapters(adapters);
    }

    public static void Initialize(IEnumerable<IGamepadAdapter>? adapters)
    {
        Instance = new GamepadEventPoller(adapters);
    }

    internal void RefreshAdapters(IEnumerable<IGamepadAdapter>? adapters)
    {
        var snapshot = adapters?.ToArray();
        Adapters = snapshot;
 
        if (snapshot is null)
            return;
 
        foreach (var adapter in snapshot)
        {
            if (!_configsByGamepadId.ContainsKey(adapter.GamepadId))
                _configsByGamepadId[adapter.GamepadId] = new Dictionary<string, GamepadButtonEventConfiguration>();
        }
    }

    public IEnumerable<IGamepadAdapter>? Adapters { get; private set; }

    public bool PauseAllInput { get; set; }

    public event Action<GamepadButtonDownEventArgs>? ButtonDown;

    internal void PollForEvents(long tick)
    {
        if (PauseAllInput || ButtonDown is null || Adapters is null) return;
 
        foreach (var adapter in Adapters)
        {
            if (!_configsByGamepadId.TryGetValue(adapter.GamepadId, out var configs))
                continue;
 
            foreach (var kvp in configs)
            {
                var button = kvp.Key;
                var config = kvp.Value;
 
                if (config.IsPaused || !adapter.PressedButtons.Contains(button)) continue;
 
                if (config.ReadyForNextEvent(tick))
                {
                    config._lastEventTick = tick;
                    configs[button] = config;
 
                    ButtonDown?.Invoke(new GamepadButtonDownEventArgs(config, adapter));
                }
            }
        }
    }

    public void StartMonitoringButton(string gamepadId, string button, double timeBetweenEvents = -1, bool isPaused = false)
    {
        if (timeBetweenEvents < 0)
            timeBetweenEvents = Engine.Instance.Configuration.TimeBetweenGamepadEvents;
 
        if (!_configsByGamepadId.TryGetValue(gamepadId, out var configMap))
        {
            configMap = new Dictionary<string, GamepadButtonEventConfiguration>();
            _configsByGamepadId[gamepadId] = configMap;
        }
 
        configMap[button] = new GamepadButtonEventConfiguration(button, timeBetweenEvents, isPaused);
    }

    public void StopMonitoringButton(string gamepadId, string button)
    {
        if (_configsByGamepadId.TryGetValue(gamepadId, out var configMap))
        {
            configMap.Remove(button);
        }
    }

    public void StopMonitoringAllButtons(string gamepadId)
    {
        _configsByGamepadId.Remove(gamepadId);
    }

    public IReadOnlyDictionary<string, IReadOnlyDictionary<string, GamepadButtonEventConfiguration>> AllButtonConfigsByGamepadId
        => _configsByGamepadId.ToDictionary(
            entry => entry.Key,
            entry => (IReadOnlyDictionary<string, GamepadButtonEventConfiguration>)entry.Value);
}