YUI.add('axis', function (Y, NAME) {

/**

 * Provides base functionality for drawing chart axes.

 *

 * @module charts

 * @submodule axis

 */

var CONFIG = Y.config,

    DOCUMENT = CONFIG.doc,

    Y_Lang = Y.Lang,

    IS_STRING = Y_Lang.isString,

    Y_DOM = Y.DOM,

    LeftAxisLayout,

    RightAxisLayout,

    BottomAxisLayout,

    TopAxisLayout;

/**

 * Algorithmic strategy for rendering a left axis.

 *

 * @class LeftAxisLayout

 * @constructor

 * @submodule axis

 */

LeftAxisLayout = function() {};

LeftAxisLayout.prototype = {

    /**

     *  Default margins for text fields.

     *

     *  @private

     *  @method _getDefaultMargins

     *  @return Object

     */

    _getDefaultMargins: function()

    {

        return {

            top: 0,

            left: 0,

            right: 4,

            bottom: 0

        };

    },

    /**

     * Sets the length of the tick on either side of the axis line.

     *

     * @method setTickOffset

     * @protected

     */

    setTickOffsets: function()

    {

        var host = this,

            majorTicks = host.get("styles").majorTicks,

            tickLength = majorTicks.length,

            halfTick = tickLength * 0.5,

            display = majorTicks.display;

        host.set("topTickOffset",  0);

        host.set("bottomTickOffset",  0);

        switch(display)

        {

            case "inside" :

                host.set("rightTickOffset",  tickLength);

                host.set("leftTickOffset", 0);

            break;

            case "outside" :

                host.set("rightTickOffset", 0);

                host.set("leftTickOffset",  tickLength);

            break;

            case "cross":

                host.set("rightTickOffset", halfTick);

                host.set("leftTickOffset",  halfTick);

            break;

            default:

                host.set("rightTickOffset", 0);

                host.set("leftTickOffset", 0);

            break;

        }

    },

    /**

     * Draws a tick

     *

     * @method drawTick

     * @param {Path} path reference to the path `Path` element in which to draw the tick.

     * @param {Object} pt Point on the axis in which the tick will intersect.

     * @param {Object} tickStyle Hash of properties to apply to the tick.

     * @protected

     */

    drawTick: function(path, pt, tickStyles)

    {

        var host = this,

            style = host.get("styles"),

            padding = style.padding,

            tickLength = tickStyles.length,

            start = {x:padding.left, y:pt.y},

            end = {x:tickLength + padding.left, y:pt.y};

        host.drawLine(path, start, end);

    },

    /**

     * Calculates the coordinates for the first point on an axis.

     *

     * @method getLineStart

     * @return {Object}

     * @protected

     */

    getLineStart: function()

    {

        var style = this.get("styles"),

            padding = style.padding,

            majorTicks = style.majorTicks,

            tickLength = majorTicks.length,

            display = majorTicks.display,

            pt = {x:padding.left, y:0};

        if(display === "outside")

        {

            pt.x += tickLength;

        }

        else if(display === "cross")

        {

            pt.x += tickLength/2;

        }

        return pt;

    },

    /**

     * Calculates the point for a label.

     *

     * @method getLabelPoint

     * @param {Object} point Point on the axis in which the tick will intersect.

     * @return {Object}

     * @protected

     */

    getLabelPoint: function(point)

    {

        return {x:point.x - this.get("leftTickOffset"), y:point.y};

    },

    /**

     * Updates the value for the `maxLabelSize` for use in calculating total size.

     *

     * @method updateMaxLabelSize

     * @param {HTMLElement} label to measure

     * @protected

     */

    updateMaxLabelSize: function(labelWidth, labelHeight)

    {

        var host = this,

            props = this._labelRotationProps,

            rot = props.rot,

            absRot = props.absRot,

            sinRadians = props.sinRadians,

            cosRadians = props.cosRadians,

            max;

        if(rot === 0)

        {

            max = labelWidth;

        }

        else if(absRot === 90)

        {

            max = labelHeight;

        }

        else

        {

            max = (cosRadians * labelWidth) + (sinRadians * labelHeight);

        }

        host._maxLabelSize = Math.max(host._maxLabelSize, max);

    },

    /**

     * Determines the available label width when the axis width has been explicitly set.

     *

     * @method getExplicitlySized

     * @return Boolean

     * @protected

     */

    getExplicitlySized: function(styles)

    {

        if(this._explicitWidth)

        {

            var host = this,

                w = host._explicitWidth,

                totalTitleSize = host._totalTitleSize,

                leftTickOffset = host.get("leftTickOffset"),

                margin = styles.label.margin.right;

            host._maxLabelSize =  w - (leftTickOffset + margin + totalTitleSize);

            return true;

        }

        return false;

    },

    /**

     * Rotate and position title.

     *

     * @method positionTitle

     * @param {HTMLElement} label to rotate position

     * @protected

     */

    positionTitle: function(label)

    {

        var host = this,

            bounds = host._titleBounds,

            margin = host.get("styles").title.margin,

            props = host._titleRotationProps,

            w = bounds.right - bounds.left,

            labelWidth = label.offsetWidth,

            labelHeight = label.offsetHeight,

            x = (labelWidth * -0.5) + (w * 0.5),

            y = (host.get("height") * 0.5) - (labelHeight * 0.5);

        props.labelWidth = labelWidth;

        props.labelHeight = labelHeight;

        if(margin && margin.left)

        {

            x += margin.left;

        }

        props.x = x;

        props.y = y;

        props.transformOrigin = [0.5, 0.5];

        host._rotate(label, props);

    },

    /**

     * Rotate and position labels.

     *

     * @method positionLabel

     * @param {HTMLElement} label to rotate position

     * @param {Object} pt hash containing the x and y coordinates in which the label will be positioned

     * against.

     * @protected

     */

    positionLabel: function(label, pt, styles, i)

    {

        var host = this,

            offset = parseFloat(styles.label.offset),

            tickOffset = host.get("leftTickOffset"),

            totalTitleSize = this._totalTitleSize,

            leftOffset = pt.x + totalTitleSize - tickOffset,

            topOffset = pt.y,

            props = this._labelRotationProps,

            rot = props.rot,

            absRot = props.absRot,

            maxLabelSize = host._maxLabelSize,

            labelWidth = this._labelWidths[i],

            labelHeight = this._labelHeights[i];

        if(rot === 0)

        {

            leftOffset -= labelWidth;

            topOffset -= labelHeight * offset;

        }

        else if(rot === 90)

        {

            leftOffset -= labelWidth * 0.5;

            topOffset = topOffset + labelWidth/2 - (labelWidth * offset);

        }

        else if(rot === -90)

        {

            leftOffset -= labelWidth * 0.5;

            topOffset = topOffset - labelHeight + labelWidth/2 - (labelWidth * offset);

        }

        else

        {

            leftOffset -= labelWidth + (labelHeight * absRot/360);

            topOffset -= labelHeight * offset;

        }

        props.labelWidth = labelWidth;

        props.labelHeight = labelHeight;

        props.x = Math.round(maxLabelSize + leftOffset);

        props.y = Math.round(topOffset);

        this._rotate(label, props);

    },

    /**

     * Adjusts the coordinates of an axis label based on the rotation.

     *

     * @method _setRotationCoords

     * @param {Object} props Coordinates, dimension and rotation properties of the label.

     * @protected

     */

    _setRotationCoords: function(props)

    {

        var rot = props.rot,

            absRot = props.absRot,

            leftOffset,

            topOffset,

            labelWidth = props.labelWidth,

            labelHeight = props.labelHeight;

        if(rot === 0)

        {

            leftOffset = labelWidth;

            topOffset = labelHeight * 0.5;

        }

        else if(rot === 90)

        {

            topOffset = 0;

            leftOffset = labelWidth * 0.5;

        }

        else if(rot === -90)

        {

            leftOffset = labelWidth * 0.5;

            topOffset = labelHeight;

        }

        else

        {

            leftOffset = labelWidth + (labelHeight * absRot/360);

            topOffset = labelHeight * 0.5;

        }

        props.x -= leftOffset;

        props.y -= topOffset;

    },

    /**

     * Returns the transformOrigin to use for an axis label based on the position of the axis

     * and the rotation of the label.

     *

     * @method _getTransformOrigin

     * @param {Number} rot The rotation (in degrees) of the label.

     * @return Array

     * @protected

     */

    _getTransformOrigin: function(rot)

    {

        var transformOrigin;

        if(rot === 0)

        {

            transformOrigin = [0, 0];

        }

        else if(rot === 90)

        {

            transformOrigin = [0.5, 0];

        }

        else if(rot === -90)

        {

            transformOrigin = [0.5, 1];

        }

        else

        {

            transformOrigin = [1, 0.5];

        }

        return transformOrigin;

    },

    /**

     * Adjust the position of the Axis widget's content box for internal axes.

     *

     * @method offsetNodeForTick

     * @param {Node} cb contentBox of the axis

     * @protected

     */

    offsetNodeForTick: function()

    {

    },

    /**

     * Sets the width of the axis based on its contents.

     *

     * @method setCalculatedSize

     * @protected

     */

    setCalculatedSize: function()

    {

        var host = this,

            graphic = this.get("graphic"),

            style = host.get("styles"),

            label = style.label,

            tickOffset = host.get("leftTickOffset"),

            max = host._maxLabelSize,

            totalTitleSize = this._totalTitleSize,

            ttl = Math.round(totalTitleSize + tickOffset + max + label.margin.right);

        if(this._explicitWidth)

        {

            ttl = this._explicitWidth;

        }

        this.set("calculatedWidth", ttl);

        graphic.set("x", ttl - tickOffset);

    }

};

Y.LeftAxisLayout = LeftAxisLayout;

/**

 * RightAxisLayout contains algorithms for rendering a right axis.

 *

 * @class RightAxisLayout

 * @constructor

 * @submodule axis

 */

RightAxisLayout = function(){};