import EventDispatcher from './EventDispatcher';
import BaseEvent from './BaseEvent';

/**
 * EventBroker is a simple publish and subscribe static class that you can use to fire and receive notifications.
 * Loosely coupled event handling, the subscriber does not know the publisher. Both of them only need to know the event type.
 *
 * @class EventBroker
 * @module StructureJS
 * @submodule event
 * @requires EventDispatcher
 * @requires BaseEvent
 * @static
 * @author Robert S. (www.codeBelt.com)
 */
class EventBroker
{
    /**
     * A reference to the EventDispatcher object.
     *
     * @property _eventDispatcher
     * @type {EventDispatcher}
     * @private
     * @static
     */
    private static _eventDispatcher:EventDispatcher = new EventDispatcher();

    /**
     * A list of wait for objects.
     *
     * @property _waitForList
     * @type {Array<{eventTypes:Array<string>, callback:Function, callbackScope:any, events:Array<any>, once:boolean}>}
     * @private
     * @static
     */
    private static _waitForList:Array<{eventTypes:Array<string>, callback:Function, callbackScope:any, events:Array<any>, once:boolean}> = [];

    constructor()
    {
        throw new Error('[EventBroker] Do not instantiate the EventBroker class because it is a static class.');
    }

    /**
     * Registers an event listener object with an EventBroker object so that the listener receives notification of an event.
     *
     * @method addEventListener
     * @param type {String} The type of event.
     * @param callback {Function} The listener function that processes the event. The callback function will receive a {{#crossLink "BaseEvent"}}{{/crossLink}} object or custom event that extends the {{#crossLink "BaseEvent"}}{{/crossLink}} class.
     * @param scope {any} The scope of the callback function.
     * @param [priority=0] {int} Influences the order in which the listeners are called. Listeners with lower priorities are called after ones with higher priorities.
     * @static
     * @public
     * @example
     *     EventBroker.addEventListener('change', this._handlerMethod, this);
     *     // Example of using a constant event type.
     *     EventBroker.addEventListener(BaseEvent.CHANGE, this._handlerMethod, this);
     *
     *     // The event passed to the method will always be a BaseEvent object.
     *     _handlerMethod(event) {
     *          console.log(event.data);
     *     }
     */
    public static addEventListener(type:string, callback:Function, scope:any, priority:number = 0):void
    {
        EventBroker._eventDispatcher.addEventListener(type, callback, scope, priority);
    }

    /**
     * Registers an event listener object once with an EventDispatcher object so the listener will receive the notification of an event.
     *
     * @method addEventListenerOnce
     * @param type {String} The type of event.
     * @param callback {Function} The listener function that processes the event. The callback function will receive a {{#crossLink "BaseEvent"}}{{/crossLink}} object or custom event that extends the {{#crossLink "BaseEvent"}}{{/crossLink}} class.
     * @param scope {any} The scope of the callback function.
     * @param [priority=0] {int} Influences the order in which the listeners are called. Listeners with lower priorities are called after ones with higher priorities.
     * @static
     * @public
     * @example
     *     EventBroker.addEventListenerOnce('change', this._handlerMethod, this);
     *     // Example of using a constant event type.
     *     EventBroker.addEventListenerOnce(BaseEvent.CHANGE, this._handlerMethod, this);
     *
     *     // The event passed to the method will always be a BaseEvent object.
     *     _handlerMethod(event) {
     *          console.log(event.data);
     *     }
     */
    public static addEventListenerOnce(type:string, callback:Function, scope:any, priority:number = 0):void
    {
        EventBroker._eventDispatcher.addEventListenerOnce(type, callback, scope, priority);
    }

    /**
     * Removes a specified listener from the EventBroker object.
     *
     * @method removeEventListener
     * @param type {String} The type of event.
     * @param callback {Function} The callback function to be removed.
     * @param scope {any} The scope of the callback function to be removed.
     * @static
     * @public
     * @example
     *     EventBroker.removeEventListener('change', this._handlerMethod, this);
     *
     *     EventBroker.removeEventListener(BaseEvent.CHANGE, this._handlerMethod, this);
     */
    public static removeEventListener(type:string, callback:Function, scope:any):void
    {
        EventBroker._eventDispatcher.removeEventListener(type, callback, scope);
    }

    /**
     * A way to listen for multiple events.
     *
     * If only listening for one event use {{#crossLink "EventBroker/addEventListener:method"}}{{/crossLink}}.
     *
     * @method waitFor
     * @param eventTypes {Array<string>} A list of event types you are waiting for.
     * @param callback {Function} The callback function that will be triggered when all event types are
     * @param scope {any} The scope of the callback function.
     * @static
     * @public
     * @example
     *     EventBroker.waitFor(['someEvent', 'anotherEvent', CustomEvent.CHANGE], this._handlerMethod, this);
     *
     *     _handlerMethod(events) {
     *          // An array of the event objects you waited for.
     *     }
     */
    public static waitFor(eventTypes:Array<string>, callback:Function, scope:any):void
    {
        EventBroker._waitForList.push({
            eventTypes: eventTypes,
            callback: callback,
            callbackScope: scope,
            events: [],
            once: false
        });
    }

