PkmnLibSharp/PkmnLibSharp/Battling/Events/BattleEventListener.cs

using System;
using System.Runtime.InteropServices;
using System.Threading.Tasks;

namespace PkmnLibSharp.Battling.Events
{
    public class BattleEventListener
    {
        public delegate Task BattleEventDelegate(EventData evt);
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void BattleEventPtrDelegate(IntPtr ptr);

        private readonly BattleEventDelegate _del;
        // ReSharper disable once PrivateFieldCanBeConvertedToLocalVariable
        private readonly BattleEventPtrDelegate _innerDel;
        internal readonly IntPtr FunctionPtr;
        private Task _currentTask;

        public BattleEventListener(BattleEventDelegate del)
        {
            _del = del;
            _innerDel = OnEventPtr;
            FunctionPtr = Marshal.GetFunctionPointerForDelegate<BattleEventPtrDelegate>(_innerDel);
        }

        private void OnEventPtr(IntPtr ptr)
        {
            // If we're still registering another event, wait until that's done. This ensures events always arrive in
            // the correct order.
            _currentTask?.Wait();
            // We do however want to run the event handler async, so that the battle code can keep running up till its
            // next event.
            _currentTask = Task.Run(() => InternalRunner(ptr));
        }

        private async Task InternalRunner(IntPtr ptr)
        {
            var wrapped = WrapEventPtr(ptr);
            await _del.Invoke(wrapped);
        }
        
        private static EventData WrapEventPtr(IntPtr ptr)
        {
            var evtType = (EventDataKind)Creaturelib.Generated.EventData.GetKind(ptr);
            switch (evtType)
            {
                case EventDataKind.Damage:
                    return new DamageEvent(evtType, ptr);
                case EventDataKind.Heal:
                    return new HealEvent(evtType, ptr);
                case EventDataKind.Faint:
                    return new FaintEvent(evtType, ptr);
                case EventDataKind.Switch:
                    return new SwitchEvent(evtType, ptr);
                case EventDataKind.TurnStart:
                    return new TurnStartEvent(evtType, ptr);
                case EventDataKind.TurnEnd:
                    return new TurnEndEvent(evtType, ptr);
                case EventDataKind.ExperienceGain:
                    return new ExperienceGainEvent(evtType, ptr);
                case EventDataKind.DisplayText:
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
            Creaturelib.Generated.EventData.Destruct(ptr);
            throw new NotImplementedException($"Unhandled battle event: '{evtType}'");
        }
    }
}