/**

* class ArgumentParser
*
* Object for parsing command line strings into js objects.
*
* Inherited from [[ActionContainer]]
**/

'use strict';

var util = require('util'); var format = require('util').format; var Path = require('path'); var sprintf = require('sprintf-js').sprintf;

// Constants var c = require('./const');

var $$ = require('./utils');

var ActionContainer = require('./action_container');

// Errors var argumentErrorHelper = require('./argument/error');

var HelpFormatter = require('./help/formatter');

var Namespace = require('./namespace');

/**

* new ArgumentParser(options)
*
* Create a new ArgumentParser object.
*
* ##### Options:
* - `prog`  The name of the program (default: Path.basename(process.argv[1]))
* - `usage`  A usage message (default: auto-generated from arguments)
* - `description`  A description of what the program does
* - `epilog`  Text following the argument descriptions
* - `parents`  Parsers whose arguments should be copied into this one
* - `formatterClass`  HelpFormatter class for printing help messages
* - `prefixChars`  Characters that prefix optional arguments
* - `fromfilePrefixChars` Characters that prefix files containing additional arguments
* - `argumentDefault`  The default value for all arguments
* - `addHelp`  Add a -h/-help option
* - `conflictHandler`  Specifies how to handle conflicting argument names
* - `debug`  Enable debug mode. Argument errors throw exception in
*   debug mode and process.exit in normal. Used for development and
*   testing (default: false)
*
* See also [original guide][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#argumentparser-objects
**/

function ArgumentParser(options) {

if (!(this instanceof ArgumentParser)) {
  return new ArgumentParser(options);
}
var self = this;
options = options || {};

options.description = (options.description || null);
options.argumentDefault = (options.argumentDefault || null);
options.prefixChars = (options.prefixChars || '-');
options.conflictHandler = (options.conflictHandler || 'error');
ActionContainer.call(this, options);

options.addHelp = typeof options.addHelp === 'undefined' || !!options.addHelp;
options.parents = options.parents || [];
// default program name
options.prog = (options.prog || Path.basename(process.argv[1]));
this.prog = options.prog;
this.usage = options.usage;
this.epilog = options.epilog;
this.version = options.version;

this.debug = (options.debug === true);

this.formatterClass = (options.formatterClass || HelpFormatter);
this.fromfilePrefixChars = options.fromfilePrefixChars || null;
this._positionals = this.addArgumentGroup({ title: 'Positional arguments' });
this._optionals = this.addArgumentGroup({ title: 'Optional arguments' });
this._subparsers = null;

// register types
function FUNCTION_IDENTITY(o) {
  return o;
}
this.register('type', 'auto', FUNCTION_IDENTITY);
this.register('type', null, FUNCTION_IDENTITY);
this.register('type', 'int', function (x) {
  var result = parseInt(x, 10);
  if (isNaN(result)) {
    throw new Error(x + ' is not a valid integer.');
  }
  return result;
});
this.register('type', 'float', function (x) {
  var result = parseFloat(x);
  if (isNaN(result)) {
    throw new Error(x + ' is not a valid float.');
  }
  return result;
});
this.register('type', 'string', function (x) {
  return '' + x;
});

// add help and version arguments if necessary
var defaultPrefix = (this.prefixChars.indexOf('-') > -1) ? '-' : this.prefixChars[0];
if (options.addHelp) {
  this.addArgument(
    [ defaultPrefix + 'h', defaultPrefix + defaultPrefix + 'help' ],
    {
      action: 'help',
      defaultValue: c.SUPPRESS,
      help: 'Show this help message and exit.'
    }
  );
}
if (typeof this.version !== 'undefined') {
  this.addArgument(
    [ defaultPrefix + 'v', defaultPrefix + defaultPrefix + 'version' ],
    {
      action: 'version',
      version: this.version,
      defaultValue: c.SUPPRESS,
      help: "Show program's version number and exit."
    }
  );
}

// add parent arguments and defaults
options.parents.forEach(function (parent) {
  self._addContainerActions(parent);
  if (typeof parent._defaults !== 'undefined') {
    for (var defaultKey in parent._defaults) {
      if (parent._defaults.hasOwnProperty(defaultKey)) {
        self._defaults[defaultKey] = parent._defaults[defaultKey];
      }
    }
  }
});

}

