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

/**

 * Adds legend functionality to charts.

 *

 * @module charts

 * @submodule charts-legend

 */

var TOP = "top",

RIGHT = "right",

BOTTOM = "bottom",

LEFT = "left",

EXTERNAL = "external",

HORIZONTAL = "horizontal",

VERTICAL = "vertical",

WIDTH = "width",

HEIGHT = "height",

POSITION = "position",

_X = "x",

_Y = "y",

PX = "px",

PieChartLegend,

LEGEND = {

    setter: function(val)

    {

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

        if(legend)

        {

            legend.destroy(true);

        }

        if(val instanceof Y.ChartLegend)

        {

            legend = val;

            legend.set("chart", this);

        }

        else

        {

            val.chart = this;

            if(!val.hasOwnProperty("render"))

            {

                val.render = this.get("contentBox");

                val.includeInChartLayout = true;

            }

            legend = new Y.ChartLegend(val);

        }

        return legend;

    }

},

/**

 * Contains methods for displaying items horizontally in a legend.

 *

 * @module charts

 * @submodule charts-legend

 * @class HorizontalLegendLayout

 */

HorizontalLegendLayout = {

    /**

     * Displays items horizontally in a legend.

     *

     * @method _positionLegendItems

     * @param {Array} items Array of items to display in the legend.

     * @param {Number} maxWidth The width of the largest item in the legend.

     * @param {Number} maxHeight The height of the largest item in the legend.

     * @param {Number} totalWidth The total width of all items in a legend.

     * @param {Number} totalHeight The total height of all items in a legend.

     * @param {Number} padding The left, top, right and bottom padding properties for the legend.

     * @param {Number} horizontalGap The horizontal distance between items in a legend.

     * @param {Number} verticalGap The vertical distance between items in a legend.

     * @param {String} hAlign The horizontal alignment of the legend.

     * @protected

     */

    _positionLegendItems: function(items, maxWidth, maxHeight, totalWidth, totalHeight, padding, horizontalGap, verticalGap, hAlign)

    {

        var i = 0,

            rowIterator = 0,

            item,

            node,

            itemWidth,

            itemHeight,

            len,

            width = this.get("width"),

            rows,

            rowsLen,

            row,

            totalWidthArray,

            legendWidth,

            topHeight = padding.top - verticalGap,

            limit = width - (padding.left + padding.right),

            left,

            top,

            right,

            bottom;

        HorizontalLegendLayout._setRowArrays(items, limit, horizontalGap);

        rows = HorizontalLegendLayout.rowArray;

        totalWidthArray = HorizontalLegendLayout.totalWidthArray;

        rowsLen = rows.length;

        for(; rowIterator < rowsLen; ++ rowIterator)

        {

            topHeight += verticalGap;

            row = rows[rowIterator];

            len = row.length;

            legendWidth =  HorizontalLegendLayout.getStartPoint(width, totalWidthArray[rowIterator], hAlign, padding);

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

            {

                item = row[i];

                node = item.node;

                itemWidth = item.width;

                itemHeight = item.height;

                item.x = legendWidth;

                item.y = 0;

                left = !isNaN(left) ? Math.min(left, legendWidth) : legendWidth;

                top = !isNaN(top) ? Math.min(top, topHeight) : topHeight;

                right = !isNaN(right) ? Math.max(legendWidth + itemWidth, right) : legendWidth + itemWidth;

                bottom = !isNaN(bottom) ? Math.max(topHeight + itemHeight, bottom) : topHeight + itemHeight;

                node.setStyle("left", legendWidth + PX);

                node.setStyle("top", topHeight + PX);

                legendWidth += itemWidth + horizontalGap;

            }

            topHeight += item.height;

        }

        this._contentRect = {

            left: left,

            top: top,

            right: right,

            bottom: bottom

        };

        if(this.get("includeInChartLayout"))

        {

            this.set("height", topHeight + padding.bottom);

        }

    },

    /**

     * Creates row and total width arrays used for displaying multiple rows of

     * legend items based on the items, available width and horizontalGap for the legend.

     *

     * @method _setRowArrays

     * @param {Array} items Array of legend items to display in a legend.

     * @param {Number} limit Total available width for displaying items in a legend.

     * @param {Number} horizontalGap Horizontal distance between items in a legend.

     * @protected

     */

    _setRowArrays: function(items, limit, horizontalGap)

    {

        var item = items[0],

            rowArray = [[item]],

            i = 1,

            rowIterator = 0,

            len = items.length,

            totalWidth = item.width,

            itemWidth,

            totalWidthArray = [[totalWidth]];

        for(; i < len; ++i)

        {

            item = items[i];

            itemWidth = item.width;

            if((totalWidth + horizontalGap + itemWidth) <= limit)

            {

                totalWidth += horizontalGap + itemWidth;

                rowArray[rowIterator].push(item);

            }

            else

            {

                totalWidth = horizontalGap + itemWidth;

                if(rowArray[rowIterator])

                {

                    rowIterator += 1;

                }

                rowArray[rowIterator] = [item];

            }

            totalWidthArray[rowIterator] = totalWidth;

        }

        HorizontalLegendLayout.rowArray = rowArray;

        HorizontalLegendLayout.totalWidthArray = totalWidthArray;

    },

    /**

     * Returns the starting x-coordinate for a row of legend items.

     *

     * @method getStartPoint

     * @param {Number} w Width of the legend.

     * @param {Number} totalWidth Total width of all labels in the row.

     * @param {String} align Horizontal alignment of items for the legend.

     * @param {Object} padding Object contain left, top, right and bottom padding properties.

     * @return Number

     * @protected

     */

    getStartPoint: function(w, totalWidth, align, padding)

    {

        var startPoint;

        switch(align)

        {

            case LEFT :

                startPoint = padding.left;

            break;

            case "center" :

                startPoint = (w - totalWidth) * 0.5;

            break;

            case RIGHT :

                startPoint = w - totalWidth - padding.right;

            break;

        }

        return startPoint;

    }

},

