//! 事件处理相关函数
//!
//! 包含事件监听、事件分发、事件队列处理等功能。
//! 
//! # 事件流
//! 
//! ```text
//! 用户点击 (x, y)
//!   ↓
//! HitTest 索引查找
//!   ↓
//! 找到 HitArea (vnode_id, event_types)
//!   ↓
//! 检查是否有事件处理器
//!   ↓
//! 调用 JS: __iris_invokeEventHandler(vnode_id, event_type, data)
//!   ↓
//! Vue 组件响应
//! ```

use super::RuntimeOrchestrator;

use anyhow::{anyhow, Result};
use tracing::{debug, info, warn};

/// 事件监听器选项
#[derive(Debug, Clone, Default)]
pub struct EventListenerOptions {
    /// 是否在捕获阶段监听
    pub capture: bool,
    /// 是否只触发一次
    pub once: bool,
    /// 是否被动监听（不调用 preventDefault）
    pub passive: bool,
}

impl RuntimeOrchestrator {
    /// 通过 HitTest 处理鼠标点击事件
    /// 
    /// 这是主要的点击事件入口，使用 HitTest 索引自动找到目标元素
    /// 
    /// # 参数
    /// 
    /// * `x` - 鼠标 X 坐标（像素）
    /// * `y` - 鼠标 Y 坐标（像素）
    /// * `button` - 鼠标按钮（0=左键, 1=中键, 2=右键）
    pub fn handle_mouse_click_by_position(&mut self, x: f32, y: f32, button: u8) -> Result<()> {
        // 1. HitTest 找到点击的元素
        let hit_area = self.hit_test(x, y)
            .ok_or_else(|| anyhow!("No element at ({}, {})", x, y))?;
        
        debug!(
            node_id = hit_area.node_id,
            vnode_id = ?hit_area.vnode_id,
            tag = %hit_area.tag,
            class = %hit_area.class,
            event_types = ?hit_area.event_types,
            "HitTest found element for click"
        );
        
        // 2. 检查是否有事件处理器
        let has_click_handler = hit_area.event_types.as_ref()
            .map(|events| events.contains("click"))
            .unwrap_or(false);
        
        if !has_click_handler {
            debug!(
                node_id = hit_area.node_id,
                "Element has no click handler, ignoring click"
            );
            return Ok(());
        }
        
        // 3. 调用 JS 事件处理器
        if let Some(ref vnode_id) = hit_area.vnode_id {
            let vnode_id_clone = vnode_id.clone();
            #[cfg(feature = "vue-sfc")]
            {
                self.invoke_js_event_handler(&vnode_id_clone, "click", x, y, button)?;
            }
            
            #[cfg(not(feature = "vue-sfc"))]
            {
                warn!("Vue SFC feature not enabled, cannot invoke JS event handler");
            }
        }
        
        // 4. 标记为脏（触发重渲染）
        self.dirty = true;
        
        Ok(())
    }
    
    /// 通过 vnode_id 直接调用 JS 事件处理器
    /// 
    /// # 参数
    /// 
    /// * `vnode_id` - Vue VNode ID
    /// * `event_type` - 事件类型（如 "click", "mouseover"）
    /// * `x` - 事件 X 坐标
    /// * `y` - 事件 Y 坐标
    /// * `button` - 鼠标按钮
    /// 
    /// # 返回
    /// 
    /// * `Ok(bool)` - 是否应该停止传播（true = stopPropagation 被调用）
    #[cfg(feature = "vue-sfc")]
    fn invoke_js_event_handler(
        &mut self,
        vnode_id: &str,
        event_type: &str,
        x: f32,
        y: f32,
        button: u8,
    ) -> Result<bool> {
        // 构建事件数据（包含 stopPropagation 支持）
        let event_data = serde_json::json!({
            "x": x,
            "y": y,
            "button": button,
            "clientX": x,
            "clientY": y,
            "screenX": x,
            "screenY": y,
            "_propagationStopped": false,  // stopPropagation 标志
            "stopPropagation": "function() { this._propagationStopped = true; }"  // 占位符
        });
        
        let event_data_str = serde_json::to_string(&event_data)
            .unwrap_or_else(|_| "{}".to_string());
        
        // 调用 JS 函数（构建完整的 event 对象）
        let js_code = format!(
            "(function() {{ \
                var event = {}; \
                event.stopPropagation = function() {{ \
                    event._propagationStopped = true; \
                    globalThis.__iris_lastEventPropagationStopped = true; \
                }}; \
                var result = __iris_invokeEventHandler(\"{}\", \"{}\", event); \
                return result; \
            }})()",
            event_data_str,
            vnode_id,
            event_type
        );
        
        debug!(
            vnode_id,
            event_type,
            js_code_len = js_code.len(),
            "Invoking JS event handler"
        );
        
        match self.js_runtime.eval(&js_code) {
            Ok(_result) => {
                info!(
                    vnode_id,
                    event_type,
                    "JS event handler invoked successfully"
                );
                
                // 检测 stopPropagation：通过全局变量
                let should_stop = self.check_stop_propagation();
                
                if should_stop {
                    debug!(
                        vnode_id,
                        event_type,
                        "stopPropagation() called in JS event handler"
                    );
                }
                
                Ok(should_stop)
            }
            Err(e) => {
                warn!(
                    vnode_id,
                    event_type,
                    error = %e,
                    "Failed to invoke JS event handler"
                );
                Err(anyhow!("JS event handler error: {}", e))
            }
        }
    }
    
    /// 通过 vnode_id 分发事件（不依赖 HitTest）
    /// 
    /// # 参数
    /// 
    /// * `vnode_id` - Vue VNode ID
    /// * `event_type` - 事件类型
    /// * `x` - X 坐标
    /// * `y` - Y 坐标
    pub fn dispatch_event_by_vnode_id(
        &mut self,
        vnode_id: &str,
        event_type: &str,
        x: f32,
        y: f32,
    ) -> Result<()> {
        // 查找 HitArea（用于验证事件类型）
        let hit_area = self.hit_index.find_by_vnode_id(vnode_id)
            .ok_or_else(|| anyhow!("VNode {} not found in HitIndex", vnode_id))?;
        
        // 检查是否有该事件类型
        let has_handler = hit_area.event_types.as_ref()
            .map(|events| events.contains(event_type))
            .unwrap_or(false);
        
        if !has_handler {
            warn!(
                vnode_id,
                event_type,
                "VNode does not have event handler for this type"
            );
            return Ok(());
        }
        
        // 调用 JS 处理器
        #[cfg(feature = "vue-sfc")]
        {
            let vnode_id_str = vnode_id.to_string();
            self.invoke_js_event_handler(&vnode_id_str, event_type, x, y, 0)?;
        }
        
        #[cfg(not(feature = "vue-sfc"))]
        {
            warn!("Vue SFC feature not enabled");
        }
        
        self.dirty = true;
        
        Ok(())
    }
    