    /**
     * A way to listen for multiple events. Once all events all are triggered this listener will be removed.
     *
     * If only listening for one event use {{#crossLink "EventBroker/addEventListenerOnce:method"}}{{/crossLink}}.
     *
     * @method waitForOnce
     * @param eventTypes {Array<string>} A list of event types you are waiting for.
     * @param callback {Function} The callback function that will be triggered when all event types are
     * @param scope {any} The scope of the callback function.
     * @static
     * @public
     * @example
     *     EventBroker.waitForOnce(['someEvent', 'anotherEvent', CustomEvent.CHANGE], this._handlerMethod, this);
     *
     *     _handlerMethod(events) {
     *          // An array of the event objects you waited for.
     *     }
     */
    public static waitForOnce(eventTypes:Array<string>, callback:Function, scope:any):void
    {
        EventBroker._waitForList.push({
            eventTypes: eventTypes,
            callback: callback,
            callbackScope: scope,
            events: [],
            once: true
        });
    }

    /**
     * A way to listen for multiple events. Once all events all are triggered it will no longer
     *
     * @method removeWaitFor
     * @param eventTypes {Array<string>} A list of event types you are waiting for.
     * @param callback {Function} The callback function that will be triggered when all event types are
     * @param scope {any} The scope of the callback function.
     * @static
     * @public
     * @example
     *     EventBroker.removeWaitFor(['someEvent', 'anotherEvent', CustomEvent.CHANGE], this._handlerMethod, this);
     */
    public static removeWaitFor(eventTypes:Array<string>, callback:Function, scope:any):void
    {
        let waitForObject:any;
        for (let i = EventBroker._waitForList.length - 1; i >= 0; i--)
        {
            waitForObject = EventBroker._waitForList[i];

            if (waitForObject.eventTypes.toString() === eventTypes.toString() && waitForObject.callback === callback && waitForObject.callbackScope === scope)
            {
                EventBroker._waitForList.splice(i, 1);
            }
        }
    }

    /**
     * Dispatches an event within the EventBroker object.
     *
     * @method dispatchEvent
     * @param event {string|BaseEvent} The Event object or event type string you want to dispatch.
     * @param [data=null] {any} The optional data you want to send with the event. Do not use this parameter if you are passing in a {{#crossLink "BaseEvent"}}{{/crossLink}}.
     * @param [scope=null] {any} You can optionally pass in the target of the object that dispatched the global event. Since {{#crossLink "EventBroker"}}{{/crossLink}}
     * @static
     * @public
     * @example
     *      EventBroker.dispatchEvent('change');
     *
     *      // Example: Sending data with the event.
     *      EventBroker.dispatchEvent('change', {some: 'data'});
     *
     *      // Example: Sending a BaseEvent or custom event object.
     *      let event = new BaseEvent(BaseEvent.CHANGE);
     *      event.data = {some: 'data'};
     *      EventBroker.dispatchEvent(event);
     */
    public static dispatchEvent(type:any, data:any = null, scope:any = EventBroker):void
    {
        let event:any = type;

        if (typeof event === 'string')
        {
            event = new BaseEvent(type, false, false, data);
        }

        event.target = scope;
        event.currentTarget = scope;

        EventBroker._eventDispatcher.dispatchEvent(event);

        EventBroker._dispatchWaitFor(event);
    }

    /**
     * Helper method to dispatch events on the waitForObject objects.
     *
     * @method _dispatchWaitFor
     * @static
     * @private
     */
    private static _dispatchWaitFor(event:BaseEvent):void
    {
        let waitForObject:any;
        let eventTypeIndex:number;
        for (let i = EventBroker._waitForList.length - 1; i >= 0; i--)
        {
            waitForObject = EventBroker._waitForList[i];

            eventTypeIndex = waitForObject.eventTypes.indexOf(event.type);

            if (eventTypeIndex > -1)
            {
                waitForObject.events[eventTypeIndex] = event;
            }

            if (waitForObject.eventTypes.length === Object.keys(waitForObject.events).length)
            {
                waitForObject.callback.call(waitForObject.scope, waitForObject.events);

                waitForObject.events = [];

                // If the once value is true we want to remove the listener right after this callback was called.
                if (waitForObject.once === true)
                {
                    EventBroker._waitForList.splice(i, 1);
                }
            }
        }
    }

    /**
     * Check if EventBroker has a specific event listener already added.
     *
     * @method hasEventListener
     * @param type {String} The type of event.
     * @param callback {Function} The listener method to call.
     * @param scope {any} The scope of the listener object.
     * @return {boolean}
     * @static
     * @public
     * @example
     *      EventBroker.hasEventListener(BaseEvent.CHANGE, this._handlerMethod, this);
     */
    public static hasEventListener(type:string, callback:Function, scope:any):boolean
    {
        return EventBroker._eventDispatcher.hasEventListener(type, callback, scope);
    }

    /**
     * Returns and array of all current event types and there current listeners.
     *
     * @method getEventListeners
     * @return {Array<any>}
     * @static
     * @public
     * @example
     *      const listenerList = this.getEventListeners();
     */
    public static getEventListeners():Array<any>
    {
        return EventBroker._eventDispatcher.getEventListeners();
    }

    /**
     * Prints out each event listener in the console.log
     *
     * @method print
     * @return {string}
     * @static
     * @public
     * @example
     *      this.printEventListeners();
     *
     *      // [ClassName] is listening for the 'BaseEvent.change' event.
     *      // [AnotherClassName] is listening for the 'BaseEvent.refresh' event.
     */
    public static printEventListeners():void
    {
        EventBroker._eventDispatcher.printEventListeners();
    }

}

export default EventBroker;