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

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

    /**
     * Abbestellen eines Events
     * @param id Nummer der Buchung
     * @returns {} 
     */
    unSubscribe(id: number): 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 callback
     * @returns {} Nummer der Buchung
     */
    public subscribe(callback: (payload?: any) => void) : number {
        var subscription = new Subscription(this._nextId++, callback);
        this._subscriptions[subscription.id] = subscription;
        return subscription.id;
    }

    /**
     * Abbestellen eines Events
     * @param id Nummer der Buchung
     * @returns {} 
     */
    public unSubscribe(id: number) : void {
        this._subscriptions[id] = undefined;
    }

    /**
     * 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]) {
                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 callback Optinaler Callback
     */
    subscribe(name: string, callback: (payload?: any) => void) {
        let event: IEvent = this._events[name] || ((this._events[name] = new Event(name)));
        return event.subscribe(callback);
    }

    /**
     * Abbestellen eines Events
     * @param name Name des Events
     * @param token Nummer der Buchung
     */
    unSubscribe(name: string, token: number) {
        if (this._events[name]) {
            (<IEvent>(this._events[name])).unSubscribe(token);
        }
    }

    /**
     * Event auslösen
     * @param name Name des Events
     * @param payload Optinaler Payload
     */
    publish(name: string, payload?: any) {
        if (this._events[name]) {
            (<IEvent>(this._events[name])).notify(payload);
        }
    }
<<<<<<< local
}=======
}

/**
* Public Event-Manager-Modul
*/
export let eventManager: EventManager = new EventManager();

>>>>>>> other