/*!
 *
 * Copyright (c) 2013 Sebastian Golasch
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

'use strict';

// ext. libs
var Q = require('q');
var uuid = require('node-uuid');
var cheerio = require('cheerio');

// int. global
var reporter = null;

/**
 * Actions are a way to control your browsers, e.g. simulate user interactions
 * like clicking elements, open urls, filling out input fields, etc.
 *
 * @class Actions
 * @constructor
 * @part Actions
 * @api
 */

var Actions = function () {
  this.uuids = {};
};

/**
 * It can be really cumbersome to repeat selectors all over when performing
 * multiple actions or assertions on the same element(s).
 * When you use the query method (or its alias $), you're able to specify a
 * selector once instead of repeating it all over the place.
 *
 * So, instead of writing this:
 *
 * ```javascript
 * test.open('http://doctorwhotv.co.uk/')
 *     .assert.text('#nav').is('Navigation')
 *     .assert.visible('#nav')
 *     .assert.attr('#nav', 'data-nav', 'true')
 *     .click('#nav')
 *     .done();
 * ```
 *
 * you can write this:
 *
 * ```javascript
 * test.open('http://doctorwhotv.co.uk/')
 *     .query('#nav')
 *       .assert.text().is('Navigation')
 *       .assert.visible()
 *       .assert.attr('data-nav', 'true')
 *       .click()
 *     .end()
 *     .done();
 * ```
 *
 * Always make sure, you terminate it with the [assertions.html#meth-end](end) method!
 *
 * @api
 * @method query
 * @param {string} selector Selector of the element to query
 * @chainable
 */

Actions.prototype.query = function (selector) {
  var that = !this.test ? this : this.test;
  that.lastChain.push('querying');
  that.selector = selector;
  that.querying = true;
  return this.test ? this : that;
};

/**
 * Alias of query
 *
 * @api
 * @method $
 * @param {string} selector Selector of the element to query
 * @chainable
 */

Actions.prototype.$ = Actions.prototype.query;

/**
 * Triggers a mouse event on the first element found matching the provided selector.
 * Supported events are mouseup, mousedown, click, mousemove, mouseover and mouseout.
 * TODO: IMPLEMENT
 *
 * @method mouseEvent
 * @param {string} type
 * @param {string} selector
 * @chainable
 */

Actions.prototype.mouseEvent = function (type, selector) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('mouseEvent', 'mouseEvent', type, selector, hash);
  this._addToActionQueue([type, selector, hash], 'mouseEvent', cb);
  return this;
};

/**
 * Sets HTTP_AUTH_USER and HTTP_AUTH_PW values for HTTP based authentication systems.
 *
 * If your site is behind a HTTP basic auth, you're able to set the username and the password
 *
 * ```javascript
 * test.setHttpAuth('OSWIN', 'rycbrar')
 *     .open('http://admin.therift.com');
 * ```
 *
 * Most of the time, you`re not storing your passwords within files that will be checked
 * in your vcs, for this scenario, you have two options:
 *
 * The first option is, to use daleks cli capabilities to generate config variables
 * from the command line, like this
 *
 * ```batch
 * $ dalek --vars USER=OSWIN,PASS=rycbrar
 * ```
 *
 * ```javascript
 * test.setHttpAuth(test.config.get('USER'), test.config.get('PASS'))
 *     .open('http://admin.therift.com');
 * ```
 *
 * The second option is, to use env variables to generate config variables
 * from the command line, like this
 *
 * ```batch
 * $ SET USER=OSWIN
 * $ SET PASS=rycbrar
 * $ dalek
 * ```
 *
 * ```javascript
 * test.setHttpAuth(test.config.get('USER'), test.config.get('PASS'))
 *     .open('http://admin.therift.com');
 * ```
 *
 * If both, dalek variables & env variables are set, the dalek variables win.
 * For more information about this, I recommend to check out the [configuration docs](/docs/config.html)
 *
 * TODO: IMPLEMENT
 * 
 * @method setHttpAuth
 * @param {string} username
 * @param {string} password
 * @return {Actions}
 */

Actions.prototype.setHttpAuth = function (username, password) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('setHttpAuth', 'setHttpAuth', username, password, hash);
  this._addToActionQueue([username, password, hash], 'setHttpAuth', cb);
  return this;
};