    /// 获取所有可交互元素的信息（用于调试）
    pub fn get_interactive_elements_info(&self) -> Vec<String> {
        let areas = self.get_interactive_areas();
        areas.iter().map(|area| {
            format!(
                "{}#{} (vnode: {}) - {}",
                area.tag,
                area.node_id,
                area.vnode_id.as_deref().unwrap_or("N/A"),
                area.event_types.as_deref().unwrap_or("no events")
            )
        }).collect()
    }
    
    /// 打印可交互元素信息（调试用）
    pub fn print_interactive_elements(&self) {
        let info = self.get_interactive_elements_info();
        info!(count = info.len(), "Interactive elements:");
        for (i, element) in info.iter().enumerate() {
            debug!("  {}: {}", i + 1, element);
        }
    }
    
    /// 处理鼠标按下事件
    pub fn handle_mouse_down(&mut self, x: f32, y: f32, button: u8) -> Result<()> {
        let hit_area = self.hit_test(x, y)
            .ok_or_else(|| anyhow!("No element at ({}, {})", x, y))?;
        
        let has_handler = hit_area.event_types.as_ref()
            .map(|events| events.contains("mousedown"))
            .unwrap_or(false);
        
        if !has_handler {
            return Ok(());
        }
        
        if let Some(ref vnode_id) = hit_area.vnode_id {
            let vnode_id_clone = vnode_id.clone();
            #[cfg(feature = "vue-sfc")]
            {
                self.invoke_js_event_handler(&vnode_id_clone, "mousedown", x, y, button)?;
            }
        }
        
        self.dirty = true;
        Ok(())
    }
    
    /// 处理鼠标释放事件
    pub fn handle_mouse_up(&mut self, x: f32, y: f32, button: u8) -> Result<()> {
        let hit_area = self.hit_test(x, y)
            .ok_or_else(|| anyhow!("No element at ({}, {})", x, y))?;
        
        let has_handler = hit_area.event_types.as_ref()
            .map(|events| events.contains("mouseup"))
            .unwrap_or(false);
        
        if !has_handler {
            return Ok(());
        }
        
        if let Some(ref vnode_id) = hit_area.vnode_id {
            let vnode_id_clone = vnode_id.clone();
            #[cfg(feature = "vue-sfc")]
            {
                self.invoke_js_event_handler(&vnode_id_clone, "mouseup", x, y, button)?;
            }
        }
        
        self.dirty = true;
        Ok(())
    }
    
    /// 处理鼠标悬停进入事件（基于 HitTest）
    pub fn handle_mouse_enter_by_position(&mut self, x: f32, y: f32) -> Result<()> {
        let hit_area = self.hit_test(x, y);
        
        if let Some(area) = hit_area {
            let has_handler = area.event_types.as_ref()
                .map(|events| events.contains("mouseover"))
                .unwrap_or(false);
            
            if has_handler {
                if let Some(ref vnode_id) = area.vnode_id {
                    let vnode_id_clone = vnode_id.clone();
                    #[cfg(feature = "vue-sfc")]
                    {
                        self.invoke_js_event_handler(&vnode_id_clone, "mouseover", x, y, 0)?;
                    }
                }
                self.dirty = true;
            }
        }
        
        Ok(())
    }
    
    /// 处理鼠标悬停离开事件（基于 HitTest）
    pub fn handle_mouse_leave_by_position(&mut self, _x: f32, _y: f32, last_vnode_id: Option<&str>) -> Result<()> {
        if let Some(vnode_id) = last_vnode_id {
            // 查找该元素的 event_types
            let hit_area = self.hit_index.find_by_vnode_id(vnode_id);
            
            if let Some(area) = hit_area {
                let has_handler = area.event_types.as_ref()
                    .map(|events| events.contains("mouseout"))
                    .unwrap_or(false);
                
                if has_handler {
                    let vnode_id_str = vnode_id.to_string();
                    #[cfg(feature = "vue-sfc")]
                    {
                        self.invoke_js_event_handler(&vnode_id_str, "mouseout", _x, _y, 0)?;
                    }
                    self.dirty = true;
                }
            }
        }
        
        Ok(())
    }
    
    /// 处理双击事件
    pub fn handle_dblclick(&mut self, x: f32, y: f32) -> Result<()> {
        let hit_area = self.hit_test(x, y)
            .ok_or_else(|| anyhow!("No element at ({}, {})", x, y))?;
        
        let has_handler = hit_area.event_types.as_ref()
            .map(|events| events.contains("dblclick"))
            .unwrap_or(false);
        
        if !has_handler {
            return Ok(());
        }
        
        if let Some(ref vnode_id) = hit_area.vnode_id {
            let vnode_id_clone = vnode_id.clone();
            #[cfg(feature = "vue-sfc")]
            {
                self.invoke_js_event_handler(&vnode_id_clone, "dblclick", x, y, 0)?;
            }
        }
        
        self.dirty = true;
        Ok(())
    }
    
