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

/**

 * Provides functionality for drawing fills in a series.

 *

 * @module charts

 * @submodule series-fill-util

 */

var Y_Lang = Y.Lang;

/**

 * Utility class used for drawing area fills.

 *

 * @class Fills

 * @constructor

 * @submodule series-fill-util

 */

function Fills() {}

Fills.ATTRS = {

    area: {

        getter: function()

        {

            return this._defaults || this._getAreaDefaults();

        },

        setter: function(val)

        {

            var defaults = this._defaults || this._getAreaDefaults();

            this._defaults = Y.merge(defaults, val);

        }

    }

};

Fills.prototype = {

    /**

     * Returns a path shape used for drawing fills.

     *

     * @method _getPath

     * @return Path

     * @private

     */

    _getPath: function()

    {

        var path = this._path;

        if(!path)

        {

            path = this.get("graphic").addShape({type:"path"});

            this._path = path;

        }

        return path;

    },

    /**

     * Toggles visibility

     *

     * @method _toggleVisible

     * @param {Boolean} visible indicates visibilitye

     * @private

     */

    _toggleVisible: function(visible)

    {

        if(this._path)

        {

            this._path.set("visible", visible);

        }

    },

    /**

     * Draws fill

     *

     * @method drawFill

     * @param {Array} xcoords The x-coordinates for the series.

     * @param {Array} ycoords The y-coordinates for the series.

     * @protected

     */

    drawFill: function(xcoords, ycoords)

    {

        if(xcoords.length < 1)

        {

            return;

        }

        var isNumber = Y_Lang.isNumber,

            len = xcoords.length,

            firstX = xcoords[0],

            firstY = ycoords[0],

            lastValidX = firstX,

            lastValidY = firstY,

            nextX,

            nextY,

            pointValid,

            noPointsRendered = true,

            i = 0,

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

            path = this._getPath(),

            color = styles.color || this._getDefaultColor(this.get("graphOrder"), "slice");

        path.clear();

        path.set("fill", {

            color: color,

            opacity: styles.alpha

        });

        path.set("stroke", {weight: 0});

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

        {

            nextX = xcoords[i];

            nextY = ycoords[i];

            pointValid = isNumber(nextX) && isNumber(nextY);

            if(!pointValid)

            {

                continue;

            }

            if(noPointsRendered)

            {

                this._firstValidX = nextX;

                this._firstValidY = nextY;

                noPointsRendered = false;

                path.moveTo(nextX, nextY);

            }

            else

            {

                path.lineTo(nextX, nextY);

            }

            lastValidX = nextX;

            lastValidY = nextY;

        }

        this._lastValidX = lastValidX;

        this._lastValidY = lastValidY;

        path.end();

    },

    /**

     * Draws a fill for a spline

     *

     * @method drawAreaSpline

     * @protected

     */

    drawAreaSpline: function()

    {

        if(this.get("xcoords").length < 1)

        {

            return;

        }

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

            ycoords = this.get("ycoords"),

            curvecoords = this.getCurveControlPoints(xcoords, ycoords),

            len = curvecoords.length,

            cx1,

            cx2,

            cy1,

            cy2,

            x,

            y,

            i = 0,

            firstX = xcoords[0],

            firstY = ycoords[0],

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

            path = this._getPath(),

            color = styles.color || this._getDefaultColor(this.get("graphOrder"), "slice");

        path.set("fill", {

            color: color,

            opacity: styles.alpha

        });

        path.set("stroke", {weight: 0});

        path.moveTo(firstX, firstY);

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

        {

            x = curvecoords[i].endx;

            y = curvecoords[i].endy;

            cx1 = curvecoords[i].ctrlx1;

            cx2 = curvecoords[i].ctrlx2;

            cy1 = curvecoords[i].ctrly1;

            cy2 = curvecoords[i].ctrly2;

            path.curveTo(cx1, cy1, cx2, cy2, x, y);

        }

        if(this.get("direction") === "vertical")

        {

            path.lineTo(this._leftOrigin, y);

            path.lineTo(this._leftOrigin, firstY);

        }

        else

        {

            path.lineTo(x, this._bottomOrigin);

            path.lineTo(firstX, this._bottomOrigin);

        }

        path.lineTo(firstX, firstY);

        path.end();

    },

    /**

     * Draws a a stacked area spline

     *

     * @method drawStackedAreaSpline

     * @protected

     */

    drawStackedAreaSpline: function()

    {

        if(this.get("xcoords").length < 1)

        {

            return;

        }

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

            ycoords = this.get("ycoords"),

            curvecoords,

            order = this.get("order"),

            seriesCollection = this.get("seriesTypeCollection"),

            prevXCoords,

            prevYCoords,

            len,

            cx1,

            cx2,

            cy1,

            cy2,

            x,

            y,

            i = 0,

            firstX,

            firstY,

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

            path = this._getPath(),

            color = styles.color || this._getDefaultColor(this.get("graphOrder"), "slice");

        firstX = xcoords[0];

        firstY = ycoords[0];

        curvecoords = this.getCurveControlPoints(xcoords, ycoords);

        len = curvecoords.length;

        path.set("fill", {

            color: color,

            opacity: styles.alpha

        });

        path.set("stroke", {weight: 0});

        path.moveTo(firstX, firstY);

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

        {

            x = curvecoords[i].endx;

            y = curvecoords[i].endy;

            cx1 = curvecoords[i].ctrlx1;

            cx2 = curvecoords[i].ctrlx2;

            cy1 = curvecoords[i].ctrly1;

            cy2 = curvecoords[i].ctrly2;

            path.curveTo(cx1, cy1, cx2, cy2, x, y);

        }

        if(order > 0)

        {

            prevXCoords = seriesCollection[order - 1].get("xcoords").concat().reverse();

            prevYCoords = seriesCollection[order - 1].get("ycoords").concat().reverse();

            curvecoords = this.getCurveControlPoints(prevXCoords, prevYCoords);

            i = 0;

            len = curvecoords.length;

            path.lineTo(prevXCoords[0], prevYCoords[0]);

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

            {

                x = curvecoords[i].endx;

                y = curvecoords[i].endy;

                cx1 = curvecoords[i].ctrlx1;

                cx2 = curvecoords[i].ctrlx2;

                cy1 = curvecoords[i].ctrly1;

                cy2 = curvecoords[i].ctrly2;

                path.curveTo(cx1, cy1, cx2, cy2, x, y);

            }

        }

        else

        {

            if(this.get("direction") === "vertical")

            {

                path.lineTo(this._leftOrigin, ycoords[ycoords.length-1]);

                path.lineTo(this._leftOrigin, firstY);

            }

            else

            {

                path.lineTo(xcoords[xcoords.length-1], this._bottomOrigin);

                path.lineTo(firstX, this._bottomOrigin);

            }

        }

        path.lineTo(firstX, firstY);

        path.end();

    },

    /**

     * Storage for default area styles.

     *

     * @property _defaults

     * @type Object

     * @private

     */

    _defaults: null,

    /**

     * Concatenates coordinate array with correct coordinates for closing an area fill.

     *

     * @method _getClosingPoints

     * @return Array

     * @protected

     */

    _getClosingPoints: function()

    {

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

            ycoords = this.get("ycoords").concat(),

            firstValidIndex,

            lastValidIndex;

        if(this.get("direction") === "vertical")

        {

            lastValidIndex = this._getLastValidIndex(xcoords);

            firstValidIndex = this._getFirstValidIndex(xcoords);

            ycoords.push(ycoords[lastValidIndex]);

            ycoords.push(ycoords[firstValidIndex]);

            xcoords.push(this._leftOrigin);

            xcoords.push(this._leftOrigin);

        }

        else

        {

            lastValidIndex = this._getLastValidIndex(ycoords);

            firstValidIndex = this._getFirstValidIndex(ycoords);

            xcoords.push(xcoords[lastValidIndex]);

            xcoords.push(xcoords[firstValidIndex]);

            ycoords.push(this._bottomOrigin);

            ycoords.push(this._bottomOrigin);

        }

        xcoords.push(xcoords[0]);

        ycoords.push(ycoords[0]);

        return [xcoords, ycoords];

    },

    /**

     * Returns the order of the series closest to the current series that has a valid value for the current index.

     *

     * @method _getHighestValidOrder

     * @param {Array} seriesCollection Array of series of a given type.

     * @param {Number} index Index of the series item.

     * @param {Number} order Index of the the series in the seriesCollection

     * @param {String} direction Indicates the direction of the series

     * @return Number

     * @private

     */

    _getHighestValidOrder: function(seriesCollection, index, order, direction)

    {

        var coords = direction === "vertical" ? "stackedXCoords" : "stackedYCoords",

            coord;

        while(isNaN(coord) && order > -1)

        {

          order = order - 1;

          if(order > -1)

          {

            coord = seriesCollection[order].get(coords)[index];

          }

        }

        return order;

    },

    /**

     * Returns an array containing the x and y coordinates for a given series and index.

     *

     * @method _getCoordsByOrderAndIndex

     * @param {Array} seriesCollection Array of series of a given type.

     * @param {Number} index Index of the series item.

     * @param {Number} order Index of the the series in the seriesCollection

     * @param {String} direction Indicates the direction of the series

     * @return Array

     * @private

     */

    _getCoordsByOrderAndIndex: function(seriesCollection, index, order, direction)

    {

        var xcoord,

            ycoord;

        if(direction === "vertical")

        {

            xcoord = order < 0 ? this._leftOrigin : seriesCollection[order].get("stackedXCoords")[index];

            ycoord = this.get("stackedYCoords")[index];

        }

        else

        {

            xcoord = this.get("stackedXCoords")[index];

            ycoord = order < 0 ? this._bottomOrigin : seriesCollection[order].get("stackedYCoords")[index];

        }

        return [xcoord, ycoord];

    },

    /**

     * Concatenates coordinate array with the correct coordinates for closing an area stack.

     *

     * @method _getStackedClosingPoints