/**
 * Switches to an iFrame context
 *
 * Sometimes you encounter situations, where you need to drive/access an iFrame sitting in your page.
 * You can access such frames with this mehtod, but be aware of the fact, that the complete test context
 * than switches to the iframe context, every action and assertion will be executed within the iFrame context.
 * Btw.: The domain of the IFrame can be whatever you want, this method has no same origin policy restrictions.
 *
 * If you wan't to get back to the parents context, you have to use the [toParent](#meth-toParent) method.
 *
 * ```html
 * <div>
 *   <iframe id="login" src="/login.html"/>
 * </div>
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.withiframe.com')
 *    .assert.title().is('Title of a page that embeds an iframe')
 *    .toFrame('#login')
 *      .assert.title().is('Title of a page that can be embedded as an iframe')
 *    .toParent()
 *    .done();
 * ```
 *
 * > NOTE: Buggy in Firefox
 * 
 * @api
 * @method toFrame
 * @param {string} selector Selector of the frame to switch to
 * @chainable
 */

Actions.prototype.toFrame = function (selector) {
  var hash = uuid.v4();

if (this.querying === true) {
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('toFrame', 'toFrame', selector, hash);
  this._addToActionQueue([selector, hash], 'toFrame', cb);
  return this;
};

/**
 * Switches back to the parent page context when the test context has been
 * switched to an iFrame context
 *
 * ```html
 * <div>
 *   <iframe id="login" src="/login.html"/>
 * </div>
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.withiframe.com')
 *    .assert.title().is('Title of a page that embeds an iframe')
 *    .toFrame('#login')
 *      .assert.title().is('Title of a page that can be embedded as an iframe')
 *    .toParent()
 *    .assert.title().is('Title of a page that embeds an iframe')
 *    .done();
 * ```
 *
 * > NOTE: Buggy in Firefox
 * 
 * @api
 * @method toParent
 * @chainable
 */

Actions.prototype.toParent = function () {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('toFrame', 'toFrame', null, hash);
  this._addToActionQueue([null, hash], 'toFrame', cb);
  return this;
};

/**
 * Switches to a different window context
 *
 * Sometimes you encounter situations, where you need to access a .
 * You can access such frames with this mehtod, but be aware of the fact, that the complete test context
 * than switches to the window context, every action and assertion will be executed within the chosen window context.
 * Btw.: The domain of the window can be whatever you want, this method has no same origin policy restrictions.
 *
 * If you want to get back to the parents context, you have to use the [toParentWindow](#meth-toParentWindow) method.
 *
 * ```html
 * <div>
 *   <a onclick="window.open('http://google.com','goog','width=480, height=300')">Open Google</a>
 * </div>
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *    .assert.title().is('Title of a page that can open a popup window')
 *    .toWindow('goog')
 *      .assert.title().is('Google')
 *    .toParentWindow()
 *    .done();
 * ```
 *
 * > NOTE: Buggy in Firefox
 * 
 * @api
 * @method toWindow
 * @param {string} name Name of the window to switch to
 * @chainable
 */

Actions.prototype.toWindow = function (name) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('toWindow', 'toWindow', name, hash);
  this._addToActionQueue([name, hash], 'toWindow', cb);
  return this;
};

/**
 * Switches back to the parent windoe context when the test context has been
 * switched to a different windoe context
 *
 * ```html
 * <div>
 *   <a onclick="window.open('http://google.com','goog','width=480, height=300')">Open Google</a>
 * </div>
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *    .assert.title().is('Title of a page that can open a popup window')
 *    .toWindow('goog')
 *      .assert.title().is('Google')
 *    .toParentWindow()
 *    .assert.title().is('Title of a page that can open a popup window')
 *    .done();
 * ```
 *
 * > NOTE: Buggy in Firefox
 * 
 * @api
 * @method toParentWindow
 * @chainable
 */

Actions.prototype.toParentWindow = function () {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('toWindow', 'toWindow', null, hash);
  this._addToActionQueue([null, hash], 'toWindow', cb);
  return this;
};

/**
 * Wait until a resource that matches the given testFx is loaded to process a next step.
 *
 * TODO: IMPLEMENT
 * 
 * @method waitForResource
 * @param {string} ressource URL of the ressource that should be waited for
 * @param {number} timeout Timeout in miliseconds
 * @chainable
 */

Actions.prototype.waitForResource = function (ressource, timeout) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('waitForResource', 'waitForResource', ressource, timeout, hash);
  this._addToActionQueue([ressource, (timeout ? parseInt(timeout, 10) : 5000), hash], 'waitForResource', cb);
  return this;
};

/**
 * Waits until the passed text is present in the page contents before processing the immediate next step.
 *
 * TODO: IMPLEMENT
 * 
 * @method waitForText
 * @param {string} text Text to be waited for
 * @param {number} timeout Timeout in miliseconds
 * @chainable
 */