    /// 实现 DOM 事件冒泡机制
    /// 
    /// 从目标元素开始，沿着父节点链向上传播事件，
    /// 直到根节点或遇到 stopPropagation()。
    /// 
    /// # 参数
    /// 
    /// * `target_node_id` - 目标元素 node_id
    /// * `event_type` - 事件类型（如 "click"）
    /// * `x` - 事件 X 坐标
    /// * `y` - 事件 Y 坐标
    /// * `button` - 鼠标按钮（0=左键, 1=中键, 2=右键）
    /// 
    /// # 返回
    /// 
    /// * `Ok(())` - 冒泡完成
    /// * `Err(...)` - 处理失败
    pub fn bubble_event(
        &mut self,
        target_node_id: u64,
        event_type: &str,
        x: f32,
        y: f32,
        button: u8,
    ) -> Result<()> {
        // 1. 构建冒泡路径：目标 → 父 → 祖父 → ... → root
        let bubble_path = self.build_bubble_path(target_node_id);
        
        debug!(
            target_node_id,
            event_type,
            path_len = bubble_path.len(),
            "Starting event bubbling"
        );
        
        // 2. 沿路径冒泡
        for (index, node_id) in bubble_path.iter().enumerate() {
            // 获取当前节点的 HitArea
            let hit_area = self.hit_index.get_area(*node_id);
            
            if hit_area.is_none() {
                continue;
            }
            
            let area = hit_area.unwrap();
            
            // 检查当前节点是否有该事件类型的处理器
            let has_handler = area.event_types.as_ref()
                .map(|events| events.contains(event_type))
                .unwrap_or(false);
            
            if !has_handler {
                debug!(
                    node_id = *node_id,
                    event_type,
                    "Node has no handler for this event type, skipping"
                );
                continue;
            }
            
            // 调用 JS 事件处理器
            if let Some(ref vnode_id) = area.vnode_id {
                let vnode_id_clone = vnode_id.clone();
                
                debug!(
                    node_id = *node_id,
                    vnode_id = vnode_id_clone,
                    event_type,
                    bubble_index = index,
                    "Invoking event handler during bubble"
                );
                
                #[cfg(feature = "vue-sfc")]
                {
                    // 调用 JS 事件处理器
                    let should_stop = self.invoke_js_event_handler(
                        &vnode_id_clone,
                        event_type,
                        x,
                        y,
                        button,
                    )?;
                    
                    // 检查是否应该停止冒泡
                    if should_stop {
                        debug!(
                            node_id = *node_id,
                            vnode_id = vnode_id_clone,
                            event_type,
                            "Event propagation stopped by stopPropagation()"
                        );
                        return Ok(());
                    }
                    
                    // 检查事件委托：如果当前节点有委托规则，处理委托事件
                    if let Some(delegations) = self.event_delegations.get(node_id) {
                        let delegations_clone = delegations.clone();
                        for (selector, delegated_event_type) in delegations_clone {
                            // 只处理匹配的事件类型
                            if delegated_event_type == event_type {
                                // 检查目标节点是否匹配选择器
                                if self.matches_delegation_selector(target_node_id, &selector) {
                                    debug!(
                                        parent_node_id = *node_id,
                                        target_node_id,
                                        selector,
                                        event_type,
                                        "Event delegation matched, handling delegated event"
                                    );
                                    
                                    // 处理委托事件
                                    if let Err(e) = self.handle_delegated_event(
                                        target_node_id,
                                        *node_id,
                                        &event_type,
                                        x,
                                        y,
                                        button,
                                    ) {
                                        warn!(error = %e, "Failed to handle delegated event");
                                    }
                                }
                            }
                        }
                    }
                }
                
                #[cfg(not(feature = "vue-sfc"))]
                {
                    warn!("Vue SFC feature not enabled");
                }
            }
        }
        
        // 3. 标记为脏（触发重渲染）
        self.dirty = true;
        
        debug!(event_type, "Event bubbling completed");
        
        Ok(())
    }
    
    /// 构建冒泡路径
    /// 
    /// 从目标节点开始，沿着 parent_id 向上遍历到根节点。
    /// 
    /// # 参数
    /// 
    /// * `start_node_id` - 起始节点 ID
    /// 
    /// # 返回
    /// 
    /// 冒泡路径上的节点 ID 列表（从目标到根）
    fn build_bubble_path(&self, start_node_id: u64) -> Vec<u64> {
        let mut path = Vec::new();
        let mut current_id = Some(start_node_id);
        
        // 防止无限循环（最大深度 100）
        let max_depth = 100;
        let mut depth = 0;
        
        while let Some(node_id) = current_id {
            path.push(node_id);
            
            // 获取当前节点的 parent_id
            if let Some(area) = self.hit_index.get_area(node_id) {
                current_id = area.parent_id;
            } else {
                // 如果找不到 HitArea，说明已经是根节点或错误
                break;
            }
            
            depth += 1;
            if depth >= max_depth {
                warn!(
                    start_node_id,
                    "Bubble path exceeded max depth, stopping"
                );
                break;
            }
        }
        
        debug!(
            start_node_id,
            path_len = path.len(),
            "Built bubble path"
        );
        
        path
    }
    
    /// 实现 DOM 事件捕获机制
    /// 
    /// 从根节点开始，沿着父节点链向下传播到目标节点，
    /// 在到达目标之前调用所有捕获阶段的事件处理器。
    /// 
    /// # 参数
    /// 
    /// * `target_node_id` - 目标元素 node_id
    /// * `event_type` - 事件类型（如 "click"）
    /// * `x` - 事件 X 坐标
    /// * `y` - 事件 Y 坐标
    /// * `button` - 鼠标按钮（0=左键, 1=中键, 2=右键）
    /// 
    /// # 返回
    /// 
    /// * `Ok(())` - 捕获完成
    /// * `Err(...)` - 处理失败
    pub fn capture_event(
        &mut self,
        target_node_id: u64,
        event_type: &str,
        x: f32,
        y: f32,
        button: u8,
    ) -> Result<()> {
        // 1. 构建捕获路径：root → ... → 父 → 目标
        let capture_path = self.build_capture_path(target_node_id);
        
        debug!(
            target_node_id,
            event_type,
            path_len = capture_path.len(),
            "Starting event capturing"
        );
        
        // 2. 沿路径捕获（从根到目标，不包括目标）
        for (index, node_id) in capture_path.iter().enumerate() {
            // 获取当前节点的 HitArea
            let hit_area = self.hit_index.get_area(*node_id);
            
            if hit_area.is_none() {
                continue;
            }
            
            let area = hit_area.unwrap();
            
            // 检查当前节点是否有该事件类型的捕获处理器
            // TODO: 未来需要区分捕获和冒泡处理器
            // 目前假设所有处理器都会在两个阶段都触发
            let has_handler = area.event_types.as_ref()
                .map(|events| events.contains(event_type))
                .unwrap_or(false);
            
            if !has_handler {
                debug!(
                    node_id = *node_id,
                    event_type,
                    "Node has no handler for this event type, skipping"
                );
                continue;
            }
            
            // 调用 JS 事件处理器
            if let Some(ref vnode_id) = area.vnode_id {
                let vnode_id_clone = vnode_id.clone();
                
                debug!(
                    node_id = *node_id,
                    vnode_id = vnode_id_clone,
                    event_type,
                    capture_index = index,
                    "Invoking event handler during capture"
                );
                
                #[cfg(feature = "vue-sfc")]
                {
                    // 调用 JS 事件处理器
                    let should_stop = self.invoke_js_event_handler(
                        &vnode_id_clone,
                        event_type,
                        x,
                        y,
                        button,
                    )?;
                    
                    // 检查是否应该停止传播
                    if should_stop {
                        debug!(
                            node_id = *node_id,
                            vnode_id = vnode_id_clone,
                            event_type,
                            "Event propagation stopped during capture phase"
                        );
                        return Ok(());
                    }
                }
                
                #[cfg(not(feature = "vue-sfc"))]
                {
                    warn!("Vue SFC feature not enabled");
                }
            }
        }
        
        debug!(event_type, "Event capturing completed");
        
        Ok(())
    }
    