util.inherits(ArgumentParser, ActionContainer);

/**

* ArgumentParser#addSubparsers(options) -> [[ActionSubparsers]]
* - options (object): hash of options see [[ActionSubparsers.new]]
*
* See also [subcommands][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#sub-commands
**/

ArgumentParser.prototype.addSubparsers = function (options) {

if (this._subparsers) {
  this.error('Cannot have multiple subparser arguments.');
}

options = options || {};
options.debug = (this.debug === true);
options.optionStrings = [];
options.parserClass = (options.parserClass || ArgumentParser);

if (!!options.title || !!options.description) {

  this._subparsers = this.addArgumentGroup({
    title: (options.title || 'subcommands'),
    description: options.description
  });
  delete options.title;
  delete options.description;

} else {
  this._subparsers = this._positionals;
}

// prog defaults to the usage message of this parser, skipping
// optional arguments and with no "usage:" prefix
if (!options.prog) {
  var formatter = this._getFormatter();
  var positionals = this._getPositionalActions();
  var groups = this._mutuallyExclusiveGroups;
  formatter.addUsage(this.usage, positionals, groups, '');
  options.prog = formatter.formatHelp().trim();
}

// create the parsers action and add it to the positionals list
var ParsersClass = this._popActionClass(options, 'parsers');
var action = new ParsersClass(options);
this._subparsers._addAction(action);

// return the created parsers action
return action;

};

ArgumentParser.prototype._addAction = function (action) {

if (action.isOptional()) {
  this._optionals._addAction(action);
} else {
  this._positionals._addAction(action);
}
return action;

};

ArgumentParser.prototype._getOptionalActions = function () {

return this._actions.filter(function (action) {
  return action.isOptional();
});

};

ArgumentParser.prototype._getPositionalActions = function () {

return this._actions.filter(function (action) {
  return action.isPositional();
});

};

/**

* ArgumentParser#parseArgs(args, namespace) -> Namespace|Object
* - args (array): input elements
* - namespace (Namespace|Object): result object
*
* Parsed args and throws error if some arguments are not recognized
*
* See also [original guide][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#the-parse-args-method
**/

ArgumentParser.prototype.parseArgs = function (args, namespace) {

var argv;
var result = this.parseKnownArgs(args, namespace);

args = result[0];
argv = result[1];
if (argv && argv.length > 0) {
  this.error(
    format('Unrecognized arguments: %s.', argv.join(' '))
  );
}
return args;

};

/**

* ArgumentParser#parseKnownArgs(args, namespace) -> array
* - args (array): input options
* - namespace (Namespace|Object): result object
*
* Parse known arguments and return tuple of result object
* and unknown args
*
* See also [original guide][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#partial-parsing
**/

ArgumentParser.prototype.parseKnownArgs = function (args, namespace) {

var self = this;

// args default to the system args
args = args || process.argv.slice(2);

// default Namespace built from parser defaults
namespace = namespace || new Namespace();

self._actions.forEach(function (action) {
  if (action.dest !== c.SUPPRESS) {
    if (!$$.has(namespace, action.dest)) {
      if (action.defaultValue !== c.SUPPRESS) {
        var defaultValue = action.defaultValue;
        if (typeof action.defaultValue === 'string') {
          defaultValue = self._getValue(action, defaultValue);
        }
        namespace[action.dest] = defaultValue;
      }
    }
  }
});

Object.keys(self._defaults).forEach(function (dest) {
  namespace[dest] = self._defaults[dest];
});

// parse the arguments and exit if there are any errors
try {
  var res = this._parseKnownArgs(args, namespace);

  namespace = res[0];
  args = res[1];
  if ($$.has(namespace, c._UNRECOGNIZED_ARGS_ATTR)) {
    args = $$.arrayUnion(args, namespace[c._UNRECOGNIZED_ARGS_ATTR]);
    delete namespace[c._UNRECOGNIZED_ARGS_ATTR];
  }
  return [ namespace, args ];
} catch (e) {
  this.error(e);
}

};

