/*

YUI 3.10.3 (build 2fb5187)

Copyright 2013 Yahoo! Inc. All rights reserved.

Licensed under the BSD License.

http://yuilibrary.com/license/

*/

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

/**

 * Provides functionality for creating charts.

 *

 * @module charts

 * @submodule charts-base

 */

var CONFIG = Y.config,

    WINDOW = CONFIG.win,

    DOCUMENT = CONFIG.doc,

    Y_Lang = Y.Lang,

    IS_STRING = Y_Lang.isString,

    _getClassName = Y.ClassNameManager.getClassName,

    SERIES_MARKER = _getClassName("seriesmarker");

/**

 * Gridlines draws gridlines on a Graph.

 *

 * @class Gridlines

 * @constructor

 * @extends Base

 * @uses Renderer

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

 * @submodule charts-base

 */

Y.Gridlines = Y.Base.create("gridlines", Y.Base, [Y.Renderer], {

    /**

     * Reference to the `Path` element used for drawing Gridlines.

     *

     * @property _path

     * @type Path

     * @private

     */

    _path: null,

    /**

     * Removes the Gridlines.

     *

     * @method remove

     * @private

     */

    remove: function()

    {

        var path = this._path;

        if(path)

        {

            path.destroy();

        }

    },

    /**

     * Draws the gridlines

     *

     * @method draw

     * @protected

     */

    draw: function()

    {

        if(this.get("axis") && this.get("graph"))

        {

            this._drawGridlines();

        }

    },

    /**

     * Algorithm for drawing gridlines

     *

     * @method _drawGridlines

     * @private

     */

    _drawGridlines: function()

    {

        var path,

            axis = this.get("axis"),

            axisPosition = axis.get("position"),

            points,

            i = 0,

            l,

            direction = this.get("direction"),

            graph = this.get("graph"),

            w = graph.get("width"),

            h = graph.get("height"),

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

            color = line.color,

            weight = line.weight,

            alpha = line.alpha,

            count = this.get("count"),

            length,

            lineFunction;

        if(isFinite(w) && isFinite(h) && w > 0 && h > 0)

        {

            if(count && Y.Lang.isNumber(count))

            {

                points = this._getPoints(count, w, h);

            }

            else if(axisPosition !== "none" && axis && axis.get("tickPoints"))

            {

                points = axis.get("tickPoints");

            }

            else

            {

                points = this._getPoints(axis.get("styles").majorUnit.count, w, h);

            }

            l = points.length;

            path = graph.get("gridlines");

            path.set("width", w);

            path.set("height", h);

            path.set("stroke", {

                weight: weight,

                color: color,

                opacity: alpha

            });

            if(direction === "vertical")

            {

                lineFunction = this._verticalLine;

                length = h;

            }

            else

            {

                lineFunction = this._horizontalLine;

                length = w;

            }

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

            {

                lineFunction(path, points[i], length);

            }

            path.end();

        }

    },

    /**

     * Calculates the coordinates for the gridlines based on a count.

     *

     * @method _getPoints

     * @param {Number} count Number of gridlines

     * @return Array

     * @private

     */

    _getPoints: function(count, w, h)

    {

        var i,

            points = [],

            multiplier,

            divisor = count - 1;

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

        {

            multiplier = i/divisor;

            points[i] = {

                x: w * multiplier,

                y: h * multiplier

            };

        }

        return points;

    },

    /**

     * Algorithm for horizontal lines.

     *

     * @method _horizontalLine

     * @param {Path} path Reference to path element

     * @param {Object} pt Coordinates corresponding to a major unit of an axis.

     * @param {Number} w Width of the Graph

     * @private

     */

    _horizontalLine: function(path, pt, w)

    {

        path.moveTo(0, pt.y);

        path.lineTo(w, pt.y);

    },

    /**

     * Algorithm for vertical lines.

     *

     * @method _verticalLine

     * @param {Path} path Reference to path element

     * @param {Object} pt Coordinates corresponding to a major unit of an axis.

     * @param {Number} h Height of the Graph

     * @private

     */

    _verticalLine: function(path, pt, h)

    {

        path.moveTo(pt.x, 0);

        path.lineTo(pt.x, h);

    },

    /**

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

     * base implementation.

     *

     * @method _getDefaultStyles

     * @return Object

     * @protected

     */

    _getDefaultStyles: function()

    {

        var defs = {

            line: {

                color:"#f0efe9",

                weight: 1,

                alpha: 1

            }

        };

        return defs;

    }

},

{

    ATTRS: {

        /**

         * Indicates the direction of the gridline.

         *

         * @attribute direction

         * @type String

         */

        direction: {},

        /**

         * Indicate the `Axis` in which to bind

         * the gridlines.

         *

         * @attribute axis

         * @type Axis

         */

        axis: {},

        /**

         * Indicates the `Graph` in which the gridlines

         * are drawn.

         *

         * @attribute graph

         * @type Graph

         */

        graph: {},

        /**

         * Indicates the number of gridlines to display. If no value is set, gridlines will equal the number of ticks in

         * the corresponding axis.

         *

         * @attribute count

         * @type Number

         */

        count: {}

    }

});

