/**
 * 全局事件管理器
 * 统一管理所有事件处理器，提供事件路由、分发、监控和调试功能
 */

import { eventBus } from '../eventBus.js';
import { panelHandler, PANEL_EVENT_TYPES, panelActions } from './PanelHandler.js';
import tabPageHandler, { TABPAGE_EVENT_TYPES, tabPageActions } from './TabPageHandler.js';
import areaHandler, { AREA_EVENT_TYPES, areaActions } from './AreaHandler.js';

// 全局事件类型常量
export const GLOBAL_EVENT_TYPES = {
  // 系统级事件
  SYSTEM_INIT: 'system.init',
  SYSTEM_READY: 'system.ready',
  SYSTEM_DESTROY: 'system.destroy',
  SYSTEM_ERROR: 'system.error',
  SYSTEM_PERFORMANCE: 'system.performance',
  
  // 事件路由
  EVENT_ROUTE_START: 'event.route.start',
  EVENT_ROUTE_SUCCESS: 'event.route.success',
  EVENT_ROUTE_ERROR: 'event.route.error',
  EVENT_ROUTE_FALLBACK: 'event.route.fallback',
  
  // 跨组件通信
  CROSS_COMPONENT_BROADCAST: 'cross.component.broadcast',
  CROSS_COMPONENT_REQUEST: 'cross.component.request',
  CROSS_COMPONENT_RESPONSE: 'cross.component.response',
  
  // 事件链
  EVENT_CHAIN_START: 'event.chain.start',
  EVENT_CHAIN_PROGRESS: 'event.chain.progress',
  EVENT_CHAIN_COMPLETE: 'event.chain.complete',
  EVENT_CHAIN_ERROR: 'event.chain.error',
  
  // 性能监控
  PERFORMANCE_MONITOR_START: 'performance.monitor.start',
  PERFORMANCE_MONITOR_END: 'performance.monitor.end',
  PERFORMANCE_THRESHOLD_EXCEEDED: 'performance.threshold.exceeded',
  
  // 调试和日志
  DEBUG_EVENT_EMIT: 'debug.event.emit',
  DEBUG_EVENT_HANDLE: 'debug.event.handle',
  DEBUG_PERFORMANCE: 'debug.performance',
  DEBUG_MEMORY: 'debug.memory'
};

// 事件路由配置
const EVENT_ROUTES = {
  // Panel事件路由
  [PANEL_EVENT_TYPES.PANEL_DRAG_START]: {
    handlers: ['panelHandler', 'areaHandler'],
    priority: 1,
    timeout: 5000
  },
  [PANEL_EVENT_TYPES.PANEL_MAXIMIZE]: {
    handlers: ['panelHandler', 'areaHandler'],
    priority: 1,
    timeout: 3000
  },
  [PANEL_EVENT_TYPES.PANEL_CLOSE_REQUEST]: {
    handlers: ['panelHandler', 'tabPageHandler'],
    priority: 2,
    timeout: 5000
  },
  
  // TabPage事件路由
  [TABPAGE_EVENT_TYPES.TABPAGE_DRAG_START]: {
    handlers: ['tabPageHandler', 'areaHandler'],
    priority: 1,
    timeout: 5000
  },
  [TABPAGE_EVENT_TYPES.TABPAGE_SWITCH]: {
    handlers: ['tabPageHandler', 'panelHandler'],
    priority: 2,
    timeout: 3000
  },
  [TABPAGE_EVENT_TYPES.TABPAGE_CLOSE_REQUEST]: {
    handlers: ['tabPageHandler', 'panelHandler'],
    priority: 2,
    timeout: 5000
  },
  
  // Area事件路由
  [AREA_EVENT_TYPES.AREA_DRAG_START]: {
    handlers: ['areaHandler', 'tabPageHandler'],
    priority: 1,
    timeout: 5000
  },
  [AREA_EVENT_TYPES.AREA_MERGE]: {
    handlers: ['areaHandler', 'tabPageHandler', 'panelHandler'],
    priority: 1,
    timeout: 10000
  },
  [AREA_EVENT_TYPES.AREA_DOCK_CENTER]: {
    handlers: ['areaHandler', 'tabPageHandler'],
    priority: 1,
    timeout: 8000
  }
};

