"use strict";
/**
 * Defines a dialog-panel to display messages.
 * Every message that fulfills will get the dialog-content as well as the pressed button as return.
 *
 *
 * <i>Copyright (c) 2014 ITSA - https://github.com/itsa</i>
 * New BSD License - http://choosealicense.com/licenses/bsd-3-clause/
 *
 *
 * @module dialog
 * @class Dialog
 * @since 0.0.1
*/
 
require('js-ext');
require('polyfill');
require('./css/dialog.css');
 
var NAME = '[dialog]: ',
    MESSAGE_LEVELS = {
        'message': 1,
        'warn': 2,
        'error': 3
    },
    MESSAGE_HASHES = {
        'message': 'messages',
        'warn': 'warnings',
        'error': 'errors'
    },
    MESSAGE_HASHES_NR = {
        1: 'messages',
        2: 'warnings',
        3: 'errors'
    },
    FOLLOWUP_DELAY = 150,
    createHashMap = require('js-ext/extra/hashmap.js').createMap;
 
module.exports = function (window) {
 
    var DOCUMENT = window.document,
        Classes = require('js-ext/extra/classes.js'),
        UTILS = require('utils'),
        later = UTILS.later,
        async = UTILS.async,
        dialog, Dialog, Event;
 
    window._ITSAmodules || Object.protectedProp(window, '_ITSAmodules', createHashMap());
 
/*jshint boss:true */
    if (Dialog=window._ITSAmodules.Dialog) {
/*jshint boss:false */
        return Dialog; // Dialog was already created
    }
 
    require('panel')(window);
    Event = require('itsa-event');
 
    /**
     * Model that is passed through to the Panel.
     *
     * @property model
     * @default {
            draggable: true
       }
     * @type Object
     * @since 0.0.1
     */
 
    /**
     * Internal property that tells what message-level is currently active.
     *
     * @property _currentMessageLevel
     * @default 0
     * @type Number
     * @private
     * @since 0.0.1
     */
 
    /**
     * Internal hash all queued message with level=1 (*:message)
     *
     * @property messages
     * @default []
     * @type Array
     * @since 0.0.1
     */
 
    /**
     * Internal hash all queued message with level=2 (*:warn)
     *
     * @property warnings
     * @default []
     * @type Array
     * @since 0.0.1
     */
 
    /**
     * Internal hash all queued message with level=3 (*:error)
     *
     * @property errors
     * @default []
     * @type Array
     * @since 0.0.1
     */
    Dialog = Classes.createClass(function() {
        var instance = this;
        instance.model = {
            draggable: true
        };
        instance._currentMessageLevel = 0;
        instance.messages = [];
        instance.warnings = [];
        instance.errors = [];
        instance.createContainer();
        instance.setupListeners();
    }, {
 
       /**
         * Creates a Panel-instance that will be used to display the messages.
         * Sets instance.model as panel's model and defines model.callback
         * which fulfills the message when a button on the dialog is pressed,
         *
         * @method createContainer
         * @since 0.0.1
         */
        createContainer: function() {
            var instance = this,
                model = instance.model;
            model.callback = function(buttonNode) {
                var containerNode = DOCUMENT.createElement('div'),
                    contentNode = instance.panel.getElement('>div[is="content"]'),
                    messagePromise = model.messagePromise;
                containerNode = contentNode.cloneNode(true);
                // now append a copy of the buttonNode:
                containerNode.append(buttonNode.getOuterHTML());
                messagePromise.fulfill(containerNode);
                // we can safely remove the newly created container-node: the vdom holds it for 1 minute
                containerNode.remove();
            };
            instance.panel = DOCUMENT.createPanel(model);
        },
 
       /**
         * Processes messages that are emitted by `messages`-module and add them in the queue.
         *
         * @method queueMessage
         * @param e {Object} the eventobject
         * @since 0.0.1
         */
        queueMessage: function(e) {
            var instance = this,
                messagePromise = e.messagePromise,
                type = e.type,
                level = MESSAGE_LEVELS[type],
                list = instance[MESSAGE_HASHES[type]];
            list[list.length] = messagePromise;
            messagePromise.finally(
                function() {
                    list.remove(messagePromise);
                    // handle the next message (if there)
                    instance.handleMessage(true);
                }
            );
            (level>instance._currentMessageLevel) && instance.handleMessage(!instance.isWaiting(), level);
        },
 
       /**
         * Defines subscribers to the events: *:message, *:warn and *:error.
         *
         * @method setupListeners
         * @since 0.0.1
         */
        setupListeners: function() {
            var instance = this;
            Event.after(['*:message', '*:warn', '*:error'], instance.queueMessage.bind(instance));
        },
 
       /**
         * Tells whether `dialog` is waitin g for new messages and is currently iddle.
         *
         * @method isWaiting
         * @return {Boolean} whether `dialog` is waitin g for new messages
         * @since 0.0.1
         */
        isWaiting: function() {
            return (this._currentMessageLevel===0);
        },
 
       /**
         * Retrieves the next message from the queue and calls showMessage() if it finds one.
         *
         * @method handleMessage
         * @param [delay] {Boolean} if there should be a delay between the previous dialog and the new one
         * @param [level] {Number} to force handling a specific level
         * @since 0.0.1
         */
        handleMessage: function(delay, level) {
            var instance = this,
                model = instance.model,
                messagePromise;
            if (!level) {
                // search level
                if (instance.errors.length>0) {
                    level = 3;
                }
                else if (instance.warnings.length>0) {
                    level = 2;
                }
                else if (instance.messages.length>0) {
                    level = 1;
                }
            }
            if (!level || (instance[MESSAGE_HASHES_NR[level]].length===0)) {
                // DO NOT make messagePromise null: it sould be there as return value
                // of the last message
                instance._currentMessageLevel = 0;
                model.header = null;
                model.content = '';
                model.footer = null;
                model.validate = null;
                model.visible = false;
                return;
            }
            instance._currentMessageLevel = level;
            // now process the highest message
            messagePromise = instance[MESSAGE_HASHES_NR[level]][0];
            if (delay) {
                model.visible = false;
                later(instance.showMessage.bind(instance, messagePromise), FOLLOWUP_DELAY);
            }
            else {
                async(instance.showMessage.bind(instance, messagePromise));
            }
        },
 
       /**
         * Shows the specified message-promise.
         *
         * @method showMessage
         * @param messagePromise {Promise} the message to be shown.
         * @since 0.0.1
         */
        showMessage: function(messagePromise) {
            var model = this.model;
            window.scrollTo(0, 0);
            model.messagePromise = messagePromise;
            model.header = messagePromise.header;
            model.content = messagePromise.content;
            model.footer = messagePromise.footer;
            model.validate = messagePromise.validate;
            model.visible = true;
        }
    });
 
    // instantiate Dialog and make it operational:
    dialog = new Dialog();
 
    window._ITSAmodules.Dialog = Dialog;
 
    return Dialog;
};