GamePadWatcher

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using XInputDotNetPure;

namespace XInputToVJoy
{
    public delegate void OnGamePadButtonPressed(object sender, GamePadButtonEventArgs args);
    public delegate void OnGamePadButtonReleased(object sender, GamePadButtonEventArgs args);

    public delegate void OnGamePadDpadPressed(object sender, GamePadDpadEventArgs args);
    public delegate void OnGamePadDpadReleased(object sender, GamePadDpadEventArgs args);

    public delegate void OnGamePadTriggerStateChanged(object sender, GamePadTriggerEventArgs args);
    public delegate void OnGamePadThumbStickStateChanged(object sender, GamePadThumbStickEventArgs args);

    public class GamePadWatcher
    {
        private GamePadState _state;
        private Dictionary<Button, DateTime> _buttonHolds = new Dictionary<Button, DateTime>();
        private Dictionary<Dpad, DateTime> _dpadHolds = new Dictionary<Dpad, DateTime>();

        public GamePadWatcher()
        {
            _state = GamePad.GetState(PlayerIndex.One);
            _ = Task.Run(PollState);
        }

        public event OnGamePadButtonPressed GamePadButtonPressed;

        public event OnGamePadButtonReleased GamePadButtonReleased;

        public event OnGamePadThumbStickStateChanged GamePadThumbStickStateChanged;

        public event OnGamePadTriggerStateChanged GamePadTriggerStateChanged;

        public event OnGamePadDpadPressed GamePadDpadPressed;

        public event OnGamePadDpadReleased GamePadDpadReleased;

        private void PollState()
        {
            while (true)
            {
                var currentState = GamePad.GetState(PlayerIndex.One, GamePadDeadZone.Circular);

                foreach (var stateChange in CheckPressedButtons(_state.Buttons, currentState.Buttons))
                {
                    _buttonHolds.Add(stateChange.button, DateTime.Now);
                    GamePadButtonPressed(this, new GamePadButtonEventArgs(stateChange.button, stateChange.state));
                }

                foreach (var stateChange in CheckReleasedButtons(_state.Buttons, currentState.Buttons))
                {
                    var buttonHold = _buttonHolds[stateChange.button];
                    _buttonHolds.Remove(stateChange.button);
                    GamePadButtonReleased(this, new GamePadButtonEventArgs(stateChange.button, stateChange.state, buttonHold));
                }

                foreach(var stateChange in CheckThumbSticks(_state.ThumbSticks, currentState.ThumbSticks))
                {
                    GamePadThumbStickStateChanged(this, new GamePadThumbStickEventArgs(stateChange.stick, stateChange.value));
                }

                foreach (var stateChange in CheckTriggers(_state.Triggers, currentState.Triggers))
                {
                    GamePadTriggerStateChanged(this, new GamePadTriggerEventArgs(stateChange.trigger, stateChange.value));
                }

                foreach (var stateChange in CheckPressedDpad(_state.DPad, currentState.DPad))
                {
                    _dpadHolds.Add(stateChange.dpad, DateTime.Now);
                    GamePadDpadPressed(this, new GamePadDpadEventArgs(stateChange.dpad, stateChange.value));
                }

                foreach (var stateChange in CheckReleasedDpad(_state.DPad, currentState.DPad))
                {
                    var dpadHold = _dpadHolds[stateChange.dpad];
                    _dpadHolds.Remove(stateChange.dpad);
                    GamePadDpadReleased(this, new GamePadDpadEventArgs(stateChange.dpad, stateChange.value, dpadHold));
                }

                _state = currentState;
                Thread.Sleep(10);
            }
        }