// 事件执行监控
class EventExecutionMonitor {
  constructor() {
    this.executionMap = new Map();
    this.performanceHistory = [];
    this.errorHistory = [];
    this.maxHistorySize = 200;
  }

  /**
   * 开始事件监控
   * @param {string} eventId - 事件ID
   * @param {Object} eventData - 事件数据
   */
  startMonitoring(eventId, eventData) {
    const execution = {
      eventId,
      eventType: eventData.eventType || eventData.type,
      startTime: Date.now(),
      handlers: [],
      status: 'running',
      eventData: { ...eventData }
    };
    
    this.executionMap.set(eventId, execution);
    return execution;
  }

  /**
   * 记录处理器开始
   * @param {string} eventId - 事件ID
   * @param {string} handlerName - 处理器名称
   */
  recordHandlerStart(eventId, handlerName) {
    const execution = this.executionMap.get(eventId);
    if (execution) {
      execution.handlers.push({
        name: handlerName,
        startTime: Date.now(),
        status: 'running'
      });
    }
  }

  /**
   * 记录处理器完成
   * @param {string} eventId - 事件ID
   * @param {string} handlerName - 处理器名称
   * @param {boolean} success - 是否成功
   * @param {number} duration - 执行时长
   * @param {Error} error - 错误信息
   */
  recordHandlerComplete(eventId, handlerName, success, duration, error = null) {
    const execution = this.executionMap.get(eventId);
    if (execution) {
      const handler = execution.handlers.find(h => h.name === handlerName);
      if (handler) {
        handler.endTime = Date.now();
        handler.duration = duration;
        handler.status = success ? 'completed' : 'error';
        handler.error = error;
      }
    }
  }

  /**
   * 完成事件监控
   * @param {string} eventId - 事件ID
   */
  completeMonitoring(eventId) {
    const execution = this.executionMap.get(eventId);
    if (execution) {
      execution.endTime = Date.now();
      execution.status = 'completed';
      execution.totalDuration = execution.endTime - execution.startTime;
      
      // 记录性能历史
      this.performanceHistory.push({
        eventId,
        eventType: execution.eventType,
        totalDuration: execution.totalDuration,
        handlerCount: execution.handlers.length,
        timestamp: Date.now()
      });
      
      // 限制历史大小
      if (this.performanceHistory.length > this.maxHistorySize) {
        this.performanceHistory.shift();
      }
      
      // 检查性能阈值
      if (execution.totalDuration > 1000) { // 超过1秒
        eventBus.emit(GLOBAL_EVENT_TYPES.PERFORMANCE_THRESHOLD_EXCEEDED, {
          eventId,
          eventType: execution.eventType,
          duration: execution.totalDuration,
          threshold: 1000
        });
      }
    }
    
    return execution;
  }

  /**
   * 记录错误
   * @param {string} eventId - 事件ID
   * @param {Error} error - 错误信息
   */
  recordError(eventId, error) {
    const execution = this.executionMap.get(eventId);
    if (execution) {
      execution.status = 'error';
      execution.error = error;
      execution.endTime = Date.now();
      execution.totalDuration = execution.endTime - execution.startTime;
      
      // 记录错误历史
      this.errorHistory.push({
        eventId,
        eventType: execution.eventType,
        error: error.message,
        stack: error.stack,
        timestamp: Date.now()
      });
      
      // 限制错误历史大小
      if (this.errorHistory.length > this.maxHistorySize) {
        this.errorHistory.shift();
      }
    }
  }

  /**
   * 获取执行统计
   * @returns {Object} 执行统计
   */
  getExecutionStats() {
    const running = Array.from(this.executionMap.values()).filter(e => e.status === 'running');
    const completed = Array.from(this.executionMap.values()).filter(e => e.status === 'completed');
    const errors = Array.from(this.executionMap.values()).filter(e => e.status === 'error');
    
    return {
      running: running.length,
      completed: completed.length,
      errors: errors.length,
      total: this.executionMap.size,
      averageDuration: completed.length > 0 ? 
        completed.reduce((sum, e) => sum + e.totalDuration, 0) / completed.length : 0,
      recentPerformance: this.performanceHistory.slice(-10),
      recentErrors: this.errorHistory.slice(-10)
    };
  }

