//不再使用，禁止扫描

#[cfg(test)]
mod html_renderer_tests {
    use super::*;
    
    // ==== 旧 HTML 渲染路径 - 保留为测试/参考 ====
    //
    // 以下代码是 iris-cmd dev 旧有的从 index.html 直接渲染 HTML 的路径。
    // 当前统一使用 DevApp 通过 SFC 管道处理 Vue 项目，此路径保留为参考。
    
    /// HTML 渲染应用（用于从 index.html 渲染）
    struct HtmlRenderApp {
        window: Option<Window>,
        renderer: Option<iris_gpu::Renderer>,
        orchestrator: iris_engine::orchestrator::RuntimeOrchestrator,
        draw_commands: Vec<iris_gpu::DrawCommand>,
        width: u32,
        height: u32,
        show_fps: bool,
        fps: f32,
        frame_count: u32,
        last_fps_time: std::time::Instant,
    }
    
    impl HtmlRenderApp {
        fn new(
            orchestrator: iris_engine::orchestrator::RuntimeOrchestrator,
            width: u32,
            height: u32,
            _file_name: &str,
            show_fps: bool,
        ) -> Result<Self> {
            Ok(Self {
                window: None,
                renderer: None,
                orchestrator,
                draw_commands: Vec::new(),
                width,
                height,
                show_fps,
                fps: 0.0,
                frame_count: 0,
                last_fps_time: std::time::Instant::now(),
            })
        }
        
        /// 生成绘制命令
        fn generate_draw_commands(&mut self) {
            self.draw_commands.clear();
            
            let commands = self.orchestrator.generate_render_commands();
            self.draw_commands = commands;
        }
    }
    
    impl winit::application::ApplicationHandler for HtmlRenderApp {
        fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
            if self.window.is_none() {
                let window = event_loop.create_window(
                    Window::default_attributes()
                        .with_title("Iris - HTML Renderer")
                        .with_inner_size(winit::dpi::PhysicalSize::new(self.width, self.height))
                        .with_resizable(true),
                );
                
                match window {
                    Ok(win) => {
                        print_success("Window created");
                        self.window = Some(win);
                    }
                    Err(e) => {
                        print_warning(&format!("Failed to create window: {}", e));
                    }
                }
            }
        }
        