    /// 构建捕获路径
    /// 
    /// 从根节点开始，沿着 parent_id 向下遍历到目标节点。
    /// 先构建冒泡路径（目标 → 根），然后反转。
    /// 
    /// # 参数
    /// 
    /// * `target_node_id` - 目标节点 ID
    /// 
    /// # 返回
    /// 
    /// 捕获路径上的节点 ID 列表（从根到目标）
    fn build_capture_path(&self, target_node_id: u64) -> Vec<u64> {
        // 先构建冒泡路径（目标 → 根）
        let mut bubble_path = self.build_bubble_path(target_node_id);
        
        // 反转为捕获路径（根 → 目标）
        bubble_path.reverse();
        
        debug!(
            target_node_id,
            path_len = bubble_path.len(),
            "Built capture path"
        );
        
        bubble_path
    }
    
    /// 实现完整的三阶段事件流（DOM Level 3 规范）
    /// 
    /// 事件流包含三个阶段：
    /// 1. 捕获阶段 (Capture Phase): root → ... → parent → target
    /// 2. 目标阶段 (Target Phase): target
    /// 3. 冒泡阶段 (Bubble Phase): target → parent → ... → root
    /// 
    /// # 参数
    /// 
    /// * `target_node_id` - 目标元素 node_id
    /// * `event_type` - 事件类型（如 "click"）
    /// * `x` - 事件 X 坐标
    /// * `y` - 事件 Y 坐标
    /// * `button` - 鼠标按钮（0=左键, 1=中键, 2=右键）
    /// 
    /// # 返回
    /// 
    /// * `Ok(())` - 事件流完成
    /// * `Err(...)` - 处理失败
    pub fn dispatch_event_three_phase(
        &mut self,
        target_node_id: u64,
        event_type: &str,
        x: f32,
        y: f32,
        button: u8,
    ) -> Result<()> {
        info!(
            target_node_id,
            event_type,
            "Starting three-phase event dispatch"
        );
        
        // 阶段 1: 捕获阶段
        debug!("Phase 1: Capture phase");
        self.capture_event(target_node_id, event_type, x, y, button)?;
        
        // 阶段 2: 目标阶段（在 capture_event 中已处理）
        // 注意：目标节点在捕获阶段已经被处理
        // 根据 DOM 规范，目标节点的事件处理器只执行一次
        
        // 阶段 3: 冒泡阶段
        debug!("Phase 3: Bubble phase");
        self.bubble_event(target_node_id, event_type, x, y, button)?;
        
        info!(event_type, "Three-phase event dispatch completed");
        
        Ok(())
    }
    
    // ==========================================
    // 以下是未来需要实现的 TODO 方法
    // ==========================================
    // TODO: 事件冒泡机制
    // TODO: 事件捕获阶段
    // TODO: 键盘事件处理
    // TODO: 表单事件处理
    // TODO: 触摸事件处理
    // 注意：以下辅助方法已在 core.rs 中实现，无需重复定义
}

// ============================================
// 事件委托 API
// ============================================

impl RuntimeOrchestrator {
    /// 注册事件委托
    #[cfg(feature = "vue-sfc")]
    pub fn register_event_delegation(
        &mut self,
        parent_node_id: u64,
        selector: &str,
        event_type: &str,
    ) {
        self.event_delegations
            .entry(parent_node_id)
            .or_insert_with(Vec::new)
            .push((selector.to_string(), event_type.to_string()));
        
        debug!(
            parent_node_id,
            selector,
            event_type,
            "Registered event delegation"
        );
    }
    
    /// 移除事件委托
    #[cfg(feature = "vue-sfc")]
    pub fn remove_event_delegation(
        &mut self,
        parent_node_id: u64,
        selector: &str,
        event_type: &str,
    ) {
        if let Some(delegations) = self.event_delegations.get_mut(&parent_node_id) {
            delegations.retain(|(s, e)| s != selector || e != event_type);
        }
    }
    
    /// 检查目标节点是否匹配委托选择器
    /// 
    /// 支持的选择器类型：
    /// - 标签名选择器: "button", "li", "div"
    /// - Class 选择器: ".item", ".btn-primary"
    /// - ID 选择器: "#submit-btn", "#my-form"
    /// - 后代选择器: "ul li", "div button"
    /// - 子选择器: "ul > li", "div > button"
    /// - 多 Class: ".btn.btn-primary"
    #[cfg(feature = "vue-sfc")]
    fn matches_delegation_selector(
        &self,
        target_node_id: u64,
        selector: &str,
    ) -> bool {
        if let Some(ref dom_tree) = self.dom_tree {
            // 递归查找目标节点
            if let Some(node) = Self::find_node_in_tree(dom_tree, target_node_id) {
                // 检测是否为复合选择器
                if selector.contains(">") {
                    // 子选择器: "ul > li"
                    return self.matches_child_selector(dom_tree, target_node_id, selector);
                } else if selector.contains(' ') && !selector.starts_with('.') && !selector.starts_with('#') {
                    // 后代选择器: "ul li" (不包含 > 且包含空格)
                    return self.matches_descendant_selector(dom_tree, target_node_id, selector);
                } else if selector.starts_with('.') && selector[1..].contains('.') {
                    // 多 Class 选择器: ".btn.btn-primary"
                    return self.matches_multiple_classes(node, selector);
                } else if selector.starts_with('.') {
                    // 单 Class 选择器: .classname
                    return self.matches_class_selector(node, &selector[1..]);
                } else if selector.starts_with('#') {
                    // ID 选择器: #id
                    return self.matches_id_selector(node, &selector[1..]);
                } else {
                    // 标签名选择器: button, div, etc.
                    return self.matches_tag_selector(node, selector);
                }
            }
        }
        
        false
    }
    
