import { noError } from "./errors.ts";

export interface EventEmitter<M extends EventMap> {
	on: On<M>;
	dispatch<E extends keyof M>(event: E, ...args: Parameters<M[E]>): void;
}

export interface On<M extends EventMap> {
	<E extends keyof M>(...args: OnParametersFor<M, E>): () => void;
}

export type OnParametersFor<M extends EventMap, E extends keyof M> = Extract<
	OnParameters<M>,
	[event: E, cb: any]
>;

export type OnParameters<M extends EventMap> = {
	[E in keyof M]: [event: E, cb: M[E]];
}[keyof M];

interface EventMap {
	[event: string]: (...args: any[]) => void;
}

type EventListeners<M extends EventMap> = {
	[E in keyof M]?: Array<M[E]>;
};

export function createEventEmitter<M extends EventMap>(): EventEmitter<M> {
	const listeners: EventListeners<M> = {};

	return {
		on(...[event, cb]: OnParameters<M>): () => void {
			listeners[event] ??= [];
			listeners[event].push(cb);

			return () => {
				listeners[event] = listeners[event]?.filter((listener) => cb !== listener);
			};
		},

		dispatch<E extends keyof M>(event: E, ...args: Parameters<M[E]>): void {
			if (listeners[event]) {
				let firstError: unknown = noError;

				for (const cb of listeners[event]) {
					try {
						cb(...args);
					} catch (err) {
						if (firstError === noError) {
							firstError = err;
						}
					}
				}

				/* node:coverage disable */
				if (firstError !== noError && typeof window !== "undefined") {
					window.dispatchEvent(new ErrorEvent("error", { error: firstError }));
				}
				/* node:coverage enable */
			}
		},
	};
}