/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/. */

var EXPORTED_SYMBOLS = ["MozMillController", "globalEventRegistry",
                        "sleep", "windowMap"];

const Cc = Components.classes;
const Ci = Components.interfaces;
const Cu = Components.utils;

var EventUtils = {}; Cu.import('resource://mozmill/stdlib/EventUtils.js', EventUtils);

var assertions = {}; Cu.import('resource://mozmill/modules/assertions.js', assertions);
var broker = {}; Cu.import('resource://mozmill/driver/msgbroker.js', broker);
var elementslib = {}; Cu.import('resource://mozmill/driver/elementslib.js', elementslib);
var errors = {}; Cu.import('resource://mozmill/modules/errors.js', errors);
var mozelement = {}; Cu.import('resource://mozmill/driver/mozelement.js', mozelement);
var utils = {}; Cu.import('resource://mozmill/stdlib/utils.js', utils);
var windows = {}; Cu.import('resource://mozmill/modules/windows.js', windows);

// Declare most used utils functions in the controller namespace
var assert = new assertions.Assert();
var waitFor = assert.waitFor;

var sleep = utils.sleep;

// For Mozmill 1.5 backward compatibility
var windowMap = windows.map;

waitForEvents = function () {
}

waitForEvents.prototype = {
  /**
   * Initialize list of events for given node
   */
  init: function waitForEvents_init(node, events) {
    if (node.getNode != undefined)
      node = node.getNode();

    this.events = events;
    this.node = node;
    node.firedEvents = {};
    this.registry = {};

    for each (var e in events) {
      var listener = function (event) {
        this.firedEvents[event.type] = true;
      }

      this.registry[e] = listener;
      this.registry[e].result = false;
      this.node.addEventListener(e, this.registry[e], true);
    }
  },

  /**
   * Wait until all assigned events have been fired
   */
  wait: function waitForEvents_wait(timeout, interval) {
    for (var e in this.registry) {
      assert.waitFor(function () {
        return this.node.firedEvents[e] == true;
      }, "waitForEvents.wait(): Event '" + ex + "' has been fired.", timeout, interval);

      this.node.removeEventListener(e, this.registry[e], true);
    }
  }
}

/**
 * Class to handle menus and context menus
 *
 * @constructor
 * @param {MozMillController} controller
 *        Mozmill controller of the window under test
 * @param {string} menuSelector
 *        jQuery like selector string of the element
 * @param {object} document
 *        Document to use for finding the menu
 *        [optional - default: aController.window.document]
 */
var Menu = function (controller, menuSelector, document) {
  this._controller = controller;
  this._menu = null;

  document = document || controller.window.document;
  var node = document.querySelector(menuSelector);
  if (node) {
    // We don't unwrap nodes automatically yet (Bug 573185)
    node = node.wrappedJSObject || node;
    this._menu = new mozelement.Elem(node);
  } else {
    throw new Error("Menu element '" + menuSelector + "' not found.");
  }
}

