"""
语音编辑器模块
提供可视化界面用于配置和测试语音控制功能
"""

import time
from typing import Dict, Any, List, Optional
import threading

class EditorMode:
    """编辑器模式枚举"""
    CONFIGURATION = "configuration"
    COMMAND_MAPPING = "command_mapping"
    VOICE_TRAINING = "voice_training"
    TESTING = "testing"
    MONITORING = "monitoring"
    PRESETS = "presets"

class VoiceEditor:
    """
    语音编辑器
    提供可视化界面用于配置和测试语音控制功能
    """
    
    def __init__(self, plugin):
        """
        初始化语音编辑器
        
        Args:
            plugin: 语音控制插件实例
        """
        self.plugin = plugin
        self.enabled = False
        self.initialized = False
        
        # 编辑器配置
        self.editor_config = {
            "window_width": 1024,
            "window_height": 768,
            "refresh_rate": 30.0,
            "enable_preview": True,
            "enable_realtime_update": True,
            "show_debug_info": False,
            "theme": "dark"
        }
        
        # 当前编辑器状态
        self.editor_state = {
            "current_mode": EditorMode.CONFIGURATION,
            "selected_tab": "general",
            "is_recording": False,
            "is_testing": False,
            "preview_active": False,
            "monitoring_active": True
        }
        
        # UI组件
        self.ui_components = {
            "main_window": None,
            "toolbar": None,
            "property_panel": None,
            "preview_panel": None,
            "status_bar": None,
            "config_view": None,
            "command_view": None,
            "training_view": None,
            "test_view": None,
            "monitor_view": None,
            "preset_view": None
        }
        
        # 编辑器数据
        self.editor_data = {
            "config_cache": {},
            "command_cache": {},
            "preset_cache": {},
            "live_data": {},
            "test_history": []
        }
        
        # 编辑器操作历史
        self.operation_history = []
        self.history_pointer = -1
        self.max_history_size = 100
        
        # 实时监控数据
        self.monitor_data = {
            "audio_levels": [],
            "recognition_results": [],
            "synthesis_events": [],
            "command_executions": [],
            "performance_metrics": {}
        }
        
        # 测试数据
        self.test_data = {
            "test_cases": [],
            "test_results": [],
            "current_test": None
        }
        
        # 回调函数
        self.editor_callbacks = {
            "mode_changed": [],
            "tab_changed": [],
            "data_updated": [],
            "test_started": [],
            "test_completed": [],
            "recording_started": [],
            "recording_stopped": []
        }
        
        # 统计信息
        self.editor_stats = {
            "windows_opened": 0,
            "operations_performed": 0,
            "undo_operations": 0,
            "redo_operations": 0,
            "data_refreshed": 0,
            "preview_updates": 0,
            "tests_run": 0
        }
        
        # 线程管理
        self.editor_thread = None
        self.monitor_thread = None
        self.running = False
        
        # 时间戳记录
        self.last_refresh_time = 0.0
        self.last_preview_update = 0.0
        self.last_monitor_update = 0.0
        
        print("✓ 语音编辑器已创建")
        
    def initialize(self) -> bool:
        """
        初始化语音编辑器
        
        Returns:
            是否初始化成功
        """
        try:
            # 初始化UI组件（模拟）
            self._initialize_ui_components()
            
            # 加载缓存数据
            self._load_editor_cache()
            
            self.initialized = True
            print("✓ 语音编辑器初始化完成")
            return True
            
        except Exception as e:
            print(f"✗ 语音编辑器初始化失败: {e}")
            import traceback
            traceback.print_exc()
            return False
            
    def enable(self) -> bool:
        """
        启用语音编辑器
        
        Returns:
            是否启用成功
        """
        try:
            if not self.initialized:
                print("✗ 语音编辑器未初始化")
                return False
                
            self.enabled = True
            self.running = True
            
            # 启动编辑器线程
            self.editor_thread = threading.Thread(target=self._editor_update_loop, daemon=True)
            self.editor_thread.start()
            
            # 启动监控线程
            if self.editor_config["enable_realtime_update"]:
                self.monitor_thread = threading.Thread(target=self._monitor_update_loop, daemon=True)
                self.monitor_thread.start()
            
            print("✓ 语音编辑器已启用")
            return True
            
        except Exception as e:
            print(f"✗ 语音编辑器启用失败: {e}")
            import traceback
            traceback.print_exc()
            return False
            
    def disable(self):
        """禁用语音编辑器"""
        try:
            self.enabled = False
            self.running = False
            
            # 等待线程结束
            if self.editor_thread and self.editor_thread.is_alive():
                self.editor_thread.join(timeout=2.0)
                
            if self.monitor_thread and self.monitor_thread.is_alive():
                self.monitor_thread.join(timeout=2.0)
                
            # 关闭UI组件
            self._close_ui_components()
            
            print("✓ 语音编辑器已禁用")
            
        except Exception as e:
            print(f"✗ 语音编辑器禁用失败: {e}")
            import traceback
            traceback.print_exc()
            
    def finalize(self):
        """清理语音编辑器资源"""
        try:
            self.disable()
            self.ui_components.clear()
            self.editor_data.clear()
            self.operation_history.clear()
            self.monitor_data.clear()
            self.test_data.clear()
            self.editor_callbacks.clear()
            self.initialized = False
            print("✓ 语音编辑器资源已清理")
            
        except Exception as e:
            print(f"✗ 语音编辑器资源清理失败: {e}")
            import traceback
            traceback.print_exc()
            
    def update(self, dt: float):
        """
        更新语音编辑器状态
        
        Args:
            dt: 时间增量
        """
        try:
            if not self.enabled:
                return
                
            # 更新统计信息
            pass
            
        except Exception as e:
            print(f"✗ 语音编辑器更新失败: {e}")
            import traceback
            traceback.print_exc()
            
    def _editor_update_loop(self):
        """编辑器更新循环"""
        try:
            refresh_interval = 1.0 / self.editor_config["refresh_rate"]
            
            while self.running:
                if self.enabled:
                    self._update_editor_display()
                    
                time.sleep(refresh_interval)
                
        except Exception as e:
            print(f"✗ 编辑器更新循环失败: {e}")
            
    def _monitor_update_loop(self):
        """监控更新循环"""
        try:
            monitor_interval = 0.1  # 100ms
            
            while self.running:
                if self.enabled and self.editor_config["enable_realtime_update"]:
                    self._update_monitor_data()
                    
                time.sleep(monitor_interval)
                
        except Exception as e:
            print(f"✗ 监控更新循环失败: {e}")
            
    def _initialize_ui_components(self):
        """初始化UI组件"""
        try:
            # 在实际实现中，这里会创建实际的UI组件
            # 由于这是模拟实现，我们只创建占位符
            self.ui_components["main_window"] = "MainWindow"
            self.ui_components["toolbar"] = "Toolbar"
            self.ui_components["property_panel"] = "PropertyPanel"
            self.ui_components["preview_panel"] = "PreviewPanel"
            self.ui_components["status_bar"] = "StatusBar"
            self.ui_components["config_view"] = "ConfigView"
            self.ui_components["command_view"] = "CommandView"
            self.ui_components["training_view"] = "TrainingView"
            self.ui_components["test_view"] = "TestView"
            self.ui_components["monitor_view"] = "MonitorView"
            self.ui_components["preset_view"] = "PresetView"
            
            print("✓ UI组件初始化完成")
        except Exception as e:
            print(f"✗ UI组件初始化失败: {e}")
            
    def _close_ui_components(self):
        """关闭UI组件"""
        try:
            # 在实际实现中，这里会关闭实际的UI组件
            self.ui_components.clear()
            print("✓ UI组件已关闭")
        except Exception as e:
            print(f"✗ UI组件关闭失败: {e}")
            
    def _load_editor_cache(self):
        """加载编辑器缓存"""
        try:
            # 模拟加载缓存数据
            if self.plugin.config_manager:
                self.editor_data["config_cache"] = self.plugin.config_manager.get_config()
                
            if self.plugin.command_processor:
                self.editor_data["command_cache"] = self.plugin.command_processor.get_command_mappings()
                
            print("✓ 编辑器缓存加载完成")
        except Exception as e:
            print(f"✗ 编辑器缓存加载失败: {e}")
            
    def _update_editor_display(self):
        """更新编辑器显示"""
        try:
            current_time = time.time()
            
            # 检查是否需要刷新
            if current_time - self.last_refresh_time >= 1.0 / self.editor_config["refresh_rate"]:
                # 更新配置视图
                self._refresh_config_view()
                
                # 更新属性面板
                self._refresh_property_panel()
                
                # 更新预览面板
                if self.editor_config["enable_preview"]:
                    self._update_preview_panel()
                    
                # 更新状态栏
                self._update_status_bar()
                
                self.last_refresh_time = current_time
                self.editor_stats["data_refreshed"] += 1
                
        except Exception as e:
            print(f"✗ 编辑器显示更新失败: {e}")
            
    def _update_monitor_data(self):
        """更新监控数据"""
        try:
            # 收集实时数据
            current_time = time.time()
            
            # 收集音频级别数据
            if self.plugin.audio_manager:
                input_level = self.plugin.audio_manager.get_audio_level("input")
                output_level = self.plugin.audio_manager.get_audio_level("output")
                
                self.monitor_data["audio_levels"].append({
                    "input": input_level,
                    "output": output_level,
                    "timestamp": current_time
                })
                
                # 保持数据大小
                if len(self.monitor_data["audio_levels"]) > 100:
                    self.monitor_data["audio_levels"] = self.monitor_data["audio_levels"][-100:]
                    
            # 收集识别结果
            if self.plugin.voice_manager:
                recognition_state = self.plugin.voice_manager.get_recognition_state()
                if recognition_state.get("current_text"):
                    self.monitor_data["recognition_results"].append({
                        "text": recognition_state["current_text"],
                        "confidence": recognition_state["confidence"],
                        "timestamp": current_time
                    })
                    
                    # 保持数据大小
                    if len(self.monitor_data["recognition_results"]) > 50:
                        self.monitor_data["recognition_results"] = self.monitor_data["recognition_results"][-50:]
                        
            # 收集合成事件
            if self.plugin.voice_manager:
                synthesis_state = self.plugin.voice_manager.get_synthesis_state()
                if synthesis_state.get("current_text"):
                    # 这里只是示例，实际应该监听合成事件
                    pass
                    
            # 收集性能指标
            self._collect_performance_metrics()
            
        except Exception as e:
            print(f"✗ 监控数据更新失败: {e}")
            
    def _collect_performance_metrics(self):
        """收集性能指标"""
        try:
            metrics = {}
            
            # 收集各模块统计信息
            if self.plugin.voice_manager:
                metrics["voice_manager"] = self.plugin.voice_manager.get_stats()
                
            if self.plugin.speech_recognizer:
                metrics["speech_recognizer"] = self.plugin.speech_recognizer.get_stats()
                
            if self.plugin.speech_synthesizer:
                metrics["speech_synthesizer"] = self.plugin.speech_synthesizer.get_stats()
                
            if self.plugin.command_processor:
                metrics["command_processor"] = self.plugin.command_processor.get_stats()
                
            if self.plugin.audio_manager:
                metrics["audio_manager"] = self.plugin.audio_manager.get_device_stats()
                
            if self.plugin.nlp_processor:
                metrics["nlp_processor"] = self.plugin.nlp_processor.get_stats()
                
            if self.plugin.event_handler:
                metrics["event_handler"] = self.plugin.event_handler.get_stats()
                
            if self.plugin.config_manager:
                metrics["config_manager"] = self.plugin.config_manager.get_config_stats()
                
            self.monitor_data["performance_metrics"] = metrics
            
        except Exception as e:
            print(f"✗ 性能指标收集失败: {e}")
            
    def _refresh_config_view(self):
        """刷新配置视图"""
        try:
            # 在实际实现中，这里会更新配置视图的显示内容
            pass
        except Exception as e:
            print(f"✗ 配置视图刷新失败: {e}")
            
    def _refresh_property_panel(self):
        """刷新属性面板"""
        try:
            # 根据当前模式更新属性面板
            current_mode = self.editor_state["current_mode"]
            
            # 在实际实现中，这里会更新属性面板的显示内容
            pass
        except Exception as e:
            print(f"✗ 属性面板刷新失败: {e}")
            
    def _update_preview_panel(self):
        """更新预览面板"""
        try:
            current_time = time.time()
            if current_time - self.last_preview_update >= 0.1:  # 100ms
                # 更新预览数据
                self.editor_data["live_data"] = self._collect_live_data()
                
                # 在实际实现中，这里会更新预览面板的显示
                self.editor_stats["preview_updates"] += 1
                self.last_preview_update = current_time
                
        except Exception as e:
            print(f"✗ 预览面板更新失败: {e}")
            
    def _collect_live_data(self) -> Dict[str, Any]:
        """
        收集实时数据
        
        Returns:
            实时数据字典
        """
        try:
            live_data = {
                "timestamp": time.time(),
                "audio": {},
                "recognition": {},
                "synthesis": {},
                "commands": {},
                "performance": {}
            }
            
            # 收集音频数据
            if self.plugin.audio_manager:
                live_data["audio"] = {
                    "input_level": self.plugin.audio_manager.get_audio_level("input"),
                    "output_level": self.plugin.audio_manager.get_audio_level("output"),
                    "is_recording": self.plugin.audio_manager.is_recording(),
                    "is_playing": self.plugin.audio_manager.is_playing()
                }
                
            # 收集识别数据
            if self.plugin.voice_manager:
                live_data["recognition"] = self.plugin.voice_manager.get_recognition_state()
                
            # 收集合成数据
            if self.plugin.voice_manager:
                live_data["synthesis"] = self.plugin.voice_manager.get_synthesis_state()
                
            # 收集命令数据
            if self.plugin.command_processor:
                live_data["commands"] = {
                    "history": self.plugin.command_processor.get_command_history()[-10:]  # 最近10条
                }
                
            # 收集性能数据
            live_data["performance"] = self._collect_performance_metrics()
                
            return live_data
            
        except Exception as e:
            print(f"✗ 实时数据收集失败: {e}")
            return {}
            
    def _update_status_bar(self):
        """更新状态栏"""
        try:
            # 在实际实现中，这里会更新状态栏的显示内容
            pass
        except Exception as e:
            print(f"✗ 状态栏更新失败: {e}")
            
    def set_editor_mode(self, mode: str) -> bool:
        """
        设置编辑器模式
        
        Args:
            mode: 编辑器模式
            
        Returns:
            是否设置成功
        """
        try:
            old_mode = self.editor_state["current_mode"]
            self.editor_state["current_mode"] = mode
            
            # 触发模式变更回调
            self._trigger_editor_callback("mode_changed", {
                "old_mode": old_mode,
                "new_mode": mode
            })
            
            print(f"✓ 编辑器模式已设置: {mode}")
            return True
            
        except Exception as e:
            print(f"✗ 编辑器模式设置失败: {e}")
            return False
            
    def set_selected_tab(self, tab: str) -> bool:
        """
        设置选中标签页
        
        Args:
            tab: 标签页名称
            
        Returns:
            是否设置成功
        """
        try:
            old_tab = self.editor_state["selected_tab"]
            self.editor_state["selected_tab"] = tab
            
            # 触发标签页变更回调
            self._trigger_editor_callback("tab_changed", {
                "old_tab": old_tab,
                "new_tab": tab
            })
            
            print(f"✓ 选中标签页已设置: {tab}")
            return True
            
        except Exception as e:
            print(f"✗ 选中标签页设置失败: {e}")
            return False
            
    def start_recording(self) -> bool:
        """
        开始录制
        
        Returns:
            是否开始成功
        """
        try:
            if not self.plugin.audio_manager:
                print("✗ 音频管理器未初始化")
                return False
                
            if self.plugin.audio_manager.start_recording():
                self.editor_state["is_recording"] = True
                
                # 触发录制开始回调
                self._trigger_editor_callback("recording_started", {
                    "timestamp": time.time()
                })
                
                print("✓ 录制已开始")
                return True
            else:
                print("✗ 录制开始失败")
                return False
                
        except Exception as e:
            print(f"✗ 录制开始失败: {e}")
            return False
            
    def stop_recording(self) -> bool:
        """
        停止录制
        
        Returns:
            是否停止成功
        """
        try:
            if not self.plugin.audio_manager:
                print("✗ 音频管理器未初始化")
                return False
                
            if self.plugin.audio_manager.stop_recording():
                self.editor_state["is_recording"] = False
                
                # 触发录制停止回调
                self._trigger_editor_callback("recording_stopped", {
                    "timestamp": time.time()
                })
                
                print("✓ 录制已停止")
                return True
            else:
                print("✗ 录制停止失败")
                return False
                
        except Exception as e:
            print(f"✗ 录制停止失败: {e}")
            return False
            
    def start_testing(self, test_case: Dict[str, Any] = None) -> bool:
        """
        开始测试
        
        Args:
            test_case: 测试用例
            
        Returns:
            是否开始成功
        """
        try:
            self.editor_state["is_testing"] = True
            
            # 添加到测试历史
            if test_case:
                self.test_data["current_test"] = test_case
                self.test_data["test_cases"].append(test_case)
                
            # 触发测试开始回调
            self._trigger_editor_callback("test_started", {
                "test_case": test_case,
                "timestamp": time.time()
            })
            
            self.editor_stats["tests_run"] += 1
            print("✓ 测试已开始")
            return True
            
        except Exception as e:
            print(f"✗ 测试开始失败: {e}")
            return False
            
    def stop_testing(self) -> bool:
        """
        停止测试
        
        Returns:
            是否停止成功
        """
        try:
            self.editor_state["is_testing"] = False
            
            # 记录测试结果
            if self.test_data["current_test"]:
                test_result = {
                    "test_case": self.test_data["current_test"],
                    "end_time": time.time(),
                    "status": "completed"
                }
                self.test_data["test_results"].append(test_result)
                self.test_data["current_test"] = None
                
            # 触发测试完成回调
            self._trigger_editor_callback("test_completed", {
                "timestamp": time.time()
            })
            
            print("✓ 测试已停止")
            return True
            
        except Exception as e:
            print(f"✗ 测试停止失败: {e}")
            return False
            
    def test_speech_recognition(self, audio_file: str = None) -> bool:
        """
        测试语音识别
        
        Args:
            audio_file: 音频文件路径（None表示使用麦克风输入）
            
        Returns:
            是否测试成功
        """
        try:
            print("✓ 语音识别测试已开始")
            
            # 在实际实现中，这里会执行语音识别测试
            # 可能包括加载音频文件、执行识别、验证结果等
            
            # 添加到测试历史
            test_entry = {
                "type": "speech_recognition",
                "audio_file": audio_file,
                "start_time": time.time(),
                "parameters": {
                    "language": self.plugin.config_manager.get_config("recognition", "language", "zh-CN") if self.plugin.config_manager else "zh-CN"
                }
            }
            
            self.editor_data["test_history"].append(test_entry)
            
            return True
            
        except Exception as e:
            print(f"✗ 语音识别测试失败: {e}")
            return False
            
    def test_speech_synthesis(self, text: str, language: str = None) -> bool:
        """
        测试语音合成
        
        Args:
            text: 要合成的文本
            language: 语言代码
            
        Returns:
            是否测试成功
        """
        try:
            if not self.plugin.speech_synthesizer:
                print("✗ 语音合成器未初始化")
                return False
                
            if not language:
                language = self.plugin.config_manager.get_config("synthesis", "language", "zh-CN") if self.plugin.config_manager else "zh-CN"
                
            print(f"✓ 语音合成测试已开始: '{text}'")
            
            # 执行语音合成
            result = self.plugin.speech_synthesizer.synthesize_speech(
                text, 
                blocking=False,
                speed=self.plugin.config_manager.get_config("synthesis", "speed", 1.0) if self.plugin.config_manager else 1.0,
                volume=self.plugin.config_manager.get_config("synthesis", "volume", 1.0) if self.plugin.config_manager else 1.0
            )
            
            # 添加到测试历史
            test_entry = {
                "type": "speech_synthesis",
                "text": text,
                "language": language,
                "start_time": time.time(),
                "success": result,
                "parameters": {
                    "speed": self.plugin.config_manager.get_config("synthesis", "speed", 1.0) if self.plugin.config_manager else 1.0,
                    "volume": self.plugin.config_manager.get_config("synthesis", "volume", 1.0) if self.plugin.config_manager else 1.0
                }
            }
            
            self.editor_data["test_history"].append(test_entry)
            
            return result
            
        except Exception as e:
            print(f"✗ 语音合成测试失败: {e}")
            return False
            
    def test_command_execution(self, command_text: str) -> bool:
        """
        测试命令执行
        
        Args:
            command_text: 命令文本
            
        Returns:
            是否测试成功
        """
        try:
            if not self.plugin.command_processor:
                print("✗ 命令处理器未初始化")
                return False
                
            print(f"✓ 命令执行测试已开始: '{command_text}'")
            
            # 执行命令处理
            result = self.plugin.command_processor.process_command(command_text, 1.0)
            
            # 添加到测试历史
            test_entry = {
                "type": "command_execution",
                "command": command_text,
                "start_time": time.time(),
                "success": result
            }
            
            self.editor_data["test_history"].append(test_entry)
            
            return result
            
        except Exception as e:
            print(f"✗ 命令执行测试失败: {e}")
            return False
            
    def toggle_preview(self, enable: bool = None) -> bool:
        """
        切换预览
        
        Args:
            enable: 是否启用预览（None表示切换）
            
        Returns:
            是否切换成功
        """
        try:
            if enable is None:
                enable = not self.editor_state["preview_active"]
                
            self.editor_state["preview_active"] = enable
            self.editor_config["enable_preview"] = enable
            
            status = "启用" if enable else "禁用"
            print(f"✓ 预览已{status}")
            return True
            
        except Exception as e:
            print(f"✗ 预览切换失败: {e}")
            return False
            
    def toggle_monitoring(self, enable: bool = None) -> bool:
        """
        切换监控
        
        Args:
            enable: 是否启用监控（None表示切换）
            
        Returns:
            是否切换成功
        """
        try:
            if enable is None:
                enable = not self.editor_state["monitoring_active"]
                
            self.editor_state["monitoring_active"] = enable
            
            status = "启用" if enable else "禁用"
            print(f"✓ 监控已{status}")
            return True
            
        except Exception as e:
            print(f"✗ 监控切换失败: {e}")
            return False
            
    def undo_operation(self) -> bool:
        """
        撤销操作
        
        Returns:
            是否撤销成功
        """
        try:
            if self.history_pointer >= 0 and self.operation_history:
                # 执行撤销操作
                operation = self.operation_history[self.history_pointer]
                self.history_pointer -= 1
                self.editor_stats["undo_operations"] += 1
                
                print("✓ 操作已撤销")
                return True
            else:
                print("⚠ 没有可撤销的操作")
                return False
                
        except Exception as e:
            print(f"✗ 操作撤销失败: {e}")
            return False
            
    def redo_operation(self) -> bool:
        """
        重做操作
        
        Returns:
            是否重做成功
        """
        try:
            if self.history_pointer < len(self.operation_history) - 1:
                # 执行重做操作
                self.history_pointer += 1
                operation = self.operation_history[self.history_pointer]
                self.editor_stats["redo_operations"] += 1
                
                print("✓ 操作已重做")
                return True
            else:
                print("⚠ 没有可重做的操作")
                return False
                
        except Exception as e:
            print(f"✗ 操作重做失败: {e}")
            return False
            
    def add_operation_to_history(self, operation: Dict[str, Any]):
        """
        添加操作到历史
        
        Args:
            operation: 操作数据
        """
        try:
            # 添加到历史记录
            self.operation_history.append(operation)
            self.history_pointer = len(self.operation_history) - 1
            
            # 保持历史记录大小
            if len(self.operation_history) > self.max_history_size:
                remove_count = len(self.operation_history) - self.max_history_size
                self.operation_history = self.operation_history[remove_count:]
                self.history_pointer -= remove_count
                self.history_pointer = max(0, self.history_pointer)
                
            self.editor_stats["operations_performed"] += 1
            
        except Exception as e:
            print(f"✗ 操作添加到历史失败: {e}")
            
    def _trigger_editor_callback(self, callback_type: str, data: Dict[str, Any]):
        """
        触发编辑器回调
        
        Args:
            callback_type: 回调类型
            data: 回调数据
        """
        try:
            if callback_type in self.editor_callbacks:
                for callback in self.editor_callbacks[callback_type]:
                    try:
                        callback(data)
                    except Exception as e:
                        print(f"✗ 编辑器回调执行失败: {e}")
        except Exception as e:
            print(f"✗ 编辑器回调触发失败: {e}")
            
    def register_editor_callback(self, callback_type: str, callback: callable):
        """
        注册编辑器回调
        
        Args:
            callback_type: 回调类型
            callback: 回调函数
        """
        try:
            if callback_type in self.editor_callbacks:
                self.editor_callbacks[callback_type].append(callback)
                print(f"✓ 编辑器回调已注册: {callback_type}")
            else:
                print(f"✗ 无效的回调类型: {callback_type}")
        except Exception as e:
            print(f"✗ 编辑器回调注册失败: {e}")
            
    def unregister_editor_callback(self, callback_type: str, callback: callable):
        """
        注销编辑器回调
        
        Args:
            callback_type: 回调类型
            callback: 回调函数
        """
        try:
            if callback_type in self.editor_callbacks:
                if callback in self.editor_callbacks[callback_type]:
                    self.editor_callbacks[callback_type].remove(callback)
                    print(f"✓ 编辑器回调已注销: {callback_type}")
        except Exception as e:
            print(f"✗ 编辑器回调注销失败: {e}")
            
    def get_editor_state(self) -> Dict[str, Any]:
        """
        获取编辑器状态
        
        Returns:
            编辑器状态字典
        """
        return self.editor_state.copy()
        
    def get_editor_config(self) -> Dict[str, Any]:
        """
        获取编辑器配置
        
        Returns:
            编辑器配置字典
        """
        return self.editor_config.copy()
        
    def set_editor_config(self, config: Dict[str, Any]) -> bool:
        """
        设置编辑器配置
        
        Args:
            config: 编辑器配置字典
            
        Returns:
            是否设置成功
        """
        try:
            self.editor_config.update(config)
            print(f"✓ 编辑器配置已更新: {self.editor_config}")
            return True
        except Exception as e:
            print(f"✗ 编辑器配置设置失败: {e}")
            return False
            
    def get_editor_data(self, data_type: str) -> Optional[Dict[str, Any]]:
        """
        获取编辑器数据
        
        Args:
            data_type: 数据类型
            
        Returns:
            数据字典或None
        """
        return self.editor_data.get(data_type)
        
    def get_monitor_data(self) -> Dict[str, Any]:
        """
        获取监控数据
        
        Returns:
            监控数据字典
        """
        return self.monitor_data.copy()
        
    def get_test_data(self) -> Dict[str, Any]:
        """
        获取测试数据
        
        Returns:
            测试数据字典
        """
        return self.test_data.copy()
        
    def get_editor_stats(self) -> Dict[str, int]:
        """
        获取编辑器统计信息
        
        Returns:
            编辑器统计字典
        """
        return self.editor_stats.copy()
        
    def reset_editor_stats(self):
        """重置编辑器统计信息"""
        try:
            self.editor_stats = {
                "windows_opened": 0,
                "operations_performed": 0,
                "undo_operations": 0,
                "redo_operations": 0,
                "data_refreshed": 0,
                "preview_updates": 0,
                "tests_run": 0
            }
            print("✓ 编辑器统计信息已重置")
        except Exception as e:
            print(f"✗ 编辑器统计信息重置失败: {e}")
            
    def refresh_editor_data(self):
        """刷新编辑器数据"""
        try:
            self._load_editor_cache()
            self._update_editor_display()
            print("✓ 编辑器数据已刷新")
        except Exception as e:
            print(f"✗ 编辑器数据刷新失败: {e}")
            
    def show_editor_window(self) -> bool:
        """
        显示编辑器窗口
        
        Returns:
            是否显示成功
        """
        try:
            # 在实际实现中，这里会显示实际的编辑器窗口
            self.editor_stats["windows_opened"] += 1
            print("✓ 编辑器窗口已显示")
            return True
        except Exception as e:
            print(f"✗ 编辑器窗口显示失败: {e}")
            return False
            
    def hide_editor_window(self) -> bool:
        """
        隐藏编辑器窗口
        
        Returns:
            是否隐藏成功
        """
        try:
            # 在实际实现中，这里会隐藏实际的编辑器窗口
            print("✓ 编辑器窗口已隐藏")
            return True
        except Exception as e:
            print(f"✗ 编辑器窗口隐藏失败: {e}")
            return False
            
    def export_editor_data(self, file_path: str) -> bool:
        """
        导出编辑器数据
        
        Args:
            file_path: 导出文件路径
            
        Returns:
            是否导出成功
        """
        try:
            # 在实际实现中，这里会导出编辑器数据到文件
            print(f"✓ 编辑器数据已导出: {file_path}")
            return True
        except Exception as e:
            print(f"✗ 编辑器数据导出失败: {e}")
            return False
            
    def import_editor_data(self, file_path: str) -> bool:
        """
        导入编辑器数据
        
        Args:
            file_path: 导入文件路径
            
        Returns:
            是否导入成功
        """
        try:
            # 在实际实现中，这里会从文件导入编辑器数据
            print(f"✓ 编辑器数据已导入: {file_path}")
            return True
        except Exception as e:
            print(f"✗ 编辑器数据导入失败: {e}")
            return False
            
    def run_comprehensive_test(self) -> Dict[str, Any]:
        """
        运行综合测试
        
        Returns:
            测试结果字典
        """
        try:
            print("✓ 开始综合测试...")
            
            test_results = {
                "timestamp": time.time(),
                "tests": {},
                "summary": {
                    "total_tests": 0,
                    "passed_tests": 0,
                    "failed_tests": 0,
                    "success_rate": 0.0
                }
            }
            
            # 测试语音识别
            test_results["tests"]["speech_recognition"] = {
                "status": "passed" if self.test_speech_recognition() else "failed",
                "details": "语音识别功能测试"
            }
            
            # 测试语音合成
            test_results["tests"]["speech_synthesis"] = {
                "status": "passed" if self.test_speech_synthesis("测试语音合成功能") else "failed",
                "details": "语音合成功能测试"
            }
            
            # 测试命令执行
            test_results["tests"]["command_execution"] = {
                "status": "passed" if self.test_command_execution("前进") else "failed",
                "details": "命令执行功能测试"
            }
            
            # 统计结果
            total_tests = len(test_results["tests"])
            passed_tests = sum(1 for test in test_results["tests"].values() if test["status"] == "passed")
            
            test_results["summary"]["total_tests"] = total_tests
            test_results["summary"]["passed_tests"] = passed_tests
            test_results["summary"]["failed_tests"] = total_tests - passed_tests
            test_results["summary"]["success_rate"] = passed_tests / total_tests if total_tests > 0 else 0.0
            
            print(f"✓ 综合测试完成: {passed_tests}/{total_tests} 通过")
            return test_results
            
        except Exception as e:
            print(f"✗ 综合测试失败: {e}")
            import traceback
            traceback.print_exc()
            return {
                "timestamp": time.time(),
                "tests": {},
                "summary": {
                    "total_tests": 0,
                    "passed_tests": 0,
                    "failed_tests": 0,
                    "success_rate": 0.0,
                    "error": str(e)
                }
            }