Actions.prototype.waitForText = function (text, timeout) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('waitForText', 'waitForText', text, timeout, hash);
  this._addToActionQueue([text, (timeout ? parseInt(timeout, 10) : 5000), hash], 'waitForText', cb);
  return this;
};

/**
 * Waits until an element matching the provided selector expression is visible in the remote DOM to process a next step.
 *
 * TODO: IMPLEMENT
 * 
 * @method waitUntilVisible
 * @param {string} selector Selector of the element that should be waited to become invisible
 * @param {number} timeout Timeout in miliseconds
 * @chainable
 */

Actions.prototype.waitUntilVisible = function (selector, timeout) {
  var hash = uuid.v4();

if (this.querying === true) {
    timeout = selector;
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('waitUntilVisible', 'waitUntilVisible', selector, timeout, hash);
  this._addToActionQueue([selector, (timeout ? parseInt(timeout, 10) : 5000), hash], 'waitUntilVisible', cb);
  return this;
};

/**
 * Waits until an element matching the provided selector expression is no longer visible in remote DOM to process a next step.
 *
 * TODO: IMPLEMENT
 * 
 * @method waitWhileVisible
 * @param {string} selector Selector of the element that should be waited to become visible
 * @param {number} timeout Timeout in miliseconds
 * @chainable
 */

Actions.prototype.waitWhileVisible = function (selector, timeout) {
  var hash = uuid.v4();

if (this.querying === true) {
    timeout = selector;
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('waitWhileVisible', 'waitWhileVisible', selector, timeout, hash);
  this._addToActionQueue([selector, (timeout ? parseInt(timeout, 10) : 5000), hash], 'waitWhileVisible', cb);
  return this;
};

/**
 * Take a screenshot of the current page.
 *
 * The pathname argument takes some placeholders that will be replaced
 * Placeholder:
 *
 *   - `:browser` - The browser name (e.g. ‘Chrome‘, ‘Safari‘, ‘Firefox‘, etc.)
 *   - `:version` -  The browser version (e.g. ‘10_0‘, ‘23_11_5‘, etc.)
 *   - `:os` - The operating system (e.g. `OSX`, `Windows`, `Linux`)
 *   - `:osVersion` - The operating system version (e.g `XP`, `7`, `10_8`, etc.)
 *   - `:viewport` - The current viewport in pixels (e.g. `w1024_h768`)
 *   - `:timestamp` - UNIX like timestapm (e.g. `637657345`)
 *   - `:date` - Current date in format MM_DD_YYYY (e.g. `12_24_2013`)
 *   - `:datetime` - Current datetime in format MM_DD_YYYY_HH_mm_ss (e.g. `12_24_2013_14_55_23`)
 *
 * ```javascript
 * // creates 'my/folder/my_file.png'
 * test.screenshot('my/folder/my_file');
 * // creates 'my/page/in/safari/homepage.png'
 * test.screenshot('my/page/in/:browser/homepage');
 * // creates 'my/page/in/safari_6_0_1/homepage.png'
 * test.screenshot('my/page/in/:browser_:version/homepage');
 * // creates 'my/page/in/safari_6_0_1/on/osx/homepage.png'
 * test.screenshot('my/page/in/:browser_:version/on/:os/homepage');
 * // creates 'my/page/in/safari_6_0_1/on/osx_10_8/homepage.png'
 * test.screenshot('my/page/in/:browser_:version/on/:os_:osVersion/homepage');
 * // creates 'my/page/at/w1024_h768/homepage.png'
 * test.screenshot('my/page/at/:viewport/homepage');
 * // creates 'my/page/at/637657345/homepage.png'
 * test.screenshot('my/page/in_time/:timestamp/homepage');
 * // creates 'my/page/at/12_24_2013/homepage.png'
 * test.screenshot('my/page/in_time/:date/homepage');
 * // creates 'my/page/at/12_24_2013_14_55_23/homepage.png'
 * test.screenshot('my/page/in_time/:datetime/homepage');
 * ```
 *
 * @api
 * @method screenshot
 * @param {string} pathname Name of the folder and file the screenshot should be saved to
 * @return chainable
 */

Actions.prototype.screenshot = function (pathname) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('screenshot', 'screenshot', pathname, hash);
  this._addToActionQueue(['', pathname, hash], 'screenshot', cb);
  return this;
};

/**
 * Pause steps suite execution for a given amount of time, and optionally execute a step on done.
 *
 * This makes sense, if you have a ticker for example, tht scrolls like every ten seconds
 * & you want to assure that the visible content changes every ten seconds
 *
 * ```javascript
 * test.open('http://myticker.org')
 *   .assert.visible('.ticker-element:first-child', 'First ticker element is visible')
 *   .wait(10000)
 *   .assert.visible('.ticker-element:nth-child(2)', 'Snd. ticker element is visible')
 *   .wait(10000)
 *   .assert.visible('.ticker-element:last-child', 'Third ticker element is visible')
 *   .done();
 * ```
 * If no timeout argument is given, a default timeout of 5 seconds will be used
 *
 * ```javascript
 * test.open('http://myticker.org')
 *   .assert.visible('.ticker-element:first-child', 'First ticker element is visible')
 *   .wait()
 *   .assert.visible('.ticker-element:nth-child(2)', 'Snd. ticker element is visible')
 *   .wait()
 *   .assert.visible('.ticker-element:last-child', 'Third ticker element is visible')
 *   .done();
 * ```
 *
 * @api
 * @method wait
 * @param {number} timeout in milliseconds
 * @chainable
 */

Actions.prototype.wait = function (timeout) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('wait', 'wait', timeout, hash);
  this._addToActionQueue([(timeout ? parseInt(timeout, 10) : 5000), hash], 'wait', cb);
  return this;
};

