/**
  \file

  \brief Implements mutils::CommandLine.

  \who \kpr
*/
#include <mutils/CommandLine.h>

namespace mutils {

/**
  Scans a GNU-style long option. The \a next argument is used only if
  there is no explicitly attached value but one is required. For options
  without a value, the value string will be set to a single null character;
  this *cannot* be produced by assignment from a C string and hence its
  meaning is unambiguous.

  \param[in] name  %Option name (without leading `--`, possibly with attached
                   value).
  \param[in] next  Next command line argument (may be the option value).

  \return Whether \a next was consumed.
*/
bool CommandLine::parseLong(const char *name, const char *next)
{
  const char *fn = "CommandLine::parseLong";
  const std::vector<Option> &opts = *validOpts_;
  MU_EXCEPTION_IF(*name == '=', fn, "Invalid option '%s'", name);

  bool used = false;
  std::string opt, arg = nullStr;  // C string cannot produce this value.
  const char *attach = strchr(name, '=');
  if (attach == nullptr) {
    opt.assign(name);
  } else {
    // Attached value.
    opt.assign(name, attach-name);
  }

  // Check if option is valid.
  auto o = std::find_if(opts.begin(), opts.end(),
               [&opt](const Option &x) { return !opt.compare(x.longName); });
  MU_EXCEPTION_IF(o == opts.end(), fn, "Unknown option '%s'", opt);

  if (! o->valueName.empty()) {
    if (attach == nullptr) {
      MU_EXCEPTION_IF(!next, fn, "Option '%s' requires a value", opt);

      // Trailing value.
      arg.assign(next);
      used = true;
    } else {
      // Attached value.
      arg.assign(attach+1);
    }
  } else {
    MU_EXCEPTION_IF(attach, fn, "Option '%s' does not take a value", opt);
  }

  // Insert option.
  auto p = longOpts_.upper_bound(opt);
  longOpts_.insert(p, LongMap::value_type(opt, arg));

  return used;
}


/**
  Scans one or more short options. The final one may have a value. The \a
  next argument is used only if there is no explicitly attached value but one
  is required. (Values attached to short options, such as `-f=foo`, are a local
  \mu extension.) For options without a value, the value string will be set to
  a single null character; this *cannot* be produced by assignment from a C
  string and hence its meaning is unambiguous.

  \param[in] name  %Option name(s) (without leading `-`, possibly with attached
                   value).
  \param[in] next  Next command line argument (may be the option value).

  \return Whether \a next was consumed.
*/
bool CommandLine::parseShort(const char *name, const char *next)
{
  const char *fn = "CommandLine::parseShort";
  const std::vector<Option> &opts = *validOpts_;

  // Allowing attached values precludes -= as an option.
  MU_EXCEPTION_IF(*name == '=', fn, "Invalid option '%s'", name);

  // Add new option(s).
  bool used = false;
  for (; *name != 0; name++) {
    char opt = *name;
    std::string arg = nullStr;  // C string cannot produce this value.

    // Check if option is valid.
    auto o = std::find_if(opts.begin(), opts.end(),
                         [opt](const Option &x) { return x.shortName == opt; });
    MU_EXCEPTION_IF(o == opts.end(), fn, "Unknown option '%c'", opt);

    // Last option may have a value.
    if (! o->valueName.empty()) {
      if (name[1] == '=') {
        // Attached value.
        arg.assign(name+2);
      } else {
        // Option must be the last of this group and needs a value.
        MU_EXCEPTION_IF(name[1] != '\0' || next == nullptr,
                        fn, "Option '%c' requires a value", opt);

        // Trailing value.
        arg.assign(next);
        used = true;
      }

      // Insert option and return.
      auto p = shortOpts_.upper_bound(opt);
      shortOpts_.insert(p, ShortMap::value_type(opt, arg));
      break;
    } else {
      MU_EXCEPTION_IF(name[1] == '=',
                      fn, "Option '%c' does not take a value", opt);

      // Insert option and continue.
      auto p = shortOpts_.upper_bound(opt);
      shortOpts_.insert(p, ShortMap::value_type(opt, arg));
    }
  }

  return used;
}

/**
  Initializes a new command line, erasing any existing contents (i.e., command
  lines do not accumulate). The complete set of valid options must be supplied
  at this time. Short options are preceded by a single hyphen (`-`) and may be
  aggregated if they do not take a value (except the last). Long options are
  preceded by two hyphens (`--`). Values can be explicitly attached to options
  (both long *and* short) using an equals sign; otherwise the following token
  is consumed.  A bare `--` token signals the end of all options (and is
  removed) and all following values are considered trailing arguments.
  Otherwise the first trailing argument is the first token that: (1) is not
  the value of an option; and (2) does not begin with a hyphen, or is a single
  bare hyphen (`-`).

  \param[in] argc  Number of command line arguments.
  \param[in] argv  Input command line arguments.
  \param[in] opts  Recognized command line options.
*/
void CommandLine::init(int argc, char *argv[], const std::vector<Option> *opts)
{
  // Clean slate.
  driver_ = (argc > 0 ? argv[0] : "");
  validOpts_ = opts;
  shortOpts_.clear();
  longOpts_.clear();
  args_.clear();

  // Parse input into maps of short and long options, plus trailing arguments.
  int i = 1;
  for (; i < argc; i++) {
    char *arg = argv[i], *next = (i+1 < argc ? argv[i+1] : nullptr);

    // End of options?
    if (!strcmp(arg, "--") || !strcmp(arg, "-") || arg[0] != '-') {
      i += !strcmp(arg, "--");
      break;
    }

    // New option(s).
    i += (arg[1] != '-' ? parseShort(arg+1, next) : parseLong(arg+2, next));
  }

  // Store trailing arguments.
  for (; i < argc; i++) { args_.push_back(argv[i]); }
}

/**
  Retrieves all occurrences of the specified option (if any).
  Use null single-letters and long names to indicate missing alternatives.

  \param[in]  option  %Option specification.
  \param[out] values  %Option values (optional).
  \param[in]  nMax     Maximum number of entries allowed for option.
  \return Number of entries for \a option.

  \exception mu::Exception
  - The number of values present exceeds \a maxVals.

  \note
  If \a values is specified for an option not taking a value, each returned
  value string will consist of a single null character (#nullStr, which is
  distinct from an empty string in C++). This allows callers to distinguish
  "no value" from "empty value".
*/
unsigned CommandLine::getOption(const Option &option, Arguments *values,
                                unsigned nMax) const
{
  const char *const fn = "CommandLine::getOption";
  std::string names;
  unsigned n = 0;

  if (values != nullptr) {
    // Fill in the values.
    values->clear();

    if (option.shortName != '\0') {
      auto s = shortOpts_.equal_range(option.shortName);
      for (auto x = s.first; x != s.second; x++, n++) {
        values->push_back(x->second);
      }
      names += '-';
      names += option.shortName;
    }
    if (! option.longName.empty()) {
      auto l = longOpts_.equal_range(option.longName);
      for (auto x = l.first; x != l.second; x++, n++) {
        values->push_back(x->second);
      }
      if (! names.empty()) { names += '/'; }
      names += "--";
      names += option.longName;
    }
  } else {
    n = (option.shortName != '\0' ?  shortOpts_.count(option.shortName) : 0) +
        (!option.longName.empty() ?   longOpts_.count(option.longName)  : 0);
  }
  MU_EXCEPTION_IF(n > nMax, fn,
                  "Option %s can appear at most %lu time%s (%lu present)",
                  names, nMax, nMax ==1 ? "" : "s", n);

  return n;
}

/**
  \param[in]  shortName  Short option name.
  \param[out] values    %Option values (optional).
  \param[in]  nMax     Maximum number of entries allowed for option.
  \return Number of entries for \a option.

  \exception mu::Exception
  - The number of values present exceeds \a maxVals.

  \note
  All copies of the option (whether referenced by short or long name) are
  returned.
*/
unsigned CommandLine::getOption(char shortName, Arguments *values,
                                unsigned nMax) const
{
  // Find option specification.
  for (auto &opt: *validOpts_) {
    if (opt.shortName == shortName) { return getOption(opt, values, nMax); }
  }
  return 0;
}

/**
  \param[in]  longName  Long option name.
  \param[out] values   %Option values (optional).
  \param[in]  nMax     Maximum number of entries allowed for option.
  \return Number of entries for \a option.

  \exception mu::Exception
  - The number of values present exceeds \a maxVals.

  \note
  All copies of the option (whether referenced by short or long name) are
  returned.
*/
unsigned CommandLine::getOption(const std::string &longName,
                                Arguments *values, unsigned nMax) const
{
  // Find option specification.
  for (auto &opt: *validOpts_) {
    if (opt.longName == longName) { return getOption(opt, values, nMax); }
  }
  return 0;
}

/**
  \param[in]  option  %Option specification.
  \return Number of options erased (short or long).

  \note
  All copies of the option (whether referenced by short or long name) are
  erased.
*/
size_t CommandLine::popOption(const Option &option)
{
  size_t rtn = 0;
  if (option.shortName != '\0') { rtn += shortOpts_.erase(option.shortName); }
  if (!option.longName.empty()) { rtn +=  longOpts_.erase(option.longName);  }
  return rtn;
}

/**
  \param[in]  shortName  Short option name.
  \return Number of options erased (long \b or short).

  \note
  All copies of the option (whether referenced by short or long name) are
  erased.
*/
size_t CommandLine::popOption(char shortName)
{
  // Find option specification.
  for (auto &opt: *validOpts_) {
    if (opt.shortName == shortName) { return popOption(opt); }
  }
  return 0;
}

/**
  \param[in]  longName  Long option name.
  \return Number of options erased (long \b or short).

  \note
  All copies of the option (whether referenced by short or long name) are
  erased.
*/
size_t CommandLine::popOption(const std::string &longName)
{
  // Find option specification.
  for (auto &opt: *validOpts_) {
    if (opt.longName == longName) { return popOption(opt); }
  }
  return 0;
}


/**
  \param[in] shortName  Short name of option.

  \return Option value.

  \exception mu::Exception
  - The option does not exist, or is not unique.
*/
long CommandLine::getInteger(char shortName) const
{
  const char *const fn = "CommandLine::getInteger";
  Arguments vals;
  MU_EXCEPTION_IF(getOption(shortName, &vals, 1) == 0, fn,
                  "Option '%c' not found", shortName);
  return strtol(vals[0].c_str(), nullptr, 10);
}

/**
  \param[in] shortName  Short name of option.
  \param[in] defValue   Default option value.

  \return Option value, or the default value if the option is not present.

  \exception mu::Exception
  - The option is not unique.
*/
long CommandLine::getInteger(char shortName, long defValue) const
{
  Arguments vals;
  return (getOption(shortName, &vals, 1) ?
            strtol(vals[0].c_str(), nullptr, 10) : defValue);
}


/**
  \param[in] shortName  Short name of option.
  \param[in] defValue   Default option value.

  \return Option value, or the default value if the option is not present.

  \exception mu::Exception
  - The option is not unique.
*/
double CommandLine::getDouble(char shortName, double defValue) const
{
  Arguments vals;
  return (getOption(shortName, &vals, 1) ?
            strtod(vals[0].c_str(), nullptr) : defValue);
}

/**
  \param[in] shortName  Short name of option.
  \param[in] defValue   Default option value.

  \return Option value, or the default value if the option is not present.

  \exception mu::Exception
  - The option is not unique.
*/
std::string CommandLine::getString(char shortName,
                                   const std::string &defValue) const
{
  Arguments vals;
  return (getOption(shortName, &vals, 1) ? vals[0] : defValue);
}


/**
  \param[in] f         Open output file stream.
  \param[in] opts      Command line options specification.
  \param[in] args      Trailing arguments usage summary.
  \param[in] quiet     Whether to omit detailed option usage.
  \param[in] basename  Whether to strip pathname from driver program output.

  \note
  If Log::level is Log::DEBUG (or greater), the options summary will include
  the corresponding Options name, if any.
*/
void CommandLine::usage(FILE *f, const std::vector<Option> &opts,
                        const char *args, bool quiet, bool basename) const
{
  size_t base = (basename ? driver_.find_last_of('/') : npos);
  fprintf(f, "Usage:  %s [OPTIONS] %s\n\nOptions:\n",
          driver_.c_str()+(base != npos ? base+1 : 0U), args);

  // Output formatted option summary.
  for (auto &opt: opts) {
    bool hasShort = ( opt.shortName != '\0'),
         hasLong  = (!opt.longName.empty()),
         hasValue = (!opt.valueName.empty());
    fprintf(f, "%s  %s%c%s%s%s%s%s%s",
            (quiet ? "" : "\n"),
            (hasShort ? "-" : ""), opt.shortName,
            (hasShort && hasLong ? ", " : ""), (hasLong ? "--" : ""),
            (hasLong  ? opt.longName.c_str() : ""),
            (hasValue ? (hasLong ? "=" : " ") : ""),
            (hasValue ? opt.valueName.c_str() : ""),
            (hasLong || hasValue ? "\n" : ""));

    if (!quiet) {
      // Print each line of the help text on an indented line.
      int indent = (hasLong || hasValue ? 8 : 4);
      const char *line = opt.helpText.c_str();
      while (line != nullptr) {
        const char *next = strchr(line, '\n');
        if (next == nullptr) {
          fprintf(f, "%*s%s\n", indent, "", line);
          line = next;
        } else {
          fprintf(f, "%*s%.*s\n", indent, "", (int )(next-line), line);
          line = next+1;
        }
        indent = 8;
      }
      if (Log::level >= Log::DEBUG && opt.keyName != nullStr) {
        fprintf(f, "%*s(File option: *SECTION = %s::%s, keyword %s)\n",
                indent, "", opt.scopeName.c_str(), opt.sectName.c_str(),
                opt.keyword().c_str());
      }
    }
  }
}

}  // namespace mutils