Menu.prototype = {

  /**
   * Open and populate the menu
   *
   * @param {ElemBase} contextElement
   *        Element whose context menu has to be opened
   * @returns {Menu} The Menu instance
   */
  open: function Menu_open(contextElement) {
    // We have to open the context menu
    var menu = this._menu.getNode();
    if ((menu.localName == "popup" || menu.localName == "menupopup") &&
        contextElement && contextElement.exists()) {
      this._controller.rightClick(contextElement);
      assert.waitFor(function () {
        return menu.state == "open";
      }, "Context menu has been opened.");
    }

    // Run through the entire menu and populate with dynamic entries
    this._buildMenu(menu);

    return this;
  },

  /**
   * Close the menu
   *
   * @returns {Menu} The Menu instance
   */
  close: function Menu_close() {
    var menu = this._menu.getNode();

    this._controller.keypress(this._menu, "VK_ESCAPE", {});
    assert.waitFor(function () {
      return menu.state == "closed";
    }, "Context menu has been closed.");

    return this;
  },

  /**
   * Retrieve the specified menu entry
   *
   * @param {string} itemSelector
   *        jQuery like selector string of the menu item
   * @returns {ElemBase} Menu element
   * @throws Error If menu element has not been found
   */
  getItem: function Menu_getItem(itemSelector) {
    // Run through the entire menu and populate with dynamic entries
    this._buildMenu(this._menu.getNode());

    var node = this._menu.getNode().querySelector(itemSelector);

    if (!node) {
      throw new Error("Menu entry '" + itemSelector + "' not found.");
    }

    return new mozelement.Elem(node);
  },

  /**
   * Click the specified menu entry
   *
   * @param {string} itemSelector
   *        jQuery like selector string of the menu item
   *
   * @returns {Menu} The Menu instance
   */
  click: function Menu_click(itemSelector) {
    this._controller.click(this.getItem(itemSelector));

    return this;
  },

  /**
   * Synthesize a keypress against the menu
   *
   * @param {string} key
   *        Key to press
   * @param {object} modifier
   *        Key modifiers
   * @see MozMillController#keypress
   *
   * @returns {Menu} The Menu instance
   */
  keypress: function Menu_keypress(key, modifier) {
    this._controller.keypress(this._menu, key, modifier);

    return this;
  },

  /**
   * Opens the context menu, click the specified entry and
   * make sure that the menu has been closed.
   *
   * @param {string} itemSelector
   *        jQuery like selector string of the element
   * @param {ElemBase} contextElement
   *        Element whose context menu has to be opened
   *
   * @returns {Menu} The Menu instance
   */
  select: function Menu_select(itemSelector, contextElement) {
    this.open(contextElement);
    this.click(itemSelector);
    this.close();
  },

  /**
   * Recursive function which iterates through all menu elements and
   * populates the menus with dynamic menu entries.
   *
   * @param {node} menu
   *        Top menu node whose elements have to be populated
   */
  _buildMenu: function Menu__buildMenu(menu) {
    var items = menu ? menu.childNodes : null;

    Array.forEach(items, function (item) {
      // When we have a menu node, fake a click onto it to populate
      // the sub menu with dynamic entries
      if (item.tagName == "menu") {
        var popup = item.querySelector("menupopup");

        if (popup) {
          var popupEvent = this._controller.window.document.createEvent("MouseEvent");
          popupEvent.initMouseEvent("popupshowing", true, true,
                                    this._controller.window, 0, 0, 0, 0, 0,
                                    false, false, false, false, 0, null);
          popup.dispatchEvent(popupEvent);

          this._buildMenu(popup);
        }
      }
    }, this);
  }
};

var MozMillController = function (window) {
  this.window = window;

  this.mozmillModule = {};
  Cu.import('resource://mozmill/driver/mozmill.js', this.mozmillModule);

  var self = this;
  assert.waitFor(function () {
    return window != null && self.isLoaded();
  }, "controller(): Window has been initialized.");

  // Ensure to focus the window which will move it virtually into the foreground
  // when focusmanager.testmode is set enabled.
  this.window.focus();

  var windowType = window.document.documentElement.getAttribute('windowtype');
  if (controllerAdditions[windowType] != undefined ) {
    this.prototype = new utils.Copy(this.prototype);
    controllerAdditions[windowType](this);
    this.windowtype = windowType;
  }
}

/**
 * Returns the global browser object of the window
 *
 * @returns {Object} The browser object
 */
MozMillController.prototype.__defineGetter__("browserObject", function () {
  return utils.getBrowserObject(this.window);
});

// constructs a MozMillElement from the controller's window
MozMillController.prototype.__defineGetter__("rootElement", function () {
  if (this._rootElement == undefined) {
    let docElement = this.window.document.documentElement;
    this._rootElement = new mozelement.MozMillElement("Elem", docElement);
  }

  return this._rootElement;
});

MozMillController.prototype.sleep = utils.sleep;
MozMillController.prototype.waitFor = assert.waitFor;

// Open the specified url in the current tab
MozMillController.prototype.open = function (url) {
  switch (this.mozmillModule.Application) {
    case "Firefox":
    case "MetroFirefox":
      // Stop a running page load to not overlap requests
      if (this.browserObject.selectedBrowser) {
        this.browserObject.selectedBrowser.stop();
      }

      this.browserObject.loadURI(url);
      break;

    default:
      throw new Error("MozMillController.open not supported.");
  }

  broker.pass({'function':'Controller.open()'});
}