/**
 * Reloads current page location.
 *
 * This is basically the same as hitting F5/refresh in your browser
 *
 * ```javascript
 * test.open('http://google.com')
 *   .reload()
 *   .done();
 * ```
 *
 * @api
 * @method reload
 * @chainable
 */

Actions.prototype.reload = function () {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('refresh', 'refresh', '', hash);
  this._addToActionQueue([hash], 'refresh', cb);
  return this;
};

/**
 * Moves a step forward in browser's history.
 *
 * This is basically the same as hitting the forward button in your browser
 *
 * ```javascript
 * test.open('http://google.com')
 *   .open('https://github.com')
 *   .assert.url.is('https://github.com/', 'We are at GitHub')
 *   .back()
 *   .assert.url.is('http://google.com', 'We are at Google!')
 *   .forward()
 *   .assert.url.is('https://github.com/', 'Back at GitHub! Timetravel FTW')
 *   .done();
 * ```
 *
 * @api
 * @method forward
 * @chainable
 */

Actions.prototype.forward = function () {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('forward', 'forward', '', hash);
  this._addToActionQueue([hash], 'forward', cb);
  return this;
};

/**
 * Moves back a step in browser's history.
 *
 * This is basically the same as hitting the back button in your browser
 *
 * ```javascript
 * test.open('http://google.com')
 *   .open('https://github.com')
 *   .assert.url.is('https://github.com/', 'We are at GitHub')
 *   .back()
 *   .assert.url.is('http://google.com', 'We are at Google!')
 *   .forward()
 *   .assert.url.is('https://github.com/', 'Back at GitHub! Timetravel FTW');
 *   .done();
 * ```
 *
 * @api
 * @method back
 * @chainable
 */

Actions.prototype.back = function () {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('back', 'back', '', hash);
  this._addToActionQueue([hash], 'back', cb);
  return this;
};

/**
 * Performs a click on the element matching the provided selector expression.
 *
 * If we take Daleks homepage (the one you're probably visiting right now),
 * the HTML looks something like this (it does not really, but hey, lets assume this for a second)
 *
 * ```html
 * <nav>
 *   <ul>
 *     <li><a id="homeapge" href="/index.html">DalekJS</a></li>
 *     <li><a id="docs" href="/docs.html">Documentation</a></li>
 *     <li><a id="faq" href="/faq.html">F.A.Q</a></li>
 *   </ul>
 * </nav>
 * ```
 *
 * ```javascript
 * test.open('http://dalekjs.com')
 *     .click('#faq')
 *     .assert.title().is('DalekJS - Frequently asked questions', 'What the F.A.Q.')
 *     .done();
 * ```
 *
 * By default, this performs a left click.
 * In the future it might become the ability to also execute a "right button" click.
 *
 * > Note: Does not work correctly in Firefox when used on `<select>` & `<option>` elements
 * 
 * @api
 * @method click
 * @param {string} selector Selector of the element to be clicked
 * @chainable
 */

