elementdrawing 1.0.0

package/src/core/event.c

@@ -0,0 +1,813 @@
+/*
+ * event.c - ElementDrawing Core: Event System
+ *
+ * Implements the event system for the ElementDrawing engine.
+ * Supports event creation/destruction, listener management with
+ * capture/bubble phases, event delegation, stop propagation,
+ * prevent default, and event dispatching with full phase support.
+ */
+
+#include "bridge.h"
+
+/* ================================================================
+ * Internal Event System State
+ * ================================================================ */
+
+static uint32_t g_listener_id_counter = 0;
+static uint32_t g_event_id_counter = 0;
+
+/* ================================================================
+ * Event Creation and Destruction
+ * ================================================================ */
+
+EDEvent* ed_event_create(const char* type, bool bubbles, bool cancelable)
+{
+    EDEvent* event = (EDEvent*)calloc(1, sizeof(EDEvent));
+    if (!event) return NULL;
+
+    if (type) {
+        strncpy(event->type, type, sizeof(event->type) - 1);
+        event->type[sizeof(event->type) - 1] = '\0';
+    }
+
+    event->phase = ED_EVENT_PHASE_NONE;
+    event->target = NULL;
+    event->current_target = NULL;
+    event->bubbles = bubbles;
+    event->cancelable = cancelable;
+    event->default_prevented = false;
+    event->propagation_stopped = false;
+    event->immediate_propagation_stopped = false;
+    event->timestamp = ed_get_timestamp_ms();
+    event->native_event = NULL;
+    event->synthetic_parent = NULL;
+    event->event_phase = 0;
+
+    return event;
+}
+
+void ed_event_destroy(EDEvent* event)
+{
+    if (!event) return;
+    free(event);
+}
+
+void ed_event_stop_propagation(EDEvent* event)
+{
+    if (!event) return;
+    event->propagation_stopped = true;
+}
+
+void ed_event_prevent_default(EDEvent* event)
+{
+    if (!event) return;
+    if (event->cancelable) {
+        event->default_prevented = true;
+    }
+}
+
+/* ================================================================
+ * Event Listener Creation
+ * ================================================================ */
+
+static EDEventListener* ed_event_listener_create(const char* event_type,
+                                                   EDEventCallback handler,
+                                                   void* user_data,
+                                                   bool capture)
+{
+    EDEventListener* listener = (EDEventListener*)calloc(1, sizeof(EDEventListener));
+    if (!listener) return NULL;
+
+    if (event_type) {
+        strncpy(listener->event_type, event_type, sizeof(listener->event_type) - 1);
+        listener->event_type[sizeof(listener->event_type) - 1] = '\0';
+    }
+
+    listener->handler = handler;
+    listener->user_data = user_data;
+    listener->capture = capture;
+    listener->passive = false;
+    listener->once = false;
+    listener->priority = 0;
+    listener->next = NULL;
+
+    return listener;
+}
+
+static void ed_event_listener_destroy(EDEventListener* listener)
+{
+    if (!listener) return;
+    free(listener);
+}
+
+/* ================================================================
+ * Event System Creation and Destruction
+ * ================================================================ */
+
+EDEventSystem* ed_event_system_create(void)
+{
+    EDEventSystem* system = (EDEventSystem*)calloc(1, sizeof(EDEventSystem));
+    if (!system) return NULL;
+
+    for (uint32_t i = 0; i < ED_EVENT_MAX_LISTENERS; i++) {
+        system->listeners[i] = NULL;
+        system->listener_counts[i] = 0;
+    }
+
+    system->delegation_root = NULL;
+    system->is_dispatching = false;
+    system->active_event_count = 0;
+    system->total_events_processed = 0;
+    system->current_event = NULL;
+
+    ed_log_debug("Event system created");
+    return system;
+}
+
+void ed_event_system_destroy(EDEventSystem* system)
+{
+    if (!system) return;
+
+    /* Destroy all listeners */
+    for (uint32_t i = 0; i < ED_EVENT_MAX_LISTENERS; i++) {
+        EDEventListener* listener = system->listeners[i];
+        while (listener) {
+            EDEventListener* next = listener->next;
+            ed_event_listener_destroy(listener);
+            listener = next;
+        }
+        system->listeners[i] = NULL;
+    }
+
+    free(system);
+    ed_log_debug("Event system destroyed");
+}
+
+/* ================================================================
+ * Event Type Hash (for listener bucketing)
+ * ================================================================ */
+
+static uint32_t ed_event_type_hash(const char* event_type)
+{
+    if (!event_type) return 0;
+    return ed_hash_fnv1a(event_type) % ED_EVENT_MAX_LISTENERS;
+}
+
+/* ================================================================
+ * Listener Registration
+ * ================================================================ */
+
+uint32_t ed_event_add_listener(EDEventSystem* system, const char* event_type,
+                                EDEventCallback handler, void* user_data, bool capture)
+{
+    if (!system || !event_type || !handler) {
+        ed_log_error("Invalid arguments to ed_event_add_listener");
+        return 0;
+    }
+
+    uint32_t bucket = ed_event_type_hash(event_type);
+
+    /* Check max listeners per bucket */
+    if (system->listener_counts[bucket] >= ED_EVENT_BUBBLE_DEPTH * 4) {
+        ed_log_warn("Listener bucket %u full for event type '%s'",
+                    bucket, event_type);
+        return 0;
+    }
+
+    EDEventListener* listener = ed_event_listener_create(event_type, handler, user_data, capture);
+    if (!listener) return 0;
+
+    uint32_t id = ++g_listener_id_counter;
+    listener->priority = id;
+
+    /* Insert into bucket (capture listeners first, then bubble, sorted by priority) */
+    EDEventListener** prev = &system->listeners[bucket];
+    EDEventListener* current = system->listeners[bucket];
+
+    while (current) {
+        /* Capture phase listeners come first */
+        if (!capture && current->capture) {
+            prev = &current->next;
+            current = current->next;
+            continue;
+        }
+        if (capture && !current->capture) {
+            break; /* Insert before bubble listeners */
+        }
+        prev = &current->next;
+        current = current->next;
+    }
+
+    listener->next = current;
+    *prev = listener;
+    system->listener_counts[bucket]++;
+
+    ed_log_debug("Listener added: type='%s', capture=%s, id=%u",
+                 event_type, capture ? "true" : "false", id);
+
+    return id;
+}
+
+bool ed_event_remove_listener(EDEventSystem* system, uint32_t listener_id)
+{
+    if (!system || listener_id == 0) return false;
+
+    /* Search all buckets for the listener */
+    for (uint32_t i = 0; i < ED_EVENT_MAX_LISTENERS; i++) {
+        EDEventListener** prev = &system->listeners[i];
+        EDEventListener* current = system->listeners[i];
+
+        while (current) {
+            if (current->priority == listener_id) {
+                *prev = current->next;
+                current->next = NULL;
+                ed_event_listener_destroy(current);
+                system->listener_counts[i]--;
+                ed_log_debug("Listener removed: id=%u", listener_id);
+                return true;
+            }
+            prev = &current->next;
+            current = current->next;
+        }
+    }
+
+    ed_log_warn("Listener not found: id=%u", listener_id);
+    return false;
+}
+
+/* ================================================================
+ * Event Path Computation
+ *
+ * Computes the propagation path from the target to the root
+ * for capture phase, and root to target for bubble phase.
+ * ================================================================ */
+
+typedef struct EDEventPathEntry {
+    void* node;
+    EDEventListener* capture_listeners;
+    EDEventListener* bubble_listeners;
+} EDEventPathEntry;
+
+typedef struct EDEventPath {
+    EDEventPathEntry entries[ED_EVENT_BUBBLE_DEPTH];
+    uint32_t count;
+} EDEventPath;
+
+static void ed_event_path_init(EDEventPath* path)
+{
+    if (!path) return;
+    memset(path, 0, sizeof(EDEventPath));
+}
+
+/* In a real implementation, this would traverse the DOM/fiber tree
+ * from the target to the root, collecting listeners at each level.
+ * Here we provide a simplified version. */
+
+static void ed_event_path_build(EDEventSystem* system, EDEventPath* path,
+                                 void* target)
+{
+    if (!system || !path || !target) return;
+
+    /* Simplified: just add the target as a single entry */
+    if (path->count < ED_EVENT_BUBBLE_DEPTH) {
+        path->entries[path->count].node = target;
+        path->entries[path->count].capture_listeners = NULL;
+        path->entries[path->count].bubble_listeners = NULL;
+        path->count++;
+    }
+
+    /* In a real implementation, walk up the tree from target to root,
+     * collecting capture and bubble listeners at each level */
+}
+
+/* ================================================================
+ * Event Dispatching
+ * ================================================================ */
+
+static void ed_event_invoke_listeners(EDEventSystem* system, EDEvent* event,
+                                       EDEventListener* listener, EDEventPhase phase)
+{
+    if (!system || !event || !listener) return;
+
+    while (listener) {
+        /* Check if propagation stopped */
+        if (event->immediate_propagation_stopped) return;
+        if (event->propagation_stopped) return;
+
+        /* Check event type match */
+        if (strcmp(listener->event_type, event->type) != 0) {
+            listener = listener->next;
+            continue;
+        }
+
+        /* Check phase match */
+        bool phase_match = false;
+        if (phase == ED_EVENT_PHASE_CAPTURE && listener->capture) {
+            phase_match = true;
+        } else if (phase == ED_EVENT_PHASE_BUBBLE && !listener->capture) {
+            phase_match = true;
+        } else if (phase == ED_EVENT_PHASE_AT_TARGET) {
+            phase_match = true;
+        }
+
+        if (!phase_match) {
+            listener = listener->next;
+            continue;
+        }
+
+        /* Set current phase and target */
+        event->phase = phase;
+        event->event_phase = (int32_t)phase;
+
+        /* Invoke the handler */
+        if (listener->handler) {
+            listener->handler(event, listener->user_data);
+        }
+
+        /* Handle once listener */
+        if (listener->once) {
+            ed_event_remove_listener(system, listener->priority);
+        }
+
+        listener = listener->next;
+    }
+}
+
+void ed_event_dispatch(EDEventSystem* system, EDEvent* event)
+{
+    if (!system || !event) return;
+
+    if (system->is_dispatching) {
+        ed_log_warn("Recursive event dispatch detected for '%s'", event->type);
+        return;
+    }
+
+    system->is_dispatching = true;
+    system->current_event = event;
+    system->active_event_count++;
+
+    ed_log_debug("Dispatching event '%s' (bubbles=%s, cancelable=%s)",
+                 event->type,
+                 event->bubbles ? "true" : "false",
+                 event->cancelable ? "true" : "false");
+
+    /* Build event path */
+    EDEventPath path;
+    ed_event_path_init(&path);
+    ed_event_path_build(system, &path, event->target);
+
+    /* Phase 1: Capture phase (root -> target) */
+    event->phase = ED_EVENT_PHASE_CAPTURE;
+    event->event_phase = ED_EVENT_PHASE_CAPTURE;
+
+    for (uint32_t i = 0; i < path.count && !event->propagation_stopped; i++) {
+        if (i == path.count - 1) break; /* Target handled separately */
+
+        event->current_target = path.entries[i].node;
+        uint32_t bucket = ed_event_type_hash(event->type);
+
+        /* Invoke capture listeners */
+        EDEventListener* listener = system->listeners[bucket];
+        while (listener && !event->immediate_propagation_stopped) {
+            if (listener->capture && strcmp(listener->event_type, event->type) == 0) {
+                if (listener->handler) {
+                    listener->handler(event, listener->user_data);
+                }
+            }
+            listener = listener->next;
+        }
+    }
+
+    /* Phase 2: At target */
+    if (!event->propagation_stopped && path.count > 0) {
+        event->phase = ED_EVENT_PHASE_AT_TARGET;
+        event->event_phase = ED_EVENT_PHASE_AT_TARGET;
+        event->current_target = event->target;
+
+        uint32_t bucket = ed_event_type_hash(event->type);
+        EDEventListener* listener = system->listeners[bucket];
+
+        while (listener && !event->immediate_propagation_stopped) {
+            if (strcmp(listener->event_type, event->type) == 0) {
+                if (listener->handler) {
+                    listener->handler(event, listener->user_data);
+                }
+            }
+            listener = listener->next;
+        }
+    }
+
+    /* Phase 3: Bubble phase (target -> root) */
+    if (event->bubbles && !event->propagation_stopped) {
+        event->phase = ED_EVENT_PHASE_BUBBLE;
+        event->event_phase = ED_EVENT_PHASE_BUBBLE;
+
+        for (int i = (int)path.count - 2; i >= 0 && !event->propagation_stopped; i--) {
+            event->current_target = path.entries[i].node;
+
+            uint32_t bucket = ed_event_type_hash(event->type);
+            EDEventListener* listener = system->listeners[bucket];
+
+            while (listener && !event->immediate_propagation_stopped) {
+                if (!listener->capture && strcmp(listener->event_type, event->type) == 0) {
+                    if (listener->handler) {
+                        listener->handler(event, listener->user_data);
+                    }
+                }
+                listener = listener->next;
+            }
+        }
+    }
+
+    /* Reset event phase */
+    event->phase = ED_EVENT_PHASE_NONE;
+    event->event_phase = 0;
+    event->current_target = NULL;
+
+    system->is_dispatching = false;
+    system->current_event = NULL;
+    system->active_event_count--;
+    system->total_events_processed++;
+
+    ed_log_debug("Event '%s' dispatch complete (default_prevented=%s)",
+                 event->type, event->default_prevented ? "true" : "false");
+}
+
+/* ================================================================
+ * Event Delegation
+ *
+ * Implements event delegation at a root node. Instead of attaching
+ * listeners to each individual element, a single listener is
+ * attached at the root and events are dispatched based on the
+ * target element.
+ * ================================================================ */
+
+typedef struct EDDelegationEntry {
+    char event_type[64];
+    bool is_registered;
+    EDEventCallback root_handler;
+    void* root_data;
+} EDDelegationEntry;
+
+#define ED_MAX_DELEGATED_TYPES 64
+
+static EDDelegationEntry g_delegated_events[ED_MAX_DELEGATED_TYPES] = {0};
+static uint32_t g_delegated_count = 0;
+
+static bool ed_event_is_delegated(const char* event_type)
+{
+    if (!event_type) return false;
+
+    for (uint32_t i = 0; i < g_delegated_count; i++) {
+        if (g_delegated_events[i].is_registered &&
+            strcmp(g_delegated_events[i].event_type, event_type) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void ed_event_setup_delegation(EDEventSystem* system, const char* event_type,
+                                       EDEventCallback root_handler, void* root_data)
+{
+    if (!system || !event_type || g_delegated_count >= ED_MAX_DELEGATED_TYPES) return;
+
+    /* Check if already delegated */
+    if (ed_event_is_delegated(event_type)) return;
+
+    EDDelegationEntry* entry = &g_delegated_events[g_delegated_count++];
+    strncpy(entry->event_type, event_type, sizeof(entry->event_type) - 1);
+    entry->event_type[sizeof(entry->event_type) - 1] = '\0';
+    entry->is_registered = true;
+    entry->root_handler = root_handler;
+    entry->root_data = root_data;
+
+    /* Register capture listener at root for delegation */
+    ed_event_add_listener(system, event_type, root_handler, root_data, true);
+
+    ed_log_debug("Event delegation set up for '%s'", event_type);
+}
+
+static void ed_event_teardown_delegation(EDEventSystem* system, const char* event_type)
+{
+    if (!system || !event_type) return;
+
+    for (uint32_t i = 0; i < g_delegated_count; i++) {
+        if (g_delegated_events[i].is_registered &&
+            strcmp(g_delegated_events[i].event_type, event_type) == 0) {
+            g_delegated_events[i].is_registered = false;
+            ed_log_debug("Event delegation torn down for '%s'", event_type);
+            return;
+        }
+    }
+}
+
+/* ================================================================
+ * Synthetic Event Pooling
+ *
+ * Reuse event objects to reduce garbage collection pressure.
+ * ================================================================ */
+
+#define ED_EVENT_POOL_SIZE 64
+
+typedef struct EDEventPool {
+    EDEvent* pool[ED_EVENT_POOL_SIZE];
+    uint32_t available;
+    uint32_t total_created;
+    uint32_t total_reused;
+} EDEventPool;
+
+static EDEventPool g_event_pool = {0};
+
+static EDEvent* ed_event_pool_acquire(const char* type, bool bubbles, bool cancelable)
+{
+    if (g_event_pool.available > 0) {
+        EDEvent* event = g_event_pool.pool[g_event_pool.available - 1];
+        g_event_pool.available--;
+        g_event_pool.total_reused++;
+
+        /* Reset event */
+        if (type) {
+            strncpy(event->type, type, sizeof(event->type) - 1);
+            event->type[sizeof(event->type) - 1] = '\0';
+        }
+        event->phase = ED_EVENT_PHASE_NONE;
+        event->target = NULL;
+        event->current_target = NULL;
+        event->bubbles = bubbles;
+        event->cancelable = cancelable;
+        event->default_prevented = false;
+        event->propagation_stopped = false;
+        event->immediate_propagation_stopped = false;
+        event->timestamp = ed_get_timestamp_ms();
+        event->native_event = NULL;
+        event->synthetic_parent = NULL;
+        event->event_phase = 0;
+
+        return event;
+    }
+
+    /* Create new event */
+    EDEvent* event = ed_event_create(type, bubbles, cancelable);
+    if (event) {
+        g_event_pool.total_created++;
+    }
+    return event;
+}
+
+static void ed_event_pool_release(EDEvent* event)
+{
+    if (!event) return;
+
+    if (g_event_pool.available < ED_EVENT_POOL_SIZE) {
+        /* Reset for reuse */
+        event->phase = ED_EVENT_PHASE_NONE;
+        event->target = NULL;
+        event->current_target = NULL;
+        event->default_prevented = false;
+        event->propagation_stopped = false;
+        event->immediate_propagation_stopped = false;
+        event->native_event = NULL;
+        event->synthetic_parent = NULL;
+        event->event_phase = 0;
+
+        g_event_pool.pool[g_event_pool.available++] = event;
+    } else {
+        ed_event_destroy(event);
+    }
+}
+
+static void ed_event_pool_cleanup(void)
+{
+    for (uint32_t i = 0; i < g_event_pool.available; i++) {
+        ed_event_destroy(g_event_pool.pool[i]);
+        g_event_pool.pool[i] = NULL;
+    }
+    g_event_pool.available = 0;
+}
+
+/* ================================================================
+ * Passive Event Support
+ *
+ * Passive event listeners cannot call preventDefault().
+ * This is important for scroll/touch events where blocking
+ * the main thread for preventDefault checks causes jank.
+ * ================================================================ */
+
+static void ed_event_dispatch_passive(EDEventSystem* system, EDEvent* event)
+{
+    if (!system || !event) return;
+
+    uint32_t bucket = ed_event_type_hash(event->type);
+    EDEventListener* listener = system->listeners[bucket];
+
+    while (listener) {
+        if (strcmp(listener->event_type, event->type) == 0 && listener->passive) {
+            /* For passive listeners, preventDefault is a no-op */
+            bool was_cancelable = event->cancelable;
+            event->cancelable = false;
+
+            if (listener->handler) {
+                listener->handler(event, listener->user_data);
+            }
+
+            event->cancelable = was_cancelable;
+        }
+        listener = listener->next;
+    }
+}
+
+/* ================================================================
+ * Event Priority Support
+ *
+ * Events can have different priorities. Discrete events (click, key)
+ * are dispatched immediately. Continuous events (mousemove, scroll)
+ * may be batched.
+ * ================================================================ */
+
+typedef enum {
+    ED_EVENT_PRIORITY_DISCRETE = 0,
+    ED_EVENT_PRIORITY_CONTINUOUS = 1,
+    ED_EVENT_PRIORITY_DEFAULT = 2
+} EDEventPriority;
+
+static EDEventPriority ed_event_get_priority(const char* event_type)
+{
+    if (!event_type) return ED_EVENT_PRIORITY_DEFAULT;
+
+    /* Discrete events: immediate dispatch */
+    if (strcmp(event_type, "click") == 0 ||
+        strcmp(event_type, "keydown") == 0 ||
+        strcmp(event_type, "keyup") == 0 ||
+        strcmp(event_type, "keypress") == 0 ||
+        strcmp(event_type, "focus") == 0 ||
+        strcmp(event_type, "blur") == 0 ||
+        strcmp(event_type, "submit") == 0 ||
+        strcmp(event_type, "change") == 0 ||
+        strcmp(event_type, "input") == 0) {
+        return ED_EVENT_PRIORITY_DISCRETE;
+    }
+
+    /* Continuous events: may be batched */
+    if (strcmp(event_type, "mousemove") == 0 ||
+        strcmp(event_type, "touchmove") == 0 ||
+        strcmp(event_type, "scroll") == 0 ||
+        strcmp(event_type, "wheel") == 0 ||
+        strcmp(event_type, "drag") == 0) {
+        return ED_EVENT_PRIORITY_CONTINUOUS;
+    }
+
+    return ED_EVENT_PRIORITY_DEFAULT;
+}
+
+/* ================================================================
+ * Event Queue for Batched Dispatch
+ * ================================================================ */
+
+typedef struct EDPendingEvent {
+    EDEvent* event;
+    EDEventPriority priority;
+    uint64_t timestamp;
+    struct EDPendingEvent* next;
+} EDPendingEvent;
+
+typedef struct EDEventQueue {
+    EDPendingEvent* head;
+    EDPendingEvent* tail;
+    uint32_t count;
+} EDEventQueue;
+
+static EDEventQueue g_event_queue = {0};
+
+static void ed_event_queue_push(EDEvent* event, EDEventPriority priority)
+{
+    if (!event) return;
+
+    EDPendingEvent* pending = (EDPendingEvent*)calloc(1, sizeof(EDPendingEvent));
+    if (!pending) {
+        /* Fallback: dispatch immediately */
+        return;
+    }
+
+    pending->event = event;
+    pending->priority = priority;
+    pending->timestamp = ed_get_timestamp_ms();
+    pending->next = NULL;
+
+    if (!g_event_queue.tail) {
+        g_event_queue.head = pending;
+        g_event_queue.tail = pending;
+    } else {
+        /* Insert by priority */
+        EDPendingEvent** prev = &g_event_queue.head;
+        EDPendingEvent* current = g_event_queue.head;
+
+        while (current && current->priority <= priority) {
+            prev = &current->next;
+            current = current->next;
+        }
+
+        pending->next = current;
+        *prev = pending;
+
+        if (!pending->next) {
+            g_event_queue.tail = pending;
+        }
+    }
+    g_event_queue.count++;
+}
+
+static EDPendingEvent* ed_event_queue_pop(void)
+{
+    if (!g_event_queue.head) return NULL;
+
+    EDPendingEvent* pending = g_event_queue.head;
+    g_event_queue.head = pending->next;
+    if (!g_event_queue.head) {
+        g_event_queue.tail = NULL;
+    }
+    g_event_queue.count--;
+
+    return pending;
+}
+
+static void ed_event_queue_flush(EDEventSystem* system)
+{
+    if (!system) return;
+
+    uint32_t dispatched = 0;
+    while (g_event_queue.count > 0) {
+        EDPendingEvent* pending = ed_event_queue_pop();
+        if (pending) {
+            ed_event_dispatch(system, pending->event);
+            ed_event_pool_release(pending->event);
+            free(pending);
+            dispatched++;
+        }
+    }
+
+    if (dispatched > 0) {
+        ed_log_debug("Event queue flushed: %u events dispatched", dispatched);
+    }
+}
+
+/* ================================================================
+ * Custom Event Dispatching with Priority
+ * ================================================================ */
+
+static void ed_event_dispatch_with_priority(EDEventSystem* system, EDEvent* event)
+{
+    if (!system || !event) return;
+
+    EDEventPriority priority = ed_event_get_priority(event->type);
+
+    switch (priority) {
+        case ED_EVENT_PRIORITY_DISCRETE:
+            /* Dispatch immediately */
+            ed_event_dispatch(system, event);
+            break;
+
+        case ED_EVENT_PRIORITY_CONTINUOUS:
+            /* Queue for batched dispatch */
+            ed_event_queue_push(event, priority);
+            break;
+
+        case ED_EVENT_PRIORITY_DEFAULT:
+        default:
+            ed_event_dispatch(system, event);
+            break;
+    }
+}
+
+/* ================================================================
+ * Event Statistics
+ * ================================================================ */
+
+typedef struct EDEventStats {
+    uint64_t total_processed;
+    uint32_t active_listeners;
+    uint32_t pool_available;
+    uint32_t pool_created;
+    uint32_t pool_reused;
+    uint32_t queued_events;
+} EDEventStats;
+
+static EDEventStats ed_event_system_get_stats(EDEventSystem* system)
+{
+    EDEventStats stats = {0};
+
+    if (system) {
+        stats.total_processed = system->total_events_processed;
+
+        for (uint32_t i = 0; i < ED_EVENT_MAX_LISTENERS; i++) {
+            stats.active_listeners += system->listener_counts[i];
+        }
+    }
+
+    stats.pool_available = g_event_pool.available;
+    stats.pool_created = g_event_pool.total_created;
+    stats.pool_reused = g_event_pool.total_reused;
+    stats.queued_events = g_event_queue.count;
+
+    return stats;
+}