ArgumentParser.prototype._parseKnownArgs = function (argStrings, namespace) {

var self = this;

var extras = [];

// replace arg strings that are file references
if (this.fromfilePrefixChars !== null) {
  argStrings = this._readArgsFromFiles(argStrings);
}
// map all mutually exclusive arguments to the other arguments
// they can't occur with
// Python has 'conflicts = action_conflicts.setdefault(mutex_action, [])'
// though I can't conceive of a way in which an action could be a member
// of two different mutually exclusive groups.

function actionHash(action) {
  // some sort of hashable key for this action
  // action itself cannot be a key in actionConflicts
  // I think getName() (join of optionStrings) is unique enough
  return action.getName();
}

var conflicts, key;
var actionConflicts = {};

this._mutuallyExclusiveGroups.forEach(function (mutexGroup) {
  mutexGroup._groupActions.forEach(function (mutexAction, i, groupActions) {
    key = actionHash(mutexAction);
    if (!$$.has(actionConflicts, key)) {
      actionConflicts[key] = [];
    }
    conflicts = actionConflicts[key];
    conflicts.push.apply(conflicts, groupActions.slice(0, i));
    conflicts.push.apply(conflicts, groupActions.slice(i + 1));
  });
});

// find all option indices, and determine the arg_string_pattern
// which has an 'O' if there is an option at an index,
// an 'A' if there is an argument, or a '-' if there is a '--'
var optionStringIndices = {};

var argStringPatternParts = [];

argStrings.forEach(function (argString, argStringIndex) {
  if (argString === '--') {
    argStringPatternParts.push('-');
    while (argStringIndex < argStrings.length) {
      argStringPatternParts.push('A');
      argStringIndex++;
    }
  } else {
    // otherwise, add the arg to the arg strings
    // and note the index if it was an option
    var pattern;
    var optionTuple = self._parseOptional(argString);
    if (!optionTuple) {
      pattern = 'A';
    } else {
      optionStringIndices[argStringIndex] = optionTuple;
      pattern = 'O';
    }
    argStringPatternParts.push(pattern);
  }
});
var argStringsPattern = argStringPatternParts.join('');

var seenActions = [];
var seenNonDefaultActions = [];

function takeAction(action, argumentStrings, optionString) {
  seenActions.push(action);
  var argumentValues = self._getValues(action, argumentStrings);

  // error if this argument is not allowed with other previously
  // seen arguments, assuming that actions that use the default
  // value don't really count as "present"
  if (argumentValues !== action.defaultValue) {
    seenNonDefaultActions.push(action);
    if (actionConflicts[actionHash(action)]) {
      actionConflicts[actionHash(action)].forEach(function (actionConflict) {
        if (seenNonDefaultActions.indexOf(actionConflict) >= 0) {
          throw argumentErrorHelper(
            action,
            format('Not allowed with argument "%s".', actionConflict.getName())
          );
        }
      });
    }
  }

  if (argumentValues !== c.SUPPRESS) {
    action.call(self, namespace, argumentValues, optionString);
  }
}

function consumeOptional(startIndex) {
  // get the optional identified at this index
  var optionTuple = optionStringIndices[startIndex];
  var action = optionTuple[0];
  var optionString = optionTuple[1];
  var explicitArg = optionTuple[2];

  // identify additional optionals in the same arg string
  // (e.g. -xyz is the same as -x -y -z if no args are required)
  var actionTuples = [];

  var args, argCount, start, stop;

  for (;;) {
    if (!action) {
      extras.push(argStrings[startIndex]);
      return startIndex + 1;
    }
    if (explicitArg) {
      argCount = self._matchArgument(action, 'A');

      // if the action is a single-dash option and takes no
      // arguments, try to parse more single-dash options out
      // of the tail of the option string
      var chars = self.prefixChars;
      if (argCount === 0 && chars.indexOf(optionString[1]) < 0) {
        actionTuples.push([ action, [], optionString ]);
        optionString = optionString[0] + explicitArg[0];
        var newExplicitArg = explicitArg.slice(1) || null;
        var optionalsMap = self._optionStringActions;

        if (Object.keys(optionalsMap).indexOf(optionString) >= 0) {
          action = optionalsMap[optionString];
          explicitArg = newExplicitArg;
        } else {
          throw argumentErrorHelper(action, sprintf('ignored explicit argument %r', explicitArg));
        }
      } else if (argCount === 1) {
        // if the action expect exactly one argument, we've
        // successfully matched the option; exit the loop
        stop = startIndex + 1;
        args = [ explicitArg ];
        actionTuples.push([ action, args, optionString ]);
        break;
      } else {
        // error if a double-dash option did not use the
        // explicit argument
        throw argumentErrorHelper(action, sprintf('ignored explicit argument %r', explicitArg));
      }
    } else {
      // if there is no explicit argument, try to match the
      // optional's string arguments with the following strings
      // if successful, exit the loop

      start = startIndex + 1;
      var selectedPatterns = argStringsPattern.substr(start);

      argCount = self._matchArgument(action, selectedPatterns);
      stop = start + argCount;

      args = argStrings.slice(start, stop);

      actionTuples.push([ action, args, optionString ]);
      break;
    }

  }

  // add the Optional to the list and return the index at which
  // the Optional's string args stopped
  if (actionTuples.length < 1) {
    throw new Error('length should be > 0');
  }
  for (var i = 0; i < actionTuples.length; i++) {
    takeAction.apply(self, actionTuples[i]);
  }
  return stop;
}

// the list of Positionals left to be parsed; this is modified
// by consume_positionals()
var positionals = self._getPositionalActions();

function consumePositionals(startIndex) {
  // match as many Positionals as possible
  var selectedPattern = argStringsPattern.substr(startIndex);
  var argCounts = self._matchArgumentsPartial(positionals, selectedPattern);

  // slice off the appropriate arg strings for each Positional
  // and add the Positional and its args to the list
  for (var i = 0; i < positionals.length; i++) {
    var action = positionals[i];
    var argCount = argCounts[i];
    if (typeof argCount === 'undefined') {
      continue;
    }
    var args = argStrings.slice(startIndex, startIndex + argCount);

    startIndex += argCount;
    takeAction(action, args);
  }

  // slice off the Positionals that we just parsed and return the
  // index at which the Positionals' string args stopped
  positionals = positionals.slice(argCounts.length);
  return startIndex;
}

// consume Positionals and Optionals alternately, until we have
// passed the last option string
var startIndex = 0;
var position;

var maxOptionStringIndex = -1;

Object.keys(optionStringIndices).forEach(function (position) {
  maxOptionStringIndex = Math.max(maxOptionStringIndex, parseInt(position, 10));
});

var positionalsEndIndex, nextOptionStringIndex;

while (startIndex <= maxOptionStringIndex) {
  // consume any Positionals preceding the next option
  nextOptionStringIndex = null;
  for (position in optionStringIndices) {
    if (!optionStringIndices.hasOwnProperty(position)) { continue; }

    position = parseInt(position, 10);
    if (position >= startIndex) {
      if (nextOptionStringIndex !== null) {
        nextOptionStringIndex = Math.min(nextOptionStringIndex, position);
      } else {
        nextOptionStringIndex = position;
      }
    }
  }

  if (startIndex !== nextOptionStringIndex) {
    positionalsEndIndex = consumePositionals(startIndex);
    // only try to parse the next optional if we didn't consume
    // the option string during the positionals parsing
    if (positionalsEndIndex > startIndex) {
      startIndex = positionalsEndIndex;
      continue;
    } else {
      startIndex = positionalsEndIndex;
    }
  }

  // if we consumed all the positionals we could and we're not
  // at the index of an option string, there were extra arguments
  if (!optionStringIndices[startIndex]) {
    var strings = argStrings.slice(startIndex, nextOptionStringIndex);
    extras = extras.concat(strings);
    startIndex = nextOptionStringIndex;
  }
  // consume the next optional and any arguments for it
  startIndex = consumeOptional(startIndex);
}

// consume any positionals following the last Optional
var stopIndex = consumePositionals(startIndex);

// if we didn't consume all the argument strings, there were extras
extras = extras.concat(argStrings.slice(stopIndex));

// if we didn't use all the Positional objects, there were too few
// arg strings supplied.
if (positionals.length > 0) {
  self.error('too few arguments');
}

// make sure all required actions were present
self._actions.forEach(function (action) {
  if (action.required) {
    if (seenActions.indexOf(action) < 0) {
      self.error(format('Argument "%s" is required', action.getName()));
    }
  }
});

// make sure all required groups have one option present
var actionUsed = false;
self._mutuallyExclusiveGroups.forEach(function (group) {
  if (group.required) {
    actionUsed = group._groupActions.some(function (action) {
      return seenNonDefaultActions.indexOf(action) !== -1;
    });

    // if no actions were used, report the error
    if (!actionUsed) {
      var names = [];
      group._groupActions.forEach(function (action) {
        if (action.help !== c.SUPPRESS) {
          names.push(action.getName());
        }
      });
      names = names.join(' ');
      var msg = 'one of the arguments ' + names + ' is required';
      self.error(msg);
    }
  }
});

// return the updated namespace and the extra arguments
return [ namespace, extras ];

};