    /// 在 DOM 树中递归查找指定 ID 的节点
    #[cfg(feature = "vue-sfc")]
    fn find_node_in_tree<'a>(node: &'a iris_layout::dom::DOMNode, target_id: u64) -> Option<&'a iris_layout::dom::DOMNode> {
        if node.id == target_id {
            return Some(node);
        }
        
        for child in &node.children {
            if let Some(found) = Self::find_node_in_tree(child, target_id) {
                return Some(found);
            }
        }
        
        None
    }
    
/// 在 DOM 树中查找节点 (可变版本)
    #[cfg(feature = "vue-sfc")]
    #[allow(dead_code)]
    fn find_node_in_tree_mut<'a>(node: &'a mut iris_layout::dom::DOMNode, target_id: u64) -> Option<&'a mut iris_layout::dom::DOMNode> {
        if node.id == target_id {
            return Some(node);
        }
        
        for child in &mut node.children {
            if let Some(found) = Self::find_node_in_tree_mut(child, target_id) {
                return Some(found);
            }
        }
        
        None
    }
    
    /// 匹配后代选择器 (如 "ul li", "div button")
    /// 
    /// 检查目标节点是否有祖先节点匹配选择器的所有部分
    #[cfg(feature = "vue-sfc")]
    fn matches_descendant_selector(
        &self,
        dom_tree: &iris_layout::dom::DOMNode,
        target_node_id: u64,
        selector: &str,
    ) -> bool {
        // 分割选择器: "ul li" -> ["ul", "li"]
        let parts: Vec<&str> = selector.split_whitespace().collect();
        if parts.len() < 2 {
            return false;
        }
        
        // 最后一部分应该是目标节点的标签
        let target_tag = parts.last().unwrap();
        
        // 查找目标节点
        let target_node = match Self::find_node_in_tree(dom_tree, target_node_id) {
            Some(node) => node,
            None => return false,
        };
        
        // 验证目标节点标签匹配
        if !self.matches_tag_selector(target_node, target_tag) {
            return false;
        }
        
        // 检查是否有祖先节点匹配前面的部分
        // 例如: "ul li" 需要目标节点的某个祖先是 <ul>
        let ancestor_selector = &parts[0..parts.len()-1].join(" ");
        
        // 递归检查所有祖先
        self.has_matching_ancestor(dom_tree, target_node_id, ancestor_selector)
    }
    
    /// 检查目标节点是否有匹配的祖先
    #[cfg(feature = "vue-sfc")]
    fn has_matching_ancestor(
        &self,
        dom_tree: &iris_layout::dom::DOMNode,
        target_node_id: u64,
        selector: &str,
    ) -> bool {
        // 查找目标节点
        let target_node = match Self::find_node_in_tree(dom_tree, target_node_id) {
            Some(node) => node,
            None => return false,
        };
        
        // 如果目标是根节点，没有祖先
        if target_node.parent_id == 0 {
            return false;
        }
        
        // 查找父节点
        let parent_id = target_node.parent_id;
        if let Some(parent_node) = Self::find_node_in_tree(dom_tree, parent_id) {
            // 检查父节点是否匹配选择器
            if self.matches_simple_selector(parent_node, selector) {
                return true;
            }
            
            // 递归检查父节点的祖先
            self.has_matching_ancestor(dom_tree, parent_id, selector)
        } else {
            false
        }
    }
    
    /// 匹配简单选择器 (标签、Class、ID)
    #[cfg(feature = "vue-sfc")]
    fn matches_simple_selector(&self, node: &iris_layout::dom::DOMNode, selector: &str) -> bool {
        if selector.starts_with('.') {
            self.matches_class_selector(node, &selector[1..])
        } else if selector.starts_with('#') {
            self.matches_id_selector(node, &selector[1..])
        } else {
            self.matches_tag_selector(node, selector)
        }
    }
    
    /// 匹配子选择器 (如 "ul > li", "div > button")
    /// 
    /// 检查目标节点的直接父节点是否匹配选择器
    #[cfg(feature = "vue-sfc")]
    fn matches_child_selector(
        &self,
        dom_tree: &iris_layout::dom::DOMNode,
        target_node_id: u64,
        selector: &str,
    ) -> bool {
        // 分割选择器: "ul > li" -> ["ul", "li"]
        let parts: Vec<&str> = selector.split_whitespace().filter(|s| *s != ">").collect();
        if parts.len() != 2 {
            return false;
        }
        
        let parent_selector = parts[0];
        let target_tag = parts[1];
        
        // 查找目标节点
        let target_node = match Self::find_node_in_tree(dom_tree, target_node_id) {
            Some(node) => node,
            None => return false,
        };
        
        // 验证目标节点标签匹配
        if !self.matches_tag_selector(target_node, target_tag) {
            return false;
        }
        
        // 查找直接父节点
        if target_node.parent_id == 0 {
            return false;
        }
        
        let parent_id = target_node.parent_id;
        if let Some(parent_node) = Self::find_node_in_tree(dom_tree, parent_id) {
            // 检查父节点是否匹配选择器
            self.matches_simple_selector(parent_node, parent_selector)
        } else {
            false
        }
    }
    
    /// 匹配多 Class 选择器 (如 ".btn.btn-primary")
    /// 
    /// 检查节点是否同时包含所有指定的 class
    #[cfg(feature = "vue-sfc")]
    fn matches_multiple_classes(&self, node: &iris_layout::dom::DOMNode, selector: &str) -> bool {
        // 移除开头的 . 并分割: ".btn.btn-primary" -> ["btn", "btn-primary"]
        let classes: Vec<&str> = selector[1..].split('.').collect();
        
        // 获取节点的 class 属性
        if let Some(class_attr) = node.attributes.get("class") {
            let node_classes: Vec<&str> = class_attr.split_whitespace().collect();
            
            // 检查所有需要的 class 都存在
            classes.iter().all(|required_class| {
                node_classes.contains(required_class)
            })
        } else {
            false
        }
    }
    
    /// 匹配标签名选择器
    #[cfg(feature = "vue-sfc")]
    fn matches_tag_selector(&self, node: &iris_layout::dom::DOMNode, tag: &str) -> bool {
        match &node.node_type {
            iris_layout::dom::NodeType::Element(tag_name) => {
                tag_name.eq_ignore_ascii_case(tag)
            }
            _ => false,
        }
    }
    
    /// 匹配 Class 选择器
    #[cfg(feature = "vue-sfc")]
    fn matches_class_selector(&self, node: &iris_layout::dom::DOMNode, class_name: &str) -> bool {
        if let Some(class_attr) = node.attributes.get("class") {
            // class 属性可能包含多个类名，用空格分隔
            class_attr.split_whitespace().any(|c| c == class_name)
        } else {
            false
        }
    }
    
    /// 匹配 ID 选择器
    #[cfg(feature = "vue-sfc")]
    fn matches_id_selector(&self, node: &iris_layout::dom::DOMNode, id: &str) -> bool {
        if let Some(node_id) = node.attributes.get("id") {
            node_id == id
        } else {
            false
        }
    }
    
    /// 检查 stopPropagation 标志
    /// 
    /// 通过全局变量 `__iris_lastEventPropagationStopped` 检测
    /// JS 事件处理器是否调用了 `event.stopPropagation()`。
    /// 
    /// # 实现原理
    /// 
    /// 1. JS 端的 `stopPropagation()` 方法会设置全局变量
    /// 2. Rust 端读取该全局变量并转换为 bool
    /// 3. 清理全局变量，避免影响下次调用
    #[cfg(feature = "vue-sfc")]
    fn check_stop_propagation(&mut self) -> bool {
        // 读取全局变量
        let check_code = "globalThis.__iris_lastEventPropagationStopped";
        
        match self.js_runtime.eval(check_code) {
            Ok(value) => {
                // 使用 Boa Engine 的 to_boolean() 方法转换为 bool
                let stopped = value.to_boolean();
                
                // 清理全局变量，避免影响下次调用
                let _ = self.js_runtime.eval("delete globalThis.__iris_lastEventPropagationStopped");
                
                stopped
            }
            Err(e) => {
                debug!(
                    error = %e,
                    "Failed to check stopPropagation flag"
                );
                false
            }
        }
    }
    
    /// 处理委托事件
    #[cfg(feature = "vue-sfc")]
    fn handle_delegated_event(
        &mut self,
        target_node_id: u64,
        parent_node_id: u64,
        event_type: &str,
        x: f32,
        y: f32,
        button: u8,
    ) -> Result<()> {
        if let Some(parent_area) = self.hit_index.get_area(parent_node_id) {
            if let Some(ref parent_vnode_id) = parent_area.vnode_id {
                let parent_vnode_id_clone = parent_vnode_id.clone();
                let _should_stop = self.invoke_js_event_handler(
                    &parent_vnode_id_clone,
                    event_type,
                    x,
                    y,
                    button,
                )?;
                
                debug!(
                    target_node_id,
                    parent_node_id,
                    event_type,
                    "Delegated event handled"
                );
            }
        }
        
        Ok(())
    }
}