/**

 * Graph manages and contains series instances for a `CartesianChart`

 * instance.

 *

 * @class Graph

 * @constructor

 * @extends Widget

 * @uses Renderer

 * @submodule charts-base

 */

Y.Graph = Y.Base.create("graph", Y.Widget, [Y.Renderer], {

    /**

     * @method bindUI

     * @private

     */

    bindUI: function()

    {

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

        bb.setStyle("position", "absolute");

        this.after("widthChange", this._sizeChangeHandler);

        this.after("heightChange", this._sizeChangeHandler);

        this.after("stylesChange", this._updateStyles);

        this.after("groupMarkersChange", this._drawSeries);

    },

    /**

     * @method syncUI

     * @private

     */

    syncUI: function()

    {

        var background,

            cb,

            bg,

            sc = this.get("seriesCollection"),

            series,

            i = 0,

            len = sc ? sc.length : 0,

            hgl = this.get("horizontalGridlines"),

            vgl = this.get("verticalGridlines");

        if(this.get("showBackground"))

        {

            background = this.get("background");

            cb = this.get("contentBox");

            bg = this.get("styles").background;

            bg.stroke = bg.border;

            bg.stroke.opacity = bg.stroke.alpha;

            bg.fill.opacity = bg.fill.alpha;

            bg.width = this.get("width");

            bg.height = this.get("height");

            bg.type = bg.shape;

            background.set(bg);

        }

        for(; i < len; ++i)

        {

            series = sc[i];

            if(series instanceof Y.SeriesBase)

            {

                series.render();

            }

        }

        if(hgl && hgl instanceof Y.Gridlines)

        {

            hgl.draw();

        }

        if(vgl && vgl instanceof Y.Gridlines)

        {

            vgl.draw();

        }

    },

    /**

     * Object of arrays containing series mapped to a series type.

     *

     * @property seriesTypes

     * @type Object

     * @private

     */

    seriesTypes: null,

    /**

     * Returns a series instance based on an index.

     *

     * @method getSeriesByIndex

     * @param {Number} val index of the series

     * @return CartesianSeries

     */

    getSeriesByIndex: function(val)

    {

        var col = this.get("seriesCollection"),

            series;

        if(col && col.length > val)

        {

            series = col[val];

        }

        return series;

    },

    /**

     * Returns a series instance based on a key value.

     *

     * @method getSeriesByKey

     * @param {String} val key value of the series

     * @return CartesianSeries

     */

    getSeriesByKey: function(val)

    {

        var obj = this._seriesDictionary,

            series;

        if(obj && obj.hasOwnProperty(val))

        {

            series = obj[val];

        }

        return series;

    },

    /**

     * Adds dispatcher to a `_dispatcher` used to

     * to ensure all series have redrawn before for firing event.

     *

     * @method addDispatcher

     * @param {CartesianSeries} val series instance to add

     * @protected

     */

    addDispatcher: function(val)

    {

        if(!this._dispatchers)

        {

            this._dispatchers = [];

        }

        this._dispatchers.push(val);

    },

    /**

     * Collection of series to be displayed in the graph.

     *

     * @property _seriesCollection

     * @type Array

     * @private

     */

    _seriesCollection: null,

    /**

     * Object containing key value pairs of `CartesianSeries` instances.

     *

     * @property _seriesDictionary

     * @type Object

     * @private

     */

    _seriesDictionary: null,

    /**

     * Parses series instances to be displayed in the graph.

     *

     * @method _parseSeriesCollection

     * @param {Array} Collection of `CartesianSeries` instances or objects container `CartesianSeries` attributes values.

     * @private

     */

    _parseSeriesCollection: function(val)

    {

        if(!val)

        {

            return;

        }

        var len = val.length,

            i = 0,

            series,

            seriesKey;

        this._seriesCollection = [];

        this._seriesDictionary = {};

        this.seriesTypes = [];

        for(; i < len; ++i)

        {

            series = val[i];

            if(!(series instanceof Y.CartesianSeries) && !(series instanceof Y.PieSeries))

            {

                this._createSeries(series);

                continue;

            }

            this._addSeries(series);

        }

        len = this._seriesCollection.length;

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

        {

            series = this.get("seriesCollection")[i];

            seriesKey = series.get("direction") === "horizontal" ? "yKey" : "xKey";

            this._seriesDictionary[series.get(seriesKey)] = series;

        }

    },

    /**

     * Adds a series to the graph.

     *

     * @method _addSeries

     * @param {CartesianSeries} series Series to add to the graph.

     * @private

     */

    _addSeries: function(series)

    {

        var type = series.get("type"),

            seriesCollection = this.get("seriesCollection"),

            graphSeriesLength = seriesCollection.length,

            seriesTypes = this.seriesTypes,

            typeSeriesCollection;

        if(!series.get("graph"))

        {

            series.set("graph", this);

        }

        seriesCollection.push(series);

        if(!seriesTypes.hasOwnProperty(type))

        {

            this.seriesTypes[type] = [];

        }

        typeSeriesCollection = this.seriesTypes[type];

        series.set("graphOrder", graphSeriesLength);

        series.set("order", typeSeriesCollection.length);

        typeSeriesCollection.push(series);

        series.set("seriesTypeCollection", typeSeriesCollection);

        this.addDispatcher(series);

        series.after("drawingComplete", Y.bind(this._drawingCompleteHandler, this));

        this.fire("seriesAdded", series);

    },

    /**

     * Creates a `CartesianSeries` instance from an object containing attribute key value pairs. The key value pairs include

     * attributes for the specific series and a type value which defines the type of series to be used.

     *

     * @method createSeries

     * @param {Object} seriesData Series attribute key value pairs.

     * @private

     */

    _createSeries: function(seriesData)

    {

        var type = seriesData.type,

            seriesCollection = this.get("seriesCollection"),

            seriesTypes = this.seriesTypes,

            typeSeriesCollection,

            SeriesClass,

            series;

            seriesData.graph = this;

        if(!seriesTypes.hasOwnProperty(type))

        {

            seriesTypes[type] = [];

        }

        typeSeriesCollection = seriesTypes[type];

        seriesData.graph = this;

        seriesData.order = typeSeriesCollection.length;

        seriesData.graphOrder = seriesCollection.length;

        SeriesClass = this._getSeries(seriesData.type);

        series = new SeriesClass(seriesData);

        this.addDispatcher(series);

        series.after("drawingComplete", Y.bind(this._drawingCompleteHandler, this));

        typeSeriesCollection.push(series);

        seriesCollection.push(series);

        series.set("seriesTypeCollection", typeSeriesCollection);

        if(this.get("rendered"))

        {

            series.render();

        }

    },

    /**

     * String reference for pre-defined `Series` classes.

     *

     * @property _seriesMap

     * @type Object

     * @private

     */

    _seriesMap: {

        line : Y.LineSeries,

        column : Y.ColumnSeries,

        bar : Y.BarSeries,

        area :  Y.AreaSeries,

        candlestick : Y.CandlestickSeries,

        ohlc : Y.OHLCSeries,

        stackedarea : Y.StackedAreaSeries,

        stackedline : Y.StackedLineSeries,