ArgumentParser.prototype._readArgsFromFiles = function (argStrings) {

// expand arguments referencing files
var self = this;
var fs = require('fs');
var newArgStrings = [];
argStrings.forEach(function (argString) {
  if (self.fromfilePrefixChars.indexOf(argString[0]) < 0) {
    // for regular arguments, just add them back into the list
    newArgStrings.push(argString);
  } else {
    // replace arguments referencing files with the file content
    try {
      var argstrs = [];
      var filename = argString.slice(1);
      var content = fs.readFileSync(filename, 'utf8');
      content = content.trim().split('\n');
      content.forEach(function (argLine) {
        self.convertArgLineToArgs(argLine).forEach(function (arg) {
          argstrs.push(arg);
        });
        argstrs = self._readArgsFromFiles(argstrs);
      });
      newArgStrings.push.apply(newArgStrings, argstrs);
    } catch (error) {
      return self.error(error.message);
    }
  }
});
return newArgStrings;

};

ArgumentParser.prototype.convertArgLineToArgs = function (argLine) {

return [ argLine ];

};

ArgumentParser.prototype._matchArgument = function (action, regexpArgStrings) {

// match the pattern for this action to the arg strings
var regexpNargs = new RegExp('^' + this._getNargsPattern(action));
var matches = regexpArgStrings.match(regexpNargs);
var message;

// throw an exception if we weren't able to find a match
if (!matches) {
  switch (action.nargs) {
    /*eslint-disable no-undefined*/
    case undefined:
    case null:
      message = 'Expected one argument.';
      break;
    case c.OPTIONAL:
      message = 'Expected at most one argument.';
      break;
    case c.ONE_OR_MORE:
      message = 'Expected at least one argument.';
      break;
    default:
      message = 'Expected %s argument(s)';
  }

  throw argumentErrorHelper(
    action,
    format(message, action.nargs)
  );
}
// return the number of arguments matched
return matches[1].length;

};

ArgumentParser.prototype._matchArgumentsPartial = function (actions, regexpArgStrings) {

// progressively shorten the actions list by slicing off the
// final actions until we find a match
var self = this;
var result = [];
var actionSlice, pattern, matches;
var i, j;

function getLength(string) {
  return string.length;
}

for (i = actions.length; i > 0; i--) {
  pattern = '';
  actionSlice = actions.slice(0, i);
  for (j = 0; j < actionSlice.length; j++) {
    pattern += self._getNargsPattern(actionSlice[j]);
  }

  pattern = new RegExp('^' + pattern);
  matches = regexpArgStrings.match(pattern);

  if (matches && matches.length > 0) {
    // need only groups
    matches = matches.splice(1);
    result = result.concat(matches.map(getLength));
    break;
  }
}

// return the list of arg string counts
return result;

};

ArgumentParser.prototype._parseOptional = function (argString) {

var action, optionString, argExplicit, optionTuples;

// if it's an empty string, it was meant to be a positional
if (!argString) {
  return null;
}

// if it doesn't start with a prefix, it was meant to be positional
if (this.prefixChars.indexOf(argString[0]) < 0) {
  return null;
}

// if the option string is present in the parser, return the action
if (this._optionStringActions[argString]) {
  return [ this._optionStringActions[argString], argString, null ];
}

// if it's just a single character, it was meant to be positional
if (argString.length === 1) {
  return null;
}

// if the option string before the "=" is present, return the action
if (argString.indexOf('=') >= 0) {
  optionString = argString.split('=', 1)[0];
  argExplicit = argString.slice(optionString.length + 1);

  if (this._optionStringActions[optionString]) {
    action = this._optionStringActions[optionString];
    return [ action, optionString, argExplicit ];
  }
}

// search through all possible prefixes of the option string
// and all actions in the parser for possible interpretations
optionTuples = this._getOptionTuples(argString);

// if multiple actions match, the option string was ambiguous
if (optionTuples.length > 1) {
  var optionStrings = optionTuples.map(function (optionTuple) {
    return optionTuple[1];
  });
  this.error(format(
        'Ambiguous option: "%s" could match %s.',
        argString, optionStrings.join(', ')
  ));
// if exactly one action matched, this segmentation is good,
// so return the parsed action
} else if (optionTuples.length === 1) {
  return optionTuples[0];
}

// if it was not found as an option, but it looks like a negative
// number, it was meant to be positional
// unless there are negative-number-like options
if (argString.match(this._regexpNegativeNumber)) {
  if (!this._hasNegativeNumberOptionals.some(Boolean)) {
    return null;
  }
}
// if it contains a space, it was meant to be a positional
if (argString.search(' ') >= 0) {
  return null;
}

// it was meant to be an optional but there is no such option
// in this parser (though it might be a valid option in a subparser)
return [ null, argString, null ];

};

