/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include "cmSourceGroupCommand.h"

#include <functional>

#include <map>

#include <memory>

#include <set>

#include <unordered_map>

#include <utility>

#include <cm/optional>

#include <cm/string_view>

#include <cmext/algorithm>

#include <cmext/string_view>

#include "cmArgumentParser.h"

#include "cmArgumentParserTypes.h"

#include "cmCMakePath.h"

#include "cmDiagnostics.h"

#include "cmExecutionStatus.h"

#include "cmMakefile.h"

#include "cmSourceFile.h"

#include "cmSourceFileLocation.h"

#include "cmSourceGroup.h"

#include "cmStringAlgorithms.h"

#include "cmSystemTools.h"

#include "cmTarget.h"

namespace {

template <typename Args>

bool ProcessTree(Args const& args, cmExecutionStatus& status)

{

  cmMakefile& mf = status.GetMakefile();

  auto const& currentSourceDir = mf.GetCurrentSourceDirectory();

  std::vector<std::string> files;

  if (args.Files) {

    files.reserve(args.Files->size());

    for (auto const& file : *args.Files) {

      if (file.empty()) {

        continue;

      }

      std::string fullPath =

        cmSystemTools::CollapseFullPath(file, currentSourceDir);

      files.emplace_back(std::move(fullPath));

    }

  } else {

    std::vector<std::unique_ptr<cmSourceFile>> const& sources =

      mf.GetSourceFiles();

    for (auto const& src : sources) {

      if (!src->GetIsGenerated()) {

        files.push_back(cmSystemTools::CollapseFullPath(

          src->GetLocation().GetFullPath(), currentSourceDir));

      }

    }

  }

  // final checks

  cmCMakePath const root{ cmSystemTools::CollapseFullPath(*args.Tree) };

  cmCMakePath const prefix{

    cmCMakePath{ args.Prefix ? *args.Prefix : "" }.Normal()

  };

  auto it = files.begin();

  while (it != files.end()) {

    if (it->empty() || cmSystemTools::FileIsDirectory(*it) ||

        (it->back() == '/' || it->back() == '\\')) {

      // Ignore any empty files or directories

      it = files.erase(it);

      continue;

    }

    cmCMakePath file{ *it };

    if (!root.IsPrefix(file)) {

      status.SetError(cmStrCat('"', root.GenericString(),

                               "\" is not a prefix of file \"",

                               file.GenericString(), '"'));

      return false;

    }

    // source groups generation

    cmCMakePath sourceGroup = prefix / file.Relative(root);

    if (sourceGroup.HasParentPath()) {

      sourceGroup = sourceGroup.GetParentPath();

    }

    std::vector<std::string> tokenizedSG =

      cmTokenize(sourceGroup.GenericString(), '/', cmTokenizerMode::New);

    auto* sg = mf.GetOrCreateSourceGroup(tokenizedSG);

    if (!sg) {

      status.SetError(cmStrCat("could not create source group for file \"",

                               file.GenericString(), '"'));

      return false;

    }

    sg->AddGroupFile(file.GenericString());

    ++it;

  }

  return true;

}

} // namespace

bool cmSourceGroupCommand(std::vector<std::string> const& args,

                          cmExecutionStatus& status)