/**
 * Take a screenshot of specified node
 *
 * @param {Element} node
 *        The window or DOM element to capture
 * @param {String} name
 *        The name of the screenshot used in reporting and as filename
 * @param {Boolean} save
 *        If true saves the screenshot as 'name.jpg' in tempdir,
 *        otherwise returns a dataURL
 * @param {Element[]} highlights
 *        A list of DOM elements to highlight by drawing a red rectangle around them
 *
 * @returns {Object} Object which contains properties like filename, dataURL,
 *          name and timestamp of the screenshot
 */
MozMillController.prototype.screenshot = function (node, name, save, highlights) {
  if (!node) {
    throw new Error("node is undefined");
  }

  // Unwrap the node and highlights
  if ("getNode" in node) {
    node = node.getNode();
  }

  if (highlights) {
    for (var i = 0; i < highlights.length; ++i) {
      if ("getNode" in highlights[i]) {
        highlights[i] = highlights[i].getNode();
      }
    }
  }

  // If save is false, a dataURL is used
  // Include both in the report anyway to avoid confusion and make the report easier to parse
  var screenshot = {"filename": undefined,
                    "dataURL": utils.takeScreenshot(node, highlights),
                    "name": name,
                    "timestamp": new Date().toLocaleString()};

  if (!save) {
    return screenshot;
  }

  // Save the screenshot to disk

  let {filename, failure} = utils.saveDataURL(screenshot.dataURL, name);
  screenshot.filename = filename;
  screenshot.failure = failure;

  if (failure) {
    broker.log({'function': 'controller.screenshot()',
                'message': 'Error writing to file: ' + screenshot.filename});
  } else {
    // Send the screenshot object to python over jsbridge
    broker.sendMessage("screenshot", screenshot);
    broker.pass({'function': 'controller.screenshot()'});
  }

  return screenshot;
}

/**
 * Checks if the specified window has been loaded
 *
 * @param {DOMWindow} [aWindow=this.window] Window object to check for loaded state
 */
MozMillController.prototype.isLoaded = function (aWindow) {
  var win = aWindow || this.window;

  return windows.map.getValue(utils.getWindowId(win), "loaded") || false;
};

MozMillController.prototype.__defineGetter__("waitForEvents", function () {
  if (this._waitForEvents == undefined) {
    this._waitForEvents = new waitForEvents();
  }

  return this._waitForEvents;
});

/**
 * Wrapper function to create a new instance of a menu
 * @see Menu
 */
MozMillController.prototype.getMenu = function (menuSelector, document) {
  return new Menu(this, menuSelector, document);
};

MozMillController.prototype.__defineGetter__("mainMenu", function () {
  return this.getMenu("menubar");
});

MozMillController.prototype.__defineGetter__("menus", function () {
  logDeprecated('controller.menus', 'Use controller.mainMenu instead');
});

MozMillController.prototype.waitForImage = function (aElement, timeout, interval) {
  this.waitFor(function () {
    return aElement.getNode().complete == true;
  }, "timeout exceeded for waitForImage " + aElement.getInfo(), timeout, interval);

  broker.pass({'function':'Controller.waitForImage()'});
}

MozMillController.prototype.startUserShutdown = function (timeout, restart, next, resetProfile) {
  if (restart && resetProfile) {
    throw new Error("You can't have a user-restart and reset the profile; there is a race condition");
  }

  let shutdownObj = {
    'user': true,
    'restart': Boolean(restart),
    'next': next,
    'resetProfile': Boolean(resetProfile),
    'timeout': timeout
  };

  broker.sendMessage('shutdown', shutdownObj);
}

/**
 * Restart the application
 *
 * @param {string} aNext
 *        Name of the next test function to run after restart
 * @param {boolean} [aFlags=undefined]
 *        Additional flags how to handle the shutdown or restart. The attributes
 *        eRestarti386 (0x20) and eRestartx86_64 (0x30) have not been documented yet.
 * @see https://developer.mozilla.org/nsIAppStartup#Attributes
 */
MozMillController.prototype.restartApplication = function (aNext, aFlags) {
  var flags = Ci.nsIAppStartup.eAttemptQuit | Ci.nsIAppStartup.eRestart;

  if (aFlags) {
    flags |= aFlags;
  }

  broker.sendMessage('shutdown', {'user': false,
                                  'restart': true,
                                  'flags': flags,
                                  'next': aNext,
                                  'timeout': 0 });

  // We have to ensure to stop the test from continuing until the application is
  // shutting down. The only way to do that is by throwing an exception.
  throw new errors.ApplicationQuitError();
}