  /**
   * 获取事件执行详情
   * @param {string} eventId - 事件ID
   * @returns {Object} 执行详情
   */
  getExecutionDetail(eventId) {
    return this.executionMap.get(eventId);
  }

  /**
   * 清理过期记录
   * @param {number} maxAge - 最大年龄（毫秒）
   */
  cleanup(maxAge = 3600000) { // 1小时
    const now = Date.now();
    
    this.performanceHistory = this.performanceHistory.filter(record => 
      (now - record.timestamp) < maxAge);
    
    this.errorHistory = this.errorHistory.filter(record => 
      (now - record.timestamp) < maxAge);
    
    // 清理已完成的执行记录
    Array.from(this.executionMap.entries()).forEach(([eventId, execution]) => {
      if (execution.status !== 'running' && (now - execution.endTime) > maxAge) {
        this.executionMap.delete(eventId);
      }
    });
  }
}

/**
 * 全局事件管理器类
 */
class GlobalEventManager {
  constructor() {
    this.eventHandlers = new Map();
    this.eventRoutes = new Map(Object.entries(EVENT_ROUTES));
    this.executionMonitor = new EventExecutionMonitor();
    this.eventChains = new Map();
    this.crossComponentChannels = new Map();
    this.isInitialized = false;
    this.debugMode = false;
    
    // 处理器映射
    this.handlerMap = {
      panelHandler,
      tabPageHandler,
      areaHandler
    };
    
    // 绑定方法
    this._onGlobalEvent = this._onGlobalEvent.bind(this);
    this._onSystemError = this._handleSystemError.bind(this);
    this._cleanupExpiredData = this._cleanupExpiredData.bind(this);
    
    this._initialize();
  }

  /**
   * 初始化事件管理器
   */
  _initialize() {
    // 注册全局事件监听器
    this._registerGlobalEventListeners();
    
    // 启动定期清理
    this._startCleanupScheduler();
    
    // 启动调试模式监听
    this._startDebugMode();
    
    this.isInitialized = true;
    console.log('✅ 全局事件管理器初始化完成');
    
    // 触发系统就绪事件
    eventBus.emit(GLOBAL_EVENT_TYPES.SYSTEM_READY, {
      manager: 'globalEventManager',
      timestamp: Date.now(),
      handlers: Object.keys(this.handlerMap)
    });
  }

  /**
   * 注册全局事件监听器
   */
  _registerGlobalEventListeners() {
    const globalEvents = Object.values(GLOBAL_EVENT_TYPES);
    globalEvents.forEach(eventType => {
      eventBus.on(eventType, this._onGlobalEvent, { 
        priority: 0, // 最高优先级
        deduplication: { type: 'TTL_BASED', ttl: 50 }
      });
    });
    
    // 注册所有组件事件监听器
    this._registerComponentEventListeners();
  }

  /**
   * 注册组件事件监听器
   */
  _registerComponentEventListeners() {
    // Panel事件监听
    Object.values(PANEL_EVENT_TYPES).forEach(eventType => {
      eventBus.on(eventType, (data) => {
        this._routeEvent(eventType, data, 'panel');
      }, { priority: 1 });
    });
    
    // TabPage事件监听
    Object.values(TABPAGE_EVENT_TYPES).forEach(eventType => {
      eventBus.on(eventType, (data) => {
        this._routeEvent(eventType, data, 'tabPage');
      }, { priority: 1 });
    });
    
    // Area事件监听
    Object.values(AREA_EVENT_TYPES).forEach(eventType => {
      eventBus.on(eventType, (data) => {
        this._routeEvent(eventType, data, 'area');
      }, { priority: 1 });
    });
  }

