/**
* Repräsentiert die Buchung eines Events
*/
class Subscription {
    /**
     * Erstellt eine Instanz
     * @param id: nummer des Callbacks
     * @param module: Name des Moduls das gebucht hat
     * @param callback: Callback funktion
     */
    constructor( public id: number, public module: string, public callback: (payload?: any) => void) {}
}

/**
* Schnittstellenbeschreibung für ein Event
*/
interface IEvent {
    /**
     * Buchen eines Events
     * @param module Name des Moduls das gebucht hat
     * @param callback Callback der für den Event Registriert werden soll
     * @returns {} Nummer der Buchung 
     */
    subscribe(module: string, callback: (payload?: any) => void): number;

    /**
     * Abbestellen eines Events
     * @param id Nummer der Buchung
     * @returns {} 
     */
    unSubscribe(id: number): void;

    /**
     * Abbestellen aller Events für ein Modul
     * @param module Name des Moduls das gebucht hat
     */
    unSubscribeAll(module: string): void;

    /**
     * Event auslösen
     * @param payload 
     * @returns {} 
     */
    notify(payload?: any): void;
}

/**
 * Eventbroker-Event
 */
class Event implements IEvent {

    private _name:string;
    private _subscriptions: Subscription[];
    private _nextId: number;

    /**
     * Erstellt eine Instanz
     * @param name Eindeutiger Event-Name
     */
    constructor(public name: string) {
        this._name = name;
        this._subscriptions = [];
        this._nextId = 0;
    }

    /**
     * Buchen eines Events
     * @param module Name des Moduls das gebucht hat
     * @param callback
     * @returns {} Nummer der Buchung
     */
    public subscribe(module: string, callback: (payload?: any) => void): number {
        if (this._subscriptions.findIndex(c => c.module === module) === -1) {
            var subscription = new Subscription(this._nextId++, module, callback);
            this._subscriptions.push(subscription);
            return subscription.id;
        }
        return -1;
    }

    /**
     * Abbestellen eines Events
     * @param id Nummer der Buchung
     * @returns {} 
     */
    public unSubscribe(id: number): void {
        var index = this._subscriptions.findIndex(c => c.id === id);
        if (index !== -1)
            this._subscriptions.splice(index, 1);
    }

    /**
     * Abbestellen aller Events für ein Modul
     * @param module Name des Moduls das gebucht hat
     */
    public unSubscribeAll(module: string): void {
        var index = this._subscriptions.findIndex(c => c.module === module);
        while (index !== -1) {
            //console.log(`UnsubscribeALL: ${module} --> ${this._name}`);
            this._subscriptions.splice(index, 1);
            index = this._subscriptions.findIndex(c => c.module === module);
        }
    }

    /**
     * Event auslösen
     * @param payload Optionaler payload der mit dem Event versendet wird
     * @returns {} 
     */
    notify(payload?: any):void {
        var index;
        for (index = 0; index < this._subscriptions.length; index++) {
            if (this._subscriptions[index]) {
                //console.log(`Notify: ${this._subscriptions[index].module} --> ${this._name}`);
                this._subscriptions[index].callback(payload);
            }
        }
    }
}

/**
 * Event-Broker
 */
export class EventManager {

    private static _instance: EventManager;

    private _events: Event[];

    /**
     * Erstellt eine Instanz
     */
    private constructor() {
        this._events = [];
    }

    /**
     * Instanz
     */
    static getInstance(): EventManager {
        if (!EventManager._instance) {
            EventManager._instance = new EventManager();
        }
        return EventManager._instance;
    }

    /**
     * Buchen eins Events
     * @param name Name des Events
     * @param module Name des Moduls das gebucht hat
     * @param callback Optinaler Callback
     */
    subscribe(name: string, module: string, callback: (payload?: any) => void) {
        let event = this._events.find(c => c.name === name);
        if (!event) {
            event = new Event(name);
            this._events.push(event);
        }
        //console.log(`Subscribe --> Module ${module} --> Event ${name}`);
        return event.subscribe(module, callback);
    }

    /**
     * Abbestellen eines Events
     * @param name Name des Events
     * @param token Nummer der Buchung
     */
    unSubscribe(name: string, token: number) {
        let event = this._events.find(c => c.name === name);
        if (event) {
            event.unSubscribe(token);
            //console.log(`UnSubscribe --> Token ${token} --> Event ${name}`);
        }
    }

    /**
    * Abbestellen aller Events für ein Modul
    * @param module Name des Moduls das gebucht hat
    */
    unSubscribeAll(module: string) {
        var index;
        for (index = 0; index < this._events.length; index++) {
            if (this._events[index]) {
                this._events[index].unSubscribeAll(module);
            }
        }
    }

    /**
     * Event auslösen
     * @param name Name des Events
     * @param payload Optinaler Payload
     */
    publish(name: string, payload?: any) {
        let event = this._events.find(c => c.name === name);
        if (event) {
            //console.log(`Publish --> Event ${name}`);
            event.notify(payload);
        }
    }
}