/**
 * Stop the application
 *
 * @param {boolean} [aResetProfile=false]
 *        Whether to reset the profile during restart
 * @param {boolean} [aFlags=undefined]
 *        Additional flags how to handle the shutdown or restart. The attributes
 *        eRestarti386 and eRestartx86_64 have not been documented yet.
 * @see https://developer.mozilla.org/nsIAppStartup#Attributes
 */
MozMillController.prototype.stopApplication = function (aResetProfile, aFlags) {
  var flags = Ci.nsIAppStartup.eAttemptQuit;

  if (aFlags) {
    flags |= aFlags;
  }

  broker.sendMessage('shutdown', {'user': false,
                                  'restart': false,
                                  'flags': flags,
                                  'resetProfile': aResetProfile,
                                  'timeout': 0 });

  // We have to ensure to stop the test from continuing until the application is
  // shutting down. The only way to do that is by throwing an exception.
  throw new errors.ApplicationQuitError();
}

//Browser navigation functions
MozMillController.prototype.goBack = function () {
  this.window.content.history.back();
  broker.pass({'function':'Controller.goBack()'});

  return true;
}

MozMillController.prototype.goForward = function () {
  this.window.content.history.forward();
  broker.pass({'function':'Controller.goForward()'});

  return true;
}

MozMillController.prototype.refresh = function () {
  this.window.content.location.reload(true);
  broker.pass({'function':'Controller.refresh()'});

  return true;
}

function logDeprecated(funcName, message) {
  broker.log({'function': funcName + '() - DEPRECATED',
              'message': funcName + '() is deprecated. ' + message});
}

function logDeprecatedAssert(funcName) {
   logDeprecated('controller.' + funcName,
                 '. Use the generic `assertion` module instead.');
}

MozMillController.prototype.assertText = function (el, text) {
  logDeprecatedAssert("assertText");

  var n = el.getNode();

  if (n && n.innerHTML == text) {
    broker.pass({'function': 'Controller.assertText()'});
  } else {
    throw new Error("could not validate element " + el.getInfo() +
                    " with text "+ text);
  }

  return true;
};

/**
 * Assert that a specified node exists
 */
MozMillController.prototype.assertNode = function (el) {
  logDeprecatedAssert("assertNode");

  //this.window.focus();
  var element = el.getNode();
  if (!element) {
    throw new Error("could not find element " + el.getInfo());
  }

  broker.pass({'function': 'Controller.assertNode()'});
  return true;
};

/**
 * Assert that a specified node doesn't exist
 */
MozMillController.prototype.assertNodeNotExist = function (el) {
  logDeprecatedAssert("assertNodeNotExist");

  try {
    var element = el.getNode();
  } catch (e) {
    broker.pass({'function': 'Controller.assertNodeNotExist()'});
  }

  if (element) {
    throw new Error("Unexpectedly found element " + el.getInfo());
  } else {
    broker.pass({'function':'Controller.assertNodeNotExist()'});
  }

  return true;
};

/**
 * Assert that a form element contains the expected value
 */
MozMillController.prototype.assertValue = function (el, value) {
  logDeprecatedAssert("assertValue");

  var n = el.getNode();

  if (n && n.value == value) {
    broker.pass({'function': 'Controller.assertValue()'});
  } else {
    throw new Error("could not validate element " + el.getInfo() +
                    " with value " + value);
  }

  return false;
};

/**
 * Check if the callback function evaluates to true
 */
MozMillController.prototype.assert = function (callback, message, thisObject) {
  logDeprecatedAssert("assert");

  utils.assert(callback, message, thisObject);
  broker.pass({'function': ": controller.assert('" + callback + "')"});

  return true;
}

/**
 * Assert that a provided value is selected in a select element
 */
MozMillController.prototype.assertSelected = function (el, value) {
  logDeprecatedAssert("assertSelected");

  var n = el.getNode();
  var validator = value;

  if (n && n.options[n.selectedIndex].value == validator) {
    broker.pass({'function':'Controller.assertSelected()'});
  } else {
    throw new Error("could not assert value for element " + el.getInfo() +
                    " with value " + value);
  }

  return true;
};

