// worker_event_helper.ts
// Worker 端的全局事件助手

export interface GlobalEvent {
  type: string;
  source: string;
  target?: string;
  data?: any;
  timestamp?: number;
}

export class WorkerEventHelper {
  private workerName: string;
  private listeners: Map<string, Map<string, Function>> = new Map();

  constructor(workerName: string) {
    this.workerName = workerName;
    this.setupMessageHandler();
    console.log(`🔧 ${workerName} 事件助手已初始化`);
  }

  /**
   * 设置消息处理器
   */
  private setupMessageHandler() {
    self.addEventListener("message", (event: MessageEvent) => {
      const message = event.data;
      if (message.type === "globalEvent") {
        this.handleGlobalEvent(message.event);
      } else if (message.type === "globalEventReceived") {
        this.handleEventReceived(message.eventType, message.listenerId, message.event);
      }
    });
  }

  /**
   * 处理接收到的全局事件
   */
  private handleGlobalEvent(event: GlobalEvent) {
    console.log(`📨 ${this.workerName} 收到全局事件: ${event.type} (来源: ${event.source})`);
    
    // 触发本地监听器
    const eventListeners = this.listeners.get(event.type);
    if (eventListeners) {
      eventListeners.forEach((callback) => {
        try {
          callback(event);
        } catch (error) {
          console.error(`❌ ${this.workerName} 事件处理器出错:`, error);
        }
      });
    }
  }

  /**
   * 处理事件监听器回调
   */
  private handleEventReceived(eventType: string, listenerId: string, event: GlobalEvent) {
    const eventListeners = this.listeners.get(eventType);
    if (eventListeners) {
      const callback = eventListeners.get(listenerId);
      if (callback) {
        try {
          callback(event);
        } catch (error) {
          console.error(`❌ ${this.workerName} 事件监听器出错:`, error);
        }
      }
    }
  }

  /**
   * 分发全局事件
   */
  dispatchEvent(type: string, data?: any, target?: string) {
    const event: GlobalEvent = {
      type,
      source: this.workerName,
      target,
      data,
      timestamp: Date.now()
    };

    console.log(`📤 ${this.workerName} 分发事件: ${type}${target ? ` -> ${target}` : ' (广播)'}`);

    self.postMessage({
      type: "dispatchGlobalEvent",
      event
    });
  }

  /**
   * 添加事件监听器
   */
  addEventListener(eventType: string, callback: (event: GlobalEvent) => void): string {
    const listenerId = `${this.workerName}_${eventType}_${Date.now()}_${Math.random()}`;
    
    if (!this.listeners.has(eventType)) {
      this.listeners.set(eventType, new Map());
    }
    
    this.listeners.get(eventType)!.set(listenerId, callback);

    // 注册到主线程的事件管理器
    self.postMessage({
      type: "addEventListener",
      eventType,
      listenerId
    });

    console.log(`👂 ${this.workerName} 添加事件监听器: ${eventType}`);
    return listenerId;
  }

  /**
   * 移除事件监听器
   */
  removeEventListener(eventType: string, listenerId: string) {
    const eventListeners = this.listeners.get(eventType);
    if (eventListeners) {
      eventListeners.delete(listenerId);
      if (eventListeners.size === 0) {
        this.listeners.delete(eventType);
      }
    }
  }

  /**
   * 获取 Worker 名称
   */
  getWorkerName(): string {
    return this.workerName;
  }
}

// 创建便捷的全局函数
export function createWorkerEventHelper(workerName: string): WorkerEventHelper {
  return new WorkerEventHelper(workerName);
}