// ============================================
// 焦点管理 API
// ============================================

impl RuntimeOrchestrator {
    /// 设置焦点到指定节点
    /// 
    /// # 参数
    /// 
    /// * `node_id` - 目标节点 ID
    /// 
    /// # 返回
    /// 
    /// * `Ok(())` - 焦点设置成功
    /// * `Err(...)` - 节点不可聚焦或其他错误
    #[cfg(feature = "vue-sfc")]
    pub fn focus(&mut self, node_id: u64) -> Result<()> {
        // 检查节点是否可聚焦
        if !self.is_focusable(node_id) {
            return Err(anyhow!("Node {} is not focusable", node_id));
        }
        
        // 如果已经有焦点节点，先触发 blur 事件
        if let Some(old_focused_id) = self.focused_node_id {
            if old_focused_id != node_id {
                self.blur_node(old_focused_id)?;
            }
        }
        
        // 更新焦点
        self.focused_node_id = Some(node_id);
        
        // 触发 focus 事件
        self.focus_node(node_id)?;
        
        // 标记需要重渲染
        self.dirty = true;
        
        debug!(node_id, "Focus set to node");
        
        Ok(())
    }
    
    /// 清除当前焦点
    #[cfg(feature = "vue-sfc")]
    pub fn blur(&mut self) -> Result<()> {
        if let Some(focused_id) = self.focused_node_id {
            self.blur_node(focused_id)?;
            self.focused_node_id = None;
            self.dirty = true;
            
            debug!("Focus cleared");
        }
        
        Ok(())
    }
    
    /// 获取当前焦点节点 ID
    #[cfg(feature = "vue-sfc")]
    pub fn get_focused_node(&self) -> Option<u64> {
        self.focused_node_id
    }
    
    /// 检查节点是否可聚焦
    #[cfg(feature = "vue-sfc")]
    pub fn is_focusable(&self, node_id: u64) -> bool {
        if let Some(ref dom_tree) = self.dom_tree {
            if let Some(node) = Self::find_node_in_tree(dom_tree, node_id) {
                // 检查元素类型
                let is_focusable_type = match &node.node_type {
                    iris_layout::dom::NodeType::Element(tag) => {
                        matches!(tag.as_str(), "a" | "button" | "input" | "textarea" | "select")
                    }
                    _ => false,
                };
                
                if is_focusable_type {
                    // 检查是否 disabled
                    if let Some(disabled) = node.attributes.get("disabled") {
                        if disabled == "true" || disabled.is_empty() {
                            return false;
                        }
                    }
                    
                    return true;
                }
                
                // 检查 tabindex
                if let Some(tabindex) = node.attributes.get("tabindex") {
                    if let Ok(index) = tabindex.parse::<i32>() {
                        return index >= 0;
                    }
                }
            }
        }
        
        false
    }
    
    /// 触发节点的 focus 事件
    #[cfg(feature = "vue-sfc")]
    fn focus_node(&mut self, node_id: u64) -> Result<()> {
        if let Some(hit_area) = self.hit_index.get_area(node_id) {
            if let Some(ref vnode_id) = hit_area.vnode_id {
                let vnode_id_clone = vnode_id.clone();
                
                // 触发 focus 事件
                let _ = self.invoke_js_event_handler(
                    &vnode_id_clone,
                    "focus",
                    0.0,
                    0.0,
                    0,
                );
                
                debug!(node_id, vnode_id = vnode_id_clone, "Focus event triggered");
            }
        }
        
        Ok(())
    }
    
    /// 触发节点的 blur 事件
    #[cfg(feature = "vue-sfc")]
    fn blur_node(&mut self, node_id: u64) -> Result<()> {
        if let Some(hit_area) = self.hit_index.get_area(node_id) {
            if let Some(ref vnode_id) = hit_area.vnode_id {
                let vnode_id_clone = vnode_id.clone();
                
                // 触发 blur 事件
                let _ = self.invoke_js_event_handler(
                    &vnode_id_clone,
                    "blur",
                    0.0,
                    0.0,
                    0,
                );
                
                debug!(node_id, vnode_id = vnode_id_clone, "Blur event triggered");
            }
        }
        
        Ok(())
    }
}

