// Helper class to check DOM MutationEvents
//
// Usage:
//
// * Create a new event checker:
//     var eventChecker = new MutationEventChecker;
// * Set the attribute to watch
//     eventChecker.watchAttr(<DOM element>, "<attribute name>");
// * Set the events to expect (0..n)
//     eventChecker.expect("add", "modify");
//     OR
//     eventChecker.expect("add modify");
//     OR
//     eventChecker.expect(MutationEvent.ADDITION, MutationEvent.MODIFICATION);
//
//  An empty string or empty set of arguments is also fine as a way of checking
//  that all expected events have been received and indicating no events are
//  expected from the following code, e.g.
//
//    eventChecker.expect("");
//    // changes that are not expected to generate events
//    eventChecker.expect("modify");
//    // change that is expected to generate an event
//    ...
//
// * Either finish listening or set the next attribute to watch
//     eventChecker.finish();
//     eventChecker.watchAttr(element, "nextAttribute");
//
//   In either case a check is performed that all expected events have been
//   received.
//
// * Event checking can be temporarily disabled with ignoreEvents(). The next
//   call to expect() will cause it to resume.

function MutationEventChecker()
{
  this.expectedEvents = [];

  this.watchAttr = function(element, attr)
  {
    if (this.attr) {
      this.finish();
    }

    this.expectedEvents = [];
    this.element        = element;
    this.attr           = attr;
    this.oldValue       = element.getAttribute(attr);
    this.giveUp         = false;
    this.ignore         = false;

    this.element.addEventListener('DOMAttrModified', this._listener, false);
  }

  this.expect = function()
  {
    if (this.giveUp) {
      return;
    }

    ok(this.expectedEvents.length == 0,
       "Expecting new events for " + this.attr +
       " but the following previously expected events have still not been " +
       "received: " + this._stillExpecting());
    if (this.expectedEvents.length != 0) {
      this.giveUp = true;
      return;
    }

    this.ignore = false;

    if (arguments.length == 0 ||
        arguments.length == 1 && arguments[0] == "") {
      return;
    }

    // Turn arguments object into an array
    var args = Array.prototype.slice.call(arguments);
    // Check for whitespace separated keywords
    if (args.length == 1 && typeof args[0] === 'string' &&
        args[0].indexOf(' ') > 0) {
      args = args[0].split(' ');
    }
    // Convert strings to event Ids
    this.expectedEvents = args.map(this._argToEventId);
  }

  // Temporarily disable event checking
  this.ignoreEvents = function()
  {
    // Check all events have been received
    ok(this.giveUp || this.expectedEvents.length == 0,
      "Going to ignore subsequent events on " + this.attr +
      " attribute, but we're still expecting the following events: " +
      this._stillExpecting());

    this.ignore = true;
  }

  this.finish = function()
  {
    // Check all events have been received
    ok(this.giveUp || this.expectedEvents.length == 0,
      "Finishing listening to " + this.attr +
      " attribute, but we're still expecting the following events: " +
      this._stillExpecting());

    this.element.removeEventListener('DOMAttrModified', this._listener, false);
    this.attr = "";
  }

  this._receiveEvent = function(e)
  {
    if (this.giveUp || this.ignore) {
      this.oldValue = e.newValue;
      return;
    }

    // Make sure we're expecting something at all
    if (this.expectedEvents.length == 0) {
      ok(false, 'Unexpected ' + this._eventToName(e.attrChange) +
         ' event when none expected on ' + this.attr + ' attribute.');
      return;
    }

    var expectedEvent = this.expectedEvents.shift();

    // Make sure we got the event we expected
    if (e.attrChange != expectedEvent) {
      ok(false, 'Unexpected ' + this._eventToName(e.attrChange) +
        ' on ' + this.attr + ' attribute. Expected ' +
        this._eventToName(expectedEvent) + ' (followed by: ' +
        this._stillExpecting() + ")");
      // If we get events out of sequence, it doesn't make sense to do any
      // further testing since we don't really know what to expect
      this.giveUp = true;
      return;
    }

    // Common param checking
    is(e.target, this.element,
       'Unexpected node for mutation event on ' + this.attr + ' attribute');
    is(e.attrName, this.attr, 'Unexpected attribute name for mutation event');

    // Don't bother testing e.relatedNode since Attr nodes are on the way
    // out anyway (but then, so are mutation events...)

    // Event-specific checking
    if (e.attrChange == MutationEvent.MODIFICATION) {
      ok(this.element.hasAttribute(this.attr),
         'Attribute not set after modification');
      is(e.prevValue, this.oldValue,
         'Unexpected old value for modification to ' + this.attr +
         ' attribute');
      isnot(e.newValue, this.oldValue,
         'Unexpected new value for modification to ' + this.attr +
         ' attribute');
    } else if (e.attrChange == MutationEvent.REMOVAL) {
      ok(!this.element.hasAttribute(this.attr), 'Attribute set after removal');
      is(e.prevValue, this.oldValue,
         'Unexpected old value for removal of ' + this.attr +
         ' attribute');
      // DOM 3 Events doesn't say what value newValue will be for a removal
      // event but generally empty strings are used for other events when an
      // attribute isn't relevant
      ok(e.newValue === "",
         'Unexpected new value for removal of ' + this.attr +
         ' attribute');
    } else if (e.attrChange == MutationEvent.ADDITION) {
      ok(this.element.hasAttribute(this.attr),
         'Attribute not set after addition');
      // DOM 3 Events doesn't say what value prevValue will be for an addition
      // event but generally empty strings are used for other events when an
      // attribute isn't relevant
      ok(e.prevValue === "",
         'Unexpected old value for addition of ' + this.attr +
         ' attribute');
      ok(typeof(e.newValue) == 'string' && e.newValue !== "",
         'Unexpected new value for addition of ' + this.attr +
         ' attribute');
    } else {
      ok(false, 'Unexpected mutation event type: ' + e.attrChange);
      this.giveUp = true;
    }
    this.oldValue = e.newValue;
  }
  this._listener = this._receiveEvent.bind(this);

  this._stillExpecting = function()
  {
    if (this.expectedEvents.length == 0) {
      return "(nothing)";
    }
    var eventNames = [];
    for (var i=0; i < this.expectedEvents.length; i++) {
      eventNames.push(this._eventToName(this.expectedEvents[i]));
    }
    return eventNames.join(", ");
  }

  this._eventToName = function(evtId)
  {
    switch (evtId)
    {
    case MutationEvent.MODIFICATION:
      return "modification";
    case MutationEvent.ADDITION:
      return "addition";
    case MutationEvent.REMOVAL:
      return "removal";
    }
  }

  this._argToEventId = function(arg)
  {
    if (typeof arg === 'number')
      return arg;

    if (typeof arg !== 'string') {
      ok(false, "Unexpected event type: " + arg);
      return 0;
    }

    switch (arg.toLowerCase())
    {
    case "mod":
    case "modify":
    case "modification":
      return MutationEvent.MODIFICATION;

    case "add":
    case "addition":
      return MutationEvent.ADDITION;

    case "removal":
    case "remove":
      return MutationEvent.REMOVAL;

    default:
      ok(false, "Unexpected event name: " + arg);
      return 0;
    }
  }
}