/**
 * Assert that a provided checkbox is checked
 */
MozMillController.prototype.assertChecked = function (el) {
  logDeprecatedAssert("assertChecked");

  var element = el.getNode();

  if (element && element.checked == true) {
    broker.pass({'function':'Controller.assertChecked()'});
  } else {
    throw new Error("assert failed for checked element " + el.getInfo());
  }

  return true;
};

/**
 * Assert that a provided checkbox is not checked
 */
MozMillController.prototype.assertNotChecked = function (el) {
  logDeprecatedAssert("assertNotChecked");

  var element = el.getNode();

  if (!element) {
    throw new Error("Could not find element" + el.getInfo());
  }

  if (!element.hasAttribute("checked") || element.checked != true) {
    broker.pass({'function': 'Controller.assertNotChecked()'});
  } else {
    throw new Error("assert failed for not checked element " + el.getInfo());
  }

  return true;
};

/**
 * Assert that an element's javascript property exists or has a particular value
 *
 * if val is undefined, will return true if the property exists.
 * if val is specified, will return true if the property exists and has the correct value
 */
MozMillController.prototype.assertJSProperty = function (el, attrib, val) {
  logDeprecatedAssert("assertJSProperty");

  var element = el.getNode();

  if (!element){
    throw new Error("could not find element " + el.getInfo());
  }

  var value = element[attrib];
  var res = (value !== undefined && (val === undefined ? true :
                                                         String(value) == String(val)));
  if (res) {
    broker.pass({'function':'Controller.assertJSProperty("' + el.getInfo() + '") : ' + val});
  } else {
    throw new Error("Controller.assertJSProperty(" + el.getInfo() + ") : " +
                    (val === undefined ? "property '" + attrib +
                    "' doesn't exist" : val + " == " + value));
  }

  return true;
};

/**
 * Assert that an element's javascript property doesn't exist or doesn't have a particular value
 *
 * if val is undefined, will return true if the property doesn't exist.
 * if val is specified, will return true if the property doesn't exist or doesn't have the specified value
 */
MozMillController.prototype.assertNotJSProperty = function (el, attrib, val) {
  logDeprecatedAssert("assertNotJSProperty");

  var element = el.getNode();

  if (!element){
    throw new Error("could not find element " + el.getInfo());
  }

  var value = element[attrib];
  var res = (val === undefined ? value === undefined : String(value) != String(val));
  if (res) {
    broker.pass({'function':'Controller.assertNotProperty("' + el.getInfo() + '") : ' + val});
  } else {
    throw new Error("Controller.assertNotJSProperty(" + el.getInfo() + ") : " +
                    (val === undefined ? "property '" + attrib +
                    "' exists" : val + " != " + value));
  }

  return true;
};

/**
 * Assert that an element's dom property exists or has a particular value
 *
 * if val is undefined, will return true if the property exists.
 * if val is specified, will return true if the property exists and has the correct value
 */
MozMillController.prototype.assertDOMProperty = function (el, attrib, val) {
  logDeprecatedAssert("assertDOMProperty");

  var element = el.getNode();

  if (!element){
    throw new Error("could not find element " + el.getInfo());
  }

  var value, res = element.hasAttribute(attrib);
  if (res && val !== undefined) {
    value = element.getAttribute(attrib);
    res = (String(value) == String(val));
  }

  if (res) {
    broker.pass({'function':'Controller.assertDOMProperty("' + el.getInfo() + '") : ' + val});
  } else {
    throw new Error("Controller.assertDOMProperty(" + el.getInfo() + ") : " +
                    (val === undefined ? "property '" + attrib +
                    "' doesn't exist" : val + " == " + value));
  }

  return true;
};

/**
 * Assert that an element's dom property doesn't exist or doesn't have a particular value
 *
 * if val is undefined, will return true if the property doesn't exist.
 * if val is specified, will return true if the property doesn't exist or doesn't have the specified value
 */