// ============================================
// 键盘事件 API
// ============================================

impl RuntimeOrchestrator {
    /// 处理键盘按下事件
    #[cfg(feature = "vue-sfc")]
    pub fn handle_key_down(&mut self, key_code: u32, modifiers: u32) -> Result<()> {
        debug!(key_code, modifiers, "Key down event");
        
        // Tab 键特殊处理
        if key_code == 9 {
            let shift_pressed = (modifiers & 1) != 0;
            return self.handle_tab_key(shift_pressed);
        }
        
        // 其他键分发给焦点节点
        if let Some(focused_id) = self.focused_node_id {
            self.dispatch_key_event(focused_id, "keydown", key_code, modifiers)?;
        }
        
        Ok(())
    }
    
    /// 处理键盘释放事件
    #[cfg(feature = "vue-sfc")]
    pub fn handle_key_up(&mut self, key_code: u32, modifiers: u32) -> Result<()> {
        debug!(key_code, modifiers, "Key up event");
        
        if let Some(focused_id) = self.focused_node_id {
            self.dispatch_key_event(focused_id, "keyup", key_code, modifiers)?;
        }
        
        Ok(())
    }
    
    /// 分发键盘事件到指定节点
    #[cfg(feature = "vue-sfc")]
    fn dispatch_key_event(
        &mut self,
        node_id: u64,
        event_type: &str,
        key_code: u32,
        modifiers: u32,
    ) -> Result<()> {
        if let Some(hit_area) = self.hit_index.get_area(node_id) {
            if let Some(ref vnode_id) = hit_area.vnode_id {
                let vnode_id_clone = vnode_id.clone();
                
                let event_data = serde_json::json!({
                    "key": key_code,
                    "keyCode": key_code,
                    "modifiers": modifiers,
                });
                
                let event_data_str = serde_json::to_string(&event_data)
                    .unwrap_or_else(|_| "{}".to_string());
                
                let js_code = format!(
                    "(function() {{ \
                        var event = {}; \
                        return __iris_invokeEventHandler(\"{}\", \"{}\", event); \
                    }})()",
                    event_data_str,
                    vnode_id,
                    event_type
                );
                
                let _ = self.js_runtime.eval(&js_code);
                
                debug!(node_id, vnode_id = vnode_id_clone, event_type, key_code, "Keyboard event dispatched");
            }
        }
        
        Ok(())
    }
    
    /// 处理 Tab 键导航
    #[cfg(feature = "vue-sfc")]
    fn handle_tab_key(&mut self, shift_pressed: bool) -> Result<()> {
        debug!(shift_pressed, "Tab key pressed");
        
        let focusable_nodes = self.collect_focusable_nodes();
        
        if focusable_nodes.is_empty() {
            return Ok(());
        }
        
        let current_index = if let Some(focused_id) = self.focused_node_id {
            focusable_nodes.iter().position(|&id| id == focused_id)
        } else {
            None
        };
        
        let next_index = if let Some(idx) = current_index {
            if shift_pressed {
                if idx == 0 { focusable_nodes.len() - 1 } else { idx - 1 }
            } else {
                (idx + 1) % focusable_nodes.len()
            }
        } else {
            0
        };
        
        let next_node_id = focusable_nodes[next_index];
        self.focus(next_node_id)?;
        
        debug!(next_node_id, next_index, total = focusable_nodes.len(), "Tab navigation completed");
        
        Ok(())
    }
    
    /// 收集所有可聚焦节点
    #[cfg(feature = "vue-sfc")]
    fn collect_focusable_nodes(&self) -> Vec<u64> {
        let mut focusable = Vec::new();
        
        if let Some(ref dom_tree) = self.dom_tree {
            Self::collect_focusable_recursive(dom_tree, &mut focusable, self);
        }
        
        focusable
    }
    
    /// 递归收集可聚焦节点
    #[cfg(feature = "vue-sfc")]
    fn collect_focusable_recursive(
        node: &iris_layout::dom::DOMNode,
        focusable: &mut Vec<u64>,
        orchestrator: &RuntimeOrchestrator,
    ) {
        if Self::is_focusable_node(node) {
            focusable.push(node.id);
        }
        
        for child in &node.children {
            Self::collect_focusable_recursive(child, focusable, orchestrator);
        }
    }
    
    /// 检查节点是否可聚焦 (静态版本)
    #[cfg(feature = "vue-sfc")]
    fn is_focusable_node(node: &iris_layout::dom::DOMNode) -> bool {
        let is_focusable_type = match &node.node_type {
            iris_layout::dom::NodeType::Element(tag) => {
                matches!(tag.as_str(), "a" | "button" | "input" | "textarea" | "select")
            }
            _ => false,
        };
        
        if is_focusable_type {
            if let Some(disabled) = node.attributes.get("disabled") {
                if disabled == "true" || disabled.is_empty() {
                    return false;
                }
            }
            return true;
        }
        
        if let Some(tabindex) = node.attributes.get("tabindex") {
            if let Ok(index) = tabindex.parse::<i32>() {
                return index >= 0;
            }
        }
        
        false
    }
}

// ============================================
// 性能优化 API
// ============================================

impl RuntimeOrchestrator {
    /// 检查事件处理器是否存在 (带缓存)
    #[cfg(feature = "vue-sfc")]
    pub fn has_event_handler_cached(&mut self, vnode_id: &str, event_type: &str) -> bool {
        self.cache_total_count += 1;

        // 检查缓存
        if let Some(event_cache) = self.event_handler_cache.get(vnode_id) {
            if let Some(&exists) = event_cache.get(event_type) {
                self.cache_hit_count += 1;
                return exists;
            }
        }

        // 缓存未命中，检查 JS 运行时
        let check_code = format!(
            "typeof globalThis.__iris_event_handlers['{}'] !== 'undefined' && \
             typeof globalThis.__iris_event_handlers['{}']['{}'] === 'function'",
            vnode_id, vnode_id, event_type
        );

        let exists = self.js_runtime.eval(&check_code)
            .map(|v| v.to_boolean())
            .unwrap_or(false);

        // 更新缓存
        self.event_handler_cache
            .entry(vnode_id.to_string())
            .or_insert_with(std::collections::HashMap::new)
            .insert(event_type.to_string(), exists);

        exists
    }