/**

 * Contains methods for displaying items vertically in a legend.

 *

 * @module charts

 * @submodule charts-legend

 * @class VerticalLegendLayout

 */

VerticalLegendLayout = {

    /**

     * Displays items vertically in a legend.

     *

     * @method _positionLegendItems

     * @param {Array} items Array of items to display in the legend.

     * @param {Number} maxWidth The width of the largest item in the legend.

     * @param {Number} maxHeight The height of the largest item in the legend.

     * @param {Number} totalWidth The total width of all items in a legend.

     * @param {Number} totalHeight The total height of all items in a legend.

     * @param {Number} padding The left, top, right and bottom padding properties for the legend.

     * @param {Number} horizontalGap The horizontal distance between items in a legend.

     * @param {Number} verticalGap The vertical distance between items in a legend.

     * @param {String} vAlign The vertical alignment of the legend.

     * @protected

     */

    _positionLegendItems: function(items, maxWidth, maxHeight, totalWidth, totalHeight, padding, horizontalGap, verticalGap, vAlign)

    {

        var i = 0,

            columnIterator = 0,

            item,

            node,

            itemHeight,

            itemWidth,

            len,

            height = this.get("height"),

            columns,

            columnsLen,

            column,

            totalHeightArray,

            legendHeight,

            leftWidth = padding.left - horizontalGap,

            legendWidth,

            limit = height - (padding.top + padding.bottom),

            left,

            top,

            right,

            bottom;

        VerticalLegendLayout._setColumnArrays(items, limit, verticalGap);

        columns = VerticalLegendLayout.columnArray;

        totalHeightArray = VerticalLegendLayout.totalHeightArray;

        columnsLen = columns.length;

        for(; columnIterator < columnsLen; ++ columnIterator)

        {

            leftWidth += horizontalGap;

            column = columns[columnIterator];

            len = column.length;

            legendHeight =  VerticalLegendLayout.getStartPoint(height, totalHeightArray[columnIterator], vAlign, padding);

            legendWidth = 0;

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

            {

                item = column[i];

                node = item.node;

                itemHeight = item.height;

                itemWidth = item.width;

                item.y = legendHeight;

                item.x = leftWidth;

                left = !isNaN(left) ? Math.min(left, leftWidth) : leftWidth;

                top = !isNaN(top) ? Math.min(top, legendHeight) : legendHeight;

                right = !isNaN(right) ? Math.max(leftWidth + itemWidth, right) : leftWidth + itemWidth;

                bottom = !isNaN(bottom) ? Math.max(legendHeight + itemHeight, bottom) : legendHeight + itemHeight;

                node.setStyle("left", leftWidth + PX);

                node.setStyle("top", legendHeight + PX);

                legendHeight += itemHeight + verticalGap;

                legendWidth = Math.max(legendWidth, item.width);

            }

            leftWidth += legendWidth;

        }

        this._contentRect = {

            left: left,

            top: top,

            right: right,

            bottom: bottom

        };

        if(this.get("includeInChartLayout"))

        {

            this.set("width", leftWidth + padding.right);

        }

    },

    /**

     * Creates column and total height arrays used for displaying multiple columns of

     * legend items based on the items, available height and verticalGap for the legend.

     *

     * @method _setColumnArrays

     * @param {Array} items Array of legend items to display in a legend.

     * @param {Number} limit Total available height for displaying items in a legend.

     * @param {Number} verticalGap Vertical distance between items in a legend.

     * @protected

     */

    _setColumnArrays: function(items, limit, verticalGap)

    {

        var item = items[0],

            columnArray = [[item]],

            i = 1,

            columnIterator = 0,

            len = items.length,

            totalHeight = item.height,

            itemHeight,

            totalHeightArray = [[totalHeight]];

        for(; i < len; ++i)

        {

            item = items[i];

            itemHeight = item.height;

            if((totalHeight + verticalGap + itemHeight) <= limit)

            {

                totalHeight += verticalGap + itemHeight;

                columnArray[columnIterator].push(item);

            }

            else

            {

                totalHeight = verticalGap + itemHeight;

                if(columnArray[columnIterator])

                {

                    columnIterator += 1;

                }

                columnArray[columnIterator] = [item];

            }

            totalHeightArray[columnIterator] = totalHeight;

        }

        VerticalLegendLayout.columnArray = columnArray;

        VerticalLegendLayout.totalHeightArray = totalHeightArray;

    },

    /**

     * Returns the starting y-coordinate for a column of legend items.

     *

     * @method getStartPoint

     * @param {Number} h Height of the legend.

     * @param {Number} totalHeight Total height of all labels in the column.

     * @param {String} align Vertical alignment of items for the legend.

     * @param {Object} padding Object contain left, top, right and bottom padding properties.

     * @return Number

     * @protected

     */

    getStartPoint: function(h, totalHeight, align, padding)

    {

        var startPoint;

        switch(align)

        {

            case TOP :

                startPoint = padding.top;

            break;

            case "middle" :

                startPoint = (h - totalHeight) * 0.5;

            break;

            case BOTTOM :

                startPoint = h - totalHeight - padding.bottom;

            break;

        }

        return startPoint;

    }

},

CartesianChartLegend = Y.Base.create("cartesianChartLegend", Y.CartesianChart, [], {

    /**

     * Redraws and position all the components of the chart instance.

     *

     * @method _redraw

     * @private

     */

    _redraw: function()

    {

        if(this._drawing)

        {

            this._callLater = true;