elementdrawing 1.0.0

package/src/core/state.c

@@ -0,0 +1,803 @@
+/*
+ * state.c - ElementDrawing Core: State Management
+ *
+ * Implements the state management system for the ElementDrawing engine.
+ * Provides a centralized state manager, individual state nodes with
+ * versioning, update batching, transaction support, and a state tree
+ * for hierarchical state management.
+ */
+
+#include "bridge.h"
+
+/* ================================================================
+ * State Update Record
+ * ================================================================ */
+
+typedef struct EDStateUpdate {
+    void* new_value;
+    EDStateUpdater reducer;
+    void* action;
+    uint64_t timestamp;
+    bool is_applied;
+    struct EDStateUpdate* next;
+} EDStateUpdate;
+
+static EDStateUpdate* ed_state_update_create(void* new_value)
+{
+    EDStateUpdate* update = (EDStateUpdate*)calloc(1, sizeof(EDStateUpdate));
+    if (!update) return NULL;
+
+    update->new_value = new_value;
+    update->reducer = NULL;
+    update->action = NULL;
+    update->timestamp = ed_get_timestamp_ms();
+    update->is_applied = false;
+    update->next = NULL;
+
+    return update;
+}
+
+static void ed_state_update_destroy(EDStateUpdate* update)
+{
+    if (!update) return;
+    free(update);
+}
+
+/* ================================================================
+ * Transaction Support
+ * ================================================================ */
+
+typedef struct EDStateTransaction {
+    uint32_t id;
+    bool is_active;
+    bool is_committed;
+    bool is_rolled_back;
+    uint32_t update_count;
+
+    /* Snapshot of state versions at transaction start */
+    uint32_t* version_snapshots;
+    void** value_snapshots;
+    uint32_t snapshot_capacity;
+
+    struct EDStateTransaction* next;
+} EDStateTransaction;
+
+static EDStateTransaction* g_active_transaction = NULL;
+static uint32_t g_transaction_id_counter = 0;
+
+static EDStateTransaction* ed_transaction_create(uint32_t state_count)
+{
+    EDStateTransaction* txn = (EDStateTransaction*)calloc(1, sizeof(EDStateTransaction));
+    if (!txn) return NULL;
+
+    txn->id = ++g_transaction_id_counter;
+    txn->is_active = true;
+    txn->is_committed = false;
+    txn->is_rolled_back = false;
+    txn->update_count = 0;
+
+    if (state_count > 0) {
+        txn->snapshot_capacity = state_count;
+        txn->version_snapshots = (uint32_t*)calloc(state_count, sizeof(uint32_t));
+        txn->value_snapshots = (void**)calloc(state_count, sizeof(void*));
+    } else {
+        txn->snapshot_capacity = 16;
+        txn->version_snapshots = (uint32_t*)calloc(16, sizeof(uint32_t));
+        txn->value_snapshots = (void**)calloc(16, sizeof(void*));
+    }
+
+    return txn;
+}
+
+static void ed_transaction_destroy(EDStateTransaction* txn)
+{
+    if (!txn) return;
+    if (txn->version_snapshots) free(txn->version_snapshots);
+    if (txn->value_snapshots) free(txn->value_snapshots);
+    free(txn);
+}
+
+/* ================================================================
+ * State Manager Creation and Destruction
+ * ================================================================ */
+
+EDStateManager* ed_state_manager_create(void)
+{
+    EDStateManager* manager = (EDStateManager*)calloc(1, sizeof(EDStateManager));
+    if (!manager) return NULL;
+
+    for (uint32_t i = 0; i < ED_HOOKS_STATE_SLOTS; i++) {
+        manager->states[i] = NULL;
+        manager->state_counts[i] = 0;
+    }
+
+    manager->total_states = 0;
+    manager->active_states = 0;
+    manager->total_updates = 0;
+    manager->batched_updates = 0;
+    manager->is_batching = false;
+    manager->batch_callback = NULL;
+
+    ed_log_debug("State manager created");
+    return manager;
+}
+
+void ed_state_manager_destroy(EDStateManager* manager)
+{
+    if (!manager) return;
+
+    /* Destroy all state nodes */
+    for (uint32_t i = 0; i < ED_HOOKS_STATE_SLOTS; i++) {
+        EDStateNode* node = manager->states[i];
+        while (node) {
+            EDStateNode* next = node->next;
+            ed_state_destroy(node);
+            node = next;
+        }
+        manager->states[i] = NULL;
+    }
+
+    free(manager);
+    ed_log_debug("State manager destroyed");
+}
+
+/* ================================================================
+ * State Node Creation and Destruction
+ * ================================================================ */
+
+EDStateNode* ed_state_create(void* initial_value)
+{
+    EDStateNode* state = (EDStateNode*)calloc(1, sizeof(EDStateNode));
+    if (!state) return NULL;
+
+    state->value = initial_value;
+    state->updater = NULL;
+    state->version = 0;
+    state->last_update_time = ed_get_timestamp_ms();
+    state->is_pending = false;
+    state->next = NULL;
+
+    return state;
+}
+
+void ed_state_destroy(EDStateNode* state)
+{
+    if (!state) return;
+
+    /* Free update queue if present */
+    state->updater = NULL;
+    state->value = NULL;
+    free(state);
+}
+
+/* ================================================================
+ * State Registration
+ * ================================================================ */
+
+static uint32_t ed_state_compute_slot(EDStateNode* state)
+{
+    /* Simple slot computation based on pointer hash */
+    uintptr_t ptr = (uintptr_t)state;
+    return (uint32_t)(ptr % ED_HOOKS_STATE_SLOTS);
+}
+
+static void ed_state_manager_register(EDStateManager* manager, EDStateNode* state)
+{
+    if (!manager || !state) return;
+
+    uint32_t slot = ed_state_compute_slot(state);
+    state->next = manager->states[slot];
+    manager->states[slot] = state;
+    manager->state_counts[slot]++;
+    manager->total_states++;
+    manager->active_states++;
+}
+
+static void ed_state_manager_unregister(EDStateManager* manager, EDStateNode* state)
+{
+    if (!manager || !state) return;
+
+    uint32_t slot = ed_state_compute_slot(state);
+    EDStateNode** prev = &manager->states[slot];
+    EDStateNode* current = manager->states[slot];
+
+    while (current) {
+        if (current == state) {
+            *prev = current->next;
+            state->next = NULL;
+            manager->state_counts[slot]--;
+            manager->active_states--;
+            return;
+        }
+        prev = &current->next;
+        current = current->next;
+    }
+}
+
+/* ================================================================
+ * State Updates
+ * ================================================================ */
+
+void ed_state_update(EDStateNode* state, void* new_value)
+{
+    if (!state) return;
+
+    if (g_active_transaction && g_active_transaction->is_active) {
+        /* Record in transaction */
+        g_active_transaction->update_count++;
+    }
+
+    state->value = new_value;
+    state->version++;
+    state->last_update_time = ed_get_timestamp_ms();
+    state->is_pending = false;
+}
+
+void ed_state_batch_update(EDStateManager* manager, EDStateNode** states,
+                            void** values, uint32_t count)
+{
+    if (!manager || !states || !values || count == 0) return;
+
+    manager->is_batching = true;
+
+    /* Apply all updates */
+    for (uint32_t i = 0; i < count; i++) {
+        if (states[i]) {
+            states[i]->value = values[i];
+            states[i]->version++;
+            states[i]->last_update_time = ed_get_timestamp_ms();
+            states[i]->is_pending = true; /* Mark as pending until flush */
+            manager->batched_updates++;
+        }
+    }
+
+    manager->total_updates += count;
+
+    /* If auto-flush is enabled, flush immediately */
+    if (!manager->is_batching) {
+        ed_state_flush_updates(manager);
+    }
+}
+
+void ed_state_flush_updates(EDStateManager* manager)
+{
+    if (!manager) return;
+
+    /* Mark all pending states as committed */
+    for (uint32_t i = 0; i < ED_HOOKS_STATE_SLOTS; i++) {
+        EDStateNode* state = manager->states[i];
+        while (state) {
+            if (state->is_pending) {
+                state->is_pending = false;
+            }
+            state = state->next;
+        }
+    }
+
+    manager->is_batching = false;
+
+    /* Invoke batch callback if set */
+    if (manager->batch_callback) {
+        /* In a real implementation, this would trigger re-render */
+    }
+
+    ed_log_debug("State updates flushed (total=%llu, batched=%llu)",
+                 (unsigned long long)manager->total_updates,
+                 (unsigned long long)manager->batched_updates);
+}
+
+uint32_t ed_state_version(EDStateNode* state)
+{
+    return state ? state->version : 0;
+}
+
+/* ================================================================
+ * State Tree (Hierarchical State)
+ * ================================================================ */
+
+typedef struct EDStateTree {
+    EDStateNode* root;
+    uint32_t depth;
+    uint32_t node_count;
+} EDStateTree;
+
+static EDStateTree* ed_state_tree_create(void)
+{
+    EDStateTree* tree = (EDStateTree*)calloc(1, sizeof(EDStateTree));
+    if (!tree) return NULL;
+
+    tree->root = NULL;
+    tree->depth = 0;
+    tree->node_count = 0;
+
+    return tree;
+}
+
+static void ed_state_tree_destroy(EDStateTree* tree)
+{
+    if (!tree) return;
+    /* StateNodes are owned by the StateManager, not the tree */
+    free(tree);
+}
+
+typedef struct EDStateTreeNode {
+    EDStateNode* state;
+    struct EDStateTreeNode* parent;
+    struct EDStateTreeNode* first_child;
+    struct EDStateTreeNode* next_sibling;
+    uint32_t child_count;
+} EDStateTreeNode;
+
+static EDStateTreeNode* ed_state_tree_node_create(EDStateNode* state)
+{
+    EDStateTreeNode* node = (EDStateTreeNode*)calloc(1, sizeof(EDStateTreeNode));
+    if (!node) return NULL;
+
+    node->state = state;
+    node->parent = NULL;
+    node->first_child = NULL;
+    node->next_sibling = NULL;
+    node->child_count = 0;
+
+    return node;
+}
+
+static void ed_state_tree_node_add_child(EDStateTreeNode* parent, EDStateTreeNode* child)
+{
+    if (!parent || !child) return;
+
+    child->parent = parent;
+
+    if (!parent->first_child) {
+        parent->first_child = child;
+    } else {
+        /* Add as last sibling */
+        EDStateTreeNode* sibling = parent->first_child;
+        while (sibling->next_sibling) {
+            sibling = sibling->next_sibling;
+        }
+        sibling->next_sibling = child;
+    }
+    parent->child_count++;
+}
+
+static EDStateTreeNode* ed_state_tree_find(EDStateTreeNode* root, EDStateNode* target)
+{
+    if (!root) return NULL;
+    if (root->state == target) return root;
+
+    EDStateTreeNode* found = ed_state_tree_find(root->first_child, target);
+    if (found) return found;
+
+    return ed_state_tree_find(root->next_sibling, target);
+}
+
+/* ================================================================
+ * Transaction Implementation
+ * ================================================================ */
+
+static EDStateTransaction* ed_state_begin_transaction(EDStateManager* manager)
+{
+    if (!manager) return NULL;
+
+    if (g_active_transaction && g_active_transaction->is_active) {
+        ed_log_warn("Transaction already active (id=%u)", g_active_transaction->id);
+        return g_active_transaction;
+    }
+
+    EDStateTransaction* txn = ed_transaction_create(manager->active_states);
+    if (!txn) return NULL;
+
+    /* Snapshot current state versions */
+    uint32_t idx = 0;
+    for (uint32_t i = 0; i < ED_HOOKS_STATE_SLOTS && idx < txn->snapshot_capacity; i++) {
+        EDStateNode* state = manager->states[i];
+        while (state && idx < txn->snapshot_capacity) {
+            txn->version_snapshots[idx] = state->version;
+            txn->value_snapshots[idx] = state->value;
+            idx++;
+            state = state->next;
+        }
+    }
+
+    g_active_transaction = txn;
+    ed_log_debug("Transaction started (id=%u)", txn->id);
+    return txn;
+}
+
+static bool ed_state_commit_transaction(EDStateManager* manager, EDStateTransaction* txn)
+{
+    if (!manager || !txn || !txn->is_active) return false;
+
+    txn->is_active = false;
+    txn->is_committed = true;
+
+    /* Flush updates */
+    ed_state_flush_updates(manager);
+
+    ed_log_debug("Transaction committed (id=%u, updates=%u)",
+                 txn->id, txn->update_count);
+
+    if (g_active_transaction == txn) {
+        g_active_transaction = NULL;
+    }
+
+    ed_transaction_destroy(txn);
+    return true;
+}
+
+static bool ed_state_rollback_transaction(EDStateManager* manager, EDStateTransaction* txn)
+{
+    if (!manager || !txn || !txn->is_active) return false;
+
+    txn->is_active = false;
+    txn->is_rolled_back = true;
+
+    /* Restore state values from snapshots */
+    uint32_t idx = 0;
+    for (uint32_t i = 0; i < ED_HOOKS_STATE_SLOTS && idx < txn->snapshot_capacity; i++) {
+        EDStateNode* state = manager->states[i];
+        while (state && idx < txn->snapshot_capacity) {
+            if (state->version != txn->version_snapshots[idx]) {
+                state->value = txn->value_snapshots[idx];
+                state->version = txn->version_snapshots[idx];
+                state->is_pending = false;
+            }
+            idx++;
+            state = state->next;
+        }
+    }
+
+    ed_log_debug("Transaction rolled back (id=%u)", txn->id);
+
+    if (g_active_transaction == txn) {
+        g_active_transaction = NULL;
+    }
+
+    ed_transaction_destroy(txn);
+    return true;
+}
+
+/* ================================================================
+ * Update Batching with Priority
+ * ================================================================ */
+
+typedef struct EDBatchedUpdate {
+    EDStateNode* state;
+    void* new_value;
+    EDSchedulerPriority priority;
+    uint64_t timestamp;
+    struct EDBatchedUpdate* next;
+} EDBatchedUpdate;
+
+typedef struct EDBatchQueue {
+    EDBatchedUpdate* head;
+    EDBatchedUpdate* tail;
+    uint32_t count;
+} EDBatchQueue;
+
+static EDBatchQueue g_batch_queue = {0};
+
+static void ed_batch_queue_push(EDBatchQueue* queue, EDStateNode* state,
+                                 void* new_value, EDSchedulerPriority priority)
+{
+    if (!queue || !state) return;
+
+    EDBatchedUpdate* update = (EDBatchedUpdate*)calloc(1, sizeof(EDBatchedUpdate));
+    if (!update) return;
+
+    update->state = state;
+    update->new_value = new_value;
+    update->priority = priority;
+    update->timestamp = ed_get_timestamp_ms();
+    update->next = NULL;
+
+    if (!queue->tail) {
+        queue->head = update;
+        queue->tail = update;
+    } else {
+        /* Insert by priority (highest first) */
+        EDBatchedUpdate** prev = &queue->head;
+        EDBatchedUpdate* current = queue->head;
+
+        while (current && current->priority <= priority) {
+            prev = &current->next;
+            current = current->next;
+        }
+
+        update->next = current;
+        *prev = update;
+
+        if (!update->next) {
+            queue->tail = update;
+        }
+    }
+    queue->count++;
+}
+
+static EDBatchedUpdate* ed_batch_queue_pop(EDBatchQueue* queue)
+{
+    if (!queue || !queue->head) return NULL;
+
+    EDBatchedUpdate* update = queue->head;
+    queue->head = update->next;
+    if (!queue->head) {
+        queue->tail = NULL;
+    }
+    queue->count--;
+
+    return update;
+}
+
+static void ed_batch_queue_flush(EDStateManager* manager)
+{
+    if (!manager) return;
+
+    uint32_t applied = 0;
+    while (g_batch_queue.count > 0) {
+        EDBatchedUpdate* update = ed_batch_queue_pop(&g_batch_queue);
+        if (update) {
+            ed_state_update(update->state, update->new_value);
+            applied++;
+            free(update);
+        }
+    }
+
+    ed_state_flush_updates(manager);
+
+    ed_log_debug("Batch queue flushed: %u updates applied", applied);
+}
+
+/* ================================================================
+ * State Observer Pattern
+ * ================================================================ */
+
+typedef void (*EDStateObserver)(EDStateNode* state, void* old_value, void* new_value);
+
+typedef struct EDStateObserverEntry {
+    EDStateNode* target;
+    EDStateObserver callback;
+    void* context;
+    struct EDStateObserverEntry* next;
+} EDStateObserverEntry;
+
+#define ED_MAX_OBSERVERS 256
+
+static EDStateObserverEntry* g_observers[ED_MAX_OBSERVERS] = {0};
+static uint32_t g_observer_count = 0;
+
+static uint32_t ed_state_add_observer(EDStateNode* state, EDStateObserver callback, void* context)
+{
+    if (!state || !callback || g_observer_count >= ED_MAX_OBSERVERS) return 0;
+
+    EDStateObserverEntry* entry = (EDStateObserverEntry*)calloc(1, sizeof(EDStateObserverEntry));
+    if (!entry) return 0;
+
+    entry->target = state;
+    entry->callback = callback;
+    entry->context = context;
+
+    uint32_t slot = g_observer_count;
+    entry->next = g_observers[slot];
+    g_observers[slot] = entry;
+    g_observer_count++;
+
+    return slot;
+}
+
+static void ed_state_notify_observers(EDStateNode* state, void* old_value, void* new_value)
+{
+    if (!state) return;
+
+    for (uint32_t i = 0; i < g_observer_count; i++) {
+        EDStateObserverEntry* entry = g_observers[i];
+        while (entry) {
+            if (entry->target == state && entry->callback) {
+                entry->callback(state, old_value, new_value);
+            }
+            entry = entry->next;
+        }
+    }
+}
+
+/* ================================================================
+ * State Snapshot and Restore
+ * ================================================================ */
+
+typedef struct EDStateSnapshot {
+    void** values;
+    uint32_t* versions;
+    uint32_t count;
+} EDStateSnapshot;
+
+static EDStateSnapshot* ed_state_create_snapshot(EDStateManager* manager)
+{
+    if (!manager) return NULL;
+
+    EDStateSnapshot* snapshot = (EDStateSnapshot*)calloc(1, sizeof(EDStateSnapshot));
+    if (!snapshot) return NULL;
+
+    uint32_t count = manager->active_states;
+    snapshot->values = (void**)calloc(count, sizeof(void*));
+    snapshot->versions = (uint32_t*)calloc(count, sizeof(uint32_t));
+    snapshot->count = count;
+
+    if (!snapshot->values || !snapshot->versions) {
+        free(snapshot->values);
+        free(snapshot->versions);
+        free(snapshot);
+        return NULL;
+    }
+
+    /* Capture current state */
+    uint32_t idx = 0;
+    for (uint32_t i = 0; i < ED_HOOKS_STATE_SLOTS && idx < count; i++) {
+        EDStateNode* state = manager->states[i];
+        while (state && idx < count) {
+            snapshot->values[idx] = state->value;
+            snapshot->versions[idx] = state->version;
+            idx++;
+            state = state->next;
+        }
+    }
+
+    return snapshot;
+}
+
+static void ed_state_destroy_snapshot(EDStateSnapshot* snapshot)
+{
+    if (!snapshot) return;
+    free(snapshot->values);
+    free(snapshot->versions);
+    free(snapshot);
+}
+
+static bool ed_state_restore_snapshot(EDStateManager* manager, EDStateSnapshot* snapshot)
+{
+    if (!manager || !snapshot) return false;
+
+    uint32_t idx = 0;
+    for (uint32_t i = 0; i < ED_HOOKS_STATE_SLOTS && idx < snapshot->count; i++) {
+        EDStateNode* state = manager->states[i];
+        while (state && idx < snapshot->count) {
+            state->value = snapshot->values[idx];
+            state->version = snapshot->versions[idx];
+            state->is_pending = false;
+            idx++;
+            state = state->next;
+        }
+    }
+
+    ed_log_debug("State restored from snapshot (%u states)", snapshot->count);
+    return true;
+}
+
+/* ================================================================
+ * State Manager Statistics
+ * ================================================================ */
+
+typedef struct EDStateManagerStats {
+    uint32_t total_states;
+    uint32_t active_states;
+    uint64_t total_updates;
+    uint64_t batched_updates;
+    uint32_t active_transactions;
+} EDStateManagerStats;
+
+static EDStateManagerStats ed_state_manager_get_stats(EDStateManager* manager)
+{
+    EDStateManagerStats stats = {0};
+    if (!manager) return stats;
+
+    stats.total_states = manager->total_states;
+    stats.active_states = manager->active_states;
+    stats.total_updates = manager->total_updates;
+    stats.batched_updates = manager->batched_updates;
+    stats.active_transactions = (g_active_transaction && g_active_transaction->is_active) ? 1 : 0;
+
+    return stats;
+}
+
+/* ================================================================
+ * State Derivation (Computed Values)
+ * ================================================================ */
+
+typedef void* (*EDStateDeriver)(void** inputs, uint32_t input_count);
+
+typedef struct EDDerivedState {
+    EDStateDeriver deriver;
+    EDStateNode** inputs;
+    uint32_t input_count;
+    EDStateNode* output;
+    uint32_t* cached_versions;  /* Versions of inputs when last computed */
+    bool is_dirty;
+} EDDerivedState;
+
+static EDDerivedState* ed_derived_state_create(EDStateDeriver deriver,
+                                                 EDStateNode** inputs,
+                                                 uint32_t input_count)
+{
+    if (!deriver || !inputs || input_count == 0) return NULL;
+
+    EDDerivedState* derived = (EDDerivedState*)calloc(1, sizeof(EDDerivedState));
+    if (!derived) return NULL;
+
+    derived->deriver = deriver;
+    derived->inputs = inputs;
+    derived->input_count = input_count;
+    derived->output = ed_state_create(NULL);
+    derived->cached_versions = (uint32_t*)calloc(input_count, sizeof(uint32_t));
+    derived->is_dirty = true;
+
+    if (!derived->output || !derived->cached_versions) {
+        if (derived->output) ed_state_destroy(derived->output);
+        free(derived->cached_versions);
+        free(derived);
+        return NULL;
+    }
+
+    /* Record initial versions */
+    for (uint32_t i = 0; i < input_count; i++) {
+        if (inputs[i]) {
+            derived->cached_versions[i] = inputs[i]->version;
+        }
+    }
+
+    return derived;
+}
+
+static void ed_derived_state_destroy(EDDerivedState* derived)
+{
+    if (!derived) return;
+    if (derived->output) ed_state_destroy(derived->output);
+    free(derived->cached_versions);
+    free(derived);
+}
+
+static bool ed_derived_state_check_dirty(EDDerivedState* derived)
+{
+    if (!derived) return false;
+
+    for (uint32_t i = 0; i < derived->input_count; i++) {
+        if (derived->inputs[i] &&
+            derived->inputs[i]->version != derived->cached_versions[i]) {
+            derived->is_dirty = true;
+            return true;
+        }
+    }
+
+    return derived->is_dirty;
+}
+
+static void* ed_derived_state_compute(EDDerivedState* derived)
+{
+    if (!derived || !derived->deriver) return NULL;
+
+    if (!ed_derived_state_check_dirty(derived)) {
+        return derived->output->value;
+    }
+
+    /* Compute new value */
+    void** input_values = (void**)calloc(derived->input_count, sizeof(void*));
+    if (!input_values) return derived->output->value;
+
+    for (uint32_t i = 0; i < derived->input_count; i++) {
+        input_values[i] = derived->inputs[i] ? derived->inputs[i]->value : NULL;
+    }
+
+    void* result = derived->deriver(input_values, derived->input_count);
+
+    /* Update cached versions */
+    for (uint32_t i = 0; i < derived->input_count; i++) {
+        if (derived->inputs[i]) {
+            derived->cached_versions[i] = derived->inputs[i]->version;
+        }
+    }
+
+    derived->output->value = result;
+    derived->output->version++;
+    derived->is_dirty = false;
+
+    free(input_values);
+    return result;
+}