interface EventBus {
  // 事件名 -> 回调函数列表
  events: Map<string, Set<CallbackFunction>>;
}

type EventHandler = (...args: any[]) => void;

class EventBus {
  private events: Map<string, Set<EventHandler>> = new Map();

  /**
   * 订阅事件
   */
  on(event: string, handler: EventHandler): void {
    if (!this.events.has(event)) {
      this.events.set(event, new Set());
    }
    this.events.get(event)!.add(handler);
  }

  /**
   * 一次性订阅（触发一次后自动移除）
   */
  once(event: string, handler: EventHandler): void {
    const wrapper: EventHandler = (...args) => {
      handler(...args);
      this.off(event, wrapper);
    };
    this.on(event, wrapper);
  }

  /**
   * 发布事件
   */
  emit(event: string, ...args: any[]): void {
    const handlers = this.events.get(event);
    if (handlers) {
      handlers.forEach(handler => {
        try {
          handler(...args);
        } catch (error) {
          console.error(`EventBus: Error in handler for "${event}"`, error);
        }
      });
    }
  }

  /**
   * 取消订阅
   */
  off(event: string, handler: EventHandler): void {
    const handlers = this.events.get(event);
    if (handlers) {
      handlers.delete(handler);
      if (handlers.size === 0) {
        this.events.delete(event);
      }
    }
  }

  /**
   * 移除某事件的所有监听器
   */
  offAll(event?: string): void {
    if (event) {
      this.events.delete(event);
    } else {
      this.events.clear();
    }
  }
}

// 单例导出
export const eventBus = new EventBus();

// 同步 EventBus — emit 阻塞式执行
class SyncEventBus {
  private events = new Map<string, Set<Function>>();

  emit(event: string, ...args: any[]): void {
    const handlers = this.events.get(event);
    if (handlers) {
      // 逐个同步调用，任何一个慢都会阻塞后续
      for (const handler of handlers) {
        handler(...args);  // 阻塞在这里直到 handler 返回
      }
    }
    // 所有 handler 执行完毕后才到达这里
  }
}

class PrioritySyncBus {
  // 按优先级分桶：critical 必须当帧完成，normal 可延迟
  private buckets = {
    critical: new Map<string, Set<Function>>(),  // 立即执行
    normal:   new Map<string, Set<Function>>(),  // 当帧执行但在 critical 之后
    deferred: new Map<string, Set<Function>>(),  // 延迟到下一帧
  };

  emit(event: string, ...args: any[]): void {
    // 1. 立即执行关键回调（如战斗伤害结算）
    this.buckets.critical.get(event)?.forEach(h => h(...args));

    // 2. 执行普通回调
    this.buckets.normal.get(event)?.forEach(h => h(...args));

    // 3. 延迟回调推入下一帧队列
    const deferred = this.buckets.deferred.get(event);
    if (deferred) {
      requestAnimationFrame(() => {
        deferred.forEach(h => h(...args));
      });
    }
  }
}

class TimeBudgetBus {
  private readonly BUDGET_MS = 4; // 每次 emit 最多占用 4ms

  emit(event: string, ...args: any[]): void {
    const handlers = [...(this.events.get(event) || [])];
    const start = performance.now();
    let i = 0;

    // 在时间预算内尽可能多执行
    while (i < handlers.length) {
      handlers[i](...args);
      i++;

      if (performance.now() - start > this.BUDGET_MS && i < handlers.length) {
        // 超时，剩余回调推迟到下一帧
        const remaining = handlers.slice(i);
        requestAnimationFrame(() => {
          remaining.forEach(h => h(...args));
        });
        break;
      }
    }
  }
}

// 异步 EventBus — emit 非阻塞
class AsyncEventBus {
  private events = new Map<string, Set<Function>>();

  emit(event: string, ...args: any[]): void {
    const handlers = this.events.get(event);
    if (handlers) {
      for (const handler of handlers) {
        // 推入微任务队列，不阻塞当前执行
        queueMicrotask(() => handler(...args));
      }
    }
    // 立即返回，handler 尚未执行
  }

  // 或使用 Promise 包装
  async emitAsync(event: string, ...args: any[]): Promise<void> {
    const handlers = this.events.get(event);
    if (handlers) {
      await Promise.all(
        [...handlers].map(h => Promise.resolve().then(() => h(...args)))
      );
    }
  }
}