        fn window_event(
            &mut self,
            event_loop: &winit::event_loop::ActiveEventLoop,
            _window_id: winit::window::WindowId,
            event: winit::event::WindowEvent,
        ) {
            use winit::event::{WindowEvent, ElementState};
            use winit::keyboard::{Key, NamedKey};
            
            match event {
                WindowEvent::CloseRequested => {
                    event_loop.exit();
                }
                WindowEvent::KeyboardInput { event: input, .. } => {
                    if input.state == ElementState::Pressed {
                        if let Key::Named(NamedKey::Escape) = input.logical_key {
                            event_loop.exit();
                        }
                    }
                }
                WindowEvent::Resized(new_size) => {
                    self.width = new_size.width;
                    self.height = new_size.height;
                    
                    if let Some(renderer) = &mut self.renderer {
                        renderer.resize(new_size);
                    }
                }
                WindowEvent::RedrawRequested => {
                    self.generate_draw_commands();
                    
                    if let Some(renderer) = &mut self.renderer {
                        renderer.submit_commands(self.draw_commands.clone());
                        if let Err(e) = renderer.render() {
                            print_warning(&format!("Render error: {}", e));
                        }
                        
                        self.frame_count += 1;
                        let now = std::time::Instant::now();
                        let elapsed = now.duration_since(self.last_fps_time).as_secs_f32();
                        if elapsed >= 1.0 {
                            self.fps = self.frame_count as f32 / elapsed;
                            self.frame_count = 0;
                            self.last_fps_time = now;
                            
                            if self.show_fps {
                                print_info(&format!("FPS: {:.0}", self.fps));
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        
        fn about_to_wait(&mut self, _event_loop: &winit::event_loop::ActiveEventLoop) {
            if let Some(window) = self.window.take() {
                if self.renderer.is_none() {
                    let window_size = window.inner_size();
                    print_info(&format!("Initializing GPU renderer ({}x{})...", window_size.width, window_size.height));
                    
                    match pollster::block_on(iris_gpu::Renderer::new(window)) {
                        Ok(renderer) => {
                            print_success("GPU renderer initialized");
                            self.renderer = Some(renderer);
                        }
                        Err(e) => {
                            print_warning(&format!("Failed to initialize GPU renderer: {}", e));
                        }
                    }
                } else {
                    self.window = Some(window);
                }
            }
            
            if let Some(window) = &self.window {
                window.request_redraw();
            }
        }
    }
    
    /// 从 HTML DOM 树启动原生窗口渲染（旧路径，保留为测试参考）
    #[allow(dead_code, unused_variables)]
    fn start_native_renderer_from_html(
        show_fps: bool,
        project_root: &std::path::Path,
        dom_tree: iris_layout::dom::DOMTree,
        config: &IrisConfig,
        devtools_enabled: bool,
        devtools_width: u32,
        devtools_height: u32,
        chrome_config: ChromeConfig,
    ) -> Result<()> {
        use winit::event_loop::EventLoop;
        use tracing::info;
        use iris_layout::css::parse_stylesheet;
        use iris_engine::orchestrator::RuntimeOrchestrator;
        
        print_success("Starting native window renderer from HTML...");
        print_info("This will create native windows with WebGPU rendering");
        println!();
        print_info("Press Ctrl+C or close windows to exit");
        if devtools_enabled {
            print_info("Press F12 to toggle DevTools");
        }
        println!();
        
        info!("Initializing development server with HTML-based rendering");
        
        let mut orchestrator = RuntimeOrchestrator::new();
        orchestrator.initialize()
            .map_err(|e| anyhow::anyhow!("Failed to initialize orchestrator: {}", e))?;
        
        let mut combined_css = String::new();
        
        fn print_dom_debug(node: &iris_layout::DOMNode, depth: usize) {
            if depth > 3 { return; }
            let indent = "  ".repeat(depth);
            match &node.node_type {
                iris_layout::dom::NodeType::Element(tag) => {
                    println!("{}[DOM] Element: <{}> ({} children)", indent, tag, node.children.len());
                }
                iris_layout::dom::NodeType::Text(text) => {
                    let preview = if text.chars().count() > 30 {
                        text.chars().take(30).collect::<String>() + "..."
                    } else {
                        text.clone()
                    };
                    println!("{}[DOM] Text: \"{}\"", indent, preview);
                }
                iris_layout::dom::NodeType::Comment(_) => {
                    println!("{}[DOM] Comment", indent);
                }
            }
            for child in &node.children {
                print_dom_debug(child, depth + 1);
            }
        }
        println!("[DEBUG] DOM tree structure:");
        print_dom_debug(&dom_tree.root, 0);
        
        fn extract_styles(node: &iris_layout::DOMNode, css: &mut String, depth: usize) {
            let indent = "  ".repeat(depth);
            
            if let Some(tag) = node.tag_name() {
                if tag == "style" {
                    let text = node.collect_text();
                    if !text.trim().is_empty() {
                        css.push_str(&text);
                        css.push('\n');
                        println!("{}[DEBUG] Found <style> with {} bytes", indent, text.len());
                    }
                }
            }
            
            for child in &node.children {
                extract_styles(child, css, depth + 1);
            }
        }
        
        extract_styles(&dom_tree.root, &mut combined_css, 0);
        
        print_info(&format!("Extracted {} bytes of CSS from <style> tags", combined_css.len()));
        if !combined_css.is_empty() {
            print_info(&format!("CSS preview: {}...", &combined_css[..combined_css.len().min(100)]));
        } else {
            print_warning("No CSS found in HTML!");
        }
        
        let stylesheet = parse_stylesheet(&combined_css);
        
        if let Err(e) = orchestrator.compute_layout_from_dom(dom_tree, stylesheet) {
            print_warning(&format!("Failed to compute layout: {}", e));
            return Ok(());
        }
        
        print_success("Layout computed successfully");
        
        let commands = orchestrator.generate_render_commands();
        print_info(&format!("Generated {} draw commands", commands.len()));
        
        let event_loop = EventLoop::new()
            .map_err(|e| anyhow::anyhow!("Failed to create event loop: {}", e))?;
        
        let mut app = HtmlRenderApp::new(
            orchestrator,
            1024,
            768,
            "index.html",
            show_fps,
        )?;
        
        print_info("Starting render loop...");
        print_info("Press ESC or close window to exit");
        println!();
        
        event_loop.run_app(&mut app)
            .map_err(|e| anyhow::anyhow!("Event loop error: {}", e))?;
        
        Ok(())
    }
}