import type { IEventBuilder, IEventMap } from '../IEventBuilder.ts'

interface HandlerWrapper<T extends (...args: any[]) => any> {
  fn: T
  once: boolean
}

export class EventBuilderImpl<Events extends IEventMap> implements IEventBuilder<Events> {
  private _eventHandlers = new Map<keyof Events, Set<HandlerWrapper<Events[keyof Events]>>>()

  /**
   * 添加事件监听器
   * @param eventName 事件名称
   * @param handler 监听器
   * @param options { immediate: 立即执行一次 immediateArgs: 立即执行的参数 once: 只监听一次 }
   * @returns 返回一个 `unsubscribe` 函数，用于移除当前监听
   * @example
   * eventBus.subscribe('noArgs', () => {})
   * eventBus.subscribe('greet', name => {}, { immediate: true, immediateArgs: ['abc'] })
   * eventBus.subscribe('onResize', (w, h) => {}, { immediate: true, immediateArgs: [1, 2] })
   */
  subscribe<E extends keyof Events, F extends Events[E]>(
    eventName: E,
    handler: F,
    options?: {
      immediate?: boolean
      immediateArgs?: Parameters<F>
      once?: boolean
    },
  ): () => void {
    if (!handler) return () => {}
    if (!this._eventHandlers.has(eventName)) {
      this._eventHandlers.set(eventName, new Set<HandlerWrapper<F>>())
    }

    const set = this._eventHandlers.get(eventName)!
    const wrapper: HandlerWrapper<F> = { fn: handler, once: options?.once ?? false }
    if (![...set].some((wrapper) => wrapper.fn === handler)) {
      set.add(wrapper)
    }

    if (options?.immediate) {
      try {
        handler(...(options.immediateArgs ?? []))
      } catch (e) {
        console.error(e)
      }
    }

    return () => {
      set.delete(wrapper)
      // 如果该事件下无监听器，则删除集合
      if (set.size === 0) this._eventHandlers.delete(eventName)
    }
  }

  /**
   * 移除事件监听器
   * @param eventName 事件名称
   * @param handler 监听器
   * @example
   * eventBus.remove('noArgs', () => {})
   */
  remove<E extends keyof Events, F extends Events[E]>(eventName: E, handler: F) {
    const set = this._eventHandlers.get(eventName)
    if (!set) return

    for (const wrapper of set) {
      if (wrapper.fn === handler) {
        set.delete(wrapper)
      }
    }
    if (set.size === 0) {
      this._eventHandlers.delete(eventName)
    }
  }

  /**
   * 通知事件
   * @param eventName 事件名称
   * @param args 参数
   * @example
   * eventBus.notify('noArgs')
   * eventBus.notify('greet', 'Alice')
   * eventBus.notify('onResize', 1, 2)
   */
  notify<E extends keyof Events, F extends Events[E]>(eventName: E, ...args: Parameters<F>) {
    if (!this._eventHandlers.has(eventName)) return

    const set = this._eventHandlers.get(eventName)!
    for (const wrapper of set) {
      try {
        wrapper.fn(...args)
      } catch (e) {
        console.error(e)
      }

      if (wrapper.once) {
        set.delete(wrapper)
      }
    }
  }

  destroy() {
    this._eventHandlers.clear()
  }
}