/**
 * ### 全局事件管理
 *
 * ```js
 * // 注册
 * Events.register("eventName", () => {
 *     // 触发执行
 * });
 *
 * // 触发
 * Events.emit("eventName", '支持参数');
 *
 * // 移除
 * Events.remove("eventName");
 * ```
 */
export default class Events {

	// 监听数组
	private static listeners = new Map<any, Observer<any>[]>();

	/**
	 * 注册事件（会叠加）
	 *
	 * @param key      事件名称
	 * @param callback 回调函数
	 */
	public static register<T>(key: T, callback: Function) {
		const observers: Observer<T>[] | undefined = Events.listeners.get(key);
		if (!observers) {
			Events.listeners.set(key, []);
		}
		Events.listeners.get(key)?.push(new Observer<T>(key, callback));
	}

	/**
	 * 重置并注册（不会叠加）
	 *
	 * @param key     事件名称
	 * @param callback 回调函数
	 */
	public static reset<T>(key: T, callback: Function) {
		Events.listeners.set(key, []);
		this.register(key, callback);
	}

	/**
	 * 移除事件
	 *
	 * @param key     事件名称
	 */
	public static remove<T>(key: T) {
		const observers: Observer<T>[] | undefined = Events.listeners.get(key);
		if (observers) {
			for (let i = 0, l = observers.length; i < l; i++) {
				if (observers[i].equals(key)) {
					observers.splice(i, 1);
					break;
				}
			}
		}
		Events.listeners.delete(key);
	}

	/**
	 * 触发事件
	 *
	 * @param key 事件名称
	 * @param args 参数
	 */
	public static emit<T>(key: T, ...args: any[]) {
		const observers: Observer<T>[] | undefined = Events.listeners.get(key);
		if (observers) {
			for (const observer of observers) {
				// 通知
				observer.notify(...args);
			}
		}
	}
}

/** 观察者 */
class Observer<T> {

	private callback: Function = () => {}; // 回调函数

	private readonly key: T;

	constructor(key: T, callback: Function) {
		this.key = key;
		this.callback = callback;
	}

	/**
	 * 发送通知
	 *
	 * @param args 不定参数
	 */
	notify(...args: any[]): void {
		this.callback.call(this.key, ...args);
	}

	equals(name: any): boolean {
		return name === this.key;
	}
}