define([
	"doh/_browserRunner", "require",
	"dojo/aspect", "dojo/Deferred", "dojo/dom-class", "dojo/dom-construct", "dojo/dom-geometry", "dojo/_base/lang", "dojo/ready",
	"dojo/_base/unload", "dojo/when", "dojo/_base/window", "dojo/sniff", "dojo/has", "dojo/has!android?doh/plugins/android-webdriver-robot"
], function(doh, require, aspect, Deferred, domClass, construct, geom, lang, ready, unload, when, win, sniff, has, webdriver){

// loading state
var _robot = null;

var isSecure = (function(){
	var key = Math.random();
	return function(fcn){
		return key;
	};
})();

var _keyPress = function(/*Number*/ charCode, /*Number*/ keyCode, /*Boolean*/ alt, /*Boolean*/ ctrl, /*Boolean*/ shift, /*Boolean*/ meta, /*Integer?*/ delay, /*Boolean*/ async){
	// internal function to type one non-modifier key

	// typecasting Numbers helps Sun's IE plugin lookup methods that take int arguments

	// otherwise JS will send a double and Sun will complain
	_robot.typeKey(isSecure(), Number(charCode), Number(keyCode), Boolean(alt), Boolean(ctrl), Boolean(shift), Boolean(meta), Number(delay||0), Boolean(async||false));
};

// Queue of pending actions plus the currently executing action registered via sequence().
// Each action is a function that either:
//		1. does a setTimeout()
//		2. calls java Robot (mouse movement, typing a single letter, etc.)
//		3. executes user defined function (for when app called sequence() directly).
// Each function can return a Promise, or just a plain value if it executes synchronously.
var seqPromise;
aspect.before(doh, "_runFixture", function(){
	// At the start of each new test fixture, clear any leftover queued actions from the previous test fixture.
	// This will happen when the previous test throws an error, or times out.
	var _seqPromise = seqPromise;
	// need setTimeout to avoid false error; seqPromise from passing test is not fulfilled until after this execution trace finishes!
	// really we should not have both `seqPromise` here and `var d = new doh.Deferred()` in the test
	setTimeout(function(){
		if(_seqPromise && !_seqPromise.isFulfilled()){
			_seqPromise.cancel(new Error("new test starting, cancelling pending & in-progress queued events from previous test")); 
		}
	},0);
	seqPromise = new Deferred();
	seqPromise.resolve(true);
});

// Previous mouse position (from most recent mouseMoveTo() command)
var lastMouse = {x: 5, y: 5};

// For 2.0, remove code to set doh.robot global.
var robot = doh.robot = {
	_robotLoaded: true,
	_robotInitialized: false,
	// prime the event pump for fast browsers like Google Chrome - it's so fast, it doesn't stop to listen for keypresses!
	_spaceReceived: false,
	_primePump: false,

	_killApplet: function(){}, // overridden by Robot.html

	killRobot: function(){
		if(robot._robotLoaded){
			robot._robotLoaded = false;
			domClass.remove(document.documentElement, "dohRobot");
			robot._killApplet();
		}
	},

	// Robot init methods

	// controls access to doh.run
	// basically, doh.run takes two calls to start the robot:
	// one (or more after the robot loads) from the test page
	// one from either the applet or an error condition
	_runsemaphore: {
		lock: ["lock"],
		unlock: function(){
			try{
				return this.lock.shift();
			}catch(e){
				return null;
			}
		}
	},

	startRobot: function(){
		//startRobot should be called to initialize the robot (after the java applet is loaded).
		//one good place to do this is in a dojo.addOnLoad handler. This function will be called
		//automatically if it is not already called when doh.run() is invoked.
		if(!this._robotInitialized){
			this._robotInitialized = true;
			// if the iframe requested the applet and got a 404, then _robot is obviously unavailable
			// at least run the non-robot tests!
			if(robot._appletDead){
				robot._onKeyboard();
			}else{
				_robot._callLoaded(isSecure());
			}
		}

		// When robot finishes initializing it types a key, firing the _onKeyboard() listener, which calls _run(),
		// which resolves this Deferred.
		return this._started;
	},

	// _loaded: Deferred
	//		Deferred that resolves when the _initRobot() has been called.
	//		Note to be confused with dojo/robotx.js, which defines initRobot() without an underscore
	_loaded: new doh.Deferred(),

	_initRobot: function(r){
		// called from Robot
		// Robot calls _initRobot in its startup sequence

		// Prevent rerunning the whole test (see #8958 for details)
		if(doh._initRobotCalled){ return; }
		doh._initRobotCalled = true;

		// add dohRobot class to HTML element so tests can use that in CSS rules if desired
		domClass.add(document.documentElement, "dohRobot");
		window.scrollTo(0, 0);
//		document.documentElement.scrollTop = document.documentElement.scrollLeft = 0;
		_robot = r;
		_robot._setKey(isSecure());
		this._loaded.resolve(true);
	},

	// _started: Deferred
	//		Deferred that resolves when startRobot() has signaled completing by typing on the keyboard,
	//		which in turn calls _run().
	_started: new doh.Deferred(),

	// some utility functions to help the iframe use private variables
	_run: function(frame){
		// called after the robot has been able to type on the keyboard, indicating that it's started
		frame.style.visibility = "hidden";
		this._started.resolve(true);
	},

	_initKeyboard: function(){
		_robot._initKeyboard(isSecure());
	},

	_onKeyboard: function(){
		// replaced by iframe when applet present.
		// remote robots don't have frames so pass a mock frame.
		this._run({style:{visibility:""}});
	},

	_initWheel: function(){
		_robot._initWheel(isSecure());
	},

	_setDocumentBounds: function(docScreenX, docScreenY){
		var robotView = document.getElementById("dohrobotview");
		_robot.setDocumentBounds(isSecure(), Number(docScreenX), Number(docScreenY), Number(robotView.offsetLeft), Number(robotView.offsetTop));
	},

	_notified: function(keystring){
		_robot._notified(isSecure(), keystring);
	},

	// if the applet is 404 or cert is denied, this becomes true and kills tests
	_appletDead: false,

	_assertRobot: function(){
		// make sure the applet is there and cert accepted
		// otherwise, skip the test requesting the robot action
		if(robot._appletDead){ throw new Error('robot not available; skipping test.'); }
	},

	_mouseMove: function(/*Number*/ x, /*Number*/ y, /*Boolean*/ absolute, /*Integer?*/ duration){
		// This function is no longer used, but left for back-compat
		if(absolute){
			var scroll = {y: (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
			x: (window.pageXOffset || geom.fixIeBiDiScrollLeft(document.documentElement.scrollLeft) || document.body.scrollLeft || 0)};
			y -= scroll.y;
			x -= scroll.x;
		}
		_robot.moveMouse(isSecure(), Number(x), Number(y), Number(0), Number(duration||100));
	},

	// Main robot API
	sequence: function(/*Function*/ f, /*Integer?*/ delay, /*Integer?*/ duration){
		// summary:
		//		Defer an action by adding it to the robot's incrementally delayed queue of actions to execute.
		// f:
		//		A function containing actions you want to defer.  It can return a Promise
		//		to delay further actions.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// duration:
		//		Delay to wait after firing.

		function waitFunc(ms){
			// Returns a function that returns a Promise that fires after ms milliseconds.
			return function(){
				var timer, d;
				d = new Deferred(function(){ clearTimeout(timer); });
				timer = setTimeout(function(){ d.resolve(true); }, ms);
				return d;
			};
		}

		// Queue action to run specified function, plus optional "wait" actions for delay and duration.
		if(delay){ seqPromise = seqPromise.then(waitFunc(delay)); }
		seqPromise = seqPromise.then(f);
		if(duration){ seqPromise = seqPromise.then(waitFunc(duration)); }
	},

	typeKeys: function(/*String|Number*/ chars, /*Integer?*/ delay, /*Integer?*/ duration){
		// summary:
		//		Types a string of characters in order, or types a dojo.keys.* constant.
		// description:
		//		Types a string of characters in order, or types a dojo.keys.* constant.
		// example:
		// |	robot.typeKeys("dijit.ed", 500);
		// chars:
		//		String of characters to type, or a dojo.keys.* constant
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// duration:
		//		Time, in milliseconds, to spend pressing all of the keys.
		//		The default is (string length)*50 ms.

		this._assertRobot();
		var isNum = typeof(chars) == Number;
		duration = duration||(isNum?50: chars.length*50);
		if(isNum){
			this.sequence(lang.partial(_keyPress, chars, chars, false, false, false, false, 0, 0),
				delay, duration);
		}else{
			for(var i = 0; i < chars.length; i++){
				this.sequence(lang.partial(_keyPress, chars.charCodeAt(i), 0, false, false, false, false, 0, 0),
					i == 0 ? delay : 0, Math.max(Math.ceil(duration/chars.length), 0));
			}
		}
	},

	keyPress: function(/*Integer*/ charOrCode, /*Integer?*/ delay, /*Object*/ modifiers, /*Boolean*/ asynchronous){
		// summary:
		//		Types a key combination, like SHIFT-TAB.
		// description:
		//		Types a key combination, like SHIFT-TAB.
		// example:
		//		to press shift-tab immediately, call robot.keyPress(dojo.keys.TAB, 0, {shift: true})
		// charOrCode:
		//		char/JS keyCode/dojo.keys.* constant for the key you want to press
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// modifiers:
		//		JSON object that represents all of the modifier keys being pressed.
		//		It takes the following Boolean attributes:
		//
		//		- shift
		//		- alt
		//		- ctrl
		//		- meta
		// asynchronous:
		//		If true, the delay happens asynchronously and immediately, outside of the browser's JavaScript thread and any previous calls.
		//		This is useful for interacting with the browser's modal dialogs.

		this._assertRobot();
		if(!modifiers){
			modifiers = {alt:false, ctrl:false, shift:false, meta:false};
		}else{
			// normalize modifiers
			var attrs = ["alt", "ctrl", "shift", "meta"];
			for(var i = 0; i<attrs.length; i++){
				if(!modifiers[attrs[i]]){
					modifiers[attrs[i]] = false;
				}
			}
		}
		var isChar = typeof(charOrCode)=="string";
		if(asynchronous){
			_keyPress(isChar?charOrCode.charCodeAt(0):0, isChar?0:charOrCode, modifiers.alt, modifiers.ctrl, modifiers.shift, modifiers.meta, delay, true);
			return;
		}
		this.sequence(function(){
			_keyPress(isChar?charOrCode.charCodeAt(0):0, isChar?0:charOrCode, modifiers.alt, modifiers.ctrl, modifiers.shift, modifiers.meta, 0);
		}, delay);
	},

	keyDown: function(/*Integer*/ charOrCode, /*Integer?*/ delay){
		// summary:
		//		Holds down a single key, like SHIFT or 'a'.
		// description:
		//		Holds down a single key, like SHIFT or 'a'.
		// example:
		//		to hold down the 'a' key immediately, call robot.keyDown('a')
		// charOrCode:
		//		char/JS keyCode/dojo.keys.* constant for the key you want to hold down
		//		Warning: holding down a shifted key, like 'A', can have unpredictable results.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all

		this._assertRobot();
		this.sequence(function(){
			var isChar = typeof(charOrCode)=="string";
			_robot.downKey(isSecure(), isChar?charOrCode:0, isChar?0:charOrCode, 0);
		}, delay);
	},

	keyUp: function(/*Integer*/ charOrCode, /*Integer?*/ delay){
		// summary:
		//		Releases a single key, like SHIFT or 'a'.
		// description:
		//		Releases a single key, like SHIFT or 'a'.
		// example:
		//		to release the 'a' key immediately, call robot.keyUp('a')
		// charOrCode:
		//		char/JS keyCode/dojo.keys.* constant for the key you want to release
		//		Warning: releasing a shifted key, like 'A', can have unpredictable results.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all

		this._assertRobot();
		this.sequence(function(){
			var isChar=typeof(charOrCode)=="string";
			_robot.upKey(isSecure(), isChar?charOrCode:0, isChar?0:charOrCode, 0);
		}, delay);
	},


	mouseClick: function(/*Object*/ buttons, /*Integer?*/ delay){
		// summary:
		//		Convenience function to do a press/release.
		//		See robot.mousePress for more info.
		// description:
		//		Convenience function to do a press/release.
		//		See robot.mousePress for more info.

		this._assertRobot();
		robot.mousePress(buttons, delay);
		robot.mouseRelease(buttons, 1);
	},

	mousePress: function(/*Object*/ buttons, /*Integer?*/ delay){
		// summary:
		//		Presses mouse buttons.
		// description:
		//		Presses the mouse buttons you pass as true.
		//		Example: to press the left mouse button, pass {left: true}.
		//		Mouse buttons you don't specify keep their previous pressed state.
		// buttons:
		//		JSON object that represents all of the mouse buttons being pressed.
		//		It takes the following Boolean attributes:
		//
		//		- left
		//		- middle
		//		- right
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all

		this._assertRobot();
		if(!buttons){ return; }
		this.sequence(function(){
			var attrs = ["left", "middle", "right"];
			for(var i = 0; i<attrs.length; i++){
				if(!buttons[attrs[i]]){
					buttons[attrs[i]] = false;
				}
			}
			_robot.pressMouse(isSecure(), Boolean(buttons.left), Boolean(buttons.middle), Boolean(buttons.right), Number(0));
		}, delay);
	},

	mouseMoveTo: function(/*Object*/ point, /*Integer?*/ delay, /*Integer?*/ duration, /*Boolean*/ absolute){
		// summary:
		//		Move the mouse from the current position to the specified point.
		//		Delays reading contents point until queued command starts running.
		//		See mouseMove() for details.
		// point: Object
		//		x, y position relative to viewport, or if absolute == true, to document

		this._assertRobot();
		duration = duration||100;

		// Calculate number of mouse movements we will do, based on specified duration.
		// IE6-8 timers have a granularity of 15ms, so only do one mouse move every 15ms
		var steps = duration<=1 ? 1 : // duration==1 -> user wants to jump the mouse
			(duration/15)|1; // |1 to ensure an odd # of intermediate steps for sensible interpolation
		var stepDuration = Math.floor(duration/steps);

		// Starting and ending points of the mouse movement.
		var start, end;

		this.sequence(function(){
			// This runs right before we start moving the mouse.   At this time (but not before), point is guaranteed
			// to be filled w/the correct data.   So set start and end points for the movement of the mouse.
			start = lastMouse;
			if(absolute){
				// Adjust end to be relative to viewport
				var scroll = {y: (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
					x: (window.pageXOffset || geom.fixIeBiDiScrollLeft(document.documentElement.scrollLeft) || document.body.scrollLeft || 0)};
				end = { y: point.y - scroll.y, x: point.x - scroll.x };
			}else{
				end = point;
			}
			//console.log("mouseMoveTo() start, going from (", lastMouse.x, lastMouse.y, "), (", end.x, end.y, "), delay = " +
			//	delay + ", duration = " + duration);
		}, delay || 0);

		// Function to positions the mouse along the line from start to end at the idx'th position (from 0 .. steps)
		function step(idx){
			function easeInOutQuad(/*Number*/ t, /*Number*/ b, /*Number*/ c, /*Number*/ d){
				t /= d / 2;
				if(t < 1)
					return Math.round(c / 2 * t * t + b);
				t--;
				return Math.round(-c / 2 * (t * (t - 2) - 1) + b);
			}

			var x = idx == steps ? end.x : easeInOutQuad(idx, start.x, end.x - start.x, steps),
				y = idx == steps ? end.y : easeInOutQuad(idx, start.y, end.y - start.y, steps);

			// If same position as the last time, don't bother calling java robot.
			if(x == lastMouse.x && y == lastMouse.y){ return true; }

			_robot.moveMouse(isSecure(), Number(x), Number(y), Number(0), Number(1));
			lastMouse = {x: x, y: y};
		}

		// Schedule mouse moves from beginning to end of line.
		// Start from t=1 because there's no need to move the mouse to where it already is
		for (var t = 1; t <= steps; t++){
			// Use lang.partial() to lock in value of t before the t++
			this.sequence(lang.partial(step, t), 0, stepDuration);
		}
	},

	mouseMove: function(/*Number*/ x, /*Number*/ y, /*Integer?*/ delay, /*Integer?*/ duration, /*Boolean*/ absolute){
		// summary:
		//		Moves the mouse to the specified x,y offset relative to the viewport.
		// x:
		//		x offset relative to the viewport, in pixels, to move the mouse.
		// y:
		//		y offset relative to the viewport, in pixels, to move the mouse.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		// |		robot.mouseClick({left: true}, 100) // first call; wait 100ms
		// |		robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// duration:
		//		Approximate time Robot will spend moving the mouse
		//		The default is 100ms. This also affects how many mousemove events will
		//		be generated, which is the log of the duration.
		// absolute:
		//		Boolean indicating whether the x and y values are absolute coordinates.
		//		If false, then mouseMove expects that the x,y will be relative to the window. (clientX/Y)
		//		If true, then mouseMove expects that the x,y will be absolute. (pageX/Y)

		this.mouseMoveTo({x: x, y: y}, delay, duration, absolute);
	},

	mouseRelease: function(/*Object*/ buttons, /*Integer?*/ delay){
		// summary:
		//		Releases mouse buttons.
		// description:
		//		Releases the mouse buttons you pass as true.
		//		Example: to release the left mouse button, pass {left: true}.
		//		Mouse buttons you don't specify keep their previous pressed state.
		//		See robot.mousePress for more info.

		this._assertRobot();
		if(!buttons){ return; }
		this.sequence(function(){
			var attrs = ["left", "middle", "right"];
			for(var i = 0; i<attrs.length; i++){
				if(!buttons[attrs[i]]){
					buttons[attrs[i]] = false;
				}
			}
			_robot.releaseMouse(isSecure(), Boolean(buttons.left), Boolean(buttons.middle), Boolean(buttons.right), Number(0));
		}, delay);
	},

	// mouseWheelSize: Integer value that determines the amount of wheel motion per unit
	mouseWheelSize: 1,

	mouseWheel: function(/*Number*/ wheelAmt, /*Integer?*/ delay, /*Integer?*/ duration){
		// summary:
		//		Spins the mouse wheel.
		// description:
		//		Spins the wheel wheelAmt "notches."
		//		Negative wheelAmt scrolls up/away from the user.
		//		Positive wheelAmt scrolls down/toward the user.
		//		Note: this will all happen in one event.
		//		Warning: the size of one mouse wheel notch is an OS setting.
		//		You can access this size from robot.mouseWheelSize
		// wheelAmt:
		//		Number of notches to spin the wheel.
		//		Negative wheelAmt scrolls up/away from the user.
		//		Positive wheelAmt scrolls down/toward the user.
		// delay:
		//		Delay, in milliseconds, to wait before firing.
		//		The delay is a delta with respect to the previous automation call.
		//		For example, the following code ends after 600ms:
		//			robot.mouseClick({left: true}, 100) // first call; wait 100ms
		//			robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
		// duration:
		//		Approximate time Robot will spend moving the mouse
		//		By default, the Robot will wheel the mouse as fast as possible.

		this._assertRobot();
		if(!wheelAmt){ return; }
		this.sequence(function(){
			_robot.wheelMouse(isSecure(), Number(wheelAmt), Number(0), Number(duration||0));
		}, delay, duration);
	},

	setClipboard: function(/*String*/ data,/*String?*/ format){
		// summary:
		//		Set clipboard content.
		// description:
		//		Set data as clipboard content, overriding anything already there. The
		//		data will be put to the clipboard using the given format.
		// data:
		//		New clipboard content to set
		// format:
		//		Set this to "text/html" to put richtext to the clipboard.
		//		Otherwise, data is treated as plaintext. By default, plaintext
		//		is used.
		if(format==='text/html'){
			_robot.setClipboardHtml(isSecure(), data);
		}else{
			_robot.setClipboardText(isSecure(), data);
		}
	}
};

// After page has finished loading, create the applet iframe.
// Note: could eliminate dojo/ready dependency by tying this code to startRobot() call, but then users
// are required to put doh.run() inside of a dojo/ready.   Probably they are already doing that though.
ready(function(){
	// console.log("creating applet iframe");
	var iframesrc;
	var scripts = document.getElementsByTagName("script");
	for(var x = 0; x<scripts.length; x++){
		var s = scripts[x].getAttribute('src');
		if(s && (s.substr(s.length-9) == "runner.js")){
			iframesrc = s.substr(0, s.length-9)+'Robot.html';
			break;
		}
	}

	if(!iframesrc){
		// if user set document.domain to something else, send it to the Robot too
		iframesrc = require.toUrl("./Robot.html") + "?domain=" + escape(document.domain);
	}
	construct.place('<div id="dohrobotview" style="border:0px none; margin:0px; padding:0px; position:absolute; bottom:0px; right:0px; width:1px; height:1px; overflow:hidden; visibility:hidden; background-color:red;"></div>',
		win.body());

	if(!has("doh-custom-robot")){
		// load default robot when not custom def given
		construct.place('<iframe application="true" style="border:0px none; z-index:32767; padding:0px; margin:0px; position:absolute; left:0px; top:0px; height:100px; width:200px; overflow:hidden; background-color:transparent;" tabIndex="-1" src="'+iframesrc+'" ALLOWTRANSPARENCY="true"></iframe>',
			win.body());
	}else{
		// custom def given
		console.log("using custom robot");
		_robot = webdriver;
		// mix in exports
		for(var i in _robot){
			if(robot[i]&&_robot[i]){
				robot[i]=_robot[i];
			}
		}
		// continue init instead of waiting on frame
		robot._initRobot(_robot);
	}
});

// Start the robot as the first "test" when DOH runs.
doh.registerGroup("initialize robot", [
	{
		name: "load robot",
		timeout: 120000,
		runTest: function(){
			// first wait for robot to tell us it's loaded, i.e. that _initRobot() has been called
			return robot._loaded;
		}
	},
	{
		name: "start robot",
		timeout: 20000,
		runTest: function(){
			// then we call startRobot(), and wait it to asynchronously complete
			return robot.startRobot();
		}
	}
]);

// Register the killRobot() command as the last "test" to run.
// There's no good API to do this, so instead call doh.registerGroup() when the app first calls doh.run(),
// since presumably all the real tests have already been registered.   Note that doh.run() is called multiple times,
// so make sure to only call registerGroup() once.
var _oldRun = doh.run;
doh.run = function(){
	doh.registerGroup("kill robot", {
		name: "killRobot",
		timeout: 10000,
		runTest: function(){
			robot.killRobot();
		}
	});
	doh.run = _oldRun;
	doh.run();
};


return robot;
});