ArgumentParser.prototype._getOptionTuples = function (optionString) {

var result = [];
var chars = this.prefixChars;
var optionPrefix;
var argExplicit;
var action;
var actionOptionString;

// option strings starting with two prefix characters are only split at
// the '='
if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) >= 0) {
  if (optionString.indexOf('=') >= 0) {
    var optionStringSplit = optionString.split('=', 1);

    optionPrefix = optionStringSplit[0];
    argExplicit = optionStringSplit[1];
  } else {
    optionPrefix = optionString;
    argExplicit = null;
  }

  for (actionOptionString in this._optionStringActions) {
    if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) {
      action = this._optionStringActions[actionOptionString];
      result.push([ action, actionOptionString, argExplicit ]);
    }
  }

// single character options can be concatenated with their arguments
// but multiple character options always have to have their argument
// separate
} else if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) < 0) {
  optionPrefix = optionString;
  argExplicit = null;
  var optionPrefixShort = optionString.substr(0, 2);
  var argExplicitShort = optionString.substr(2);

  for (actionOptionString in this._optionStringActions) {
    if (!$$.has(this._optionStringActions, actionOptionString)) continue;

    action = this._optionStringActions[actionOptionString];
    if (actionOptionString === optionPrefixShort) {
      result.push([ action, actionOptionString, argExplicitShort ]);
    } else if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) {
      result.push([ action, actionOptionString, argExplicit ]);
    }
  }