    /// 清除事件处理器缓存
    #[cfg(feature = "vue-sfc")]
    pub fn clear_event_handler_cache(&mut self) {
        self.event_handler_cache.clear();
    }

    /// 清除 HitTest 缓存
    #[cfg(feature = "vue-sfc")]
    pub fn clear_hit_test_cache(&mut self) {
        self.hit_test_cache.clear();
    }

    /// 清除所有缓存
    #[cfg(feature = "vue-sfc")]
    pub fn clear_all_caches(&mut self) {
        self.clear_event_handler_cache();
        self.clear_hit_test_cache();
    }

    /// 获取缓存命中率
    #[cfg(feature = "vue-sfc")]
    pub fn get_cache_hit_rate(&self) -> f64 {
        if self.cache_total_count == 0 {
            0.0
        } else {
            self.cache_hit_count as f64 / self.cache_total_count as f64
        }
    }

    /// 获取缓存统计信息
    #[cfg(feature = "vue-sfc")]
    pub fn get_cache_stats(&self) -> (u64, u64, f64) {
        (
            self.cache_hit_count,
            self.cache_total_count,
            self.get_cache_hit_rate(),
        )
    }

    /// 缓存 HitTest 结果
    #[cfg(feature = "vue-sfc")]
    pub fn cache_hit_test_result(&mut self, node_id: u64, result: Option<super::hit_test::HitArea>) {
        self.hit_test_cache.insert(node_id, result);
    }

    /// 获取缓存的 HitTest 结果
    #[cfg(feature = "vue-sfc")]
    pub fn get_cached_hit_test(&mut self, node_id: u64) -> Option<Option<super::hit_test::HitArea>> {
        self.cache_total_count += 1;
        if let Some(result) = self.hit_test_cache.get(&node_id) {
            self.cache_hit_count += 1;
            Some(result.clone())
        } else {
            None
        }
    }
}

// ============================================
// 高级事件功能 API
// ============================================

impl RuntimeOrchestrator {
    /// 设置事件监听器选项
    #[cfg(feature = "vue-sfc")]
    pub fn set_event_listener_options(
        &mut self,
        vnode_id: &str,
        event_type: &str,
        options: EventListenerOptions,
    ) {
        self.event_listener_options
            .entry(vnode_id.to_string())
            .or_insert_with(std::collections::HashMap::new)
            .insert(event_type.to_string(), options);
    }

    /// 获取事件监听器选项
    #[cfg(feature = "vue-sfc")]
    pub fn get_event_listener_options(&self, vnode_id: &str, event_type: &str) -> Option<EventListenerOptions> {
        self.event_listener_options
            .get(vnode_id)
            .and_then(|map| map.get(event_type))
            .cloned()
    }

    /// 检查是否为 once 监听器，如果是则移除
    #[cfg(feature = "vue-sfc")]
    pub fn check_and_remove_once_listener(&mut self, vnode_id: &str, event_type: &str) -> bool {
        if let Some(options) = self.get_event_listener_options(vnode_id, event_type) {
            if options.once {
                // 移除监听器
                if let Some(map) = self.event_listener_options.get_mut(vnode_id) {
                    map.remove(event_type);
                }
                return true;
            }
        }
        false
    }

    /// 检测双击事件
    #[cfg(feature = "vue-sfc")]
    pub fn check_double_click(&mut self, node_id: u64) -> bool {
        use std::time::{Instant, Duration};

        let now = Instant::now();
        let double_click_threshold = Duration::from_millis(300);

        if let Some(last_click) = self.last_click_times.get(&node_id) {
            let elapsed = now.duration_since(*last_click);
            
            // 更新点击时间
            self.last_click_times.insert(node_id, now);
            
            // 检查是否为双击
            if elapsed < double_click_threshold {
                debug!(node_id, "Double click detected");
                return true;
            }
        }

        // 记录点击时间
        self.last_click_times.insert(node_id, now);
        false
    }

    /// 清除双击检测状态
    #[cfg(feature = "vue-sfc")]
    pub fn clear_double_click_state(&mut self, node_id: u64) {
        self.last_click_times.remove(&node_id);
    }

    /// 触发 dblclick 事件
    #[cfg(feature = "vue-sfc")]
    pub fn trigger_double_click(&mut self, node_id: u64, x: f32, y: f32) -> Result<()> {
        debug!(node_id, x, y, "Triggering double click");
        
        if let Some(hit_area) = self.hit_index.get_area(node_id) {
            if let Some(ref vnode_id) = hit_area.vnode_id {
                let vnode_id_clone = vnode_id.clone();
                
                let event_data = serde_json::json!({
                    "detail": 2,
                    "clientX": x,
                    "clientY": y,
                });
                
                let event_data_str = serde_json::to_string(&event_data)
                    .unwrap_or_else(|_| "{}".to_string());
                
                let js_code = format!(
                    "(function() {{ \
                        var event = {}; \
                        return __iris_invokeEventHandler(\"{}\", \"dblclick\", event); \
                    }})()",
                    event_data_str,
                    vnode_id
                );
                
                let _ = self.js_runtime.eval(&js_code);
                
                debug!(node_id, vnode_id = vnode_id_clone, "Double click event triggered");
            }
        }
        
        Ok(())
    }

    /// 处理长按事件
    #[cfg(feature = "vue-sfc")]
    pub fn handle_long_press(&mut self, node_id: u64, duration_ms: u64) -> Result<()> {
        debug!(node_id, duration_ms, "Long press event");
        
        if let Some(hit_area) = self.hit_index.get_area(node_id) {
            if let Some(ref vnode_id) = hit_area.vnode_id {
                let vnode_id_clone = vnode_id.clone();
                
                let event_data = serde_json::json!({
                    "duration": duration_ms,
                });
                
                let event_data_str = serde_json::to_string(&event_data)
                    .unwrap_or_else(|_| "{}".to_string());
                
                let js_code = format!(
                    "(function() {{ \
                        var event = {}; \
                        return __iris_invokeEventHandler(\"{}\", \"longpress\", event); \
                    }})()",
                    event_data_str,
                    vnode_id
                );
                
                let _ = self.js_runtime.eval(&js_code);
                
                debug!(node_id, vnode_id = vnode_id_clone, "Long press event triggered");
            }
        }
        
        Ok(())
    }
}
