hypen_engine/

engine.rs

use crate::{
    dispatch::{Action, ActionDispatcher},
    ir::{ComponentRegistry, Element},
    lifecycle::{ComponentLifecycle, ModuleInstance, ResourceCache},
    reactive::{DependencyGraph, Scheduler},
    reconcile::{reconcile, InstanceTree, Patch},
    state::StateChange,
};

/// Callback type for rendering patches to the platform
pub type RenderCallback = Box<dyn Fn(&[Patch]) + Send + Sync>;

/// The main Hypen engine that orchestrates everything
pub struct Engine {
    /// Component registry for expanding custom components
    component_registry: ComponentRegistry,

    /// Current module instance
    module: Option<ModuleInstance>,

    /// Instance tree (virtual tree, no platform objects)
    tree: InstanceTree,

    /// Reactive dependency graph
    dependencies: DependencyGraph,

    /// Scheduler for dirty nodes
    scheduler: Scheduler,

    /// Action dispatcher
    actions: ActionDispatcher,

    /// Component lifecycle manager
    lifecycle: ComponentLifecycle,

    /// Resource cache
    resources: ResourceCache,

    /// Callback to send patches to the platform renderer
    render_callback: Option<RenderCallback>,

    /// Revision counter for remote UI
    revision: u64,
}

impl Engine {
    pub fn new() -> Self {
        Self {
            component_registry: ComponentRegistry::new(),
            module: None,
            tree: InstanceTree::new(),
            dependencies: DependencyGraph::new(),
            scheduler: Scheduler::new(),
            actions: ActionDispatcher::new(),
            lifecycle: ComponentLifecycle::new(),
            resources: ResourceCache::new(),
            render_callback: None,
            revision: 0,
        }
    }

    /// Register a custom component
    pub fn register_component(&mut self, component: crate::ir::Component) {
        self.component_registry.register(component);
    }

    /// Set the component resolver for dynamic component loading
    /// The resolver receives (component_name, context_path) and should return
    /// ResolvedComponent { source, path } or None
    pub fn set_component_resolver<F>(&mut self, resolver: F)
    where
        F: Fn(&str, Option<&str>) -> Option<crate::ir::ResolvedComponent> + Send + Sync + 'static,
    {
        self.component_registry.set_resolver(std::sync::Arc::new(resolver));
    }

    /// Set the module instance
    pub fn set_module(&mut self, module: ModuleInstance) {
        self.module = Some(module);
    }

    /// Set the render callback
    pub fn set_render_callback<F>(&mut self, callback: F)
    where
        F: Fn(&[Patch]) + Send + Sync + 'static,
    {
        self.render_callback = Some(Box::new(callback));
    }

    /// Register an action handler
    pub fn on_action<F>(&mut self, action_name: impl Into<String>, handler: F)
    where
        F: Fn(&Action) + Send + Sync + 'static,
    {
        self.actions.on(action_name, handler);
    }

    /// Render an element tree (initial render or full re-render)
    pub fn render(&mut self, element: &Element) {
        // Expand components (registry needs mutable access for lazy loading)
        let expanded = self.component_registry.expand(element);

        // Get current state (clone to avoid borrow conflicts)
        let state = self
            .module
            .as_ref()
            .map(|m| m.get_state().clone())
            .unwrap_or(serde_json::Value::Null);

        // Clear dependency graph before rebuilding
        self.dependencies.clear();

        // Reconcile and generate patches (dependencies are collected during tree construction)
        let patches = reconcile(&mut self.tree, &expanded, None, &state, &mut self.dependencies);

        // Send patches to renderer
        self.emit_patches(patches);

        self.revision += 1;
    }

    /// Handle a state change notification from the module host
    /// The host keeps the actual state - we just need to know what changed
    pub fn notify_state_change(&mut self, change: &StateChange) {
        // Find affected nodes based on changed paths
        let mut affected_nodes = indexmap::IndexSet::new();
        for path in change.paths() {
            affected_nodes.extend(self.dependencies.get_affected_nodes(path));
        }

        // Mark affected nodes as dirty
        self.scheduler.mark_many_dirty(affected_nodes.iter().copied());

        // Re-render dirty subtrees
        // Note: The host will be asked to provide values during rendering via a callback
        self.render_dirty();
    }

    /// Convenience method for backward compatibility / JSON patches
    pub fn update_state(&mut self, state_patch: serde_json::Value) {
        // Update module state FIRST before rendering
        if let Some(module) = &mut self.module {
            module.update_state(state_patch.clone());
        }

        // Then notify and render with the new state
        let change = StateChange::from_json(&state_patch);
        self.notify_state_change(&change);
    }

    /// Dispatch an action
    pub fn dispatch_action(&mut self, action: Action) -> Result<(), String> {
        self.actions.dispatch(&action)
    }

    /// Render only dirty nodes
    fn render_dirty(&mut self) {
        let patches = crate::render::render_dirty_nodes(
            &mut self.scheduler,
            &mut self.tree,
            self.module.as_ref(),
        );

        if !patches.is_empty() {
            self.emit_patches(patches);
            self.revision += 1;
        }
    }

    /// Send patches to the renderer
    fn emit_patches(&self, patches: Vec<Patch>) {
        if let Some(ref callback) = self.render_callback {
            callback(&patches);
        }
    }

    /// Get the current revision number
    pub fn revision(&self) -> u64 {
        self.revision
    }

    /// Get access to the component registry
    pub fn component_registry(&self) -> &ComponentRegistry {
        &self.component_registry
    }

    /// Get mutable access to the component registry
    pub fn component_registry_mut(&mut self) -> &mut ComponentRegistry {
        &mut self.component_registry
    }

    /// Get access to the resource cache
    pub fn resources(&self) -> &ResourceCache {
        &self.resources
    }

    /// Get mutable access to the resource cache
    pub fn resources_mut(&mut self) -> &mut ResourceCache {
        &mut self.resources
    }
}

impl Default for Engine {
    fn default() -> Self {
        Self::new()
    }
}

/// Extract changed paths from a state patch
fn extract_changed_paths(patch: &serde_json::Value) -> Vec<String> {
    let mut paths = Vec::new();
    extract_paths_recursive(patch, String::new(), &mut paths);
    paths
}

fn extract_paths_recursive(value: &serde_json::Value, prefix: String, paths: &mut Vec<String>) {
    match value {
        serde_json::Value::Object(map) => {
            for (key, val) in map {
                let path = if prefix.is_empty() {
                    key.clone()
                } else {
                    format!("{}.{}", prefix, key)
                };
                paths.push(path.clone());
                extract_paths_recursive(val, path, paths);
            }
        }
        _ => {
            if !prefix.is_empty() {
                paths.push(prefix);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn test_extract_changed_paths() {
        let patch = json!({
            "user": {
                "name": "Alice",
                "age": 30
            }
        });

        let paths = extract_changed_paths(&patch);
        assert!(paths.contains(&"user".to_string()));
        assert!(paths.contains(&"user.name".to_string()));
        assert!(paths.contains(&"user.age".to_string()));
    }
}