        private (Button button, ButtonState state)[] CheckPressedButtons(GamePadButtons oldVal, GamePadButtons newVal)
        {
            var buttonsPressed = new List<(Button button, ButtonState state)>();

            if (oldVal.A != newVal.A && newVal.A != ButtonState.Released)
                buttonsPressed.Add((Button.A, newVal.A));

            if (oldVal.B != newVal.B && newVal.B != ButtonState.Released)
                buttonsPressed.Add((Button.B, newVal.B));

            if (oldVal.X != newVal.X && newVal.X != ButtonState.Released)
                buttonsPressed.Add((Button.X, newVal.X));

            if (oldVal.Y != newVal.Y && newVal.Y != ButtonState.Released)
                buttonsPressed.Add((Button.Y, newVal.Y));

            if (oldVal.Back != newVal.Back && newVal.Back != ButtonState.Released)
                buttonsPressed.Add((Button.Back, newVal.Back));

            if (oldVal.Start != newVal.Start && newVal.Start != ButtonState.Released)
                buttonsPressed.Add((Button.Start, newVal.Start));

            if (oldVal.LeftShoulder != newVal.LeftShoulder && newVal.LeftShoulder != ButtonState.Released)
                buttonsPressed.Add((Button.LeftShoulder, newVal.LeftShoulder));

            if (oldVal.LeftStick != newVal.LeftStick && newVal.LeftStick != ButtonState.Released)
                buttonsPressed.Add((Button.LeftStick, newVal.LeftStick));

            if (oldVal.RightShoulder != newVal.RightShoulder && newVal.RightShoulder != ButtonState.Released)
                buttonsPressed.Add((Button.RightShoulder, newVal.RightShoulder));

            if (oldVal.RightStick != newVal.RightStick && newVal.RightStick != ButtonState.Released)
                buttonsPressed.Add((Button.RightStick, newVal.RightStick));

            return buttonsPressed.ToArray();
        }

        private (Button button, ButtonState state)[] CheckReleasedButtons(GamePadButtons oldVal, GamePadButtons newVal)
        {
            var buttonsPressed = new List<(Button button, ButtonState state)>();

            if (oldVal.A != newVal.A && newVal.A != ButtonState.Pressed)
                buttonsPressed.Add((Button.A, newVal.A));

            if (oldVal.B != newVal.B && newVal.B != ButtonState.Pressed)
                buttonsPressed.Add((Button.B, newVal.B));

            if (oldVal.X != newVal.X && newVal.X != ButtonState.Pressed)
                buttonsPressed.Add((Button.X, newVal.X));

            if (oldVal.Y != newVal.Y && newVal.Y != ButtonState.Pressed)
                buttonsPressed.Add((Button.Y, newVal.Y));

            if (oldVal.Back != newVal.Back && newVal.Back != ButtonState.Pressed)
                buttonsPressed.Add((Button.Back, newVal.Back));

            if (oldVal.Start != newVal.Start && newVal.Start != ButtonState.Pressed)
                buttonsPressed.Add((Button.Start, newVal.Start));

            if (oldVal.LeftShoulder != newVal.LeftShoulder && newVal.LeftShoulder != ButtonState.Pressed)
                buttonsPressed.Add((Button.LeftShoulder, newVal.LeftShoulder));

            if (oldVal.LeftStick != newVal.LeftStick && newVal.LeftStick != ButtonState.Pressed)
                buttonsPressed.Add((Button.LeftStick, newVal.LeftStick));

            if (oldVal.RightShoulder != newVal.RightShoulder && newVal.RightShoulder != ButtonState.Pressed)
                buttonsPressed.Add((Button.RightShoulder, newVal.RightShoulder));

            if (oldVal.RightStick != newVal.RightStick && newVal.RightStick != ButtonState.Pressed)
                buttonsPressed.Add((Button.RightStick, newVal.RightStick));

            return buttonsPressed.ToArray();
        }

        private (Stick stick, GamePadThumbSticks value)[] CheckThumbSticks(GamePadThumbSticks oldVal, GamePadThumbSticks newVal)
        {
            var stickStates = new List<(Stick stick, GamePadThumbSticks value)>();

            if (oldVal.Left.X != newVal.Left.X || oldVal.Left.Y != newVal.Left.Y)
                stickStates.Add((Stick.Left, newVal));

            if (oldVal.Right.X != newVal.Right.X || oldVal.Right.Y != newVal.Right.Y)
                stickStates.Add((Stick.Right, newVal));

            return stickStates.ToArray();
        }

