/*

Copyright (c) 2009, Yahoo! Inc. All rights reserved.

Code licensed under the BSD License:

http://developer.yahoo.net/yui/license.txt

version: 3.0.0b1

build: 1163

*/

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

/**

 * The Node Utility provides a DOM-like interface for interacting with DOM nodes.

 * @module node

 * @submodule node-base

 */    

/**

 * The Node class provides a wrapper for manipulating DOM Nodes.

 * Node properties can be accessed via the set/get methods.

 * Use Y.get() to retrieve Node instances.

 *

 * <strong>NOTE:</strong> Node properties are accessed using

 * the <code>set</code> and <code>get</code> methods.

 *

 * @class Node

 * @constructor

 * @for Node

 */

// "globals"

var g_nodes = {},

    g_nodelists = {},

    g_restrict = {},

    g_slice = Array.prototype.slice,

    DOT = '.',

    NODE_NAME = 'nodeName',

    NODE_TYPE = 'nodeType',

    OWNER_DOCUMENT = 'ownerDocument',

    TAG_NAME = 'tagName',

    UID = '_yuid',

    SuperConstr = Y.Base,

    SuperConstrProto = Y.Base.prototype,

    Node = function(node, restricted) {

        var config = null;

        this[UID] = Y.stamp(node);

        if (!this[UID]) { // stamp failed; likely IE non-HTMLElement

            this[UID] = Y.guid(); 

        }

        g_nodes[this[UID]] = node;

        Node._instances[this[UID]] = this;

        if (restricted) {

            config = {

                restricted: restricted

            };

            g_restrict[this[UID]] = true; 

        }

        this._lazyAttrInit = true;

        this._silentInit = true;

        SuperConstr.call(this, config);

    },

    // used with previous/next/ancestor tests

    _wrapFn = function(fn) {

        var ret = null;

        if (fn) {

            ret = (typeof fn === 'string') ?

            function(n) {

                return Y.Selector.test(n, fn);

            } : 

            function(n) {

                return fn(Node.get(n));

            };

        }

        return ret;

    };

// end "globals"

Node.NAME = 'Node';

Node.DOM_EVENTS = {

    abort: true,

    blur: true,

    change: true,

    click: true,

    close: true,

    command: true,

    contextmenu: true,

    drag: true,

    dragstart: true,

    dragenter: true,

    dragover: true,

    dragleave: true,

    dragend: true,

    drop: true,

    dblclick: true,

    error: true,

    focus: true,

    keydown: true,

    keypress: true,

    keyup: true,

    load: true,

    mousedown: true,

    mousemove: true,

    mouseout: true, 

    mouseover: true, 

    mouseup: true,

    mousemultiwheel: true,

    mousewheel: true,

    submit: true,

    mouseenter: true,

    mouseleave: true,

    scroll: true,

    reset: true,

    resize: true,

    select: true,

    textInput: true,

    unload: true

};

// Add custom event adaptors to this list.  This will make it so

// that delegate, key, available, contentready, etc all will

// be available through Node.on

Y.mix(Node.DOM_EVENTS, Y.Env.evt.plugins);

Node._instances = {};

/**

 * Registers plugins to be instantiated at the class level (plugins 

 * which should be plugged into every instance of Node by default).

 *

 * @method Node.plug

 * @static

 *

 * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)

 * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin

 */

Node.plug = function() {

    var args = g_slice.call(arguments, 0);

    args.unshift(Node);

    Y.Base.plug.apply(Y.Base, args);

    return Node;

};

/**

 * Unregisters any class level plugins which have been registered by the Node

 *

 * @method Node.unplug

 * @static

 *

 * @param {Function | Array} plugin The plugin class, or an array of plugin classes

 */

Node.unplug = function() {

    var args = g_slice.call(arguments, 0);

    args.unshift(Node);

    Y.Base.unplug.apply(Y.Base, args);

    return Node;

};

/**

 * Retrieves the DOM node bound to a Node instance

 * @method Node.getDOMNode

 * @static

 *

 * @param {Y.Node || HTMLNode} node The Node instance or an HTMLNode

 * @return {HTMLNode} The DOM node bound to the Node instance.  If a DOM node is passed

 * as the node argument, it is simply returned.

 */

Node.getDOMNode = function(node) {

    if (node) {

        if (node instanceof Node) {

            node = g_nodes[node[UID]];

        } else if (!node[NODE_NAME] || Y.DOM.isWindow(node)) { // must already be a DOMNode 

            node = null;

        }

    }

    return node || null;

};

