// Copyright IBM Corp. 2014,2016. All Rights Reserved.
// Node module: loopback-phase
// This file is licensed under the MIT License.
// License text available at https://opensource.org/licenses/MIT

var g = require('strong-globalize')();

var Phase = require('./phase');
var zipMerge = require('./merge-name-lists');
var async = require('async');

module.exports = PhaseList;

/**
 * An ordered list of phases.
 *
 * ```js
 * var PhaseList = require('loopback-phase').PhaseList;
 * var phases = new PhaseList();
 * phases.add('my-phase');
 * ```
 *
 * @class PhaseList
 */

function PhaseList() {
  this._phases = [];
  this._phaseMap = {};
}

/**
 * Get the first `Phase` in the list.
 *
 * @returns {Phase} The first phase.
 */

PhaseList.prototype.first = function() {
  return this._phases[0];
};

/**
 * Get the last `Phase` in the list.
 *
 * @returns {Phase} The last phase.
 */

PhaseList.prototype.last = function() {
  return this._phases[this._phases.length - 1];
};

/**
 * Add one or more phases to the list.
 *
 * @param {Phase|String|String[]} phase The phase (or phases) to be added.
 * @returns {Phase|Phase[]} The added phase or phases.
 */

PhaseList.prototype.add = function(phase) {
  var phaseList = this;
  var phaseArray = Array.isArray(phase) ? phase : null;

  if(phaseArray) {
    return phaseArray.map(phaseList.add.bind(phaseList));
  }

  phase = this._resolveNameAndAddToMap(phase);
  this._phases.push(phase);

  return phase;
};

PhaseList.prototype._resolveNameAndAddToMap = function(phaseOrName) {
  var phase = phaseOrName;

  if(typeof phase === 'string') {
    phase = new Phase(phase);
  }

  if (phase.id in this._phaseMap) {
    throw new Error(g.f('Phase "%s" already exists.', phase.id));
  }


  if(!phase.__isPhase__) {
    throw new Error(g.f('Cannot add a non phase object to a {{PhaseList}}'));
  }

  this._phaseMap[phase.id] = phase;
  return phase;
};

/**
 * Add a new phase at the specified index.
 * @param {Number} index The zero-based index.
 * @param {String|String[]} phase The name of the phase to add.
 * @returns {Phase} The added phase.
 */

PhaseList.prototype.addAt = function(index, phase) {
  phase = this._resolveNameAndAddToMap(phase);
  this._phases.splice(index, 0, phase);
  return phase;
};

/**
 * Add a new phase as the next one after the given phase.
 * @param {String} after The referential phase.
 * @param {String|String[]} phase The name of the phase to add.
 * @returns {Phase} The added phase.
 */

PhaseList.prototype.addAfter = function(after, phase) {
  var ix = this.getPhaseNames().indexOf(after);
  if (ix === -1) {
    throw new Error(g.f('Unknown phase: %s', after));
  }
  return this.addAt(ix+1, phase);
};

/**
 * Add a new phase as the previous one before the given phase.
 * @param {String} before The referential phase.
 * @param {String|String[]} phase The name of the phase to add.
 * @returns {Phase} The added phase.
 */

PhaseList.prototype.addBefore = function(before, phase) {
  var ix = this.getPhaseNames().indexOf(before);
  if (ix === -1) {
    throw new Error(g.f('Unknown phase: %s', before));
  }
  return this.addAt(ix, phase);
};

/**
 * Remove a `Phase` from the list.
 *
 * @param {Phase|String} phase The phase to be removed.
 * @returns {Phase} The removed phase.
 */

PhaseList.prototype.remove = function(phase) {
  var phases = this._phases;
  var phaseMap = this._phaseMap;
  var phaseId;

  if(!phase) return null;

  if(typeof phase === 'object') {
    phaseId = phase.id;
  } else {
    phaseId = phase;
    phase = phaseMap[phaseId];
  }

  if(!phase || !phase.__isPhase__) return null;

  phases.splice(phases.indexOf(phase), 1);
  delete this._phaseMap[phaseId];

  return phase;
};

