/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#include "cmAddCustomRuleCommand.h"

#include <algorithm>
#include <utility>

#include <cm/memory>
#include <cm/optional>
#include <cm/string_view>
#include <cmext/algorithm>
#include <cmext/string_view>

#include "cmsys/RegularExpression.hxx"

#include "cmArgumentParser.h"
#include "cmArgumentParserTypes.h"
#include "cmExecutionStatus.h"
#include "cmGeneratorExpression.h"
#include "cmMakefile.h"
#include "cmRange.h"
#include "cmRule.h"
#include "cmState.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"

namespace {
bool IsReservedName(std::string const& name)
{
  static cmsys::RegularExpression reservedNameValidator("^[A-Z_.:+-]+$");

  return reservedNameValidator.find(name);
}

template <typename Result>
class FromRuleArgumentParser : public cmArgumentParser<Result>
{
public:
  FromRuleArgumentParser()
    : cmArgumentParser<Result>()
  {
    this->Bind("CHAIN"_s, &Result::Chain)
      .Bind("OVERRIDE"_s, &Result::Override)
      .BindParsedKeywords(&Result::ParsedKeywords);
  }
};
}

bool cmAddCustomRuleCommand(std::vector<std::string> const& args,
                            cmExecutionStatus& status)
{
  if (args.size() < 2) {
    status.SetError("called with incorrect number of arguments");
    return false;
  }

  // keywords
  static cm::static_string_view const COMMAND{ "COMMAND"_s };
  static cm::static_string_view const OUTPUT{ "OUTPUT"_s };
  static cm::static_string_view const DEPENDS{ "DEPENDS"_s };
  static cm::static_string_view const DEPFILE{ "DEPFILE"_s };
  static cm::static_string_view const BYPRODUCTS{ "BYPRODUCTS"_s };
  static cm::static_string_view const GLOBAL{ "GLOBAL"_s };
  static cm::static_string_view const CONFIGURATOR{ "CONFIGURATOR"_s };
  static cm::static_string_view const FOR_FILE_SET{ "FOR_FILE_SET"_s };
  static cm::static_string_view const FOR_SOURCE{ "FOR_SOURCE"_s };
  static cm::static_string_view const FROM_RULE{ "FROM_RULE"_s };

  static cm::string_view const Keywords[]{ COMMAND,      OUTPUT,     DEPENDS,
                                           DEPFILE,      BYPRODUCTS, GLOBAL,
                                           CONFIGURATOR, FROM_RULE };
  cmMakefile& mf = status.GetMakefile();
  std::string const& ruleName = args[0];

  // Check the rule name.
  if (cm::contains(Keywords, ruleName)) {
    status.SetError("rule name is missing.");
    return false;
  }
  // check name validity
  if (IsReservedName(ruleName)) {
    status.SetError("names in all uppercase are reserved for CMake.");
    return false;
  }
  if (!cmGeneratorExpression::IsValidTargetName(ruleName)) {
    status.SetError(cmStrCat("invalid name for RULE: ", ruleName, '.'));
    return false;
  }

  // Make sure the rule does not already exist.
  if (mf.FindRuleToUse(ruleName)) {
    status.SetError(
      cmStrCat("cannot create RULE \"", ruleName,
               "\" because another RULE with the same name already exists."));
    return false;
  }

  struct BaseArguments : public ArgumentParser::ParseResult
  {
    cm::optional<ArgumentParser::NonEmpty<std::vector<std::string>>>
      Configurators;
    bool Global = false;
    std::vector<cm::string_view> ParsedKeywords;

    cm::RuleScope GetScope()
    {
      return this->Global ? cm::RuleScope::Global : cm::RuleScope::Local;
    }
  };

  if (cm::contains(args, FROM_RULE)) {
    struct Arguments : public BaseArguments
    {
      std::string FromRule;
    };

    std::vector<std::string> unexpectedArgs;
    auto parser = cmArgumentParser<Arguments>{}
                    .Bind(FROM_RULE, &Arguments::FromRule)
                    .Bind(CONFIGURATOR, &Arguments::Configurators)
                    .Bind(GLOBAL, &Arguments::Global)
                    .BindParsedKeywords(&Arguments::ParsedKeywords);
    auto parsedArgs =
      parser.Parse(cmMakeRange(args).advance(1), &unexpectedArgs);

    // do various checks for arguments consistency
    if (!parsedArgs.Check("", &unexpectedArgs, status)) {
      cmSystemTools::SetFatalErrorOccurred();
      return false;
    }

    if ((std::count(parsedArgs.ParsedKeywords.cbegin(),
                    parsedArgs.ParsedKeywords.cend(), FROM_RULE) > 1) ||
        (std::count(parsedArgs.ParsedKeywords.cbegin(),
                    parsedArgs.ParsedKeywords.cend(), CONFIGURATOR) > 1)) {
      status.SetError(
        "only one occurrence of \"FROM_RULE\" or \"CONFIGURATOR\" "
        "options is allowed.");
      return false;
    }

    // Configurator syntax: <configurator> (CHAIN|OVERRIDE)
    struct ConfiguratorArguments : public ArgumentParser::ParseResult
    {
      std::string Configurator;
      bool Chain = false;
      bool Override = false;
      std::vector<cm::string_view> ParsedKeywords;
    };

    // configurators syntax: FOR_FILE_SET <configurator> <options>
    //                       FOR_SOURCE <configurator> <options>
    struct ConfiguratorsArguments : public ArgumentParser::ParseResult
    {
      cm::optional<ConfiguratorArguments> ForFileSet;
      cm::optional<ConfiguratorArguments> ForSource;
    } parsedConfigurators;

    if (parsedArgs.Configurators) {
      auto fileSetConfiguratorParser =
        FromRuleArgumentParser<ConfiguratorArguments>{}.Bind(
          FOR_FILE_SET, &ConfiguratorArguments::Configurator);

      auto sourceConfiguratorParser =
        FromRuleArgumentParser<ConfiguratorArguments>{}.Bind(
          FOR_SOURCE, &ConfiguratorArguments::Configurator);

      auto configuratorsParser =
        cmArgumentParser<ConfiguratorsArguments>{}
          .BindSubParser(FOR_FILE_SET, fileSetConfiguratorParser,
                         &ConfiguratorsArguments::ForFileSet)
          .BindSubParser(FOR_SOURCE, sourceConfiguratorParser,
                         &ConfiguratorsArguments::ForSource);

      unexpectedArgs.clear();
      configuratorsParser.Parse(parsedConfigurators, *parsedArgs.Configurators,
                                &unexpectedArgs);

      // do various checks for arguments consistency
      if (!parsedConfigurators.Check("", &unexpectedArgs, status)) {
        cmSystemTools::SetFatalErrorOccurred();
        return false;
      }

      if (!parsedConfigurators.ForFileSet && !parsedConfigurators.ForSource) {
        status.SetError(
          cmStrCat("cannot create RULE \"", ruleName,
                   "\" because the options \"FOR_FILE_SET\" or \"FOR_SOURCE\" "
                   "are expected for the \"CONFIGURATOR\" option."));
        cmSystemTools::SetFatalErrorOccurred();
        return false;
      }

      if ((parsedConfigurators.ForFileSet &&
           std::count(parsedConfigurators.ForFileSet->ParsedKeywords.cbegin(),
                      parsedConfigurators.ForFileSet->ParsedKeywords.cend(),
                      FOR_FILE_SET) > 1) ||
          (parsedConfigurators.ForSource &&
           std::count(parsedConfigurators.ForSource->ParsedKeywords.cbegin(),
                      parsedConfigurators.ForSource->ParsedKeywords.cend(),
                      FOR_SOURCE) > 1)) {
        status.SetError(
          "only one occurrence of \"FOR_FILE_SET\" or \"FOR_SOURCE\" "
          "sub-options of \"CONFIGURATOR\" option is allowed.");
        return false;
      }

      auto checkConfigurator =
        [&status, &mf,
         &ruleName](cm::optional<ConfiguratorArguments>& configurator,
                    cm::string_view type) -> bool {
        if (!configurator) {
          return true;
        }
        ConfiguratorArguments& ca = configurator.value();

        cm::optional<cmStateEnums::CommandType> commandType =
          mf.GetState()->GetCommandType(ca.Configurator);
        if (!commandType) {
          status.SetError(cmStrCat("command specified for \"", type,
                                   "\" does not exist: ", ca.Configurator,
                                   '.'));
          cmSystemTools::SetFatalErrorOccurred();
          return false;
        }
        if (*commandType != cmStateEnums::CommandType::Function) {
          status.SetError(cmStrCat("command specified for \"", type,
                                   "\" is not a function: ", ca.Configurator,
                                   '.'));
          cmSystemTools::SetFatalErrorOccurred();
          return false;
        }
        if (ca.Chain && ca.Override) {
          status.SetError(cmStrCat("cannot create RULE \"", ruleName,
                                   "\" because the \"CHAIN\" and \"OVERRIDE\" "
                                   "options of CONFIGURATOR \"",
                                   ca.Configurator,
                                   "\" are mutually exclusive."));
          cmSystemTools::SetFatalErrorOccurred();
          return false;
        }

        if (!ca.Chain && !ca.Override) {
          ca.Override = true;
        }

        return true;
      };

      if (!checkConfigurator(parsedConfigurators.ForFileSet, FOR_FILE_SET) ||
          !checkConfigurator(parsedConfigurators.ForSource, FOR_SOURCE)) {
        return false;
      }
    }

    cmRule const* rule = mf.FindRuleToUse(parsedArgs.FromRule);
    if (!rule) {
      status.SetError(cmStrCat("cannot create RULE \"", ruleName,
                               "\" because the RULE \"", parsedArgs.FromRule,
                               "\" does not exist or is not accessible."));
      cmSystemTools::SetFatalErrorOccurred();
      return false;
    }

    auto newRule = cm::make_unique<cmSpecializedRule>(mf, ruleName, *rule,
                                                      parsedArgs.GetScope());

    if (parsedArgs.Configurators) {
      if (parsedConfigurators.ForFileSet) {
        newRule->SetConfigurator(
          cmRule::ConfiguratorType::FileSet,
          std::move(parsedConfigurators.ForFileSet->Configurator),
          parsedConfigurators.ForFileSet->Chain
            ? cmRule::ChainConfigurators::Yes
            : cmRule::ChainConfigurators::No);
      }
      if (parsedConfigurators.ForSource) {
        newRule->SetConfigurator(
          cmRule::ConfiguratorType::Source,
          std::move(parsedConfigurators.ForSource->Configurator),
          parsedConfigurators.ForSource->Chain
            ? cmRule::ChainConfigurators::Yes
            : cmRule::ChainConfigurators::No);
      }
    }

    mf.AddRule(std::move(newRule));

    return true;
  }

  struct Arguments : public BaseArguments
  {
    ArgumentParser::NonEmpty<std::vector<std::string>> Output;
    cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>>
      Byproducts;
    ArgumentParser::NonEmpty<std::vector<std::vector<std::string>>> Commands;
    cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>> Depends;
    cm::optional<std::string> Depfile;
  };

  std::vector<std::string> unexpectedArgs;
  auto parser = cmArgumentParser<Arguments>{}
                  .Bind(OUTPUT, &Arguments::Output)
                  .Bind(BYPRODUCTS, &Arguments::Byproducts)
                  .Bind(COMMAND, &Arguments::Commands)
                  .Bind(DEPENDS, &Arguments::Depends)
                  .Bind(DEPFILE, &Arguments::Depfile)
                  .Bind(CONFIGURATOR, &Arguments::Configurators)
                  .Bind(GLOBAL, &Arguments::Global)
                  .BindParsedKeywords(&Arguments::ParsedKeywords);

  auto parsedArgs =
    parser.Parse(cmMakeRange(args).advance(1), &unexpectedArgs);

  // do various checks for arguments consistency
  if (!parsedArgs.Check("", &unexpectedArgs, status)) {
    cmSystemTools::SetFatalErrorOccurred();
    return false;
  }

  if (parsedArgs.Commands.empty() || parsedArgs.Output.empty()) {
    status.SetError(cmStrCat(
      "cannot create RULE \"", ruleName,
      "\" because the mandatory options \"COMMAND\" or \"OUTPUT\" are "
      "missing."));
    cmSystemTools::SetFatalErrorOccurred();
    return false;
  }

  if ((std::count(parsedArgs.ParsedKeywords.cbegin(),
                  parsedArgs.ParsedKeywords.cend(), DEPFILE) > 1) ||
      (std::count(parsedArgs.ParsedKeywords.cbegin(),
                  parsedArgs.ParsedKeywords.cend(), CONFIGURATOR) > 1)) {
    status.SetError("only one occurrence of \"DEPFILE\" or \"CONFIGURATOR\" "
                    "options is allowed.");
    return false;
  }

  struct ConfiguratorsArguments : public ArgumentParser::ParseResult
  {
    cm::optional<std::string> ForFileSet;
    cm::optional<std::string> ForSource;
    std::vector<cm::string_view> ParsedKeywords;
  } parsedConfigurators;

  if (parsedArgs.Configurators) {
    // parse the arguments of CONFIGURATOR option
    // CONFIGURATOR syntax: FOR_FILE_SET <configurator>
    //                      FOR_SOURCE <configurator>
    auto configuratorsParser =
      cmArgumentParser<ConfiguratorsArguments>{}
        .Bind(FOR_FILE_SET, &ConfiguratorsArguments::ForFileSet)
        .Bind(FOR_SOURCE, &ConfiguratorsArguments::ForSource)
        .BindParsedKeywords(&ConfiguratorsArguments::ParsedKeywords);

    unexpectedArgs.clear();
    configuratorsParser.Parse(parsedConfigurators, *parsedArgs.Configurators,
                              &unexpectedArgs);

    // do various checks for arguments consistency
    if (!parsedConfigurators.Check("", &unexpectedArgs, status)) {
      cmSystemTools::SetFatalErrorOccurred();
      return false;
    }

    if ((std::count(parsedConfigurators.ParsedKeywords.cbegin(),
                    parsedConfigurators.ParsedKeywords.cend(),
                    FOR_FILE_SET) > 1) ||
        (std::count(parsedConfigurators.ParsedKeywords.cbegin(),
                    parsedConfigurators.ParsedKeywords.cend(),
                    FOR_SOURCE) > 1)) {
      status.SetError(
        "only one occurrence of \"FOR_FILE_SET\" or \"FOR_SOURCE\" "
        "sub-options of \"CONFIGURATOR\" option is allowed.");
      return false;
    }

    if (!parsedConfigurators.ForFileSet && !parsedConfigurators.ForSource) {
      status.SetError(cmStrCat(
        "cannot create RULE \"", ruleName,
        "\" because the options \"FOR_FILE_SET\" or \"FOR_SOURCE\" are "
        "expected for the \"CONFIGURATOR\" option."));
      cmSystemTools::SetFatalErrorOccurred();
      return false;
    }

    auto checkConfigurator =
      [&status, &mf](cm::optional<std::string> const& configurator,
                     cm::string_view type) -> bool {
      if (!configurator) {
        return true;
      }

      auto commandType = mf.GetState()->GetCommandType(*configurator);
      if (!commandType) {
        status.SetError(cmStrCat("command specified for \"", type,
                                 "\" does not exist: ", *configurator, '.'));
        cmSystemTools::SetFatalErrorOccurred();
        return false;
      }
      if (*commandType != cmStateEnums::CommandType::Function) {
        status.SetError(cmStrCat("command specified for \"", type,
                                 "\" is not a function: ", *configurator,
                                 '.'));
        cmSystemTools::SetFatalErrorOccurred();
        return false;
      }
      return true;
    };

    if (!checkConfigurator(parsedConfigurators.ForFileSet, FOR_FILE_SET) ||
        !checkConfigurator(parsedConfigurators.ForSource, FOR_SOURCE)) {
      return false;
    }
  }

  auto rule =
    cm::make_unique<cmCustomRule>(mf, ruleName, parsedArgs.Commands,
                                  parsedArgs.Output, parsedArgs.GetScope());
  if (parsedArgs.Byproducts) {
    rule->SetByproducts(std::move(*parsedArgs.Byproducts));
  }
  if (parsedArgs.Depends) {
    rule->SetDepends(std::move(*parsedArgs.Depends));
  }
  if (parsedArgs.Depfile) {
    rule->SetDepfile(std::move(*parsedArgs.Depfile));
  }
  if (parsedArgs.Configurators) {
    if (parsedConfigurators.ForFileSet) {
      rule->SetConfigurator(cmRule::ConfiguratorType::FileSet,
                            std::move(*parsedConfigurators.ForFileSet));
    }
    if (parsedConfigurators.ForSource) {
      rule->SetConfigurator(cmRule::ConfiguratorType::Source,
                            std::move(*parsedConfigurators.ForSource));
    }
  }

  mf.AddRule(std::move(rule));

  return true;
}