MozMillController.prototype.assertNotDOMProperty = function (el, attrib, val) {
  logDeprecatedAssert("assertNotDOMProperty");

  var element = el.getNode();

  if (!element) {
    throw new Error("could not find element " + el.getInfo());
  }

  var value, res = element.hasAttribute(attrib);
  if (res && val !== undefined) {
    value = element.getAttribute(attrib);
    res = (String(value) == String(val));
  }

  if (!res) {
    broker.pass({'function':'Controller.assertNotDOMProperty("' + el.getInfo() + '") : ' + val});
  } else {
    throw new Error("Controller.assertNotDOMProperty(" + el.getInfo() + ") : " +
                    (val == undefined ? "property '" + attrib +
                    "' exists" : val + " == " + value));
  }

  return true;
};

/**
 * Assert that a specified image has actually loaded. The Safari workaround results
 * in additional requests for broken images (in Safari only) but works reliably
 */
MozMillController.prototype.assertImageLoaded = function (el) {
  logDeprecatedAssert("assertImageLoaded");

  var img = el.getNode();

  if (!img || img.tagName != 'IMG') {
    throw new Error('Controller.assertImageLoaded() failed.')
    return false;
  }

  var comp = img.complete;
  var ret = null; // Return value

  // Workaround for Safari -- it only supports the
  // complete attrib on script-created images
  if (typeof comp == 'undefined') {
    test = new Image();
    // If the original image was successfully loaded,
    // src for new one should be pulled from cache
    test.src = img.src;
    comp = test.complete;
  }

  // Check the complete attrib. Note the strict
  // equality check -- we don't want undefined, null, etc.
  // --------------------------
  if (comp === false) {
    // False -- Img failed to load in IE/Safari, or is
    // still trying to load in FF
    ret = false;
  } else if (comp === true && img.naturalWidth == 0) {
    // True, but image has no size -- image failed to
    // load in FF
    ret = false;
  } else {
    // Otherwise all we can do is assume everything's
    // hunky-dory
   ret = true;
  }

  if (ret) {
    broker.pass({'function':'Controller.assertImageLoaded'});
  } else {
    throw new Error('Controller.assertImageLoaded() failed.')
  }

  return true;
};

/**
 * Drag one element to the top x,y coords of another specified element
 */
MozMillController.prototype.mouseMove = function (doc, start, dest) {
  // if one of these elements couldn't be looked up
  if (typeof start != 'object'){
    throw new Error("received bad coordinates");
  }

  if (typeof dest != 'object'){
    throw new Error("received bad coordinates");
  }

  var triggerMouseEvent = function (element, clientX, clientY) {
    clientX = clientX ? clientX: 0;
    clientY = clientY ? clientY: 0;

    // make the mouse understand where it is on the screen
    var screenX = element.boxObject.screenX ? element.boxObject.screenX : 0;
    var screenY = element.boxObject.screenY ? element.boxObject.screenY : 0;

    var evt = element.ownerDocument.createEvent('MouseEvents');
    if (evt.initMouseEvent) {
      evt.initMouseEvent('mousemove', true, true, element.ownerDocument.defaultView,
                         1, screenX, screenY, clientX, clientY);
    } else {
      evt.initEvent('mousemove', true, true);
    }

    element.dispatchEvent(evt);
  };

  // Do the initial move to the drag element position
  triggerMouseEvent(doc.body, start[0], start[1]);
  triggerMouseEvent(doc.body, dest[0], dest[1]);

  broker.pass({'function':'Controller.mouseMove()'});
  return true;
}

/**
 * Drag an element to the specified offset on another element, firing mouse and
 * drag events. Adapted from ChromeUtils.js synthesizeDrop()
 *
 * @deprecated Use the MozMillElement object
 *
 * @param {MozElement} aSrc
 *        Source element to be dragged
 * @param {MozElement} aDest
 *        Destination element over which the drop occurs
 * @param {Number} [aOffsetX=element.width/2]
 *        Relative x offset for dropping on the aDest element
 * @param {Number} [aOffsetY=element.height/2]
 *        Relative y offset for dropping on the aDest element
 * @param {DOMWindow} [aSourceWindow=this.element.ownerDocument.defaultView]
 *        Custom source Window to be used.
 * @param {String} [aDropEffect="move"]
 *        Effect used for the drop event
 * @param {Object[]} [aDragData]
 *        An array holding custom drag data to be used during the drag event
 *        Format: [{ type: "text/plain", "Text to drag"}, ...]
 *
 * @returns {String} the captured dropEffect
 */