class SnapshotEventBus {
  emit(event: string, data: any): void {
    // 在 emit 时刻冻结数据快照
    const snapshot = structuredClone(data);

    const handlers = this.events.get(event);
    if (handlers) {
      for (const handler of handlers) {
        queueMicrotask(() => handler(snapshot));
      }
    }
  }
}

// 使用：handler 拿到的永远是 emit 时刻的一致数据
eventBus.emit("player:damaged", {
  hp: player.hp,        // 发射时的值
  damage: 30,
  timestamp: Date.now() // 附带时间戳供 handler 判断时效性
});

class VersionedEventBus {
  private version = new Map<string, number>();

  emit(event: string, data: any): void {
    const ver = (this.version.get(event) || 0) + 1;
    this.version.set(event, ver);

    const handlers = this.events.get(event);
    if (handlers) {
      for (const handler of handlers) {
        const capturedVer = ver;
        queueMicrotask(() => {
          // handler 执行时检查：如果版本已更新，说明有更新的事件
          if (this.version.get(event) === capturedVer) {
            handler(data);  // 仍是最新 → 执行
          } else {
            // 已过期 → 跳过或合并处理
            console.log(`Skipped stale ${event} v${capturedVer}`);
          }
        });
      }
    }
  }
}

interface GameEvent<T = any> {
  readonly type: string;
  readonly payload: Readonly<T>;  // 不可变
  readonly eventId: string;       // 唯一 ID
  readonly timestamp: number;     // 发生时间
  readonly frameId: number;       // 发生的帧号
}

class ImmutableEventBus {
  private frameCounter = 0;

  emit<T>(type: string, payload: T): void {
    // 创建不可变事件对象
    const event: GameEvent<T> = Object.freeze({
      type,
      payload: Object.freeze({ ...payload }),
      eventId: crypto.randomUUID(),
      timestamp: performance.now(),
      frameId: this.frameCounter,
    });

    // handler 拿到的是冻结对象，无法被任何人修改
    queueMicrotask(() => {
      this.events.get(type)?.forEach(h => h(event));
    });
  }
}

class HybridEventBus {
  private syncHandlers = new Map<string, Set<Function>>();
  private asyncHandlers = new Map<string, Set<Function>>();

  // 注册时指定同步/异步
  on(event: string, handler: Function, mode: 'sync' | 'async' = 'sync') {
    const map = mode === 'sync' ? this.syncHandlers : this.asyncHandlers;
    if (!map.has(event)) map.set(event, new Set());
    map.get(event)!.add(handler);
  }

  emit(event: string, ...args: any[]): void {
    // 第一阶段：同步回调立即执行（保证数据一致性）
    this.syncHandlers.get(event)?.forEach(h => h(...args));

    // 第二阶段：异步回调推入微任务（不阻塞主线程）
    const snapshot = structuredClone(args); // 快照数据
    this.asyncHandlers.get(event)?.forEach(h => {
      queueMicrotask(() => h(...snapshot));
    });
  }
}

// 使用示例
const bus = new HybridEventBus();

// 伤害结算必须同步 —— 后续需要知道目标是否死亡
bus.on('monster:killed', handleQuestProgress, 'sync');
bus.on('monster:killed', handleLootDrop, 'sync');

// 统计和日志可以异步 —— 不影响游戏逻辑
bus.on('monster:killed', handleAchievementCount, 'async');
bus.on('monster:killed', handleBattleLog, 'async');
bus.on('monster:killed', handleLeaderboard, 'async');

// events.ts
export const EVENTS = {
  USER_LOGIN: 'user:login',
  USER_LOGOUT: 'user:logout',
  DATA_LOADED: 'data:loaded',
  THEME_CHANGED: 'theme:changed',
} as const;

class MyComponent {
  private handler = (data: any) => { /* ... */ };

  mount() {
    eventBus.on(EVENTS.DATA_LOADED, this.handler);
  }

  unmount() {
    eventBus.off(EVENTS.DATA_LOADED, this.handler);
  }
}

interface EventMap {
  'user:login': { userId: string; timestamp: number };
  'user:logout': void;
  'data:loaded': { items: any[]; total: number };
}

class TypedEventBus {
  on<K extends keyof EventMap>(
    event: K,
    handler: (payload: EventMap[K]) => void
  ): void { /* ... */ }

  emit<K extends keyof EventMap>(
    event: K,
    payload: EventMap[K]
  ): void { /* ... */ }
}