YUI.add('series-cartesian', function (Y, NAME) {

/**

 * Provides functionality for creating a cartesian chart series.

 *

 * @module charts

 * @submodule series-cartesian

 */

var Y_Lang = Y.Lang;

/**

 * An abstract class for creating series instances with horizontal and vertical axes.

 * CartesianSeries provides the core functionality used by the following classes:

 * <ul>

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

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

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

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

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

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

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

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

 *  </ul>

 *

 * @class CartesianSeries

 * @extends SeriesBase

 * @constructor

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

 * @submodule series-base

 */

Y.CartesianSeries = Y.Base.create("cartesianSeries", Y.SeriesBase, [], {

    /**

     * Storage for `xDisplayName` attribute.

     *

     * @property _xDisplayName

     * @type String

     * @private

     */

    _xDisplayName: null,

    /**

     * Storage for `yDisplayName` attribute.

     *

     * @property _yDisplayName

     * @type String

     * @private

     */

    _yDisplayName: null,

    /**

     * Th x-coordinate for the left edge of the series.

     *

     * @property _leftOrigin

     * @type String

     * @private

     */

    _leftOrigin: null,

    /**

     * The y-coordinate for the bottom edge of the series.

     *

     * @property _bottomOrigin

     * @type String

     * @private

     */

    _bottomOrigin: null,

    /**

     * Adds event listeners.

     *

     * @method addListeners

     * @private

     */

    addListeners: function()

    {

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

            yAxis = this.get("yAxis");

        if(xAxis)

        {

            this._xDataReadyHandle = xAxis.after("dataReady", Y.bind(this._xDataChangeHandler, this));

            this._xDataUpdateHandle = xAxis.after("dataUpdate", Y.bind(this._xDataChangeHandler, this));

        }

        if(yAxis)

        {

            this._yDataReadyHandle = yAxis.after("dataReady", Y.bind(this._yDataChangeHandler, this));

            this._yDataUpdateHandle = yAxis.after("dataUpdate", Y.bind(this._yDataChangeHandler, this));

        }

        this._xAxisChangeHandle = this.after("xAxisChange", this._xAxisChangeHandler);

        this._yAxisChangeHandle = this.after("yAxisChange", this._yAxisChangeHandler);

        this._stylesChangeHandle = this.after("stylesChange", function() {

            var axesReady = this._updateAxisBase();

            if(axesReady)

            {

                this.draw();

            }

        });

        this._widthChangeHandle = this.after("widthChange", function() {

            var axesReady = this._updateAxisBase();

            if(axesReady)

            {

                this.draw();

            }

        });

        this._heightChangeHandle = this.after("heightChange", function() {

            var axesReady = this._updateAxisBase();

            if(axesReady)

            {

                this.draw();

            }

        });

        this._visibleChangeHandle = this.after("visibleChange", this._handleVisibleChange);

    },

    /**

     * Event handler for the xAxisChange event.

     *

     * @method _xAxisChangeHandler

     * @param {Object} e Event object.

     * @private

     */

    _xAxisChangeHandler: function()

    {

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

        xAxis.after("dataReady", Y.bind(this._xDataChangeHandler, this));

        xAxis.after("dataUpdate", Y.bind(this._xDataChangeHandler, this));

    },

    /**

     * Event handler the yAxisChange event.

     *

     * @method _yAxisChangeHandler

     * @param {Object} e Event object.

     * @private

     */

    _yAxisChangeHandler: function()

    {

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

        yAxis.after("dataReady", Y.bind(this._yDataChangeHandler, this));

        yAxis.after("dataUpdate", Y.bind(this._yDataChangeHandler, this));

    },

    /**

     * Constant used to generate unique id.

     *

     * @property GUID

     * @type String

     * @private

     */

    GUID: "yuicartesianseries",

    /**

     * Event handler for xDataChange event.

     *

     * @method _xDataChangeHandler

     * @param {Object} event Event object.

     * @private

     */

    _xDataChangeHandler: function()

    {

        var axesReady = this._updateAxisBase();

        if(axesReady)

        {

            this.draw();

        }

    },

    /**

     * Event handler for yDataChange event.

     *

     * @method _yDataChangeHandler

     * @param {Object} event Event object.

     * @private

     */

    _yDataChangeHandler: function()

    {

        var axesReady = this._updateAxisBase();

        if(axesReady)

        {

            this.draw();

        }

    },

    /**

     * Checks to ensure that both xAxis and yAxis data are available. If so, set the `xData` and `yData` attributes

     * and return `true`. Otherwise, return `false`.

     *

     * @method _updateAxisBase

     * @return Boolean

     * @private

     */

    _updateAxisBase: function()

    {

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

            yAxis = this.get("yAxis"),

            xKey = this.get("xKey"),

            yKey = this.get("yKey"),

            yData,

            xData,

            xReady,

            yReady,

            ready;

        if(!xAxis || !yAxis || !xKey || !yKey)

        {

            ready = false;

        }

        else

        {

            xData = xAxis.getDataByKey(xKey);

            yData = yAxis.getDataByKey(yKey);

            if(Y_Lang.isArray(xKey))

            {

                xReady = (xData && Y.Object.size(xData) > 0) ? this._checkForDataByKey(xData, xKey) : false;

            }

            else

            {

                xReady = xData ? true : false;

            }

            if(Y_Lang.isArray(yKey))

            {

                yReady = (yData && Y.Object.size(yData) > 0) ? this._checkForDataByKey(yData, yKey) : false;

            }

            else

            {

                yReady = yData ? true : false;

            }

            ready = xReady && yReady;

            if(ready)

            {

                this.set("xData", xData);

                this.set("yData", yData);

            }

        }

        return ready;

    },

    /**

     * Checks to see if all keys of a data object exist and contain data.

     *

     * @method _checkForDataByKey

     * @param {Object} obj The object to check

     * @param {Array} keys The keys to check

     * @return Boolean

     * @private

     */

    _checkForDataByKey: function(obj, keys)

    {

        var i,

            len = keys.length,

            hasData = false;

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

        {

            if(obj[keys[i]])

            {

                hasData = true;

                break;

            }

        }

        return hasData;

    },

    /**

     * Draws the series is the xAxis and yAxis data are both available.

     *

     * @method validate

     * @private

     */

    validate: function()

    {

        if((this.get("xData") && this.get("yData")) || this._updateAxisBase())

        {

            this.draw();

        }

        else

        {

            this.fire("drawingComplete");

        }

    },

    /**

     * Calculates the coordinates for the series.

     *

     * @method setAreaData

     * @protected

     */

    setAreaData: function()

    {

        var w = this.get("width"),

            h = this.get("height"),

            xAxis = this.get("xAxis"),

            yAxis = this.get("yAxis"),

            xData = this._copyData(this.get("xData")),

            yData = this._copyData(this.get("yData")),

            direction = this.get("direction"),

            dataLength = direction === "vertical" ? yData.length : xData.length,

            xOffset = xAxis.getEdgeOffset(xAxis.getTotalMajorUnits(), w),

            yOffset = yAxis.getEdgeOffset(yAxis.getTotalMajorUnits(), h),

            padding = this.get("styles").padding,

			leftPadding = padding.left,

			topPadding = padding.top,

			dataWidth = w - (leftPadding + padding.right + xOffset * 2),

			dataHeight = h - (topPadding + padding.bottom + yOffset * 2),

			xMax = xAxis.get("maximum"),

			xMin = xAxis.get("minimum"),

			yMax = yAxis.get("maximum"),

			yMin = yAxis.get("minimum"),

            graphic = this.get("graphic"),

            yAxisType = yAxis.get("type"),

            reverseYCoords = (yAxisType === "numeric" || yAxisType === "stacked"),

            xcoords,

            ycoords,

            xOriginValue = xAxis.getOrigin(),

            yOriginValue = yAxis.getOrigin();

        graphic.set("width", w);

        graphic.set("height", h);

        xOffset = xOffset + leftPadding;

        yOffset = reverseYCoords ? yOffset + dataHeight + topPadding + padding.bottom : topPadding + yOffset;

        this._leftOrigin = Math.round(xAxis._getCoordFromValue(xMin, xMax, dataWidth, xOriginValue, xOffset, false));

        this._bottomOrigin = Math.round(yAxis._getCoordFromValue(yMin, yMax, dataHeight, yOriginValue, yOffset, reverseYCoords));

        xcoords = this._getCoords(xMin, xMax, dataWidth, xData, xAxis, xOffset, false);

        ycoords = this._getCoords(yMin, yMax, dataHeight, yData, yAxis, yOffset, reverseYCoords);

        this.set("xcoords", xcoords);

		this.set("ycoords", ycoords);

        this._dataLength = dataLength;

        this._setXMarkerPlane(xcoords, dataLength);

        this._setYMarkerPlane(ycoords, dataLength);

    },

    /**

     * Returns either an array coordinates or an object key valued arrays of coordinates depending on the input.

     * If the input data is an array, an array is returned. If the input data is an object, an object will be returned.

     *

     * @method _getCoords

     * @param {Number} min The minimum value of the range of data.

     * @param {Number} max The maximum value of the range of data.

     * @param {Number} length The length, in pixels, of across which the coordinates will be calculated.

     * @param {AxisBase} axis The axis in which the data is bound.

     * @param {Number} offset The value in which to offet the first coordinate.

     * @param {Boolean} reverse Indicates whether to calculate the coordinates in reverse order.

     * @return Array|Object

     * @private

     */

    _getCoords: function(min, max, length, data, axis, offset, reverse)

    {

        var coords,

            key;

        if(Y_Lang.isArray(data))

        {

            coords = axis._getCoordsFromValues(min, max, length, data, offset, reverse);

        }

        else

        {

            coords = {};

            for(key in data)

            {

                if(data.hasOwnProperty(key))

                {

                    coords[key] = this._getCoords.apply(this, [min, max, length, data[key], axis, offset, reverse]);

                }

            }

        }

        return coords;

    },

    /**

     * Used to cache xData and yData in the setAreaData method. Returns a copy of an

     * array if an array is received as the param and returns an object literal of

     * array copies if an object literal is received as the param.

     *

     * @method _copyData

     * @param {Array|Object} val The object or array to be copied.

     * @return Array|Object

     * @private

     */

    _copyData: function(val)

    {

        var copy,

            key;

        if(Y_Lang.isArray(val))

        {

            copy = val.concat();

        }

        else

        {

            copy = {};

            for(key in val)

            {

                if(val.hasOwnProperty(key))

                {

                    copy[key] = val[key].concat();