import SplitIO from '../../types/splitio';

const NEW_LISTENER_EVENT = 'newListener';

const REMOVE_LISTENER_EVENT = 'removeListener';

function checkListener(listener: unknown) {

if (typeof listener !== 'function') {

throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);

}

}

// @TODO implement missing methods, check spec and add UTs

export class EventEmitter implements SplitIO.IEventEmitter {

private listeners: Record<string, Array<[

(...args: any[]) => void, // the event listener

boolean // whether it is a one-time listener or not

]>> = {};

private registerListener(type: string, listener: (...args: any[]) => void, oneTime: boolean) {

checkListener(listener);

// To avoid recursion in the case that type === "newListener" before

// adding it to the listeners, first emit "newListener".

this.emit(NEW_LISTENER_EVENT, type, listener);

if (!this.listeners[type]) {

this.listeners[type] = [[listener, oneTime]];

} else {

this.listeners[type].push([listener, oneTime]);

}

return this;

}

addListener(type: string, listener: (...args: any[]) => void) {

return this.registerListener(type, listener, false);

}

// alias of addListener

on(type: string, listener: (...args: any[]) => void) {

return this.addListener(type, listener);

}

once(type: string, listener: (...args: any[]) => void) {

return this.registerListener(type, listener, true);

}

// @ts-ignore

removeListener(/* type: string, listener: (...args: any[]) => void */) {

throw new Error('Method not implemented.');

}

// @ts-ignore alias of removeListener

off(/* type: string, listener: (...args: any[]) => void */) {

return this.removeListener(/* type, listener */);

}

emit(type: string, ...args: any[]): boolean {

// Returns false if the event doesn't have listeners

if (!this.listeners[type] || this.listeners[type].length === 0) return false;

// Call listeners while removing one-time listeners

this.listeners[type] = this.listeners[type].filter(listenerEntry => {

listenerEntry[0](...args);

return !listenerEntry[1];

});

return true;

}

removeAllListeners(type?: string) {

if (!this.listeners[REMOVE_LISTENER_EVENT]) {

// if not listening for `removeListener`, no need to emit

if (type) {

if (this.listeners[type]) delete this.listeners[type];

} else {

this.listeners = {};

}

} else {

// emit `removeListener` for all listeners

if (type) {

const listeners = this.listeners[type];

if (listeners) {

// LIFO order

for (let i = listeners.length - 1; i >= 0; i--) {

this.emit(REMOVE_LISTENER_EVENT, type, listeners[i]);

}

delete this.listeners[type];

}

} else {

const keys = Object.keys(this.listeners);

for (let i = 0; i < keys.length; ++i) {

const key = keys[i];

if (key === REMOVE_LISTENER_EVENT) continue;

this.removeAllListeners(key);

}

this.listeners = {};

}

}

return this;

}

}