Actions.prototype.click = function (selector) {
  var hash = uuid.v4();

if (this.querying === true) {
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('click', 'click', selector, hash);
  this._addToActionQueue([selector, hash], 'click', cb);
  return this;
};

/**
 * Submits a form.
 *
 * ```html
 * <form id="skaaro" action="skaaro.php" method="GET">
 *   <input type="hidden" name="intheshadows" value="itis"/>
 *   <input type="text" name="truth" id="truth" value=""/>
 * </form>
 * ```
 *
 * ```javascript
 * test.open('http://home.dalek.com')
 *     .type('#truth', 'out there is')
 *     .submit('#skaaro')
 *     .done();
 * ```
 *
 * > Note: Does not work in Firefox yet
 * 
 * @api
 * @method submit
 * @param {string} selector Selector of the form to be submitted
 * @chainable
 */

Actions.prototype.submit = function (selector) {
  var hash = uuid.v4();

if (this.querying === true) {
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('submit', 'submit', selector, hash);
  this._addToActionQueue([selector, hash], 'submit', cb);
  return this;
};

/**
 * Performs an HTTP request for opening a given location.
 * You can forge GET, POST, PUT, DELETE and HEAD requests.
 *
 * Basically the same as typing a location into your browsers URL bar and
 * hitting return.
 *
 * ```javascript
 * test.open('http://dalekjs.com')
 *     .assert.url().is('http://dalekjs.com', 'DalekJS I'm in you')
 *     .done();
 * ```
 *
 * @api
 * @method open
 * @param {string} location URL of the page to open
 * @chainable
 */

Actions.prototype.open = function (location) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('open', 'open', location, hash);
  this._addToActionQueue([location, hash], 'open', cb);
  return this;
};

/**
 * Types a text into an input field or text area.
 * And yes, it really types, character for character, like you would
 * do when using your keyboard.
 *
 *
 * ```html
 * <form id="skaaro" action="skaaro.php" method="GET">
 *   <input type="hidden" name="intheshadows" value="itis"/>
 *   <input type="text" name="truth" id="truth" value=""/>
 * </form>
 * ```
 *
 * ```javascript
 * test.open('http://home.dalek.com')
 *     .type('#truth', 'out there is')
 *     .assert.val('#truth', 'out there is', 'Text has been set')
 *     .done();
 * ```
 *
 * You can also send special keys using unicode.
 *
 *  * ```javascript
 * test.open('http://home.dalek.com')
 *     .type('#truth', 'out \uE008there\uE008 is')
 *     .assert.val('#truth', 'out THERE is', 'Text has been set')
 *     .done();
 * ```
 * You can go [here](https://code.google.com/p/selenium/wiki/JsonWireProtocol#/session/:sessionId/element/:id/value) to read up on special keys and unicodes for them (note that a code of U+EXXX is actually written in code as \uEXXX).
 *
 * > Note: Does not work correctly in Firefox with special keys
 * 
 * @api
 * @method type
 * @param {string} selector Selector of the form field to be filled
 * @param {string} keystrokes Text to be applied to the element
 * @chainable
 */

Actions.prototype.type = function (selector, keystrokes) {
  var hash = uuid.v4();

if (this.querying === true) {
    keystrokes = selector;
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('type', 'type', selector, keystrokes, hash);
  this._addToActionQueue([selector, keystrokes], 'type', cb);
  return this;
};

/**
 * This acts just like .type() with a key difference.
 * This action can be used on non-input elements (useful for test site wide keyboard shortcuts and the like).
 * So assumeing we have a keyboard shortcut that display an alert box, we could test that with something like this:
 *
 * ```javascript
 * test.open('http://home.dalek.com')
 *     .sendKeys('body', '\uE00C')
 *     .assert.dialogText('press the escape key give this alert text')
 *     .done();
 * ```
 *
 *
 * > Note: Does not work correctly in Firefox with special keys
 * 
 * @api
 * @method sendKeys
 * @param {string} selector Selector of the form field to be filled
 * @param {string} keystrokes Text to be applied to the element
 * @chainable
 */

Actions.prototype.sendKeys = function (selector, keystrokes) {
  var hash = uuid.v4();

if (this.querying === true) {
    keystrokes = selector;
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('sendKeys', 'sendKeys', selector, keystrokes, hash);
  this._addToActionQueue([selector, keystrokes], 'sendKeys', cb);
  return this;
};

/**
 * Types a text into the text inout field of a prompt dialog.
 * Like you would do when using your keyboard.
 *
 * ```html
 * <div>
 *   <a id="aquestion" onclick="this.innerText = window.prompt('Your favourite companion:')">????</a>
 * </div>
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *     .click('#aquestion')
 *     .answer('Rose')
 *     .assert.text('#aquestion').is('Rose', 'Awesome she was!')
 *     .done();
 * ```
 *
 *
 * > Note: Does not work in Firefox & PhantomJS
 * 
 * @api
 * @method answer
 * @param {string} keystrokes Text to be applied to the element
 * @return chainable
 */

Actions.prototype.answer = function (keystrokes) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('promptText', 'promptText', keystrokes, hash);
  this._addToActionQueue([keystrokes, hash], 'promptText', cb);
  return this;
};

/**
 * Executes a JavaScript function within the browser context
 * 
 * ```javascript
 *  test.open('http://adomain.com')
 *     .execute(function () {
 *       window.myFramework.addRow('foo');
 *       window.myFramework.addRow('bar');
 *     })
 *     .done();
 * ```
 *
 * You can also apply arguments to the function
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *     .execute(function (paramFoo, aBar) {
 *       window.myFramework.addRow(paramFoo);
 *       window.myFramework.addRow(aBar);
 *     }, 'foo', 'bar')
 *     .done();
 * ```
 *
 * > Note: Buggy in Firefox
 * 
 * @api
 * @method execute
 * @param {function} script JavaScript function that should be executed
 * @return chainable
 */

Actions.prototype.execute = function (script) {
  var hash = uuid.v4();
  var args = [this.contextVars].concat(Array.prototype.slice.call(arguments, 1) || []);
  var cb = this._generateCallbackAssertion('execute', 'execute', script, args, hash);
  this._addToActionQueue([script, args, hash], 'execute', cb);
  return this;
};

/**
 * Waits until a function returns true to process any next step.
 *
 * You can also set a callback on timeout using the onTimeout argument,
 * and set the timeout using the timeout one, in milliseconds. The default timeout is set to 5000ms.
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *     .waitFor(function () {
 *       return window.myCheck === true;
 *     })
 *     .done();
 * ```
 *
 * You can also apply arguments to the function, as well as a timeout
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *     .waitFor(function (aCheck) {
 *       return window.myThing === aCheck;
 *     }, 'aValue', 10000)
 *     .done();
 * ```
 *
 * > Note: Buggy in Firefox
 * 
 * @method waitFor
 * @param {function} fn Async function that resolves an promise when ready
 * @param {array} args Additional arguments
 * @param {number} timeout Timeout in miliseconds
 * @chainable
 * @api
 */

Actions.prototype.waitFor = function (script, args, timeout) {
  var hash = uuid.v4();
  timeout = timeout || 5000;
  var cb = this._generateCallbackAssertion('waitFor', 'waitFor', script, args, timeout, hash);
  this._addToActionQueue([script, args, timeout, hash], 'waitFor', cb);
  return this;
};

/**
 * Accepts an alert/prompt/confirm dialog. This is basically the same actions as when
 * you are clicking okay or hitting return in one of that dialogs.
 *
 * ```html
 * <div>
 *   <a id="attentione" onclick="window.alert('Alonsy!')">ALERT!ALERT!</a>
 * </div>
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *     // alert appears
 *     .click('#attentione')
 *     // alert is gone
 *     .accept()
 *     .done();
 * ```
 *
 * > Note: Does not work in Firefox & PhantomJS
 * 
 * @api
 * @method accept
 * @return chainable
 */

Actions.prototype.accept = function () {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('acceptAlert', 'acceptAlert', hash);
  this._addToActionQueue([hash], 'acceptAlert', cb);
  return this;
};

/**
 * Dismisses an prompt/confirm dialog. This is basically the same actions as when
 * you are clicking cancel in one of that dialogs.
 *
 * ```html
 * <div>
 *   <a id="nonono" onclick="(this.innerText = window.confirm('No classic doctors in the 50th?') ? 'Buh!' : ':(') ">What!</a>
 * </div>
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *     // prompt appears
 *     .click('#nonono')
 *     // prompt is gone
 *     .dismiss()
 *     .assert.text('#nonono').is(':(', 'So sad')
 *     .done();
 * ```
 *
 * > Note: Does not work in Firefox & PhantomJS
 * 
 * @api
 * @method dismiss
 * @return chainable
 */

Actions.prototype.dismiss = function () {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('dismissAlert', 'dismissAlert', hash);
  this._addToActionQueue([hash], 'dismissAlert', cb);
  return this;
};

/**
 * Resizes the browser window to a set of given dimensions (in px).
 * The default configuration of dalek opening pages is a width of 1280px
 * and a height of 1024px. You can specify your own default in the configuration.
 *
 * ```html
 * <div>
 *   <span id="magicspan">The span in the fireplace</span>
 * </div>
 * ```
 *
 * ```css
 * #magicspan {
 *   display: inline;
 * }
 *
 * // @media all and (max-width: 500px) and (min-width: 300px)
 * #magicspan {
 *   display: none;
 * }
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *     .assert.visible('#magicspan', 'Big screen, visible span')
 *     .resize({width: 400, height: 500})
 *     .assert.notVisible('#magicspan', 'Small screen, no visible span magic!')
 *     .done();
 * ```
 *
 *
 * > Note: Does not work in Firefox
 * 
 * @api
 * @method resize
 * @param {object} dimensions Width and height as properties to apply
 * @chainable
 */

Actions.prototype.resize = function (dimensions) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('resize', 'resize', dimensions, hash);
  this._addToActionQueue([dimensions, hash], 'resize', cb);
  return this;
};

/**
 * Maximizes the browser window.
 *
 * ```html
 * <div>
 *   <span id="magicspan">The span in the fireplace</span>
 * </div>
 * ```
 *
 * ```css
 * #magicspan {
 *   display: inline;
 * }
 *
 * @media all and (max-width: 500px) and (min-width: 300px) {
 *   #magicspan {
 *     display: none;
 *   }
 * }
 * ```
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *     .resize({width: 400, height: 500})
 *     .assert.notVisible('#magicspan', 'Small screen, no visible span magic!')
 *     .maximize()
 *     .assert.visible('#magicspan', 'Big screen, visible span')
 *     .done();
 * ```
 *
 * > Note: Does not work in Firefox and PhantomJS
 * 
 * @api
 * @method maximize
 * @chainable
 */

Actions.prototype.maximize = function () {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('maximize', 'maximize', hash);
  this._addToActionQueue([hash], 'maximize', cb);
  return this;
};

/**
 * Sets a cookie.
 * More configuration options will be implemented in the future,
 * by now, you can only set a cookie with a specific name and contents.
 * This will be a domain wide set cookie.
 *
 * ```javascript
 *  test.open('http://adomain.com')
 *      .setCookie('my_cookie_name', 'my=content')
 *     .done();
 * ```
 *
 * @api
 * @method setCookie
 * @chainable
 */

Actions.prototype.setCookie = function (name, contents) {
  var hash = uuid.v4();
  var cb = this._generateCallbackAssertion('setCookie', 'setCookie', name, contents, hash);
  this._addToActionQueue([name, contents, hash], 'setCookie', cb);
  return this;
};

/**
 * Waits until an element matching the provided
 * selector expression exists in remote DOM to process any next step.
 *
 * Lets assume we have a ticker that loads its contents via AJAX,
 * and appends new elements, when the call has been successfully answered:
 *
 * ```javascript
 * test.open('http://myticker.org')
 *   .assert.text('.ticker-element:first-child', 'First!', 'First ticker element is visible')
 *   // now we load the next ticker element, defsult timeout is 5 seconds
 *   .waitForElement('.ticker-element:nth-child(2)')
 *   .assert.text('.ticker-element:nth-child(2)', 'Me snd. one', 'Snd. ticker element is visible')
 *   // Lets assume that this AJAX call can take longer, so we raise the default timeout to 10 seconds
 *   .waitForElement('.ticker-element:last-child', 10000)
 *   .assert.text('.ticker-element:last-child', 'Me, third one!', 'Third ticker element is visible')
 *   .done();
 * ```
 *
 * @api
 * @method waitForElement
 * @param {string} selector Selector that matches the element to wait for
 * @param {number} timeout Timeout in milliseconds
 * @chainable
 */

Actions.prototype.waitForElement = function (selector, timeout) {
  var hash = uuid.v4();

if (this.querying === true) {
    timeout = selector;
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('waitForElement', 'waitForElement', selector + ' : ' + timeout, hash);
  this._addToActionQueue([selector, (timeout ? parseInt(timeout, 10) : 5000), hash], 'waitForElement', cb);
  return this;
};

/**
 * Fills the fields of a form with given values.
 *
 * ```html
 * <input type="hidden" value="not really a value" id="ijustwannahaveavalue"/>
 * ```
 *
 * ```javascript
 * test.open('http://dalekjs.com')
 *     .setValue('#ijustwannahaveavalue', 'a value')
 *     .title().is('DalekJS - Frequently asked questions', 'What the F.A.Q.');
 * ```
 *
 * @api
 * @method setValue
 * @param {string} selector
 * @param {string} value
 * @return {Actions}
 */

Actions.prototype.setValue = function (selector, value) {
  var hash = uuid.v4();

if (this.querying === true) {
    value = selector;
    selector = this.selector;
  }

var cb = this._generateCallbackAssertion('setValue', 'setValue', selector + ' : ' + value, hash);
  this._addToActionQueue([selector, value, hash], 'setValue', cb);
  return this;
};

// LOG (May should live in its own module)
// ---------------------------------------

Actions.prototype.logger = {};

/**
 * Logs a part of the remote dom
 *
 * ```html
 * <body>
 *   <div id="smth">
 *     <input type="hidden" value="not really a value" id="ijustwannahaveavalue"/>
 *   </div>
 * </body>
 * ```
 *
 * ```javascript
 * test.open('http://dalekjs.com/guineapig')
 *     .log.dom('#smth')
 *     .done();
 * ```
 *
 * Will output this:
 *
 * ```html
 *  DOM: #smth <input type="hidden" value="not really a value" id="ijustwannahaveavalue"/>
 * ```

* 
 * @api
 * @method log.dom
 * @param {string} selector CSS selector
 * @chainable
 */

Actions.prototype.logger.dom = function (selector) {
  var hash = uuid.v4();

var cb = function logDomCb (data) {
    if (data && data.key === 'source' && !this.uuids[data.uuid]) {
      this.uuids[data.uuid] = true;
      var $ = cheerio.load(data.value);
      var result = selector ? $(selector).html() : $.html();
      selector = selector ? selector : ' ';
      result = !result ? ' Not found' : result;
      this.reporter.emit('report:log:user', 'DOM: ' + selector + ' ' + result);
    }
  }.bind(this);

this._addToActionQueue([hash], 'source', cb);
  return this;
};

/**
 * Logs a user defined message
 *
 * ```javascript
 * test.open('http://dalekjs.com/guineapig')
 *     .execute(function () {
 *       this.data('aKey', 'aValue');
 *     })
 *     .log.message(function () {
 *       return test.data('aKey'); // outputs MESSAGE: 'aValue'
 *     })
 *     .done();
 * ```
 *
 * 'Normal' messages can be logged too:
 *
 * ```javascript
 * test.open('http://dalekjs.com/guineapig')
 *     .log.message('FooBar') // outputs MESSAGE: FooBar
 *     .done();
 * ```
 * 
 * @api
 * @method log.message
 * @param {function|string} message
 * @chainable
 */

Actions.prototype.logger.message = function (message) {
  var hash = uuid.v4();

var cb = function logMessageCb (data) {
    if (data && data.key === 'noop' && !this.uuids[data.hash]) {
      this.uuids[data.hash] = true;
      var result = (typeof(data.value) === 'function') ? data.value.bind(this)() : data.value;
      this.reporter.emit('report:log:user', 'MESSAGE: ' + result);
    }
  }.bind(this);

this._addToActionQueue([message, hash], 'noop', cb);
  return this;
};

/**
 * Generates a callback that will be fired when the action has been completed.
 * The callback itself will then validate the answer and will also emit an event
 * that the action has been successfully executed.
 *
 * @method _generateCallbackAssertion
 * @param {string} key Unique key of the action
 * @param {string} type Type of the action (normalle the actions name)
 * @return {function} The generated callback function
 * @private
 */

Actions.prototype._generateCallbackAssertion = function (key, type) {
  var cb = function (data) {
    if (data && data.key === key && !this.uuids[data.uuid]) {
      if (!data || (data.value && data.value === null)) {
        data.value = '';
      }

if (key === 'execute') {
        Object.keys(data.value.dalek).forEach(function (key) {
          this.contextVars[key] = data.value.dalek[key];
        }.bind(this));

data.value.test.forEach(function (test) {
          this.reporter.emit('report:assertion', {
            success: test.ok,
            expected: true,
            value: test.ok,
            message: test.message,
            type: 'OK'
          });

this.incrementExpectations();

if (!test.ok) {
            this.incrementFailedAssertions();
          }
        }.bind(this));

data.value = '';
      }

this.uuids[data.uuid] = true;
      reporter.emit('report:action', {
        value: data.value,
        type: type,
        uuid: data.uuid
      });
    }
  }.bind(this);
  return cb;
};

/**
 * Adds a method to the queue of actions/assertions to execute
 *
 * @method _addToActionQueue
 * @param {object} opts Options of the action to invoke
 * @param {string} driverMethod Name of the method to call on the driver
 * @param {function} A callback function that will be executed when the action has been executed
 * @private
 * @chainable
 */

Actions.prototype._addToActionQueue = function (opts, driverMethod, cb) {
  this.actionPromiseQueue.push(function () {
    var deferred = Q.defer();
    // add a generic identifier as the last argument to any action method call
    opts.push(uuid.v4());
    // check the method on the driver object && the callback function
    if (typeof(this.driver[driverMethod]) === 'function' && typeof(cb) === 'function') {
      // call the method on the driver object
      this.driver[driverMethod].apply(this.driver, opts);
      deferred.resolve();
    } else {
      deferred.reject();
    }

// listen to driver message events & apply the callback argument
    this.driver.events.on('driver:message', cb);
    return deferred.promise;
  }.bind(this));
  return this;
};

/**
 * @module DalekJS
 */

module.exports = function (opts) {
  reporter = opts.reporter;
  return Actions;
};

index.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC