/* 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;

}