YUI.add('calendar-base', function (Y, NAME) {

/**

 * The CalendarBase submodule is a basic UI calendar view that displays

 * a range of dates in a two-dimensional month grid, with one or more

 * months visible at a single time. CalendarBase supports custom date

 * rendering, multiple calendar panes, and selection.

 * @module calendar

 * @submodule calendar-base

 */

var getCN                 = Y.ClassNameManager.getClassName,

    CALENDAR              = 'calendar',

    CAL_GRID              = getCN(CALENDAR, 'grid'),

    CAL_LEFT_GRID         = getCN(CALENDAR, 'left-grid'),

    CAL_RIGHT_GRID        = getCN(CALENDAR, 'right-grid'),

    CAL_BODY              = getCN(CALENDAR, 'body'),

    CAL_HD                = getCN(CALENDAR, 'header'),

    CAL_HD_LABEL          = getCN(CALENDAR, 'header-label'),

    CAL_WDAYROW           = getCN(CALENDAR, 'weekdayrow'),

    CAL_WDAY              = getCN(CALENDAR, 'weekday'),

    CAL_COL_HIDDEN        = getCN(CALENDAR, 'column-hidden'),

    CAL_DAY_SELECTED      = getCN(CALENDAR, 'day-selected'),

    SELECTION_DISABLED    = getCN(CALENDAR, 'selection-disabled'),

    CAL_ROW               = getCN(CALENDAR, 'row'),

    CAL_DAY               = getCN(CALENDAR, 'day'),

    CAL_PREVMONTH_DAY     = getCN(CALENDAR, 'prevmonth-day'),

    CAL_NEXTMONTH_DAY     = getCN(CALENDAR, 'nextmonth-day'),

    CAL_ANCHOR            = getCN(CALENDAR, 'anchor'),

    CAL_PANE              = getCN(CALENDAR, 'pane'),

    CAL_STATUS            = getCN(CALENDAR, 'status'),

    L           = Y.Lang,

    substitute  = L.sub,

    arrayEach   = Y.Array.each,

    objEach     = Y.Object.each,

    iOf         = Y.Array.indexOf,

    hasKey      = Y.Object.hasKey,

    setVal      = Y.Object.setValue,

    isEmpty     = Y.Object.isEmpty,

    ydate       = Y.DataType.Date;

/** Create a calendar view to represent a single or multiple

    * month range of dates, rendered as a grid with date and

    * weekday labels.

    *

    * @class CalendarBase

    * @extends Widget

    * @param config {Object} Configuration object (see Configuration

    * attributes)

    * @constructor

    */

function CalendarBase() {

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

}

Y.CalendarBase = Y.extend( CalendarBase, Y.Widget, {

    /**

     * A storage for various properties of individual month

     * panes.

     *

     * @property _paneProperties

     * @type Object

     * @private

     */

    _paneProperties : {},

    /**

     * The number of month panes in the calendar, deduced

     * from the CONTENT_TEMPLATE's number of {calendar_grid}

     * tokens.

     *

     * @property _paneNumber

     * @type Number

     * @private

     */

    _paneNumber : 1,

    /**

     * The unique id used to prefix various elements of this

     * calendar instance.

     *

     * @property _calendarId

     * @type String

     * @private

     */

    _calendarId : null,

    /**

     * The hash map of selected dates, populated with

     * selectDates() and deselectDates() methods

     *

     * @property _selectedDates

     * @type Object

     * @private

     */

    _selectedDates : {},

    /**

     * A private copy of the rules object, populated

     * by setting the customRenderer attribute.

     *

     * @property _rules

     * @type Object

     * @private

     */

    _rules : {},

    /**

     * A private copy of the filterFunction, populated

     * by setting the customRenderer attribute.

     *

     * @property _filterFunction

     * @type Function

     * @private

     */

    _filterFunction : null,

    /**

     * Storage for calendar cells modified by any custom

     * formatting. The storage is cleared, used to restore

     * cells to the original state, and repopulated accordingly

     * when the calendar is rerendered.

     *

     * @property _storedDateCells

     * @type Object

     * @private

     */

    _storedDateCells : {},

    /**

     * Designated initializer

     * Initializes instance-level properties of

     * calendar.

     *

     * @method initializer

     */

    initializer : function () {

        this._paneProperties = {};

        this._calendarId = Y.guid('calendar');

        this._selectedDates = {};

        if (isEmpty(this._rules)) {

             this._rules = {};

        }

        this._storedDateCells = {};

    },

    /**

     * renderUI implementation

     *

     * Creates a visual representation of the calendar based on existing parameters.

     * @method renderUI

     */

    renderUI : function () {

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

        contentBox.appendChild(this._initCalendarHTML(this.get('date')));

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

                this._afterShowPrevMonthChange();

        }

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

                this._afterShowNextMonthChange();

        }

        this._renderCustomRules();

        this._renderSelectedDates();

        this.get("boundingBox").setAttribute("aria-labelledby", this._calendarId + "_header");

    },

    /**

     * bindUI implementation

     *

     * Assigns listeners to relevant events that change the state

     * of the calendar.

     * @method bindUI

     */

    bindUI : function () {

        this.after('dateChange', this._afterDateChange);

        this.after('showPrevMonthChange', this._afterShowPrevMonthChange);

        this.after('showNextMonthChange', this._afterShowNextMonthChange);

        this.after('headerRendererChange', this._afterHeaderRendererChange);

        this.after('customRendererChange', this._afterCustomRendererChange);

        this.after('enabledDatesRuleChange', this._afterCustomRendererChange);

        this.after('disabledDatesRuleChange', this._afterCustomRendererChange);

        this.after('focusedChange', this._afterFocusedChange);

        this.after('selectionChange', this._renderSelectedDates);

        this._bindCalendarEvents();

    },

    /**

     * An internal utility method that generates a list of selected dates

     * from the hash storage.

     *

     * @method _getSelectedDatesList

     * @protected

     * @return {Array} The array of `Date`s that are currently selected.

     */

    _getSelectedDatesList : function () {

        var output = [];

        objEach (this._selectedDates, function (year) {

            objEach (year, function (month) {

                objEach (month, function (day) {

                    output.push (day);

                }, this);

            }, this);

        }, this);

        return output;

    },

    /**

     * A utility method that returns all dates selected in a specific month.

     *

     * @method _getSelectedDatesInMonth

     * @param {Date} oDate corresponding to the month for which selected dates

     * are requested.

     * @protected

     * @return {Array} The array of `Date`s in a given month that are currently selected.

     */

    _getSelectedDatesInMonth : function (oDate) {

        var year = oDate.getFullYear(),

            month = oDate.getMonth();

        if (hasKey(this._selectedDates, year) && hasKey(this._selectedDates[year], month)) {

            return Y.Object.values(this._selectedDates[year][month]);

        } else {

            return [];

        }

    },

    /**

     * An internal parsing method that receives a String list of numbers

     * and number ranges (of the form "1,2,3,4-6,7-9,10,11" etc.) and checks

     * whether a specific number is included in this list. Used for looking

     * up dates in the customRenderer rule set.

     *

     * @method _isNumInList

     * @param {Number} num The number to look for in a list.

     * @param {String} strList The list of numbers of the form "1,2,3,4-6,7-8,9", etc.

     * @private

     * @return {boolean} Returns true if the given number is in the given list.

     */

    _isNumInList : function (num, strList) {

        if (strList === "all") {

            return true;

        } else {

            var elements = strList.split(","),

                i = elements.length,

                range;

            while (i--) {

                range = elements[i].split("-");

                if (range.length === 2 && num >= parseInt(range[0], 10) && num <= parseInt(range[1], 10)) {

                    return true;

                }

                else if (range.length === 1 && (parseInt(elements[i], 10) === num)) {

                    return true;

                }

            }

            return false;

        }

    },

    /**

     * Given a specific date, returns an array of rules (from the customRenderer rule set)

     * that the given date matches.

     *

     * @method _getRulesForDate

     * @param {Date} oDate The date for which an array of rules is needed

     * @private

     * @return {Array} Returns an array of `String`s, each containg the name of

     * a rule that the given date matches.

     */

    _getRulesForDate : function (oDate) {

        var year = oDate.getFullYear(),

                month = oDate.getMonth(),

                date = oDate.getDate(),

                wday = oDate.getDay(),

                rules = this._rules,

                outputRules = [],

                years, months, dates, days;

        for (years in rules) {

            if (this._isNumInList(year, years)) {

                if (L.isString(rules[years])) {

                        outputRules.push(rules[years]);

                }

                else {

                    for (months in rules[years]) {

                        if (this._isNumInList(month, months)) {

                            if (L.isString(rules[years][months])) {

                                    outputRules.push(rules[years][months]);

                            }

                            else {

                                for (dates in rules[years][months]) {

                                    if (this._isNumInList(date, dates)) {

                                        if (L.isString(rules[years][months][dates])) {

                                                outputRules.push(rules[years][months][dates]);

                                        }

                                        else {

                                            for (days in rules[years][months][dates]) {

                                                if (this._isNumInList(wday, days)) {

                                                    if (L.isString(rules[years][months][dates][days])) {

                                                        outputRules.push(rules[years][months][dates][days]);

                                                    }

                                                }

                                            }

                                        }

                                    }

                                }

                            }

                        }

                    }

                }

            }

        }

        return outputRules;

    },

    /**

     * A utility method which, given a specific date and a name of the rule,

     * checks whether the date matches the given rule.

     *

     * @method _matchesRule

     * @param {Date} oDate The date to check

     * @param {String} rule The name of the rule that the date should match.

     * @private

     * @return {boolean} Returns true if the date matches the given rule.

     *

     */

    _matchesRule : function (oDate, rule) {

        return (iOf(this._getRulesForDate(oDate), rule) >= 0);

    },

    /**

     * A utility method which checks whether a given date matches the `enabledDatesRule`

     * or does not match the `disabledDatesRule` and therefore whether it can be selected.

     * @method _canBeSelected

     * @param {Date} oDate The date to check

     * @private

     * @return {boolean} Returns true if the date can be selected; false otherwise.

     */

    _canBeSelected : function (oDate) {

        var enabledDatesRule = this.get("enabledDatesRule"),

            disabledDatesRule = this.get("disabledDatesRule");

        if (enabledDatesRule) {

            return this._matchesRule(oDate, enabledDatesRule);

        } else if (disabledDatesRule) {

            return !this._matchesRule(oDate, disabledDatesRule);

        } else {

            return true;

        }

    },

    /**

     * Selects a given date or array of dates.

     * @method selectDates

     * @param {Date|Array} dates A `Date` or `Array` of `Date`s.

     * @return {CalendarBase} A reference to this object

     * @chainable

     */

    selectDates : function (dates) {

        if (ydate.isValidDate(dates)) {

            this._addDateToSelection(dates);

        }

        else if (L.isArray(dates)) {

            this._addDatesToSelection(dates);

        }

        return this;

    },

    /**

     * Deselects a given date or array of dates, or deselects

     * all dates if no argument is specified.

     * @method deselectDates

     * @param {Date|Array} [dates] A `Date` or `Array` of `Date`s, or no

     * argument if all dates should be deselected.

     * @return {CalendarBase} A reference to this object

     * @chainable

     */

    deselectDates : function (dates) {

        if (!dates) {

            this._clearSelection();

        }

        else if (ydate.isValidDate(dates)) {

            this._removeDateFromSelection(dates);

        }

        else if (L.isArray(dates)) {

            this._removeDatesFromSelection(dates);

        }