{

  if (args.empty()) {

    status.SetError("called with incorrect number of arguments");

    return false;

  }

  static cm::string_view const Keywords[]{ "TREE"_s, "PREFIX"_s, "FILES"_s,

                                           "REGULAR_EXPRESSION"_s };

  cmMakefile& mf = status.GetMakefile();

  if (args.size() == 2 && !cm::contains(Keywords, args[0]) &&

      !cm::contains(Keywords, args[1])) {

    // The pre-1.8 version of the command is being invoked.

    cmSourceGroup* sg = mf.GetOrCreateSourceGroup(args[0]);

    if (!sg) {

      status.SetError("Could not create or find source group.");

      return false;

    }

    sg->SetGroupRegex(args[1]);

    return true;

  }

  struct Arguments : public ArgumentParser::ParseResult

  {

    cm::optional<std::string> GroupName;

    cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>> Files;

    cm::optional<std::string> Regex;

    cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>>

      FileSets;

    cm::optional<ArgumentParser::NonEmpty<std::string>> Tree;

    cm::optional<ArgumentParser::MaybeEmpty<std::string>> Prefix;

    std::map<std::string, std::set<std::string>> FileSetsPerTarget;

  };

  auto unsupportedKeyword =

    [&mf](Arguments&, cm::string_view key,

          cm::string_view /*value */) -> ArgumentParser::Continue {

    mf.IssueDiagnostic(

      cmDiagnostics::CMD_AUTHOR,

      cmStrCat("keyword \"", key, "\" will be ignored in this context."));

    return ArgumentParser::Continue::Yes;

  };

  // to distinguish REGULAR_EXPRESSION without values from with an empty string

  auto handleRegex = [](Arguments& result,

                        cm::string_view value) -> ArgumentParser::Continue {

    if (value.data()) {

      result.Regex = std::string{ value };

    }

    return ArgumentParser::Continue::No;

  };

  auto handleTarget = [](Arguments& result,

                         cm::string_view value) -> ArgumentParser::Continue {

    if (!result.FileSets) {

      result.AddKeywordError(

        "TARGET", cmStrCat("FILE_SETS is required for TARGET ", value, '.'));

      return ArgumentParser::Continue::No;

    }

    if (!result.FileSets->empty()) {

      result.FileSetsPerTarget[std::string{ value }].insert(

        result.FileSets->begin(), result.FileSets->end());

    }

    result.FileSets.reset();

    return ArgumentParser::Continue::Yes;

  };

  std::vector<std::string> unexpectedArgs;

  auto parser =

    cmArgumentParser<Arguments>{}.Bind("FILES"_s, &Arguments::Files);

  if (cm::contains(args, "TREE")) {

    // this is the TREE syntax

    parser.Bind("TREE"_s, &Arguments::Tree)

      .Bind("PREFIX"_s, &Arguments::Prefix)

      .Bind("REGULAR_EXPRESSION"_s, unsupportedKeyword)

      .Bind("FILE_SETS"_s, unsupportedKeyword)

      .Bind("TARGET"_s, unsupportedKeyword);

  } else {

    // assume that first argument is the group name

    parser.Bind(0, &Arguments::GroupName)

      .Bind("REGULAR_EXPRESSION"_s, handleRegex, 0)

      .Bind("FILE_SETS"_s, &Arguments::FileSets)

      .Bind("TARGET"_s, handleTarget)

      .Bind("TREE"_s, unsupportedKeyword)

      .Bind("PREFIX"_s, unsupportedKeyword);

  }

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

  // do various checks for arguments consistency

  if (!parsedArgs.Check("", &unexpectedArgs, status)) {

    cmSystemTools::SetFatalErrorOccurred();

    return false;

  }

  if (!parsedArgs.Tree && !parsedArgs.GroupName) {

    status.SetError("missing source group name.");

    cmSystemTools::SetFatalErrorOccurred();

    return false;

  }

  if (!parsedArgs.Tree && parsedArgs.FileSets) {

    status.SetError(cmStrCat("TARGET is required for FILE_SETS ",

                             cmJoin(*parsedArgs.FileSets, ", "), '.'));

    return false;

  }

  if (parsedArgs.Tree) {

    if (!ProcessTree(parsedArgs, status)) {

      cmSystemTools::SetFatalErrorOccurred();

      return false;

    }

  } else {

    if (!parsedArgs.Files && !parsedArgs.Regex &&

        parsedArgs.FileSetsPerTarget.empty()) {

      // group is not created

      return true;

    }

    auto* sg = mf.GetOrCreateSourceGroup(*parsedArgs.GroupName);

    if (!sg) {

      status.SetError("could not create or find source group");

      cmSystemTools::SetFatalErrorOccurred();

      return false;

    }

    if (parsedArgs.Regex) {

      if (!sg->SetGroupRegex(*parsedArgs.Regex)) {

        status.SetError(cmStrCat("regular expression \"", *parsedArgs.Regex,

                                 "\" is invalid"));

        return false;

      }

    }

    if (parsedArgs.Files) {

      auto const& currentSourceDir = mf.GetCurrentSourceDirectory();

      for (auto const& file : *parsedArgs.Files) {

        sg->AddGroupFile(

          cmSystemTools::CollapseFullPath(file, currentSourceDir));

      }

    }

    for (auto& item : parsedArgs.FileSetsPerTarget) {

      // check validity of arguments

      auto it = mf.GetTargets().find(item.first);

      if (it == mf.GetTargets().end()) {

        mf.IssueDiagnostic(

          cmDiagnostics::CMD_AUTHOR,

          cmStrCat(

            "TARGET \"", item.first,

            "\" is not defined in this directory. It will be ignored."));

        continue;

      }

      cmTarget const& target = it->second;

      for (auto it2 = item.second.begin(); it2 != item.second.end();) {

        if (!target.GetFileSet(*it2)) {

          mf.IssueDiagnostic(cmDiagnostics::CMD_AUTHOR,

                             cmStrCat("FILE_SET \"", *it2,

                                      "\" is not known for TARGET \"",

                                      item.first, "\". It will ignored."));

          it2 = item.second.erase(it2);

        } else {

          ++it2;

        }

      }

      if (!item.second.empty()) {

        sg->AddGroupFileSets(item.first, item.second);

      }

    }

  }

  return true;

}