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

/**

 * The Charts widget provides an api for displaying data

 * graphically.

 *

 * @module charts

 * @main charts

 */

/**

 * Provides functionality for the handling of axis data in a chart.

 *

 * @module charts

 * @submodule axis-base

 */

var Y_Lang = Y.Lang;

/**

 * The Renderer class is a base class for chart components that use the `styles`

 * attribute.

 *

 * @module charts

 * @class Renderer

 * @constructor

 */

function Renderer(){}

Renderer.ATTRS = {

        /**

         * Style properties for class

         *

         * @attribute styles

         * @type Object

         */

        styles:

        {

            getter: function()

            {

                this._styles = this._styles || this._getDefaultStyles();

                return this._styles;

            },

            setter: function(val)

            {

                this._styles = this._setStyles(val);

            }

        },

        /**

         * The graphic in which drawings will be rendered.

         *

         * @attribute graphic

         * @type Graphic

         */

        graphic: {}

};

Renderer.NAME = "renderer";

Renderer.prototype = {

    /**

     * Storage for `styles` attribute.

     *

     * @property _styles

     * @type Object

     * @private

     */

	_styles: null,

    /**

     * Method used by `styles` setter.

     *

     * @method _setStyles

     * @param {Object} newStyles Hash of properties to update.

     * @return Object

     * @protected

     */

	_setStyles: function(newstyles)

	{

		var styles = this.get("styles");

        return this._mergeStyles(newstyles, styles);

	},

    /**

     * Merges to object literals so that only specified properties are

     * overwritten.

     *

     * @method _mergeStyles

     * @param {Object} a Hash of new styles

     * @param {Object} b Hash of original styles

     * @return Object

     * @protected

     */

    _mergeStyles: function(a, b)

    {

        if(!b)

        {

            b = {};

        }

        var newstyles = Y.merge(b, {});

        Y.Object.each(a, function(value, key)

        {

            if(b.hasOwnProperty(key) && Y_Lang.isObject(value) && !Y_Lang.isFunction(value) && !Y_Lang.isArray(value))

            {

                newstyles[key] = this._mergeStyles(value, b[key]);

            }

            else

            {

                newstyles[key] = value;

            }

        }, this);

        return newstyles;

    },

    /**

     * Copies an object literal.

     *

     * @method _copyObject

     * @param {Object} obj Object literal to be copied.

     * @return Object

     * @private

     */

    _copyObject: function(obj) {

        var newObj = {},

            key,

            val;

        for(key in obj)

        {

            if(obj.hasOwnProperty(key))

            {

                val = obj[key];

                if(typeof val === "object" && !Y_Lang.isArray(val))

                {

                    newObj[key] = this._copyObject(val);

                }

                else

                {

                    newObj[key] = val;

                }

            }

        }

        return newObj;

    },

    /**

     * Gets the default value for the `styles` attribute.

     *

     * @method _getDefaultStyles

     * @return Object

     * @protected

     */

    _getDefaultStyles: function()

    {

        return {padding:{

            top:0,

            right: 0,

            bottom: 0,

            left: 0

        }};

    }

};

Y.augment(Renderer, Y.Attribute);

Y.Renderer = Renderer;

/**

 * The axis-base submodule contains functionality for the handling of axis data in a chart.

 *

 * @module charts

 * @submodule axis-base

 */

/**

 * An abstract class that provides the core functionality used by the following classes:

 * <ul>

 *      <li>{{#crossLink "CategoryAxisBase"}}{{/crossLink}}</li>

 *      <li>{{#crossLink "NumericAxisBase"}}{{/crossLink}}</li>

 *      <li>{{#crossLink "StackedAxisBase"}}{{/crossLink}}</li>

 *      <li>{{#crossLink "TimeAxisBase"}}{{/crossLink}}</li>

 *      <li>{{#crossLink "CategoryAxis"}}{{/crossLink}}</li>

 *      <li>{{#crossLink "NumericAxis"}}{{/crossLink}}</li>

 *      <li>{{#crossLink "StackedAxis"}}{{/crossLink}}</li>

 *      <li>{{#crossLink "TimeAxis"}}{{/crossLink}}</li>

 *  </ul>

 *

 * @class AxisBase

 * @constructor

 * @extends Base

 * @uses Renderer

 * @param {Object} config (optional) Configuration parameters.

 * @submodule axis-base

 */

