/*
* jQuery live links plugin
* http://github.com/nje
*/
(function ($) {
   
   var oldattr = $.attr,
    oldval = $.fn.val,
    olddata = $.data,
    oldcleandata = $.cleanData,
    linkId = 0,
    liveLinks = {};

   function attr(obj, name, value, pass) {
      // an attr that supports plain objects (won't look for .style, nodeType, etc)
      return $.isPlainObject(obj)
        ? (value === undefined ? obj[name] : (obj[name] = value))
        : oldattr(obj, name, value, pass);
   }

   function raiseEvents(type, context, change, setValue) {
      // todo: peek if there are any listeners to avoid extra work
      var ret,
        event = $.Event(type + "Changing"),
        isArray = type === "array";
      event.newValue = isArray ? change.arguments : change.newValue;
      $.event.trigger(event, [change], context);
      if (!event.isDefaultPrevented()) {
         var newvalue = isArray ? change.arguments : event.newValue;
         ret = setValue(newvalue);
         var oldvalue = change.oldValue;
         if (isArray || typeof oldvalue === "undefined" || newvalue !== oldvalue) {
            isArray ? (change.arguments = newvalue) : (change.newValue = newvalue);
            $.event.trigger(type + "Change", [change], context);
         }
      }
      return ret;
   }

   $.attr = function (elem, name, value, pass) {
      var ret = this;
      if (value === undefined)
         ret = attr(elem, name, value, pass);
      else {
         raiseEvents("attr", elem, { attrName: name, oldValue: attr(elem, name), newValue: value },
            function (newvalue) {
               attr(elem, name, value, pass);
            });
      }
      return ret;
   }

   $.fn.val = function (value) {
      var ret = this;
      if (value === undefined)
         ret = oldval.call(this);
      else {
         this.each(function () {
            var self = $(this);
            raiseEvents("attr", this, { attrName: "val", oldValue: oldval.call(self), newValue: value },
                function (newvalue) {
                   oldval.call(self, newvalue);
                });
         });
      }
      return ret;
   }

   $.data = function (elem, name, data) {
      var ret;
      if (typeof data === "undefined") {
         ret = olddata(elem, name);
      }
      else {
         var oldvalue,
            newvalue = data,
            attrName;
         if (typeof name === "object") {
            attrName = "data:!";
            newvalue = name;
         }
         else {
            attrName = "data:" + name;
            oldvalue = olddata(elem, name);
         }
         ret = raiseEvents("attr", elem, { attrName: attrName, oldValue: oldvalue, newValue: newvalue },
            function (newvalue) {
               return olddata(elem, name, newvalue);
            });
      }
      return ret;
   }

   $.cleanData = function (elems) {
      for (var i = 0, elem; (elem = elems[i]) != null; i++) {
         if ($.data(elem, "links")) {
            // remove any links that target this element
            // as the source may not be being cleaned up
            $.unlink({ target: elem });
         }
      }
      oldcleandata(elems);
   }

   $.each("pop push reverse shift sort splice unshift".split(" "), function (i, name) {
      $[name] = function (arr) {
         var args = $.makeArray(arguments);
         args.splice(0, 1);
         return raiseEvents("array", arr, { change: name, arguments: args }, function (arguments) {
            arr[name].apply(arr, arguments);
         });
      }
   });

   var special = $.event.special,
    formElems = /^(textarea|input|select)$/i;

   $.each("attrChanging attrChange arrayChanging arrayChange".split(' '), function (i, name) {
      var isattr = i < 2;

      $.fn[name] = function (filter, fn) {
         if (arguments.length === 1) {
            fn = filter;
            filter = null;
         }
         return fn ? this.bind(name, filter, fn) : this.trigger(name);
      }

      special[name] = {
         add: function (handleObj) {
            var old_handler = handleObj.handler;
            handleObj.handler = function (event, change) {
               var data = handleObj.data,
                    attrName = change ? (isattr ? change.attrName : change.change) : null;
               if (!change || !data || data === attrName || $.inArray(attrName, data) > -1) {
                  $.extend(event, change);
                  // todo: support extra parameters passed to trigger as
                  // trigger('attrChange', [<change>, extra1, extra2]).
                  old_handler.call(this, event);
               }
            }
         }
      }
   });

   special.attrChange.teardown = function () { };

   $(document).bind("change.attrChange", function (ev) {
      var self = $(ev.target);
      self.trigger("attrChange", { attrName: "val", newValue: self.val() });
   });

   var setter_lookup = {
      val: "val",
      html: "html",
      text: "text"
   }

   function processFromTo(settings, context, fn) {
      var from = settings.from,
        to = settings.to,
        sources = from.sources || from.targets,
        sourceAttrs = from.attr,
        converts = from.convert,
        targets = to.targets || to.sources,
        targetAttrs = to.attr,
        updates = to.update;
      sources = $.isArray(sources) ? sources : [sources];
      targets = $.isArray(targets) ? targets : [targets];
      updates = typeof updates === "undefined" ? null : ($.isArray(updates) ? updates : [updates]),
    sourceAttrs = typeof sourceAttrs === "undefined" ? null : ($.isArray(sourceAttrs) ? sourceAttrs : [sourceAttrs]),
    targetAttrs = typeof targetAttrs === "undefined" ? null : ($.isArray(targetAttrs) ? targetAttrs : [targetAttrs]),
    converts = $.isArray(converts) ? converts : [converts];
      $.each(sources, function (i, source) {
         var target = targets[Math.min(targets.length - 1, i)],
            sourceAttr = sourceAttrs ? sourceAttrs[Math.min(sourceAttrs.length - 1, i)] : null,
            targetAttr = targetAttrs ? targetAttrs[Math.min(targetAttrs.length - 1, i)] : null,
            convert = converts[Math.min(converts.length - 1, i)],
            update = updates ? updates[Math.min(updates.length - 1, i)] : null;
         fn({
            source: source,
            target: target,
            sourceAttr: sourceAttr,
            targetAttr: targetAttr,
            convert: convert,
            update: update
         }, context);
      });
      if (settings.twoWay) {
         var update = to.update;
         delete to.update;
         fn({ from: to, to: from }, context);
         to.update = update;
      }
   }

   function getValue(elem, attr) {
      var value = (attr && attr.indexOf("data:") === 0)
        ? elem.data(attr.substr(5))
        : (attr === "val" ? elem.val() : elem.attr(attr));
      return value;
   }

   function setValue(sourceElem, targetElem, attr, value) {
      var defaultAttr = sourceElem.attr("itemprop");
      if (!defaultAttr) {
         var e = sourceElem.get(0);
         defaultAttr = e.name || e.id;
      }
      targetElem.each(function () {
         var a = attr;
         if (!attr) {
            if (this.nodeType) {
               // val for inputs, text for everything else
               var nodeName = this.nodeName;
               a = formElems.test(nodeName) ? "val" : "text";
            }
            else {
               a = defaultAttr;
            }
         }
         var fn = setter_lookup[a];
         if (fn) {
            $(this)[fn](value);
         }
         else if (a.indexOf("data:") === 0) {
            $.data(this, a.substr(5), value);
         }
         else {
            $(this).attr(a, value);
         }
      });
   }

   $.linkLive = function (settings, context) {
      if (settings.from && settings.to) {
         processFromTo(settings, context, $.linkLive);
         return;
      }
      var source = settings.source,
        target = settings.target,
        sourceAttr = settings.sourceAttr || "",
        targetAttr = settings.targetAttr || "",
        convert = settings.convert;

      // wrap arrays in another array because $([]) is treatment of
      // the contents, not the array itself
      source = $.isArray(source) ? [source] : source;
      target = $.isArray(target) ? [target] : target;

      var handler = function (ev, forceSource) {
         var source = ev ? ev.target : forceSource;
         var attr = sourceAttr;
         if (!attr) {
            // val for inputs, text for everything else
            if (source.nodeType) {
               var nodeName = source.nodeName;
               attr = formElems.test(nodeName) ? "val" : "text";
            }
         }
         var _source = $(source),
            newValue = ev ? ev.newValue : getValue(_source, attr),
            cv = convert ? ($.convertFn[convert] || convert) : null;
         if (cv) {
            newValue = cv(newValue, settings);
         }
         if (typeof newValue !== "undefined") {
            setValue(_source, $(target, context), targetAttr, newValue);
         }
      }

      $(source, context).live("attrChange", handler);

      var list = liveLinks[source] || (liveLinks[source] = []);
      list.push({
         source: source,
         sourceAttr: sourceAttr,
         target: target,
         targetAttr: targetAttr,
         context: context,
         handler: handler
      });

      if (settings.update) {
         $(source).each(function () {
            handler(null, this);
         });

      }
   }

   $.unlinkLive = function (settings, context) {
      if (settings.from && settings.to) {
         processFromTo(settings, context, $.unlinkLive);
         return;
      }
      var source = settings.source,
        target = settings.target,
        sourceAttr = settings.sourceAttr || "",
        targetAttr = settings.targetAttr || "";
      var links = liveLinks[source];
      if (links) {
         $.each(links, function (i, link) {
            if (link.context === context && link.sourceAttr === sourceAttr && link.target === target && link.targetAttr === targetAttr) {
               $(link.source, context).die("attrChange", link.handler);
               delete links[link.source];
               link.source = null;
               link.target = null;
               link.handler = null;
               link.context = null;
               return false;
            }
         });
      }
   }

   $.link = function (settings, context) {
      if (settings.from && settings.to) {
         processFromTo(settings, context, $.link);
         return;
      }
      var source = settings.source,
        target = settings.target,
        sourceAttr = settings.sourceAttr || "",
        targetAttr = settings.targetAttr || "",
        convert = settings.convert;

      // wrap arrays in another array because $([]) is treatment of
      // the contents, not the array itself
      source = $($.isArray(source) ? [source] : source, context);
      target = $($.isArray(target) ? [target] : target, context);

      target.each(function (i, target) {
         var _target = $(target);
         source.each(function (i, source) {
            var attr = sourceAttr;
            if (!attr) {
               // val for inputs, text for everything else
               if (this.nodeType) {
                  var nodeName = this.nodeName;
                  attr = formElems.test(nodeName) ? "val" : "text";
               }
            }
            var handler = function (ev) {
               if (!ev || source === ev.target) {
                  var _source = $(ev ? ev.target : source),
                        newValue = ev ? ev.newValue : getValue(_source, attr),
                  // re-evaluate convert each occurrance to pick up dynamic changes to convertFn
                        cv = convert ? ($.convertFn[convert] || convert) : null;
                  if (cv) {
                     newValue = cv(newValue, settings);
                  }
                  if (typeof newValue !== "undefined") {
                     setValue(_source, _target, targetAttr, newValue);
                  }
               }
            };
            var id = linkId++,
                link = {
                   source: source,
                   sourceAttr: sourceAttr,
                   target: target,
                   targetAttr: targetAttr,
                   handler: handler,
                   id: id
                };
            // register this link with the target
            var data = $.data(target),
                links = data.links || (data.links = { targets: {}, sources: {} }),
                index = links.targets;
            index[id] = link;
            // register this link with the source
            data = $.data(source);
            links = data.links || (data.links = { targets: {}, sources: {} });
            index = links.sources;
            index[id] = link;
            // listen to changes on the source
            $(source).attrChange(attr ? attr.split(' ') : '', handler);
            // update if specified
            if (settings.update) {
               handler();
            }
         });
      });
   }

   /*
   Links are individually remembered via data() in order to facilitate
   removing them individually. For example, you might all at once link
   a single source to several targets, then remove the linking to one of
   the targets.

   Each link object looks like this:

   link = { source: source, sourceAttr: sourceAttr,
   target: target, targetAttr: targetAttr,
   handler: handler }

   And they are indexed per element like this:
         
   elem.data.links = {
   // index of links that have this element as the source
   sources: {
   linkId1: link1,
   linkId2: link2,
   ...
   },
   // index of links that have this element as the target
   targets: {
   linkId1: link1,
   linkId2: link2,
   ...
   }
   }

   The links are stored by a unique link id rather than array
   in order to make removing them upon unlinking faster.

   'Live' links are not associated with any dom elements for obvious reasons.
   A private dictionary is kept for them, indexed by the source selector.
   var liveLinks = {
   source1: [link1, link2, ...],
   source2: [link1, link2, ...],
   ...
   }
   */

   function getLinksFor(obj, attr, isSource) {
      var links = $.data(obj, "links"),
        index = links ? (links[isSource ? "sources" : "targets"]) : null;
      if (!index) {
         return {};
      }
      else if (attr) {
         var matched = {};
         $.each(index, function (linkId, link) {
            if (link[isSource ? "sourceAttr" : "targetAttr"] === attr) {
               matched[linkId] = link;
            }
         });
         index = matched;
      }
      return index;
   }
   function filterBy(links, obj, objAttr, isSource) {
      var matched = {},
        objField = isSource ? "source" : "target",
        objAttrField = isSource ? "sourceAttr" : "targetAttr";
      $.each(links, function (linkId, link) {
         if (link[objField] === obj && (!objAttr || link[objAttrField] === objAttr)) {
            matched[linkId] = link;
         }
      });
      return matched;
   }

   function getLinks(source, sourceAttr, target, targetAttr) {
      var matched;
      if (source) {
         matched = getLinksFor(source, sourceAttr, true);
         if (target) {
            // filter by target
            matched = filterBy(matched, target, targetAttr);
         }
      }
      else if (target) {
         matched = getLinksFor(target, targetAttr);
         if (source) {
            // filter by source
            matched = filterBy(matched, source, sourceAttr, true);
         }
      }
      else {
         matched = {};
      }
      return matched;
   }

   function unlink(link) {
      // unbind handler
      $(link.source).unbind("attrChange", link.handler);
      // remove link from sources and targets list in each side's data cache
      var links = $.data(link.source, "links");
      delete links.sources[link.id];
      links = $.data(link.target, "links");
      delete links.targets[link.id];
      // remove references to help ensure no circular references
      link.source = null;
      link.target = null;
      link.handler = null;
   }

   $.unlink = function (settings, context) {
      if (settings.from && settings.to) {
         processFromTo(settings, context, $.unlink);
         return;
      }
      var source = settings.source,
        target = settings.target,
        sourceAttr = settings.sourceAttr || "",
        targetAttr = settings.targetAttr || "";
      source = source ? $($.isArray(source) ? [source] : source, context) : null;
      target = target ? $($.isArray(target) ? [target] : target, context) : null;
      function remove(source, target) {
         var links = getLinks(source, sourceAttr, target, targetAttr);
         $.each(links, function (linkId, link) {
            unlink(link);
         });
      }
      if (source && target) {
         source.each(function (i, source) {
            target.each(function (i, target) {
               remove(source, target);
            });
         });
      }
      else if (source) {
         source.each(function (i, source) {
            remove(source);
         });
      }
      else if (target) {
         target.each(function (i, target) {
            remove(null, target);
         });
      }
   }

   $.convertFn = {
      "!": function (value) {
         return !value;
      }
   };

})(jQuery);