function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
/**
 * 应用级事件总线
 * 提供高性能、类型安全、可观测的事件通信能力
 */ import { logger } from "../../utils";
/**
 * 应用事件总线
 */ export class AppEventBus {
    /**
   * 订阅事件
   * 
   * @param event - 事件名称
   * @param listener - 事件监听器
   * @param options - 监听器选项
   * @returns 取消订阅函数
   * 
   * @example
   * ```typescript
   * const unsubscribe = eventBus.on('user:login', (data, metadata) => {
   *   console.log('用户登录:', data);
   * });
   * 
   * // 取消订阅
   * unsubscribe();
   * ```
   */ on(event, listener, options = {}) {
        const fullEventName = this.getFullEventName(event);
        const listenerId = Symbol(`listener_${++this.listenerIdCounter}`);
        const listenerWithOptions = {
            listener: listener,
            options: {
                priority: options.priority ?? 100,
                once: options.once ?? false,
                namespace: options.namespace ?? this.config.namespacePrefix,
                async: options.async ?? true
            },
            id: listenerId
        };
        if (!this.listeners.has(fullEventName)) {
            this.listeners.set(fullEventName, new Set());
        }
        const listeners = this.listeners.get(fullEventName);
        listeners.add(listenerWithOptions);
        // 按优先级排序（数字越小优先级越高）
        const sortedListeners = Array.from(listeners).sort((a, b)=>a.options.priority - b.options.priority);
        this.listeners.set(fullEventName, new Set(sortedListeners));
        // 返回取消订阅函数
        return ()=>{
            const currentListeners = this.listeners.get(fullEventName);
            if (currentListeners) {
                currentListeners.delete(listenerWithOptions);
                if (currentListeners.size === 0) {
                    this.listeners.delete(fullEventName);
                }
            }
        };
    }
    /**
   * 取消订阅事件
   * 
   * @param event - 事件名称
   * @param listener - 事件监听器（可选，不提供则取消该事件的所有监听器）
   */ off(event, listener) {
        const fullEventName = this.getFullEventName(event);
        const listeners = this.listeners.get(fullEventName);
        if (!listeners) {
            return;
        }
        if (listener) {
            // 移除指定的监听器
            for (const item of listeners){
                if (item.listener === listener) {
                    listeners.delete(item);
                    break;
                }
            }
        } else {
            // 移除所有监听器
            listeners.clear();
        }
        if (listeners.size === 0) {
            this.listeners.delete(fullEventName);
        }
    }
    /**
   * 一次性订阅事件
   * 
   * @param event - 事件名称
   * @param listener - 事件监听器
   * @param options - 监听器选项
   */ once(event, listener, options) {
        return this.on(event, listener, {
            ...options,
            once: true
        });
    }
    /**
   * 发布事件
   * 
   * @param event - 事件名称
   * @param data - 事件数据
   * @param metadata - 事件元数据（可选）
   * 
   * @example
   * ```typescript
   * await eventBus.emit('user:login', {
   *   userId: '123',
   *   username: 'john',
   * });
   * ```
   */ async emit(event, data, metadata) {
        const fullEventName = this.getFullEventName(event);
        const startTime = this.config.enablePerformanceMonitoring ? performance.now() : 0;
        // 事件验证
        if (this.config.enableValidation && !this.config.validator(fullEventName, data)) {
            logger.warn(`事件 ${fullEventName} 验证失败，已忽略`);
            return;
        }
        // 安全检查
        if (this.config.enableSecurityMode && metadata?.source) {
            if (!this.config.allowedSources.includes(metadata.source)) {
                logger.warn(`事件 ${fullEventName} 的来源 ${metadata.source} 不在白名单中，已忽略`);
                return;
            }
        }
        // 构建事件元数据
        const eventMetadata = {
            source: metadata?.source,
            timestamp: metadata?.timestamp ?? Date.now(),
            eventId: metadata?.eventId ?? `event_${++this.eventCounter}`,
            priority: metadata?.priority ?? 0,
            instanceId: metadata?.instanceId ?? this.config.instanceId,
            namespace: metadata?.namespace ?? this.config.namespacePrefix,
            ...metadata
        };
        // 创建事件包装器
        const eventWrapper = {
            data: data,
            metadata: eventMetadata
        };
        // 执行中间件（中间件可以阻止事件传播）
        if (this.middlewares.length > 0) {
            let middlewareIndex = 0;
            let nextCalled = false;
            const executeMiddleware = async ()=>{
                if (middlewareIndex < this.middlewares.length) {
                    nextCalled = false;
                    const currentIndex = middlewareIndex;
                    const middleware = this.middlewares[middlewareIndex++];
                    const next = async ()=>{
                        nextCalled = true;
                        if (currentIndex < this.middlewares.length - 1) {
                            await executeMiddleware();
                        }
                    };
                    await Promise.resolve(middleware(fullEventName, data, eventMetadata, next));
                    // 如果中间件没有调用 next()，阻止事件传播
                    if (!nextCalled) {
                        return;
                    }
                }
            };
            await executeMiddleware();
            // 如果最后一个中间件没有调用 next()，阻止事件传播
            if (!nextCalled && this.middlewares.length > 0) {
                return;
            }
        }
        // 获取监听器
        const listeners = this.listeners.get(fullEventName);
        // 记录事件历史（无论是否有监听器）
        if (this.config.enableTracking) {
            const executionTime = this.config.enablePerformanceMonitoring ? performance.now() - startTime : undefined;
            this.recordEventHistory(fullEventName, data, eventMetadata, executionTime);
        }
        if (!listeners || listeners.size === 0) {
            // 更新统计（即使没有监听器也记录）
            this.updateStats(fullEventName, 0);
            return;
        }
        // 执行监听器
        const executionPromises = [];
        const listenersToRemove = [];
        for (const listenerWithOptions of listeners){
            const executeListener = async ()=>{
                try {
                    if (listenerWithOptions.options.async) {
                        await Promise.resolve(listenerWithOptions.listener(eventWrapper.data, eventWrapper.metadata));
                    } else {
                        listenerWithOptions.listener(eventWrapper.data, eventWrapper.metadata);
                    }
                    // 如果是一次性监听器，标记为待移除
                    if (listenerWithOptions.options.once) {
                        listenersToRemove.push(listenerWithOptions);
                    }
                } catch (error) {
                    logger.error(`事件 ${fullEventName} 的监听器执行失败:`, error);
                }
            };
            executionPromises.push(executeListener());
        }
        // 等待所有监听器执行完成
        await Promise.allSettled(executionPromises);
        // 移除一次性监听器
        for (const listenerToRemove of listenersToRemove){
            listeners.delete(listenerToRemove);
        }
        if (listeners.size === 0) {
            this.listeners.delete(fullEventName);
        }
        // 更新统计信息
        const executionTime = this.config.enablePerformanceMonitoring ? performance.now() - startTime : 0;
        this.updateStats(fullEventName, executionTime, listeners.size);
    }
    /**
   * 同步发布事件（不等待异步监听器完成）
   * 
   * @param event - 事件名称
   * @param data - 事件数据
   * @param metadata - 事件元数据（可选）
   */ emitSync(event, data, metadata) {
        // 同步执行 emit，但不等待 Promise 完成
        this.emit(event, data, metadata).catch((error)=>{
            logger.error(`同步发布事件 ${event} 失败:`, error);
        });
    }
    /**
   * 注册事件中间件
   * 
   * @param middleware - 中间件函数
   * @returns 取消注册函数
   * 
   * @example
   * ```typescript
   * const unsubscribe = eventBus.use((event, data, metadata, next) => {
   *   console.log('事件触发:', event);
   *   return next();
   * });
   * ```
   */ use(middleware) {
        this.middlewares.push(middleware);
        return ()=>{
            const index = this.middlewares.indexOf(middleware);
            if (index > -1) {
                this.middlewares.splice(index, 1);
            }
        };
    }
    /**
   * 清空所有事件监听器
   */ clear() {
        this.listeners.clear();
    }
    /**
   * 清空事件历史记录
   */ clearHistory() {
        this.eventHistory = [];
    }
    /**
   * 获取事件监听器数量
   * 
   * @param event - 事件名称（可选，不提供则返回所有事件的监听器总数）
   */ listenerCount(event) {
        if (event) {
            const fullEventName = this.getFullEventName(event);
            return this.listeners.get(fullEventName)?.size || 0;
        }
        let count = 0;
        for (const listeners of this.listeners.values()){
            count += listeners.size;
        }
        return count;
    }
    /**
   * 获取所有事件名称
   */ eventNames() {
        return Array.from(this.listeners.keys());
    }
    /**
   * 获取事件历史记录
   * 
   * @param event - 事件名称（可选，如果提供则只返回该事件的历史）
   * @param limit - 限制返回的记录数
   */ getEventHistory(event, limit) {
        if (!this.config.enableTracking) {
            return [];
        }
        let history = this.eventHistory;
        if (event) {
            const fullEventName = this.getFullEventName(event);
            history = history.filter((h)=>h.event === fullEventName);
        }
        if (limit) {
            history = history.slice(-limit);
        }
        return [
            ...history
        ];
    }
    /**
   * 获取事件统计信息
   * 
   * @param event - 事件名称（可选，不提供则返回所有事件的统计）
   */ getStats(event) {
        if (event) {
            const fullEventName = this.getFullEventName(event);
            return this.stats.get(fullEventName) || {
                event: fullEventName,
                count: 0,
                avgExecutionTime: 0,
                listenerCount: 0,
                lastTriggered: 0
            };
        }
        return new Map(this.stats);
    }
    /**
   * 获取配置
   */ getConfig() {
        return {
            ...this.config
        };
    }
    /**
   * 更新配置
   */ updateConfig(config) {
        this.config = {
            ...this.config,
            ...config
        };
    }
    /**
   * 销毁事件总线（清理所有资源）
   */ destroy() {
        this.clear();
        this.clearHistory();
        this.middlewares = [];
        this.stats.clear();
    }
    /**
   * 获取完整事件名称（包含命名空间前缀）
   */ getFullEventName(event) {
        if (this.config.namespacePrefix) {
            return `${this.config.namespacePrefix}${event}`;
        }
        return event;
    }
    /**
   * 记录事件历史
   */ recordEventHistory(event, data, metadata, executionTime) {
        this.eventHistory.push({
            event,
            data,
            metadata,
            executionTime
        });
        // 限制历史记录大小
        if (this.eventHistory.length > this.config.maxHistorySize) {
            this.eventHistory.shift();
        }
    }
    /**
   * 更新统计信息
   */ updateStats(event, executionTime, listenerCount = 0) {
        if (!this.config.enablePerformanceMonitoring) {
            return;
        }
        const existingStats = this.stats.get(event);
        if (existingStats) {
            const totalTime = existingStats.avgExecutionTime * existingStats.count + executionTime;
            const newCount = existingStats.count + 1;
            this.stats.set(event, {
                ...existingStats,
                count: newCount,
                avgExecutionTime: totalTime / newCount,
                listenerCount,
                lastTriggered: Date.now()
            });
        } else {
            this.stats.set(event, {
                event,
                count: 1,
                avgExecutionTime: executionTime,
                listenerCount,
                lastTriggered: Date.now()
            });
        }
    }
    constructor(config = {}){
        /**
   * 事件监听器映射表
   * 使用 Map + Set 结构提高性能
   */ _define_property(this, "listeners", new Map());
        /**
   * 事件历史记录
   */ _define_property(this, "eventHistory", []);
        /**
   * 事件中间件列表
   */ _define_property(this, "middlewares", []);
        /**
   * 事件统计信息
   */ _define_property(this, "stats", new Map());
        /**
   * 配置
   */ _define_property(this, "config", void 0);
        /**
   * 事件计数器（用于生成唯一事件ID）
   */ _define_property(this, "eventCounter", 0);
        /**
   * 监听器ID计数器
   */ _define_property(this, "listenerIdCounter", 0);
        this.config = {
            enableTracking: config.enableTracking ?? process.env.NODE_ENV === 'development',
            maxHistorySize: config.maxHistorySize ?? 100,
            enableValidation: config.enableValidation ?? false,
            validator: config.validator ?? (()=>true),
            enablePerformanceMonitoring: config.enablePerformanceMonitoring ?? process.env.NODE_ENV === 'development',
            namespacePrefix: config.namespacePrefix ?? '',
            instanceId: config.instanceId,
            enableSecurityMode: config.enableSecurityMode ?? false,
            allowedSources: config.allowedSources ?? []
        };
    }
}

//# sourceMappingURL=AppEventBus.js.map