  /**
   * 路由事件到相应的处理器
   * @param {string} eventType - 事件类型
   * @param {Object} eventData - 事件数据
   * @param {string} source - 事件源
   */
  async _routeEvent(eventType, eventData, source) {
    const eventId = `${eventType}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
    const routeConfig = this.eventRoutes.get(eventType);
    
    // 开始监控
    this.executionMonitor.startMonitoring(eventId, { ...eventData, eventType });
    
    eventBus.emit(GLOBAL_EVENT_TYPES.EVENT_ROUTE_START, {
      eventId,
      eventType,
      source,
      routeConfig
    });
    
    try {
      if (routeConfig) {
        // 使用配置的路由
        await this._executeRoutedHandlers(eventId, eventType, eventData, routeConfig);
      } else {
        // 默认路由到相应组件处理器
        await this._executeDefaultHandler(eventId, eventType, eventData, source);
      }
      
      // 完成监控
      this.executionMonitor.completeMonitoring(eventId);
      
      eventBus.emit(GLOBAL_EVENT_TYPES.EVENT_ROUTE_SUCCESS, {
        eventId,
        eventType,
        source,
        timestamp: Date.now()
      });
      
    } catch (error) {
      // 记录错误
      this.executionMonitor.recordError(eventId, error);
      
      eventBus.emit(GLOBAL_EVENT_TYPES.EVENT_ROUTE_ERROR, {
        eventId,
        eventType,
        source,
        error: error.message,
        timestamp: Date.now()
      });
      
      // 触发系统错误事件
      eventBus.emit(GLOBAL_EVENT_TYPES.SYSTEM_ERROR, {
        eventId,
        eventType,
        source,
        error,
        timestamp: Date.now()
      });
    }
  }

  /**
   * 执行路由的处理器
   * @param {string} eventId - 事件ID
   * @param {string} eventType - 事件类型
   * @param {Object} eventData - 事件数据
   * @param {Object} routeConfig - 路由配置
   */
  async _executeRoutedHandlers(eventId, eventType, eventData, routeConfig) {
    const { handlers, priority, timeout = 5000 } = routeConfig;
    const handlerPromises = handlers.map(async (handlerName) => {
      const startTime = Date.now();
      this.executionMonitor.recordHandlerStart(eventId, handlerName);
      
      try {
        const handler = this.handlerMap[handlerName];
        if (!handler) {
          throw new Error(`Handler ${handlerName} not found`);
        }
        
        // 执行处理器
        const result = await this._executeHandlerWithTimeout(
          handler, 
          eventType, 
          eventData, 
          timeout
        );
        
        const duration = Date.now() - startTime;
        this.executionMonitor.recordHandlerComplete(eventId, handlerName, true, duration);
        
        return { handlerName, result, duration };
        
      } catch (error) {
        const duration = Date.now() - startTime;
        this.executionMonitor.recordHandlerComplete(eventId, handlerName, false, duration, error);
        throw error;
      }
    });
    
    // 等待所有处理器完成
    const results = await Promise.allSettled(handlerPromises);
    
    // 检查是否有失败的处理器
    const failures = results.filter(result => result.status === 'rejected');
    if (failures.length > 0) {
      throw new Error(`Handler execution failed: ${failures.map(f => f.reason.message).join(', ')}`);
    }
    
    return results.map(result => result.value);
  }

  /**
   * 执行默认处理器
   * @param {string} eventId - 事件ID
   * @param {string} eventType - 事件类型
   * @param {Object} eventData - 事件数据
   * @param {string} source - 事件源
   */
  async _executeDefaultHandler(eventId, eventType, eventData, source) {
    const handlerName = `${source}Handler`;
    const handler = this.handlerMap[handlerName];
    
    if (!handler) {
      throw new Error(`Default handler ${handlerName} not found`);
    }
    
    this.executionMonitor.recordHandlerStart(eventId, handlerName);
    
    try {
      const result = await this._executeHandlerWithTimeout(handler, eventType, eventData, 5000);
      const duration = Date.now() - this.executionMonitor.getExecutionDetail(eventId).startTime;
      this.executionMonitor.recordHandlerComplete(eventId, handlerName, true, duration);
      return result;
    } catch (error) {
      const duration = Date.now() - this.executionMonitor.getExecutionDetail(eventId).startTime;
      this.executionMonitor.recordHandlerComplete(eventId, handlerName, false, duration, error);
      throw error;
    }
  }

  /**
   * 带超时的处理器执行
   * @param {Object} handler - 处理器对象
   * @param {string} eventType - 事件类型
   * @param {Object} eventData - 事件数据
   * @param {number} timeout - 超时时间
   * @returns {Promise} 执行结果
   */
  async _executeHandlerWithTimeout(handler, eventType, eventData, timeout) {
    return new Promise((resolve, reject) => {
      const timer = setTimeout(() => {
        reject(new Error(`Handler execution timeout after ${timeout}ms`));
      }, timeout);
      
      try {
        // 假设处理器有处理事件的方法
        if (typeof handler._onEvent === 'function') {
          const result = handler._onEvent({ eventType, ...eventData });
          if (result instanceof Promise) {
            result.then(resolve).catch(reject).finally(() => clearTimeout(timer));
          } else {
            resolve(result);
            clearTimeout(timer);
          }
        } else {
          // 如果处理器没有_onEvent方法，直接解析
          resolve(true);
          clearTimeout(timer);
        }
      } catch (error) {
        reject(error);
        clearTimeout(timer);
      }
    });
  }

  /**
   * 处理全局事件
   * @param {Object} data - 事件数据
   */
  async _onGlobalEvent(data) {
    const { eventType } = data;
    
    try {
      switch (eventType) {
        case GLOBAL_EVENT_TYPES.SYSTEM_INIT:
          await this._handleSystemInit(data);
          break;
        case GLOBAL_EVENT_TYPES.SYSTEM_ERROR:
          await this._handleSystemError(data);
          break;
        case GLOBAL_EVENT_TYPES.PERFORMANCE_THRESHOLD_EXCEEDED:
          await this._handlePerformanceThresholdExceeded(data);
          break;
        case GLOBAL_EVENT_TYPES.CROSS_COMPONENT_REQUEST:
          await this._handleCrossComponentRequest(data);
          break;
        default:
          if (this.debugMode) {
            console.log(`🌐 全局事件: ${eventType}`, data);
          }
      }
    } catch (error) {
      console.error(`❌ 全局事件处理错误 (${eventType}):`, error);
    }
  }

  /**
   * 处理系统初始化事件
   * @param {Object} data - 事件数据
   */
  async _handleSystemInit(data) {
    console.log('🚀 系统初始化开始...', data);
    
    // 检查所有处理器是否就绪
    const handlersStatus = {};
    for (const [name, handler] of Object.entries(this.handlerMap)) {
      handlersStatus[name] = {
        ready: typeof handler === 'object',
        methods: Object.getOwnPropertyNames(Object.getPrototypeOf(handler))
      };
    }
    
    eventBus.emit(GLOBAL_EVENT_TYPES.SYSTEM_READY, {
      manager: 'globalEventManager',
      handlersStatus,
      timestamp: Date.now()
    });
  }

  /**
   * 处理系统错误事件
   * @param {Object} data - 事件数据
   */
  async _handleSystemError(data) {
    console.error('💥 系统错误:', data);
    
    // 记录错误详情
    this.errorHistory = this.errorHistory || [];
    this.errorHistory.push({
      ...data,
      timestamp: Date.now(),
      type: 'system_error'
    });
    
    // 限制错误历史大小
    if (this.errorHistory.length > 100) {
      this.errorHistory.shift();
    }
  }

  /**
   * 处理性能阈值超限事件
   * @param {Object} data - 事件数据
   */
  async _handlePerformanceThresholdExceeded(data) {
    console.warn('⚡ 性能阈值超限:', data);
    
    // 可以在这里添加性能优化建议
    eventBus.emit(GLOBAL_EVENT_TYPES.DEBUG_PERFORMANCE, {
      type: 'threshold_exceeded',
      data,
      recommendations: this._generatePerformanceRecommendations(data),
      timestamp: Date.now()
    });
  }

  /**
   * 生成性能优化建议
   * @param {Object} performanceData - 性能数据
   * @returns {Array} 建议列表
   */
  _generatePerformanceRecommendations(performanceData) {
    const recommendations = [];
    
    if (performanceData.duration > 2000) {
      recommendations.push('考虑将长时间运行的操作分解为更小的任务');
      recommendations.push('检查是否有阻塞主线程的操作');
    }
    
    if (performanceData.handlerCount > 3) {
      recommendations.push('减少事件处理器的数量以提高性能');
    }
    
    return recommendations;
  }

  /**
   * 处理跨组件请求
   * @param {Object} data - 请求数据
   */
  async _handleCrossComponentRequest(data) {
    const { requestId, targetComponent, action, payload } = data;
    
    try {
      // 查找目标组件的处理器
      const handler = this.handlerMap[`${targetComponent}Handler`];
      if (!handler) {
        throw new Error(`Target component handler ${targetComponent}Handler not found`);
      }
      
      // 执行请求
      const result = await handler[action](payload);
      
      // 发送响应
      eventBus.emit(GLOBAL_EVENT_TYPES.CROSS_COMPONENT_RESPONSE, {
        requestId,
        targetComponent,
        action,
        result,
        success: true,
        timestamp: Date.now()
      });
      
    } catch (error) {
      // 发送错误响应
      eventBus.emit(GLOBAL_EVENT_TYPES.CROSS_COMPONENT_RESPONSE, {
        requestId,
        targetComponent,
        action,
        error: error.message,
        success: false,
        timestamp: Date.now()
      });
    }
  }

  /**
   * 启动调试模式
   */
  _startDebugMode() {
    // 监听调试命令
    eventBus.on('debug.toggle', () => {
      this.debugMode = !this.debugMode;
      console.log(`🔧 调试模式${this.debugMode ? '开启' : '关闭'}`);
    });
  }

  /**
   * 启动清理调度器
   */
  _startCleanupScheduler() {
    setInterval(() => {
      this._cleanupExpiredData();
    }, 60000); // 每分钟清理一次
  }

  /**
   * 清理过期数据
   */
  _cleanupExpiredData() {
    this.executionMonitor.cleanup();
    
    // 清理事件链
    const now = Date.now();
    Array.from(this.eventChains.entries()).forEach(([chainId, chain]) => {
      if (chain.status === 'completed' && (now - chain.endTime) > 300000) { // 5分钟
        this.eventChains.delete(chainId);
      }
    });
    
    // 清理跨组件频道
    this.crossComponentChannels.forEach((channel, channelId) => {
      if (channel.lastActivity && (now - channel.lastActivity) > 600000) { // 10分钟
        this.crossComponentChannels.delete(channelId);
      }
    });
  }

  /**
   * 启动性能监控
   * @param {string} operation - 操作名称
   * @returns {string} 监控ID
   */
  startPerformanceMonitor(operation) {
    const monitorId = `perf-${operation}-${Date.now()}`;
    
    eventBus.emit(GLOBAL_EVENT_TYPES.PERFORMANCE_MONITOR_START, {
      monitorId,
      operation,
      startTime: Date.now()
    });
    
    return monitorId;
  }

  /**
   * 结束性能监控
   * @param {string} monitorId - 监控ID
   * @param {Object} metadata - 元数据
   */
  endPerformanceMonitor(monitorId, metadata = {}) {
    eventBus.emit(GLOBAL_EVENT_TYPES.PERFORMANCE_MONITOR_END, {
      monitorId,
      endTime: Date.now(),
      metadata
    });
  }

  /**
   * 创建事件链
   * @param {string} chainName - 链名称
   * @param {Array} events - 事件列表
   * @returns {string} 链ID
   */
  createEventChain(chainName, events) {
    const chainId = `chain-${chainName}-${Date.now()}`;
    
    const chain = {
      id: chainId,
      name: chainName,
      events,
      currentIndex: 0,
      status: 'pending',
      startTime: Date.now(),
      results: []
    };
    
    this.eventChains.set(chainId, chain);
    
    // 触发链开始事件
    eventBus.emit(GLOBAL_EVENT_TYPES.EVENT_CHAIN_START, {
      chainId,
      chainName,
      eventCount: events.length
    });
    
    // 开始执行链
    this._executeEventChain(chainId);
    
    return chainId;
  }

  /**
   * 执行事件链
   * @param {string} chainId - 链ID
   */
  async _executeEventChain(chainId) {
    const chain = this.eventChains.get(chainId);
    if (!chain || chain.currentIndex >= chain.events.length) {
      this._completeEventChain(chainId);
      return;
    }
    
    const currentEvent = chain.events[chain.currentIndex];
    chain.status = 'running';
    
    try {
      // 触发进度事件
      eventBus.emit(GLOBAL_EVENT_TYPES.EVENT_CHAIN_PROGRESS, {
        chainId,
        currentIndex: chain.currentIndex,
        totalEvents: chain.events.length,
        currentEvent
      });
      
      // 执行当前事件
      const result = await this._executeSingleEvent(currentEvent);
      chain.results.push(result);
      
      // 移动到下一个事件
      chain.currentIndex++;
      
      // 继续执行链
      setTimeout(() => this._executeEventChain(chainId), 100);
      
    } catch (error) {
      chain.status = 'error';
      chain.error = error;
      
      eventBus.emit(GLOBAL_EVENT_TYPES.EVENT_CHAIN_ERROR, {
        chainId,
        error: error.message,
        currentIndex: chain.currentIndex
      });
    }
  }

  /**
   * 执行单个事件
   * @param {Object} event - 事件对象
   * @returns {Promise} 执行结果
   */
  async _executeSingleEvent(event) {
    const { type, data, delay = 0 } = event;
    
    if (delay > 0) {
      await new Promise(resolve => setTimeout(resolve, delay));
    }
    
    return new Promise((resolve, reject) => {
      eventBus.emit(type, {
        ...data,
        chainExecution: true,
        timestamp: Date.now()
      });
      
      // 简单的等待机制（在实际应用中可能需要更复杂的协调）
      setTimeout(() => resolve({ type, data, executedAt: Date.now() }), 100);
    });
  }

  /**
   * 完成事件链
   * @param {string} chainId - 链ID
   */
  _completeEventChain(chainId) {
    const chain = this.eventChains.get(chainId);
    if (chain) {
      chain.status = 'completed';
      chain.endTime = Date.now();
      chain.duration = chain.endTime - chain.startTime;
      
      eventBus.emit(GLOBAL_EVENT_TYPES.EVENT_CHAIN_COMPLETE, {
        chainId,
        chainName: chain.name,
        eventCount: chain.events.length,
        duration: chain.duration,
        results: chain.results
      });
    }
  }

  /**
   * 发送跨组件广播
   * @param {string} message - 消息内容
   * @param {Object} data - 附加数据
   * @param {Array} targetComponents - 目标组件列表
   */
  broadcast(message, data = {}, targetComponents = null) {
    eventBus.emit(GLOBAL_EVENT_TYPES.CROSS_COMPONENT_BROADCAST, {
      message,
      data,
      targetComponents,
      sender: 'globalEventManager',
      timestamp: Date.now()
    });
  }

  /**
   * 发送跨组件请求
   * @param {string} targetComponent - 目标组件
   * @param {string} action - 操作名称
   * @param {Object} payload - 请求数据
   * @returns {Promise} 响应Promise
   */
  request(targetComponent, action, payload) {
    const requestId = `req-${targetComponent}-${action}-${Date.now()}`;
    
    return new Promise((resolve, reject) => {
      // 设置响应处理器
      const responseHandler = (responseData) => {
        if (responseData.requestId === requestId) {
          eventBus.off(GLOBAL_EVENT_TYPES.CROSS_COMPONENT_RESPONSE, responseHandler);
          
          if (responseData.success) {
            resolve(responseData);
          } else {
            reject(new Error(responseData.error));
          }
        }
      };
      
      eventBus.on(GLOBAL_EVENT_TYPES.CROSS_COMPONENT_RESPONSE, responseHandler);
      
      // 发送请求
      eventBus.emit(GLOBAL_EVENT_TYPES.CROSS_COMPONENT_REQUEST, {
        requestId,
        targetComponent,
        action,
        payload,
        timestamp: Date.now()
      });
      
      // 设置超时
      setTimeout(() => {
        eventBus.off(GLOBAL_EVENT_TYPES.CROSS_COMPONENT_RESPONSE, responseHandler);
        reject(new Error(`Request timeout: ${targetComponent}.${action}`));
      }, 10000);
    });
  }

  /**
   * 获取执行统计
   * @returns {Object} 执行统计
   */
  getExecutionStats() {
    return {
      ...this.executionMonitor.getExecutionStats(),
      eventChains: this.eventChains.size,
      crossComponentChannels: this.crossComponentChannels.size,
      debugMode: this.debugMode,
      initialized: this.isInitialized
    };
  }

  /**
   * 获取事件链状态
   * @returns {Array} 事件链状态列表
   */
  getEventChainStatus() {
    return Array.from(this.eventChains.values()).map(chain => ({
      id: chain.id,
      name: chain.name,
      status: chain.status,
      progress: chain.events.length > 0 ? (chain.currentIndex / chain.events.length) * 100 : 0,
      duration: chain.endTime ? chain.duration : Date.now() - chain.startTime
    }));
  }

  /**
   * 销毁事件管理器
   */
  destroy() {
    // 清理所有事件监听器
    const globalEvents = Object.values(GLOBAL_EVENT_TYPES);
    globalEvents.forEach(eventType => {
      eventBus.off(eventType, this._onGlobalEvent);
    });
    
    // 销毁各个处理器
    Object.values(this.handlerMap).forEach(handler => {
      if (typeof handler.destroy === 'function') {
        handler.destroy();
      }
    });
    
    // 清理数据
    this.eventHandlers.clear();
    this.eventChains.clear();
    this.crossComponentChannels.clear();
    
    this.isInitialized = false;
    console.log('🗑️ 全局事件管理器已销毁');
  }
}

// 创建单例实例
const globalEventManager = new GlobalEventManager();

// 全局便捷API
export const globalEventActions = {
  /**
   * 启动性能监控
   * @param {string} operation - 操作名称
   * @returns {string} 监控ID
   */
  startMonitor: (operation) => {
    return globalEventManager.startPerformanceMonitor(operation);
  },

  /**
   * 结束性能监控
   * @param {string} monitorId - 监控ID
   * @param {Object} metadata - 元数据
   */
  endMonitor: (monitorId, metadata = {}) => {
    globalEventManager.endPerformanceMonitor(monitorId, metadata);
  },

  /**
   * 创建事件链
   * @param {string} chainName - 链名称
   * @param {Array} events - 事件列表
   * @returns {string} 链ID
   */
  createChain: (chainName, events) => {
    return globalEventManager.createEventChain(chainName, events);
  },

  /**
   * 发送跨组件广播
   * @param {string} message - 消息
   * @param {Object} data - 数据
   * @param {Array} targets - 目标组件
   */
  broadcast: (message, data = {}, targets = null) => {
    globalEventManager.broadcast(message, data, targets);
  },

  /**
   * 发送跨组件请求
   * @param {string} component - 组件名
   * @param {string} action - 操作
   * @param {Object} payload - 数据
   * @returns {Promise} 响应
   */
  request: (component, action, payload) => {
    return globalEventManager.request(component, action, payload);
  },

  /**
   * 切换调试模式
   */
  toggleDebug: () => {
    eventBus.emit('debug.toggle');
  },

  /**
   * 获取统计信息
   * @returns {Object} 统计信息
   */
  getStats: () => {
    return globalEventManager.getExecutionStats();
  },

  /**
   * 获取事件链状态
   * @returns {Array} 链状态
   */
  getChainStatus: () => {
    return globalEventManager.getEventChainStatus();
  }
};

// 导出事件管理器和相关API
export default globalEventManager;