YUI.add('console', function (Y, NAME) {

/**

 * Console creates a visualization for messages logged through calls to a YUI

 * instance's <code>Y.log( message, category, source )</code> method.  The

 * debug versions of YUI modules will include logging statements to offer some

 * insight into the steps executed during that module's operation.  Including

 * log statements in your code will cause those messages to also appear in the

 * Console.  Use Console to aid in developing your page or application.

 *

 * Entry categories "info", "warn", and "error"

 * are also referred to as the log level, and entries are filtered against the

 * configured logLevel.

 *

 * @module console

 */

var getCN = Y.ClassNameManager.getClassName,

    CHECKED        = 'checked',

    CLEAR          = 'clear',

    CLICK          = 'click',

    COLLAPSED      = 'collapsed',

    CONSOLE        = 'console',

    CONTENT_BOX    = 'contentBox',

    DISABLED       = 'disabled',

    ENTRY          = 'entry',

    ERROR          = 'error',

    HEIGHT         = 'height',

    INFO           = 'info',

    LAST_TIME      = 'lastTime',

    PAUSE          = 'pause',

    PAUSED         = 'paused',

    RESET          = 'reset',

    START_TIME     = 'startTime',

    TITLE          = 'title',

    WARN           = 'warn',

    DOT = '.',

    C_BUTTON           = getCN(CONSOLE,'button'),

    C_CHECKBOX         = getCN(CONSOLE,'checkbox'),

    C_CLEAR            = getCN(CONSOLE,CLEAR),

    C_COLLAPSE         = getCN(CONSOLE,'collapse'),

    C_COLLAPSED        = getCN(CONSOLE,COLLAPSED),

    C_CONSOLE_CONTROLS = getCN(CONSOLE,'controls'),

    C_CONSOLE_HD       = getCN(CONSOLE,'hd'),

    C_CONSOLE_BD       = getCN(CONSOLE,'bd'),

    C_CONSOLE_FT       = getCN(CONSOLE,'ft'),

    C_CONSOLE_TITLE    = getCN(CONSOLE,TITLE),

    C_ENTRY            = getCN(CONSOLE,ENTRY),

    C_ENTRY_CAT        = getCN(CONSOLE,ENTRY,'cat'),

    C_ENTRY_CONTENT    = getCN(CONSOLE,ENTRY,'content'),

    C_ENTRY_META       = getCN(CONSOLE,ENTRY,'meta'),

    C_ENTRY_SRC        = getCN(CONSOLE,ENTRY,'src'),

    C_ENTRY_TIME       = getCN(CONSOLE,ENTRY,'time'),

    C_PAUSE            = getCN(CONSOLE,PAUSE),

    C_PAUSE_LABEL      = getCN(CONSOLE,PAUSE,'label'),

    RE_INLINE_SOURCE = /^(\S+)\s/,

    RE_AMP = /&(?!#?[a-z0-9]+;)/g,

    RE_GT  = />/g,

    RE_LT  = /</g,

    ESC_AMP = '&',

    ESC_GT  = '>',

    ESC_LT  = '<',

    ENTRY_TEMPLATE_STR =

        '<div class="{entry_class} {cat_class} {src_class}">'+

            '<p class="{entry_meta_class}">'+

                '<span class="{entry_src_class}">'+

                    '{sourceAndDetail}'+

                '</span>'+

                '<span class="{entry_cat_class}">'+

                    '{category}</span>'+

                '<span class="{entry_time_class}">'+

                    ' {totalTime}ms (+{elapsedTime}) {localTime}'+

                '</span>'+

            '</p>'+

            '<pre class="{entry_content_class}">{message}</pre>'+

        '</div>',

    L = Y.Lang,

    create     = Y.Node.create,

    isNumber   = L.isNumber,

    isString   = L.isString,

    merge      = Y.merge,

    substitute = Y.Lang.sub;

/**

A basic console that displays messages logged throughout your application.

@class Console

@constructor

@extends Widget

@param [config] {Object} Object literal specifying widget configuration properties.

**/

function Console() {

    Console.superclass.constructor.apply(this,arguments);

}

Y.Console = Y.extend(Console, Y.Widget,

// Y.Console prototype

{

    /**

     * Category to prefix all event subscriptions to allow for ease of detach

     * during destroy.

     *

     * @property _evtCat

     * @type string

     * @protected

     */

    _evtCat : null,

    /**

     * Reference to the Node instance containing the header contents.

     *

     * @property _head

     * @type Node

     * @default null

     * @protected

     */

    _head    : null,

    /**

     * Reference to the Node instance that will house the console messages.

     *

     * @property _body

     * @type Node

     * @default null

     * @protected

     */

    _body    : null,

    /**

     * Reference to the Node instance containing the footer contents.

     *

     * @property _foot

     * @type Node

     * @default null

     * @protected

     */

    _foot    : null,

    /**

     * Holds the object API returned from <code>Y.later</code> for the print

     * loop interval.

     *

     * @property _printLoop

     * @type Object

     * @default null

     * @protected

     */

    _printLoop : null,

    /**

     * Array of normalized message objects awaiting printing.

     *

     * @property buffer

     * @type Array

     * @default null

     * @protected

     */

    buffer   : null,

    /**

     * Wrapper for <code>Y.log</code>.

     *

     * @method log

     * @param arg* {MIXED} (all arguments passed through to <code>Y.log</code>)

     * @chainable

     */

    log : function () {

        Y.log.apply(Y,arguments);

        return this;

    },

    /**

     * Clear the console of messages and flush the buffer of pending messages.

     *

     * @method clearConsole

     * @chainable

     */

    clearConsole : function () {

        // TODO: clear event listeners from console contents

        this._body.empty();

        this._cancelPrintLoop();

        this.buffer = [];

        return this;

    },

    /**

     * Clears the console and resets internal timers.

     *

     * @method reset

     * @chainable

     */

    reset : function () {

        this.fire(RESET);

        return this;

    },

    /**

     * Collapses the body and footer.

     *

     * @method collapse

     * @chainable

     */

    collapse : function () {

        this.set(COLLAPSED, true);

        return this;

    },

    /**

     * Expands the body and footer if collapsed.

     *

     * @method expand

     * @chainable

     */

    expand : function () {

        this.set(COLLAPSED, false);

        return this;

    },

    /**

     * Outputs buffered messages to the console UI.  This is typically called

     * from a scheduled interval until the buffer is empty (referred to as the

     * print loop).  The number of buffered messages output to the Console is

     * limited to the number provided as an argument.  If no limit is passed,

     * all buffered messages are rendered.

     *

     * @method printBuffer

     * @param limit {Number} (optional) max number of buffered entries to write

     * @chainable

     */

    printBuffer: function (limit) {

        var messages    = this.buffer,

            debug       = Y.config.debug,

            entries     = [],

            consoleLimit= this.get('consoleLimit'),

            newestOnTop = this.get('newestOnTop'),

            anchor      = newestOnTop ? this._body.get('firstChild') : null,

            i;

        if (messages.length > consoleLimit) {

            messages.splice(0, messages.length - consoleLimit);

        }

        limit = Math.min(messages.length, (limit || messages.length));

        // turn off logging system

        Y.config.debug = false;

        if (!this.get(PAUSED) && this.get('rendered')) {

            for (i = 0; i < limit && messages.length; ++i) {

                entries[i] = this._createEntryHTML(messages.shift());

            }

            if (!messages.length) {

                this._cancelPrintLoop();

            }

            if (entries.length) {

                if (newestOnTop) {

                    entries.reverse();

                }

                this._body.insertBefore(create(entries.join('')), anchor);

                if (this.get('scrollIntoView')) {

                    this.scrollToLatest();

                }

                this._trimOldEntries();

            }

        }

        // restore logging system

        Y.config.debug = debug;

        return this;

    },

    /**

     * Constructor code.  Set up the buffer and entry template, publish

     * internal events, and subscribe to the configured logEvent.

     *

     * @method initializer

     * @protected

     */

    initializer : function () {

        this._evtCat = Y.stamp(this) + '|';

        this.buffer = [];

        this.get('logSource').on(this._evtCat +

            this.get('logEvent'),Y.bind("_onLogEvent",this));

        /**

         * Transfers a received message to the print loop buffer.  Default

         * behavior defined in _defEntryFn.

         *

         * @event entry

         * @param event {EventFacade} An Event Facade object with the following attribute specific properties added:

         *  <dl>

         *      <dt>message</dt>

         *          <dd>The message data normalized into an object literal (see _normalizeMessage)</dd>

         *  </dl>

         * @preventable _defEntryFn

         */

        this.publish(ENTRY, { defaultFn: this._defEntryFn });

        /**

         * Triggers the reset behavior via the default logic in _defResetFn.

         *

         * @event reset

         * @param event {EventFacade} Event Facade object

         * @preventable _defResetFn

         */

        this.publish(RESET, { defaultFn: this._defResetFn });

        this.after('rendered', this._schedulePrint);

    },

    /**

     * Tears down the instance, flushing event subscriptions and purging the UI.

     *

     * @method destructor

     * @protected

     */

    destructor : function () {

        var bb = this.get('boundingBox');

        this._cancelPrintLoop();

        this.get('logSource').detach(this._evtCat + '*');

        bb.purge(true);

    },

    /**

     * Generate the Console UI.

     *

     * @method renderUI

     * @protected

     */

    renderUI : function () {

        this._initHead();

        this._initBody();

        this._initFoot();

        // Apply positioning to the bounding box if appropriate

        var style = this.get('style');

        if (style !== 'block') {

            this.get('boundingBox').addClass(this.getClassName(style));

        }

    },

    /**

     * Sync the UI state to the current attribute state.

     *

     * @method syncUI

     */

    syncUI : function () {

        this._uiUpdatePaused(this.get(PAUSED));

        this._uiUpdateCollapsed(this.get(COLLAPSED));

        this._uiSetHeight(this.get(HEIGHT));

    },

    /**

     * Set up event listeners to wire up the UI to the internal state.

     *

     * @method bindUI

     * @protected

     */

    bindUI : function () {

        this.get(CONTENT_BOX).one('button.'+C_COLLAPSE).

            on(CLICK,this._onCollapseClick,this);

        this.get(CONTENT_BOX).one('input[type=checkbox].'+C_PAUSE).

            on(CLICK,this._onPauseClick,this);

        this.get(CONTENT_BOX).one('button.'+C_CLEAR).

            on(CLICK,this._onClearClick,this);

        // Attribute changes

        this.after(this._evtCat + 'stringsChange',

            this._afterStringsChange);

        this.after(this._evtCat + 'pausedChange',

            this._afterPausedChange);

        this.after(this._evtCat + 'consoleLimitChange',

            this._afterConsoleLimitChange);

        this.after(this._evtCat + 'collapsedChange',

            this._afterCollapsedChange);

    },

    /**

     * Create the DOM structure for the header elements.

     *

     * @method _initHead

     * @protected

     */

    _initHead : function () {

        var cb   = this.get(CONTENT_BOX),