// shouldn't ever get here
} else {
  throw new Error(format('Unexpected option string: %s.', optionString));
}
// return the collected option tuples
return result;

};

ArgumentParser.prototype._getNargsPattern = function (action) {

// in all examples below, we have to allow for '--' args
// which are represented as '-' in the pattern
var regexpNargs;

switch (action.nargs) {
  // the default (null) is assumed to be a single argument
  case undefined:
  case null:
    regexpNargs = '(-*A-*)';
    break;
  // allow zero or more arguments
  case c.OPTIONAL:
    regexpNargs = '(-*A?-*)';
    break;
  // allow zero or more arguments
  case c.ZERO_OR_MORE:
    regexpNargs = '(-*[A-]*)';
    break;
  // allow one or more arguments
  case c.ONE_OR_MORE:
    regexpNargs = '(-*A[A-]*)';
    break;
  // allow any number of options or arguments
  case c.REMAINDER:
    regexpNargs = '([-AO]*)';
    break;
  // allow one argument followed by any number of options or arguments
  case c.PARSER:
    regexpNargs = '(-*A[-AO]*)';
    break;
  // all others should be integers
  default:
    regexpNargs = '(-*' + $$.repeat('-*A', action.nargs) + '-*)';
}

// if this is an optional action, -- is not allowed
if (action.isOptional()) {
  regexpNargs = regexpNargs.replace(/-\*/g, '');
  regexpNargs = regexpNargs.replace(/-/g, '');
}

// return the pattern
return regexpNargs;

};

// // Value conversion methods //

ArgumentParser.prototype._getValues = function (action, argStrings) {

var self = this;

// for everything but PARSER args, strip out '--'
if (action.nargs !== c.PARSER && action.nargs !== c.REMAINDER) {
  argStrings = argStrings.filter(function (arrayElement) {
    return arrayElement !== '--';
  });
}

var value, argString;

// optional argument produces a default when not present
if (argStrings.length === 0 && action.nargs === c.OPTIONAL) {

  value = (action.isOptional()) ? action.constant : action.defaultValue;

  if (typeof (value) === 'string') {
    value = this._getValue(action, value);
    this._checkValue(action, value);
  }

// when nargs='*' on a positional, if there were no command-line
// args, use the default if it is anything other than None
} else if (argStrings.length === 0 && action.nargs === c.ZERO_OR_MORE &&
  action.optionStrings.length === 0) {

  value = (action.defaultValue || argStrings);
  this._checkValue(action, value);

// single argument or optional argument produces a single value
} else if (argStrings.length === 1 &&
      (!action.nargs || action.nargs === c.OPTIONAL)) {

  argString = argStrings[0];
  value = this._getValue(action, argString);
  this._checkValue(action, value);

// REMAINDER arguments convert all values, checking none
} else if (action.nargs === c.REMAINDER) {
  value = argStrings.map(function (v) {
    return self._getValue(action, v);
  });

// PARSER arguments convert all values, but check only the first
} else if (action.nargs === c.PARSER) {
  value = argStrings.map(function (v) {
    return self._getValue(action, v);
  });
  this._checkValue(action, value[0]);

// all other types of nargs produce a list
} else {
  value = argStrings.map(function (v) {
    return self._getValue(action, v);
  });
  value.forEach(function (v) {
    self._checkValue(action, v);
  });
}

// return the converted value
return value;

};

ArgumentParser.prototype._getValue = function (action, argString) {

var result;

var typeFunction = this._registryGet('type', action.type, action.type);
if (typeof typeFunction !== 'function') {
  var message = format('%s is not callable', typeFunction);
  throw argumentErrorHelper(action, message);
}

// convert the value to the appropriate type
try {
  result = typeFunction(argString);

  // ArgumentTypeErrors indicate errors
  // If action.type is not a registered string, it is a function
  // Try to deduce its name for inclusion in the error message
  // Failing that, include the error message it raised.
} catch (e) {
  var name = null;
  if (typeof action.type === 'string') {
    name = action.type;
  } else {
    name = action.type.name || action.type.displayName || '<function>';
  }
  var msg = format('Invalid %s value: %s', name, argString);
  if (name === '<function>') { msg += '\n' + e.message; }
  throw argumentErrorHelper(action, msg);
}
// return the converted value
return result;

};

