/*!
 * base-plugins <https://github.com/node-base/base-plugins>
 *
 * Copyright (c) 2015, 2017, Jon Schlinkert.
 * Released under the MIT License.
 */

'use strict';

var isRegistered = require('is-registered');
var isValid = require('is-valid-instance');
var define = require('define-property');
var isObject = require('isobject');

module.exports = function plugin() {
  return function fn(app) {
    if (isRegistered(app, 'base-plugins')) return;

    /**
     * Cache plugins
     */

    if (!app.fns) {
      define(app, 'fns', []);
    }

    /**
     * Define a plugin function to be called immediately upon init.
     * The only parameter exposed to the plugin is the application
     * instance.
     *
     * Also, if a plugin returns a function, the function will be pushed
     * onto the `fns` array, allowing the plugin to be called at a
     * later point, elsewhere in the application.
     *
     * ```js
     * // define a plugin
     * function foo(app) {
     *   // do stuff
     * }
     *
     * // register plugins
     * var app = new Base()
     *   .use(foo)
     *   .use(bar)
     *   .use(baz)
     * ```
     * @name .use
     * @param {Function} `fn` plugin function to call
     * @return {Object} Returns the item instance for chaining.
     * @api public
     */

    define(app, 'use', use);

    /**
     * Run all plugins
     *
     * ```js
     * var config = {};
     * app.run(config);
     * ```
     * @name .run
     * @param {Object} `value` Object to be modified by plugins.
     * @return {Object} Returns the item instance for chaining.
     * @api public
     */

    define(app, 'run', function(val) {
      if (!isObject(val)) return;

      if (!val.use) {
        define(val, 'fns', val.fns || []);
        define(val, 'use', use);
      }

      if (!val.fns || val.fns.indexOf(fn) === -1) {
        val.use(fn);
      }

      var len = this.fns.length;
      var idx = -1;
      while (++idx < len) {
        val.use(this.fns[idx]);
      }
      return this;
    });

    return fn;
  };

  /**
   * Call plugin `fn`. If a function is returned push it into the
   * `fns` array to be called by the `run` method.
   */

  function use(type, fn, options) {
    if (typeof type === 'string' || Array.isArray(type)) {
      fn = wrap(type, fn);
    } else {
      options = fn;
      fn = type;
    }

    var val = fn.call(this, this, this.base || {}, options || {}, this.env || {});
    if (typeof val === 'function') {
      this.fns.push(val);
    }

    if (typeof this.emit === 'function') {
      this.emit('use', val, this);
    }
    return this;
  }

  /**
   * Wrap a named plugin function so that it's only called on objects of the
   * given `type`
   *
   * @param {String} `type`
   * @param {Function} `fn` Plugin function
   * @return {Function}
   */

  function wrap(type, fn) {
    return function plugin() {
      if (!isValid(this, type)) return plugin;
      return fn.apply(this, arguments);
    };
  }
};