var hoverElements = [".yui-gb.full .yui-u", ".yui-gh .yui-u", ".yui-gi .yui-u", ".loc", ".urgle", ".foobar"];
var linkElements = [".yui-gb.full .yui-u", ".urgle", ".foobar"];
var heightElements = [".yui-gb .yui-u", ".yui-gi .yui-u"];

YUI().use('node-base', function(Y) {
  var addHover = function() {
  	if (this.hasClass('foobar')) {
	    this.addClass('noimg');
  	}
  	else {
	    this.addClass('hover');
  	}
  };
  var removeHover = function() {
  	if (this.hasClass('foobar')) {
			this.removeClass('noimg');
  	}
  	else {
			this.removeClass('hover');
  	}
  };
  Y.on("mouseover", addHover, hoverElements);
  Y.on("mouseout", removeHover, hoverElements);
});

YUI().use('node-base', function(Y) {
  var addLink = function() {
    var link = this.one('a.more').getAttribute("href");
		location.href = link;
  };
  Y.on("click", addLink, linkElements);
});

/*
// TODO: Make the "big three" boxes on the front page equal height.
YUI().use('node', function(Y) {
  var nodes, children, region, height, maxheight=0;
  var count = heightElements.length;
  for (var i=0;i<count;i++) {
    nodes = Y.all(heightElements[i]);
    nodes.each(function(v, k) {
      region = v.get('region');
      height = region.bottom - region.top;
      if (height > maxheight) {
        maxheight = height;
      }
    });
  }
});
*/