/**
 * Merge the provided list of names with the existing phases
 * in such way that the order of phases is preserved.
 *
 * **Example**
 *
 * ```js
 * // Initial list of phases
 * phaseList.add(['initial', 'session', 'auth', 'routes', 'files', 'final']);
 *
 * // zip-merge more phases
 * phaseList.zipMerge([
 *   'initial', 'postinit', 'preauth', 'auth',
 *   'routes', 'subapps', 'final', 'last'
 * ]);
 *
 * // print the result
 * console.log('Result:', phaseList.getPhaseNames());
 * // Result: [
 * //   'initial', 'postinit', 'preauth', 'session', 'auth',
 * //   'routes', 'subapps', 'files', 'final', 'last'
 * // ]
 * ```
 *
 * @param {String[]} names List of phase names to zip-merge
 */
PhaseList.prototype.zipMerge = function(names) {
  if (!names.length) return;

  var mergedNames = zipMerge(this.getPhaseNames(), names);
  this._phases = mergedNames.map(function(name) {
    var existing = this.find(name);
    return existing ?
      existing :
      this._resolveNameAndAddToMap(name);
  }, this);
};

/**
 * Find a `Phase` from the list.
 *
 * @param {String} id The phase identifier
 * @returns {Phase} The `Phase` with the given `id`.
 */

PhaseList.prototype.find = function(id) {
  return this._phaseMap[id] || null;
};

/**
 * Find or add a `Phase` from/into the list.
 *
 * @param {String} id The phase identifier
 * @returns {Phase} The `Phase` with the given `id`.
 */

PhaseList.prototype.findOrAdd = function(id) {
  var phase = this.find(id);
  if(phase) return phase;
  return this.add(id);
};

/**
 * Get the list of phases as an array of `Phase` objects.
 *
 * @returns {Phase[]} An array of phases.
 */

PhaseList.prototype.toArray = function() {
  return this._phases.slice(0);
};

/**
 * Launch the phases contained in the list. If there are no phases
 * in the list `process.nextTick` is called with the provided callback.
 *
 * @param {Object} [context] The context of each `Phase` handler.
 * @callback {Function} cb
 * @param {Error} err Any error that occured during a phase contained
 * in the list.
 */

PhaseList.prototype.run = function(ctx, cb) {
  var phases = this._phases;

  if(typeof ctx === 'function') {
    cb = ctx;
    ctx = undefined;
  }

  if(phases.length) {
    async.eachSeries(phases, function(phase, next) {
      phase.run(ctx, next);
    }, cb);
  } else {
    process.nextTick(cb);
  }
};

/**
 * Get an array of phase identifiers.
 * @returns {String[]} phaseNames
 */

PhaseList.prototype.getPhaseNames = function() {
  return this._phases.map(function(phase) {
    return phase.id;
  });
};

/**
 * Register a phase handler for the given phase (and sub-phase).
 *
 * **Example**
 *
 * ```js
 * // register via phase.use()
 * phaseList.registerHandler('routes', function(ctx, next) { next(); });
 * // register via phase.before()
 * phaseList.registerHandler('auth:before', function(ctx, next) { next(); });
 * // register via phase.after()
 * phaseList.registerHandler('auth:after', function(ctx, next) { next(); });
 * ```
 *
 * @param {String} phaseName Name of an existing phase, optionally with
 *   ":before" or ":after" suffix.
 * @param {Function(Object, Function)} handler The handler function to register
 *   with the given phase.
 */
PhaseList.prototype.registerHandler = function(phaseName, handler) {
  var subphase = 'use';
  var m = phaseName.match(/^(.+):(before|after)$/);
  if (m) {
    phaseName = m[1];
    subphase = m[2];
  }
  var phase = this.find(phaseName);
  if (!phase) throw new Error(g.f('Unknown phase %s', phaseName));
  phase[subphase](handler);
};