MozMillController.prototype.dragToElement = function (aSrc, aDest, aOffsetX,
                                                      aOffsetY, aSourceWindow,
                                                      aDropEffect, aDragData) {
  logDeprecated("controller.dragToElement", "Use the MozMillElement object.");
  return aSrc.dragToElement(aDest, aOffsetX, aOffsetY, aSourceWindow, null,
                            aDropEffect, aDragData);
};

function Tabs(controller) {
  this.controller = controller;
}

Tabs.prototype.getTab = function (index) {
  return this.controller.browserObject.browsers[index].contentDocument;
}

Tabs.prototype.__defineGetter__("activeTab", function () {
  return this.controller.browserObject.selectedBrowser.contentDocument;
});

Tabs.prototype.selectTab = function (index) {
  // GO in to tab manager and grab the tab by index and call focus.
}

Tabs.prototype.findWindow = function (doc) {
  for (var i = 0; i <= (this.controller.window.frames.length - 1); i++) {
    if (this.controller.window.frames[i].document == doc) {
      return this.controller.window.frames[i];
    }
  }

  throw new Error("Cannot find window for document. Doc title == " + doc.title);
}

Tabs.prototype.getTabWindow = function (index) {
  return this.findWindow(this.getTab(index));
}

Tabs.prototype.__defineGetter__("activeTabWindow", function () {
  return this.findWindow(this.activeTab);
});

Tabs.prototype.__defineGetter__("length", function () {
  return this.controller.browserObject.browsers.length;
});

Tabs.prototype.__defineGetter__("activeTabIndex", function () {
  var browser = this.controller.browserObject;

  switch(this.controller.mozmillModule.Application) {
    case "MetroFirefox":
      return browser.tabs.indexOf(browser.selectedTab);
    case "Firefox":
    default:
      return browser.tabContainer.selectedIndex;
  }
});

Tabs.prototype.selectTabIndex = function (aIndex) {
  var browser = this.controller.browserObject;

  switch(this.controller.mozmillModule.Application) {
    case "MetroFirefox":
      browser.selectedTab = browser.tabs[aIndex];
      break;
    case "Firefox":
    default:
      browser.selectTabAtIndex(aIndex);
  }
}

function browserAdditions (controller) {
  controller.tabs = new Tabs(controller);

  controller.waitForPageLoad = function (aDocument, aTimeout, aInterval) {
    var timeout = aTimeout || 30000;
    var win = null;
    var timed_out = false;

    // If a user tries to do waitForPageLoad(2000), this will assign the
    // interval the first arg which is most likely what they were expecting
    if (typeof(aDocument) == "number"){
      timeout = aDocument;
    }

    // If we have a real document use its default view
    if (aDocument && (typeof(aDocument) === "object") &&
        "defaultView" in aDocument)
      win = aDocument.defaultView;

    // If no document has been specified, fallback to the default view of the
    // currently selected tab browser
    win = win || this.browserObject.selectedBrowser.contentWindow;

    // Wait until the content in the tab has been loaded
    try {
      this.waitFor(function () {
        return windows.map.hasPageLoaded(utils.getWindowId(win));
      }, "Timeout", timeout, aInterval);
    }
    catch (ex if ex instanceof errors.TimeoutError) {
      timed_out = true;
    }
    finally {
      state = 'URI=' + win.document.location.href +
              ', readyState=' + win.document.readyState;
      message = "controller.waitForPageLoad(" + state + ")";

      if (timed_out) {
        throw new errors.AssertionError(message);
      }

      broker.pass({'function': message});
    }
  }
}

var controllerAdditions = {
  'navigator:browser'  :browserAdditions
};

/**
 *  DEPRECATION WARNING
 *
 * The following methods have all been DEPRECATED as of Mozmill 2.0
 */
MozMillController.prototype.assertProperty = function (el, attrib, val) {
  logDeprecatedAssert("assertProperty");

  return this.assertJSProperty(el, attrib, val);
};

MozMillController.prototype.assertPropertyNotExist = function (el, attrib) {
  logDeprecatedAssert("assertPropertyNotExist");
  return this.assertNotJSProperty(el, attrib);
};

/**
 *  DEPRECATION WARNING
 *
 * The following methods have all been DEPRECATED as of Mozmill 2.0
 * Use the MozMillElement object instead (https://developer.mozilla.org/en/Mozmill/Mozmill_Element_Object)
 */
