import auto from './auto';
import forOwn from 'lodash/_baseForOwn';
import arrayMap from 'lodash/_arrayMap';
import clone from 'lodash/_copyArray';
import isArray from 'lodash/isArray';
import trim from 'lodash/trim';

var FN_ARGS = /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /(=.+)?(\s*)$/;
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;

function parseParams(func) {
    func = func.toString().replace(STRIP_COMMENTS, '');
    func = func.match(FN_ARGS)[2].replace(' ', '');
    func = func ? func.split(FN_ARG_SPLIT) : [];
    func = func.map(function (arg){
        return trim(arg.replace(FN_ARG, ''));
    });
    return func;
}

/**
 * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent
 * tasks are specified as parameters to the function, after the usual callback
 * parameter, with the parameter names matching the names of the tasks it
 * depends on. This can provide even more readable task graphs which can be
 * easier to maintain.
 *
 * If a final callback is specified, the task results are similarly injected,
 * specified as named parameters after the initial error parameter.
 *
 * The autoInject function is purely syntactic sugar and its semantics are
 * otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.
 *
 * @name autoInject
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.auto]{@link module:ControlFlow.auto}
 * @category Control Flow
 * @param {Object} tasks - An object, each of whose properties is a function of
 * the form 'func([dependencies...], callback). The object's key of a property
 * serves as the name of the task defined by that property, i.e. can be used
 * when specifying requirements for other tasks.
 * * The `callback` parameter is a `callback(err, result)` which must be called
 *   when finished, passing an `error` (which can be `null`) and the result of
 *   the function's execution. The remaining parameters name other tasks on
 *   which the task is dependent, and the results from those tasks are the
 *   arguments of those parameters.
 * @param {Function} [callback] - An optional callback which is called when all
 * the tasks have been completed. It receives the `err` argument if any `tasks`
 * pass an error to their callback. The remaining parameters are task names
 * whose results you are interested in. This callback will only be called when
 * all tasks have finished or an error has occurred, and so do not specify
 * dependencies in the same way as `tasks` do. If an error occurs, no further
 * `tasks` will be performed, and `results` will only be valid for those tasks
 * which managed to complete. Invoked with (err, [results...]).
 * @example
 *
 * //  The example from `auto` can be rewritten as follows:
 * async.autoInject({
 *     get_data: function(callback) {
 *         // async code to get some data
 *         callback(null, 'data', 'converted to array');
 *     },
 *     make_folder: function(callback) {
 *         // async code to create a directory to store a file in
 *         // this is run at the same time as getting the data
 *         callback(null, 'folder');
 *     },
 *     write_file: function(get_data, make_folder, callback) {
 *         // once there is some data and the directory exists,
 *         // write the data to a file in the directory
 *         callback(null, 'filename');
 *     },
 *     email_link: function(write_file, callback) {
 *         // once the file is written let's email a link to it...
 *         // write_file contains the filename returned by write_file.
 *         callback(null, {'file':write_file, 'email':'user@example.com'});
 *     }
 * }, function(err, email_link) {
 *     console.log('err = ', err);
 *     console.log('email_link = ', email_link);
 * });
 *
 * // If you are using a JS minifier that mangles parameter names, `autoInject`
 * // will not work with plain functions, since the parameter names will be
 * // collapsed to a single letter identifier.  To work around this, you can
 * // explicitly specify the names of the parameters your task function needs
 * // in an array, similar to Angular.js dependency injection.  The final
 * // results callback can be provided as an array in the same way.
 *
 * // This still has an advantage over plain `auto`, since the results a task
 * // depends on are still spread into arguments.
 * async.autoInject({
 *     //...
 *     write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {
 *         callback(null, 'filename');
 *     }],
 *     email_link: ['write_file', function(write_file, callback) {
 *         callback(null, {'file':write_file, 'email':'user@example.com'});
 *     }]
 *     //...
 * }, ['email_link', function(err, email_link) {
 *     console.log('err = ', err);
 *     console.log('email_link = ', email_link);
 * }]);
 */
export default function autoInject(tasks, callback) {
    var newTasks = {};

    forOwn(tasks, function (taskFn, key) {
        var params;

        if (isArray(taskFn)) {
            params = clone(taskFn);
            taskFn = params.pop();

            newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
        } else if (taskFn.length === 1) {
            // no dependencies, use the function as-is
            newTasks[key] = taskFn;
        } else {
            params = parseParams(taskFn);
            if (taskFn.length === 0 && params.length === 0) {
                throw new Error("autoInject task functions require explicit parameters.");
            }

            params.pop();

            newTasks[key] = params.concat(newTask);
        }

        function newTask(results, taskCb) {
            var newArgs = arrayMap(params, function (name) {
                return results[name];
            });
            newArgs.push(taskCb);
            taskFn.apply(null, newArgs);
        }
    });

    auto(newTasks, callback);
}

@@ -2317,423 +2317,86 @@
 back
-. The remaining parameters are task names%0A * whose results you are interested in. This callback will only be called when%0A * all tasks have finished or an error has occurred, and so do not specify%0A * dependencies in the same way as %60tasks%60 do. If an error occurs, no further
+, and a %60results%60 object with any completed
 %0A * 
-%60
 task
-s%60 will be performed, and %60results%60 will only be valid for those tasks%0A * which managed to complete. Invoked with (err, %5Bresults...%5D)
+ results, similar to %60auto%60
 .%0A *
@@ -3377,34 +3377,31 @@
 nction(err, 
-email_link
+results
 ) %7B%0A *     c
@@ -3455,32 +3455,40 @@
 email_link = ', 
+results.
 email_link);%0A * 
@@ -3871,87 +3871,8 @@
 ion.
-  The final%0A * // results callback can be provided as an array in the same way.
 %0A *%0A
@@ -4350,23 +4350,8 @@
 * %7D,
- %5B'email_link',
  fun
@@ -4361,26 +4361,23 @@
 on(err, 
-email_link
+results
 ) %7B%0A *  
@@ -4443,16 +4443,24 @@
 nk = ', 
+results.
 email_li
@@ -4468,17 +4468,16 @@
 k);%0A * %7D
-%5D
 );%0A */%0Ae

fix autoInject docs. Closes #1216