export class Signal<T extends (...args: never[]) => void> {
  private readonly handlers = new Set<T>();

  add(handler: T): () => void {
    this.handlers.add(handler);
    return () => this.remove(handler);
  }

  remove(handler: T): void {
    this.handlers.delete(handler);
  }

  emit(...args: Parameters<T>): void {
    for (const handler of [...this.handlers]) handler(...args);
  }
}

export interface CallableSignal<T extends (...args: never[]) => void> {
  (handler: T): () => void;
  add(handler: T): () => void;
  once(handler: T): void;
  remove(handler: T): void;
  clear(): void;
  invoke(...args: Parameters<T>): void;
  invokeAsync(...args: Parameters<T>): Promise<unknown[]>;
  emit(...args: Parameters<T>): void;
}

export function createSignal<T extends (...args: never[]) => void>(): CallableSignal<T> {
  const handlers = new Set<T>();
  const signal = ((handler: T) => signal.add(handler)) as CallableSignal<T>;
  signal.add = (handler: T) => {
    handlers.add(handler);
    return () => signal.remove(handler);
  };
  signal.once = (handler: T) => {
    const wrapped = ((...args: Parameters<T>) => {
      signal.remove(wrapped as T);
      handler(...args);
    }) as T;
    signal.add(wrapped);
  };
  signal.remove = (handler: T) => {
    handlers.delete(handler);
  };
  signal.clear = () => {
    handlers.clear();
  };
  signal.invoke = (...args: Parameters<T>) => {
    signal.emit(...args);
  };
  signal.invokeAsync = async (...args: Parameters<T>) =>
    Promise.all([...handlers].map((handler) => handler(...args)));
  signal.emit = (...args: Parameters<T>) => {
    for (const handler of [...handlers]) handler(...args);
  };
  return signal;
}