Node.scrubVal = function(val, node, depth) {

    if (node && val) { // only truthy values are risky

        if (typeof val === 'object' || typeof val === 'function') { // safari nodeList === function

            if (NODE_TYPE in val || Y.DOM.isWindow(val)) {// node || window

                if (g_restrict[node[UID]] && !node.contains(val)) {

                    val = null; // not allowed to go outside of root node

                } else {

                    val = Node.get(val);

                }

            } else if (val.item || // dom collection or Node instance // TODO: check each node for restrict? block ancestor?

                    (val[0] && val[0][NODE_TYPE])) { // array of DOM Nodes

                val = Y.all(val);

            } else {

                depth = (depth === undefined) ? 4 : depth;

                if (depth > 0) {

                    for (var i in val) { // TODO: test this and pull hasOwnProperty check if safe?

                        if (val.hasOwnProperty && val.hasOwnProperty(i)) {

                            val[i] = Node.scrubVal(val[i], node, --depth);

                        }

                    }

                }

            }

        }

    } else if (val === undefined) {

        val = node; // for chaining

    }

    return val;

};

Node.addMethod = function(name, fn, context) {

    if (name && fn && typeof fn === 'function') {

        Node.prototype[name] = function() {

            context = context || this;

            var args = g_slice.call(arguments),

                ret;

            if (args[0] && args[0] instanceof Node) {

                args[0] = Node.getDOMNode(args[0]);

            }

            if (args[1] && args[1] instanceof Node) {

                args[1] = Node.getDOMNode(args[1]);

            }

            args.unshift(g_nodes[this[UID]]);

            ret = Node.scrubVal(fn.apply(context, args), this);

            return ret;

        };

    } else {

        Y.log('unable to add method: ' + name, 'warn', 'Node');

    }

};

Node.importMethod = function(host, name, altName) {

    if (typeof name === 'string') {

        altName = altName || name;

        Node.addMethod(altName, host[name], host);

    } else {

        Y.each(name, function(n) {

            Node.importMethod(host, n);

        });

    }

};

/**

 * Returns a single Node instance bound to the node or the

 * first element matching the given selector.

 * @method Y.get

 * @static

 * @param {String | HTMLElement} node a node or Selector 

 * @param {Y.Node || HTMLElement} doc an optional document to scan. Defaults to Y.config.doc. 

 * @param {Boolean} restrict Whether or not the Node instance should be restricted to accessing

 * its subtree only.

 */

Node.get = function(node, doc, restrict) {

    var instance = null;

    if (typeof node === 'string') {

        if (node.indexOf('doc') === 0) { // doc OR document

            node = Y.config.doc;

        } else if (node.indexOf('win') === 0) { // doc OR document

            node = Y.config.win;

        } else {

            node = Y.Selector.query(node, doc, true);

        }

    }

    if (node) {

        instance = Node._instances[node[UID]]; // reuse exising instances

        if (!instance) {

            instance = new Node(node, restrict);

        } else if (restrict) {

            g_restrict[instance[UID]] = true;

            instance._set('restricted', true);

        }

    }

    // TODO: restrict on subsequent call?

    return instance;

};

/**

 * Creates a new dom node using the provided markup string. 

 * @method create

 * @static

 * @param {String} html The markup used to create the element

 * @param {HTMLDocument} doc An optional document context 

 */

Node.create = function() {

    return Node.get(Y.DOM.create.apply(Y.DOM, arguments));

};

Node.ATTRS = {

    /**

     * Allows for getting and setting the text of an element.

     * Formatting is preserved and special characters are treated literally.

     * @config text

     * @type String

     */

    text: {

        getter: function() {

            return Y.DOM.getText(g_nodes[this[UID]]);

        },

        setter: function(content) {

            Y.DOM.setText(g_nodes[this[UID]], content);

            return content;

        }

    },

    'options': {

        getter: function() {

            return this.getElementsByTagName('option');

        }

    },

    /**

     * Returns a NodeList instance of all HTMLElement children.

     * @readOnly

     * @config children

     * @type NodeList

     */

    'children': {

        getter: function() {

            var node = g_nodes[this[UID]],

                children = node.children,

                childNodes, i, len;

            if (children === undefined) {

                childNodes = node.childNodes;

                children = [];

                for (i = 0, len = childNodes.length; i < len; ++i) {

                    if (childNodes[i][TAG_NAME]) {

                        children[children.length] = childNodes[i];

                    }

                }

            }

            return Y.all(children);

        }

    },

    value: {

        getter: function() {

            return Y.DOM.getValue(g_nodes[this[UID]]);

        },

        setter: function(val) {

            Y.DOM.setValue(g_nodes[this[UID]], val);

            return val;

        }

    },

/*

    style: {

        getter: function(attr) {

            return Y.DOM.getStyle(g_nodes[this[UID]].style, attr);

        }

    },

*/

    /**

     * Whether or not this Node can traverse outside of its subtree.

     * @config restricted

     * @writeOnce

     * @type Boolean

     */

    restricted: {

        writeOnce: true,

        value: false

    }

};

// call with instance context

Node.DEFAULT_SETTER = function(name, val) {

    var node = g_nodes[this[UID]],

        strPath;

    if (name.indexOf(DOT) > -1) {