Y.AxisBase = Y.Base.create("axisBase", Y.Base, [Y.Renderer], {

    /**

     * @method initializer

     * @private

     */

    initializer: function()

    {

        this.after("minimumChange", Y.bind(this._keyChangeHandler, this));

        this.after("maximumChange", Y.bind(this._keyChangeHandler, this));

        this.after("keysChange", this._keyChangeHandler);

        this.after("dataProviderChange", this._dataProviderChangeHandler);

    },

    /**

     * Returns the value corresponding to the origin on the axis.

     *

     * @method getOrigin

     * @return Number

     */

    getOrigin: function() {

        return this.get("minimum");

    },

    /**

     * Handles changes to `dataProvider`.

     *

     * @method _dataProviderChangeHandler

     * @param {Object} e Event object.

     * @private

     */

    _dataProviderChangeHandler: function()

    {

        var keyCollection = this.get("keyCollection").concat(),

            keys = this.get("keys"),

            i;

        if(keys)

        {

            for(i in keys)

            {

                if(keys.hasOwnProperty(i))

                {

                    delete keys[i];

                }

            }

        }

        if(keyCollection && keyCollection.length)

        {

            this.set("keys", keyCollection);

        }

    },

    /**

     * Calculates the maximum and minimum values for the `Data`.

     *

     * @method _updateMinAndMax

     * @private

     */

    _updateMinAndMax: function() {

    },

    /**

     * Constant used to generate unique id.

     *

     * @property GUID

     * @type String

     * @private

     */

    GUID: "yuibaseaxis",

    /**

     * Type of data used in `Axis`.

     *

     * @property _type

     * @type String

     * @readOnly

     * @private

     */

    _type: null,

    /**

     * Storage for `setMaximum` attribute.

     *

     * @property _setMaximum

     * @type Object

     * @private

     */

    _setMaximum: null,

    /**

     * Storage for `setMinimum` attribute.

     *

     * @property _setMinimum

     * @type Object

     * @private

     */

    _setMinimum: null,

    /**

     * Reference to data array.

     *

     * @property _data

     * @type Array

     * @private

     */

    _data: null,

    /**

     * Indicates whether the all data is up to date.

     *

     * @property _updateTotalDataFlag

     * @type Boolean

     * @private

     */

    _updateTotalDataFlag: true,

    /**

     * Storage for `dataReady` attribute.

     *

     * @property _dataReady

     * @type Boolean

     * @readOnly

     * @private

     */

    _dataReady: false,

    /**

     * Adds an array to the key hash.

     *

     * @method addKey

     * @param value Indicates what key to use in retrieving

     * the array.

     */

    addKey: function (value)

	{

        this.set("keys", value);

	},

    /**

     * Gets an array of values based on a key.

     *

     * @method _getKeyArray

     * @param {String} key Value key associated with the data array.

     * @param {Array} data Array in which the data resides.

     * @return Array

     * @private

     */

    _getKeyArray: function(key, data)

    {

        var i = 0,

            obj,

            keyArray = [],

            len = data.length;

        for(; i < len; ++i)

        {

            obj = data[i];

            keyArray[i] = obj[key];

        }

        return keyArray;

    },

    /**

     * Updates the total data array.

     *

     * @method _updateTotalData

     * @private

     */

    _updateTotalData: function()

    {

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

            i;

        this._data = [];

        for(i in keys)

        {

            if(keys.hasOwnProperty(i))

            {

                this._data = this._data.concat(keys[i]);

            }

        }

        this._updateTotalDataFlag = false;

    },

    /**

     * Removes an array from the key hash.

     *

     * @method removeKey

     * @param {String} value Indicates what key to use in removing from

     * the hash.

     */

    removeKey: function(value)

    {

        var keys = this.get("keys");

        if(keys.hasOwnProperty(value))

        {

            delete keys[value];

            this._keyChangeHandler();

        }

    },

    /**

     * Returns a value based of a key value and an index.

     *

     * @method getKeyValueAt

     * @param {String} key value used to look up the correct array

     * @param {Number} index within the array

     * @return Number

     */

    getKeyValueAt: function(key, index)

    {

        var value = NaN,

            keys = this.get("keys");

        if(keys[key] && Y_Lang.isNumber(parseFloat(keys[key][index])))

        {

            value = keys[key][index];

        }

        return parseFloat(value);

    },

    /**

     * Returns values based on key identifiers. When a string is passed as an argument, an array of values is returned.

     * When an array of keys is passed as an argument, an object literal with an array of values mapped to each key is

     * returned.

     *

     * @method getDataByKey

     * @param {String|Array} value value used to identify the array

     * @return Array|Object

     */

    getDataByKey: function (value)

    {

        var obj,

            i,

            len,

            key,

            keys = this.get("keys");

        if(Y_Lang.isArray(value))

        {

            obj = {};

            len = value.length;

            for(i = 0; i < len; i = i + 1)

            {

                key = value[i];

                if(keys[key])