YUI({combine: true, timeout: 10000}).use("widget", "widget-position", "widget-stack", function(Y) {
    var Lang = Y.Lang,
        Node = Y.Node;

    function Tooltip(config) {
        Tooltip.superclass.constructor.apply(this, arguments);
    }

    Tooltip.NAME = "tooltip";

    Tooltip.OFFSET_X = 15;
    Tooltip.OFFSET_Y = 15;
    Tooltip.OFFSCREEN_X = -10000;
    Tooltip.OFFSCREEN_Y = -10000;

    Tooltip.ATTRS = {

        content : {
            value: null
        },

        triggerNodes : {
            value: null,
            setter: function(val) {
                if (val && Lang.isString(val)) {
                    val = Node.all(val);
                }
                return val;
            }
        },

        delegate : {
            value: null,
            setter: function(val) {
                return Y.one(val) || Y.one("document");
            }
        },

        showDelay : {
            value:150
        },

        hideDelay : {
            value:10
        },

        autoHideDelay : {
            value:3000
        },

        visible : {
            value:false
        },

        xy: {
            value:[Tooltip.OFFSCREEN_X, Tooltip.OFFSCREEN_Y]
        }
    };

    Y.extend(Tooltip, Y.Widget, {

        initializer : function(config) {

            this._triggerClassName = this.getClassName("trigger");

            this._currTrigger = {
                node: null,
                title: null,
                mouseX: Tooltip.OFFSCREEN_X,
                mouseY: Tooltip.OFFSCREEN_Y
            };

            this._eventHandles = {
                delegate: null,
                trigger: {
                    mouseMove : null,
                    mouseOut: null
                }
            };

            this._timers = {
                show: null,
                hide: null
            };

            this.publish("triggerEnter", {defaultFn: this._defTriggerEnterFn, preventable:true});
            this.publish("triggerLeave", {preventable:false});
        },

        destructor : function() {
            this._clearCurrentTrigger();
            this._clearTimers();
            this._clearHandles();
        },

        bindUI : function() {
            this.after("delegateChange", this._afterSetDelegate);
            this.after("nodesChange", this._afterSetNodes);

            this._bindDelegate();
        },

        syncUI : function() {
            this._uiSetNodes(this.get("triggerNodes"));
        },

        setTriggerContent : function(content) {
            var contentBox = this.get("contentBox");
            contentBox.set("innerHTML", "");

            if (content) {
                if (content instanceof Node) {
                    for (var i = 0, l = content.size(); i < l; ++i) {
                        contentBox.appendChild(content.item(i));
                    }
                } else if (Lang.isString(content)) {
                    contentBox.set("innerHTML", content);
                }
            }
        },

        getParentTrigger : function(node) {
            var cn = this._triggerClassName;
            return (node.hasClass(cn)) ? node : node.ancestor(function(node) {return node.hasClass(cn);});
        },

        _afterSetNodes : function(e) {
            this._uiSetNodes(e.newVal);
        },

        _afterSetDelegate : function(e) {
            this._bindDelegate(e.newVal);
        },

        _uiSetNodes : function(nodes) {
            if (this._triggerNodes) {
                this._triggerNodes.removeClass(this._triggerClassName);
            }

            if (nodes) {
                this._triggerNodes = nodes;
                this._triggerNodes.addClass(this._triggerClassName);
            }
        },

        _bindDelegate : function() {
            var eventHandles = this._eventHandles;

            if (eventHandles.delegate) {
                eventHandles.delegate.detach();
                eventHandles.delegate = null;
            }
            eventHandles.delegate = Y.on("mouseover", Y.bind(this._onDelegateMouseOver, this), this.get("delegate"));
        },

        _onDelegateMouseOver : function(e) {
            var node = this.getParentTrigger(e.target);
            if (node && (!this._currTrigger.node || !node.compareTo(this._currTrigger.node))) {
                this._enterTrigger(node, e.pageX, e.pageY);
            }
        },

        _onNodeMouseOut : function(e) {
            var to = e.relatedTarget;
            var trigger = e.currentTarget;

            if (!trigger.contains(to)) {
                this._leaveTrigger(trigger);
            }
        },

        _onNodeMouseMove : function(e) {
            this._overTrigger(e.pageX, e.pageY);
        },

        _enterTrigger : function(node, x, y) {
            this._setCurrentTrigger(node, x, y);
            this.fire("triggerEnter", {node:node, pageX:x, pageY:y});
        },

        _defTriggerEnterFn : function(e) {
            var node = e.node;
            if (!this.get("disabled")) {
                this._clearTimers();
                var delay = (this.get("visible")) ? 0 : this.get("showDelay");
                this._timers.show = Y.later(delay, this, this._showTooltip, [node]);
            }
        },

        _leaveTrigger : function(node) {
            this.fire("triggerLeave");

            this._clearCurrentTrigger();
            this._clearTimers();

            this._timers.hide = Y.later(this.get("hideDelay"), this, this._hideTooltip);
        },

        _overTrigger : function(x, y) {
            this._currTrigger.mouseX = x;
            this._currTrigger.mouseY = y;
        },

        _showTooltip : function(node) {
            var x = this._currTrigger.mouseX;
            var y = this._currTrigger.mouseY;

            this.move(x + Tooltip.OFFSET_X, y + Tooltip.OFFSET_Y);

            this.show();
            this._clearTimers();

            this._timers.hide = Y.later(this.get("autoHideDelay"), this, this._hideTooltip);
        },

        _hideTooltip : function() {
            this._clearTimers();
            this.hide();
        },

        _setTriggerContent : function(node) {
            var content = this.get("content");
            if (content && !(content instanceof Node || Lang.isString(content))) {
                content = content[node.get("id")] || node.getAttribute("title");
            }
            this.setTriggerContent(content);
        },

        _setCurrentTrigger : function(node, x, y) {

            var currTrigger = this._currTrigger,
                triggerHandles = this._eventHandles.trigger;

            this._setTriggerContent(node);

            triggerHandles.mouseMove = Y.on("mousemove", Y.bind(this._onNodeMouseMove, this), node);
            triggerHandles.mouseOut = Y.on("mouseout", Y.bind(this._onNodeMouseOut, this), node);

            var title = node.getAttribute("title");
            node.setAttribute("title", "");

            currTrigger.mouseX = x;
            currTrigger.mouseY = y;
            currTrigger.node = node;
            currTrigger.title = title;
        },

        _clearCurrentTrigger : function() {

            var currTrigger = this._currTrigger,
                triggerHandles = this._eventHandles.trigger;

            if (currTrigger.node) {
                var node = currTrigger.node;
                var title = currTrigger.title || "";

                currTrigger.node = null;
                currTrigger.title = "";

                triggerHandles.mouseMove.detach();
                triggerHandles.mouseOut.detach();
                triggerHandles.mouseMove = null;
                triggerHandles.mouseOut = null;

                node.setAttribute("title", title);
            }
        },

        _clearTimers : function() {
            var timers = this._timers;
            if (timers.hide) {
                timers.hide.cancel();
                timers.hide = null;
            }
            if (timers.show) {
              timers.show.cancel();
              timers.show = null;
            }
        },

        _clearHandles : function() {
            var eventHandles = this._eventHandles;

            if (eventHandles.delegate) {
                this._eventHandles.delegate.detach();
            }
            if (eventHandles.trigger.mouseOut) {
                eventHandles.trigger.mouseOut.detach();
            }
            if (eventHandles.trigger.mouseMove) {
                eventHandles.trigger.mouseMove.detach();
            }
        }
    });

    Tooltip = Y.Base.build(Tooltip.NAME, Tooltip, [Y.WidgetPosition, Y.WidgetStack], {dynamic:false});

    var tt = new Tooltip({
        triggerNodes:".hastooltip",
        delegate: "#delegate",
        content: {value: null },
        shim:false,
        zIndex:2
    });
    tt.render();
});