/*

YUI 3.10.3 (build 2fb5187)

Copyright 2013 Yahoo! Inc. All rights reserved.

Licensed under the BSD License.

http://yuilibrary.com/license/

*/

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"),

            xScaleFactor = dataWidth / (xMax - xMin),

			yScaleFactor = dataHeight / (yMax - yMin),

            graphic = this.get("graphic"),

            xcoords,

            ycoords;

        graphic.set("width", w);

        graphic.set("height", h);

        //Assuming a vertical graph has a range/category for its vertical axis.

        if(direction === "vertical")

        {

            yData = yData.reverse();

        }

        this._leftOrigin = Math.round(((0 - xMin) * xScaleFactor) + leftPadding + xOffset);

        this._bottomOrigin = Math.round((dataHeight + topPadding + yOffset));

        if(yMin < 0)

        {

            this._bottomOrigin = this._bottomOrigin - ((0 - yMin) * yScaleFactor);

        }

        xcoords = this._getXCoords(xData, xMin, dataWidth, xScaleFactor, xOffset, dataLength, leftPadding);

        ycoords = this._getYCoords(yData, yMin, dataHeight, yScaleFactor, yOffset, dataLength, topPadding);

        this.set("xcoords", xcoords);

		this.set("ycoords", ycoords);

        this._dataLength = dataLength;

        this._setXMarkerPlane(xcoords, dataLength);

        this._setYMarkerPlane(ycoords, dataLength);

    },

    /**

     * 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();

                }

            }

        }

        return copy;

    },

    /**

     * Sets the marker plane for the series when the coords argument is an array.

     * If the coords argument is an object literal no marker plane is set.

     *

     * @method _setXMarkerPlane

     * @param {Array|Object} coords An array of x coordinates or an object literal

     * containing key value pairs mapped to an array of coordinates.

     * @param {Number} dataLength The length of data for the series.

     * @private

     */

    _setXMarkerPlane: function(coords, dataLength)

    {

        var i = 0,

            xMarkerPlane = [],

            xMarkerPlaneOffset = this.get("xMarkerPlaneOffset"),

            nextX;

        if(Y_Lang.isArray(coords))

        {

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

            {

                nextX = coords[i];

                xMarkerPlane.push({start:nextX - xMarkerPlaneOffset, end: nextX + xMarkerPlaneOffset});