MozMillController.prototype.select = function (aElement, index, option, value) {
  logDeprecated("controller.select", "Use the MozMillElement object.");

  return aElement.select(index, option, value);
};

MozMillController.prototype.keypress = function (aElement, aKey, aModifiers, aExpectedEvent) {
  logDeprecated("controller.keypress", "Use the MozMillElement object.");

  if (!aElement) {
    aElement = new mozelement.MozMillElement("Elem", this.window);
  }

  return aElement.keypress(aKey, aModifiers, aExpectedEvent);
}

MozMillController.prototype.type = function (aElement, aText, aExpectedEvent) {
  logDeprecated("controller.type", "Use the MozMillElement object.");

  if (!aElement) {
    aElement = new mozelement.MozMillElement("Elem", this.window);
  }

  var that = this;
  var retval = true;
  Array.forEach(aText, function (letter) {
    if (!that.keypress(aElement, letter, {}, aExpectedEvent)) {
      retval = false; }
  });

  return retval;
}

MozMillController.prototype.mouseEvent = function (aElement, aOffsetX, aOffsetY, aEvent, aExpectedEvent) {
  logDeprecated("controller.mouseEvent", "Use the MozMillElement object.");

  return aElement.mouseEvent(aOffsetX, aOffsetY, aEvent, aExpectedEvent);
}

MozMillController.prototype.click = function (aElement, left, top, expectedEvent) {
  logDeprecated("controller.click", "Use the MozMillElement object.");

  return aElement.click(left, top, expectedEvent);
}

MozMillController.prototype.doubleClick = function (aElement, left, top, expectedEvent) {
  logDeprecated("controller.doubleClick", "Use the MozMillElement object.");

  return aElement.doubleClick(left, top, expectedEvent);
}

MozMillController.prototype.mouseDown = function (aElement, button, left, top, expectedEvent) {
  logDeprecated("controller.mouseDown", "Use the MozMillElement object.");

  return aElement.mouseDown(button, left, top, expectedEvent);
};

MozMillController.prototype.mouseOut = function (aElement, button, left, top, expectedEvent) {
  logDeprecated("controller.mouseOut", "Use the MozMillElement object.");

  return aElement.mouseOut(button, left, top, expectedEvent);
};

MozMillController.prototype.mouseOver = function (aElement, button, left, top, expectedEvent) {
  logDeprecated("controller.mouseOver", "Use the MozMillElement object.");

  return aElement.mouseOver(button, left, top, expectedEvent);
};

MozMillController.prototype.mouseUp = function (aElement, button, left, top, expectedEvent) {
  logDeprecated("controller.mouseUp", "Use the MozMillElement object.");

  return aElement.mouseUp(button, left, top, expectedEvent);
};

MozMillController.prototype.middleClick = function (aElement, left, top, expectedEvent) {
  logDeprecated("controller.middleClick", "Use the MozMillElement object.");

  return aElement.middleClick(aElement, left, top, expectedEvent);
}

MozMillController.prototype.rightClick = function (aElement, left, top, expectedEvent) {
  logDeprecated("controller.rightClick", "Use the MozMillElement object.");

  return aElement.rightClick(left, top, expectedEvent);
}

MozMillController.prototype.check = function (aElement, state) {
  logDeprecated("controller.check", "Use the MozMillElement object.");

  return aElement.check(state);
}

MozMillController.prototype.radio = function (aElement) {
  logDeprecated("controller.radio", "Use the MozMillElement object.");

  return aElement.select();
}

MozMillController.prototype.waitThenClick = function (aElement, timeout, interval) {
  logDeprecated("controller.waitThenClick", "Use the MozMillElement object.");

  return aElement.waitThenClick(timeout, interval);
}

MozMillController.prototype.waitForElement = function (aElement, timeout, interval) {
  logDeprecated("controller.waitForElement", "Use the MozMillElement object.");

  return aElement.waitForElement(timeout, interval);
}

MozMillController.prototype.waitForElementNotPresent = function (aElement, timeout, interval) {
  logDeprecated("controller.waitForElementNotPresent", "Use the MozMillElement object.");

  return aElement.waitForElementNotPresent(timeout, interval);
}