        private (Trigger trigger, GamePadTriggers value)[] CheckTriggers(GamePadTriggers oldVal, GamePadTriggers newVal)
        {
            var triggerStates = new List<(Trigger trigger, GamePadTriggers value)>();

            if (oldVal.Left != newVal.Left)
                triggerStates.Add((Trigger.Left, newVal));

            if (oldVal.Right != newVal.Right)
                triggerStates.Add((Trigger.Right, newVal));

            return triggerStates.ToArray();
        }

        private (Dpad dpad, ButtonState value)[] CheckPressedDpad(GamePadDPad oldVal, GamePadDPad newVal)
        {
            var dpadStates = new List<(Dpad dpad, ButtonState value)>();

            if (oldVal.Up != newVal.Up && newVal.Up != ButtonState.Released)
                dpadStates.Add((Dpad.Up, newVal.Up));

            if(oldVal.Left != newVal.Left && newVal.Left != ButtonState.Released)
                dpadStates.Add((Dpad.Left, newVal.Left));

            if (oldVal.Down != newVal.Down && newVal.Down != ButtonState.Released)
                dpadStates.Add((Dpad.Down, newVal.Down));

            if (oldVal.Right != newVal.Right && newVal.Right != ButtonState.Released)
                dpadStates.Add((Dpad.Right, newVal.Right));

            return dpadStates.ToArray();
        }

        private (Dpad dpad, ButtonState value)[] CheckReleasedDpad(GamePadDPad oldVal, GamePadDPad newVal)
        {
            var dpadStates = new List<(Dpad dpad, ButtonState value)>();

            if (oldVal.Up != newVal.Up && newVal.Up != ButtonState.Pressed)
                dpadStates.Add((Dpad.Up, newVal.Up));

            if (oldVal.Left != newVal.Left && newVal.Left != ButtonState.Pressed)
                dpadStates.Add((Dpad.Left, newVal.Left));

            if (oldVal.Down != newVal.Down && newVal.Down != ButtonState.Pressed)
                dpadStates.Add((Dpad.Down, newVal.Down));

            if (oldVal.Right != newVal.Right && newVal.Right != ButtonState.Pressed)
                dpadStates.Add((Dpad.Right, newVal.Right));

            return dpadStates.ToArray();
        }
    }

    public enum Button
    {
        A = 1,
        B,
        X,
        Y,
        Back,
        Start,
        LeftShoulder,
        LeftStick,
        RightShoulder,
        RightStick
    }

    public enum Stick
    {
        Left = 1,
        Right
    }

    public enum Trigger
    {
        Left = 1,
        Right
    }

    public enum Dpad
    {
        Up = 0,
        Right,
        Down,
        Left,
        Centre
    }

    public class GamePadButtonEventArgs : EventArgs
    {
        public GamePadButtonEventArgs(Button button, ButtonState state)
        {
            Button = button;
            State = state;
            HoldLength = TimeSpan.Zero;
        }

        public GamePadButtonEventArgs(Button button, ButtonState state, DateTime pressedTime)
        {
            Button = button;
            State = state;
            HoldLength = DateTime.Now - pressedTime;
        }

        public Button Button;
        public ButtonState State;
        public TimeSpan HoldLength;
    }

    public class GamePadTriggerEventArgs : EventArgs
    {
        public GamePadTriggerEventArgs (Trigger trigger, GamePadTriggers state)
        {
            ShoulderTrigger = trigger;
            State = state;
        }

        public Trigger ShoulderTrigger;
        public GamePadTriggers State;
    }

    public class GamePadDpadEventArgs : EventArgs
    {
        public GamePadDpadEventArgs(Dpad dpad, ButtonState state)
        {
            Direction = dpad;
            State = state;
            HoldLength = TimeSpan.Zero;
        }

        public GamePadDpadEventArgs(Dpad dpad, ButtonState state, DateTime pressedTime)
        {
            Direction = dpad;
            State = state;
            HoldLength = DateTime.Now - pressedTime;
        }

        public Dpad Direction;
        public ButtonState State;
        public TimeSpan HoldLength;
    }

    public class GamePadThumbStickEventArgs : EventArgs
    {
        public GamePadThumbStickEventArgs(Stick stick, GamePadThumbSticks state)
        {
            ThumbStick = stick;
            State = state;
        }

        public Stick ThumbStick;
        public GamePadThumbSticks State;
    }
}