YUI.add('align-plugin', function (Y, NAME) {

    /**

     * Provides advanced positioning support for Node via a Plugin

     * for centering and alignment.

     * @module align-plugin

     */

    var OFFSET_WIDTH = 'offsetWidth',

        OFFSET_HEIGHT = 'offsetHeight',

        undefined = undefined;

    /**

     * Node plugin which can be used to align a node with another node,

     * region, or the viewport.

     *

     * @class Plugin.Align

     * @param {Object} User configuration object

     */

    function Align(config) {

        if (config.host) {

            this._host = config.host;

        }

    }

    Align.prototype = {

        /**

         * Aligns node with a point on another node or region.

         * Possible alignment points are:

         * <dl>

         *      <dt>tl</dt>

         *      <dd>top left</dd>

         *      <dt>tr</dt>

         *      <dd>top right</dd>

         *      <dt>bl</dt>

         *      <dd>bottom left</dd>

         *      <dt>br</dt>

         *      <dd>bottom right</dd>

         *      <dt>tc</dt>

         *      <dd>top center</dd>

         *      <dt>bc</dt>

         *      <dd>bottom center</dd>

         *      <dt>rc</dt>

         *      <dd>right center</dd>

         *      <dt>lc</dt>

         *      <dd>left center</dd>

         *      <dt>cc</dt>

         *      <dd>center center</dd>

         * </dl>

         * @method to

         * @param region {String|Node|HTMLElement|Object} The node or

         * region to align with. Defaults to the viewport region.

         * @param regionPoint {String} The point of the region to align with.

         * @param point {String} The point of the node aligned to the region.

         * @param resize {Boolean} Whether or not the node should re-align when

         * the window is resized. Defaults to false.

         */

        to: function(region, regionPoint, point, syncOnResize) {

            // cache original args for syncing

            this._syncArgs = Y.Array(arguments);

            if (region.top === undefined) {

                region = Y.one(region).get('region');

            }

            if (region) {

                var xy = [region.left, region.top],

                    offxy = [region.width, region.height],

                    points = Align.points,

                    node = this._host,

                    NULL = null,

                    size = node.getAttrs([OFFSET_HEIGHT, OFFSET_WIDTH]),

                    nodeoff = [0 - size[OFFSET_WIDTH], 0 - size[OFFSET_HEIGHT]], // reverse offsets

                    regionFn0 = regionPoint ? points[regionPoint.charAt(0)]: NULL,

                    regionFn1 = (regionPoint && regionPoint !== 'cc') ? points[regionPoint.charAt(1)] : NULL,

                    nodeFn0 = point ? points[point.charAt(0)] : NULL,

                    nodeFn1 = (point && point !== 'cc') ? points[point.charAt(1)] : NULL;

                if (regionFn0) {

                    xy = regionFn0(xy, offxy, regionPoint);

                }

                if (regionFn1) {

                    xy = regionFn1(xy, offxy, regionPoint);

                }

                if (nodeFn0) {

                    xy = nodeFn0(xy, nodeoff, point);

                }

                if (nodeFn1) {

                    xy = nodeFn1(xy, nodeoff, point);

                }

                if (xy && node) {

                    node.setXY(xy);

                }

                this._resize(syncOnResize);

            }

            return this;

        },

        sync: function() {

            this.to.apply(this, this._syncArgs);

            return this;

        },

        _resize: function(add) {

            var handle = this._handle;

            if (add && !handle) {

                this._handle = Y.on('resize', this._onresize, window, this);

            } else if (!add && handle) {

                handle.detach();

            }

        },

        _onresize: function() {

            var self = this;

            setTimeout(function() { // for performance

                self.sync();

            });

        },

        /**

         * Aligns the center of a node to the center of another node or region.

         * @method center

         * @param region {Node|HTMLElement|Object} optional The node or

         * region to align with. Defaults to the viewport region.

         * the window is resized. If centering to viewport, this defaults

         * to true, otherwise default is false.

         */

        center: function(region, resize) {

            this.to(region, 'cc', 'cc', resize);

            return this;

        },

        /**

         * Removes the resize handler, if any. This is called automatically

         * when unplugged from the host node.

         * @method destroy

         */

        destroy: function() {

            var handle = this._handle;

            if (handle) {

                handle.detach();

            }

        }

    };

    Align.points = {

        't': function(xy, off) {

            return xy;

        },

        'r': function(xy, off) {

            return [xy[0] + off[0], xy[1]];

        },

        'b': function(xy, off) {

            return [xy[0], xy[1] + off[1]];

        },

        'l': function(xy, off) {

            return xy;

        },

        'c': function(xy, off, point) {

            var axis = (point[0] === 't' || point[0] === 'b') ?  0 : 1,

                ret, val;

            if (point === 'cc') {

                ret = [xy[0] + off[0] / 2, xy[1] + off[1] / 2];

            } else {

                val = xy[axis] + off[axis] / 2;

                ret = (axis) ? [xy[0], val] : [val, xy[1]];

            }

             return ret;

        }

    };

    Align.NAME = 'Align';

    Align.NS = 'align';

    Align.prototype.constructor = Align;

    Y.namespace('Plugin');

    Y.Plugin.Align = Align;

}, '@VERSION@', {"requires": ["node-screen", "node-pluginhost"]});