/*!
 *
 * 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 async = require('async');
var EventEmitter2 = require('eventemitter2').EventEmitter2;
 
// int. libs
var Driver = require('./dalek/driver');
var Reporter = require('./dalek/reporter');
var Timer = require('./dalek/timer');
var Config = require('./dalek/config');
var Host = require('./dalek/host');
 
/**
 * Default options
 * @type {Object}
 */
 
var defaults = {
  reporter: ['console'],
  driver: ['native'],
  browser: ['phantomjs'],
  viewport: {width: 1280, height: 1024},
  logLevel: 3
};
 
/**
 * Setup all the options needed to configure dalek
 *
 * @param {options} opts Configuration options
 * @constructor
 */
 
var Dalek = function (opts) {
  // setup instance
  this._initialize();
 
  // register exception handler
  this._registerExceptionHandler();
 
  // normalize options
  this.options = this.normalizeOptions(opts);
 
  // getting advanced options
  if (opts && opts.advanced) {
    this.advancedOptions = opts.advanced;
  }
 
  // initiate config
  this.config = new Config(defaults, this.options, this.advancedOptions);
 
  // override tests if provided on the commandline
  if (this.options.tests) {
    this.config.config.tests = this.options.tests;
  }
 
  // prepare and load reporter(s)
  this._setupReporters();
 
  // count all passed & failed assertions
  this.reporterEvents.on('report:assertion', this._onReportAssertion.bind(this));
 
  // init the timer instance
  this.timer = new Timer();
 
  // prepare driver event emitter instance
  this._setupDriverEmitter();
 
  // check for file option, throw error if none is given
  // only bypasses if dalek runs in the remote mode
  if (!Array.isArray(this.config.get('tests')) && !this.options.remote) {
    this.reporterEvents.emit('error', 'No test files given!');
    this.driverEmitter.emit('killAll');
    process.exit(127);
  }
 
  // init the driver instance
  this._initDriver();
 
  // check if dalek runs as a remote browser launcher
  if (this.options.remote) {
    var host = new Host({reporterEvents: this.reporterEvents, config: this.config});
    host.run({
      port: !isNaN(parseFloat(this.options.remote)) && isFinite(this.options.remote) ? this.options.remote : false
    });
  }
};
 
/**
 * Daleks base module
 * Used to configure all the things
 * and to start off the tests
 *
 * @module DalekJS
 * @class Dalek
 */
 
Dalek.prototype = {
 
  /**
   * Runs the configured testsuites
   *
   * @method run
   * @chainable
   */
 
  run: function () {
    // early return; in case of remote
    if (this.options.remote) {
      return this;
    }
 
    // start the timer to measure the execution time
    this.timer.start();
 
    // emit the runner started event
    this.reporterEvents.emit('report:runner:started');
 
    // execute all given drivers sequentially
    var drivers = this.driver.getDrivers();
    async.series(drivers, this.testsuitesFinished.bind(this));
    return this;
  },
 
  /**
   * Reports the all testsuites executed event
   *
   * @method testsuitesFinished
   * @chainable
   */
 
  testsuitesFinished: function () {
    this.driverEmitter.emit('tests:complete');
    setTimeout(this.reportRunFinished.bind(this), 0);
    return this;
  },
 
  /**
   * Reports the all testsuites executed event
   *
   * @method reportRunFinished
   * @chainable
   */
 
  reportRunFinished: function () {
    this.reporterEvents.emit('report:runner:finished', {
      elapsedTime: this.timer.stop().getElapsedTimeFormatted(),
      assertions: this.assertionsFailed + this.assertionsPassed,
      assertionsFailed: this.assertionsFailed,
      assertionsPassed: this.assertionsPassed,
      status: this.runnerStatus
    });
 
    //we want to exit process with code 1 to single that test did not pass
    if(this.runnerStatus !== true) {
      var processExitCaptured = false;
 
      process.on('exit', function() {
        if(processExitCaptured === false) {
          processExitCaptured = true;
          process.exit(1);
        }
      });
    }
 
    return this;
  },
 
  /**
   * Normalizes options
   *
   * @method normalizeOptions
   * @param {object} options Raw options
   * @return {object} Normalized options
   */
 
  normalizeOptions: function (options) {
    Object.keys(options).forEach(function (key) {
      if ({reporter: 1, driver: 1}[key]) {
        options[key] = options[key].map(function (input) { return input.trim(); });
      }
    });
 
    return options;
  },
 
  /**
   * Sets up system env properties
   *
   * @method _initialize
   * @chainable
   * @private
   */
 
  _initialize: function () {
    // prepare error data
    this.warnings = [];
    this.errors = [];
 
    // prepare state data for the complete test run
    this.runnerStatus = true;
    this.assertionsFailed = 0;
    this.assertionsPassed = 0;
 
    return this;
  },
 
  /**
   * Sets up all the reporters
   *
   * @method _setupReporters
   * @chainable
   * @private
   */
 
  _setupReporters: function () {
    this.reporters = [];
    this.reporterEvents = new EventEmitter2();
    this.reporterEvents.setMaxListeners(Infinity);
    this.options.reporter = this.config.verifyReporters(this.config.get('reporter'), Reporter);
    this.options.reporter.forEach(this._addReporter, this);
    return this;
  },
 
  /**
   * Adds a reporter
   *
   * @method _addReporter
   * @param {string} reporter Name of the reporter to add
   * @chainable
   * @private
   */
 
  _addReporter: function (reporter) {
    this.reporters.push(Reporter.loadReporter(reporter, {events: this.reporterEvents, config: this.config, logLevel: this.config.get('logLevel')}));
    return this;
  },
 
  /**
   * Updates the assertion state
   *
   * @method _onReportAssertion
   * @param {object} assertion Informations aout the runned assertions
   * @chainable
   * @private
   */
 
  _onReportAssertion: function (assertion) {
    if (assertion.success) {
      this.assertionsPassed++;
    } else {
      this.runnerStatus = false;
      this.assertionsFailed++;
    }
    return this;
  },
 
  /**
   * Initizializes the driver instances
   *
   * @method _initDriver
   * @chainable
   * @private
   */
 
  _initDriver: function () {
    this.driver = new Driver({
      config: this.config,
      driverEmitter: this.driverEmitter,
      reporterEvents: this.reporterEvents
    });
 
    this.options.driver = this.config.verifyDrivers(this.config.get('driver'), this.driver);
    return this;
  },
 
  /**
   * Sets up the event dispatcher for driver events
   *
   * @method _setupDriverEmitter
   * @chainable
   * @private
   */
 
  _setupDriverEmitter: function () {
    var driverEmitter = new EventEmitter2();
    driverEmitter.setMaxListeners(Infinity);
    this.driverEmitter = driverEmitter;
    return this;
  },
 
  /**
   * Make sure to shutdown dalek & its spawned
   * components, webservers gracefully if a
   * runtime error pops up
   *
   * @method _registerExceptionHandler
   * @private
   * @chainable
   */
 
  _registerExceptionHandler: function () {
    process.setMaxListeners(Infinity);
    process.on('uncaughtException', this._shutdown.bind(this));
    return this;
  },
 
  /**
   * Shutdown on uncaught exception
   *
   * @method _shutdown
   * @param {object} exception Runtime exception
   * @private
   */
 
  _shutdown: function (exception) {
    // ios emulator hack, needs to go in the future
    if (exception.message && exception.message.search('This socket has been ended by the other party') !== -1) {
      return false;
    }
 
    this.driverEmitter.emit('killAll');
    this.reporterEvents.emit('error', exception);
  }
 
};
 
// export dalek as a module
module.exports = Dalek;