ArgumentParser.prototype._checkValue = function (action, value) {

// converted value must be one of the choices (if specified)
var choices = action.choices;
if (choices) {
  // choise for argument can by array or string
  if ((typeof choices === 'string' || Array.isArray(choices)) &&
      choices.indexOf(value) !== -1) {
    return;
  }
  // choise for subparsers can by only hash
  if (typeof choices === 'object' && !Array.isArray(choices) && choices[value]) {
    return;
  }

  if (typeof choices === 'string') {
    choices = choices.split('').join(', ');
  } else if (Array.isArray(choices)) {
    choices =  choices.join(', ');
  } else {
    choices =  Object.keys(choices).join(', ');
  }
  var message = format('Invalid choice: %s (choose from [%s])', value, choices);
  throw argumentErrorHelper(action, message);
}

};

// // Help formatting methods //

/**

* ArgumentParser#formatUsage -> string
*
* Return usage string
*
* See also [original guide][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#printing-help
**/

ArgumentParser.prototype.formatUsage = function () {

var formatter = this._getFormatter();
formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups);
return formatter.formatHelp();

};

/**

* ArgumentParser#formatHelp -> string
*
* Return help
*
* See also [original guide][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#printing-help
**/

ArgumentParser.prototype.formatHelp = function () {

var formatter = this._getFormatter();

// usage
formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups);

// description
formatter.addText(this.description);

// positionals, optionals and user-defined groups
this._actionGroups.forEach(function (actionGroup) {
  formatter.startSection(actionGroup.title);
  formatter.addText(actionGroup.description);
  formatter.addArguments(actionGroup._groupActions);
  formatter.endSection();
});

// epilog
formatter.addText(this.epilog);

// determine help from format above
return formatter.formatHelp();

};

ArgumentParser.prototype._getFormatter = function () {

var FormatterClass = this.formatterClass;
var formatter = new FormatterClass({ prog: this.prog });
return formatter;

};

// // Print functions //

/**

* ArgumentParser#printUsage() -> Void
*
* Print usage
*
* See also [original guide][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#printing-help
**/

ArgumentParser.prototype.printUsage = function () {

this._printMessage(this.formatUsage());

};

/**

* ArgumentParser#printHelp() -> Void
*
* Print help
*
* See also [original guide][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#printing-help
**/

ArgumentParser.prototype.printHelp = function () {

this._printMessage(this.formatHelp());

};

ArgumentParser.prototype._printMessage = function (message, stream) {

if (!stream) {
  stream = process.stdout;
}
if (message) {
  stream.write('' + message);
}

};

// // Exit functions //

/**

* ArgumentParser#exit(status=0, message) -> Void
* - status (int): exit status
* - message (string): message
*
* Print message in stderr/stdout and exit program
**/

ArgumentParser.prototype.exit = function (status, message) {

if (message) {
  if (status === 0) {
    this._printMessage(message);
  } else {
    this._printMessage(message, process.stderr);
  }
}

process.exit(status);

};

/**

* ArgumentParser#error(message) -> Void
* - err (Error|string): message
*
* Error method Prints a usage message incorporating the message to stderr and
* exits. If you override this in a subclass,
* it should not return -- it should
* either exit or throw an exception.
*
**/

ArgumentParser.prototype.error = function (err) {

var message;
if (err instanceof Error) {
  if (this.debug === true) {
    throw err;
  }
  message = err.message;
} else {
  message = err;
}
var msg = format('%s: error: %s', this.prog, message) + c.EOL;

if (this.debug === true) {
  throw new Error(msg);
}

this.printUsage(process.stderr);

return this.exit(2, msg);

};

module.exports = ArgumentParser;