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

#include <algorithm>
#include <map>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

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

#include "cmAlgorithms.h"
#include "cmEvaluatedTargetProperty.h"
#include "cmFileSet.h"
#include "cmGenExContext.h"
#include "cmGeneratorExpression.h"
#include "cmGeneratorExpressionDAGChecker.h"
#include "cmGeneratorTarget.h"
#include "cmList.h"
#include "cmListFileCache.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmake.h"

class cmLinkItem;

namespace {
class FileSetPropertyEntry : public cm::TargetPropertyEntry
{
public:
  FileSetPropertyEntry(
    std::vector<std::string> dirs, bool contextSensitiveDirs,
    std::unique_ptr<cmCompiledGeneratorExpression> const& cge,
    cmGeneratorFileSet const* fileSet, cmLinkItem const& item = NoLinkItem)
    : cm::TargetPropertyEntry(item)
    , BaseDirs(std::move(dirs))
    , ContextSensitiveDirs(contextSensitiveDirs)
    , Cge(cge)
    , FileSet(fileSet)
  {
  }

  static std::unique_ptr<cm::TargetPropertyEntry> CreateFileSetEntry(
    std::vector<std::string> dirs, bool contextSensitiveDirs,
    std::unique_ptr<cmCompiledGeneratorExpression> const& cge,
    cmGeneratorFileSet const* fileSet, cmLinkItem const& item = NoLinkItem)
  {
    return cm::make_unique<FileSetPropertyEntry>(
      std::move(dirs), contextSensitiveDirs, cge, fileSet, item);
  }

  std::string const& Evaluate(
    cm::GenEx::Context const& context, cmGeneratorTarget const* headTarget,
    cmGeneratorExpressionDAGChecker* dagChecker) const override
  {
    std::map<std::string, std::vector<std::string>> filesPerDir;
    this->FileSet->EvaluateFileEntry(this->BaseDirs, filesPerDir, this->Cge,
                                     context, headTarget, dagChecker);

    std::vector<std::string> files;
    for (auto const& it : filesPerDir) {
      files.insert(files.end(), it.second.begin(), it.second.end());
    }

    this->Value = cmList::to_string(files);
    return Value;
  }

  cmListFileBacktrace GetBacktrace() const override
  {
    return this->Cge->GetBacktrace();
  }

  std::string const& GetInput() const override
  {
    return this->Cge->GetInput();
  }

  bool GetHadContextSensitiveCondition() const override
  {
    return this->ContextSensitiveDirs ||
      this->Cge->GetHadContextSensitiveCondition();
  }

private:
  std::vector<std::string> const BaseDirs;
  bool const ContextSensitiveDirs;
  std::unique_ptr<cmCompiledGeneratorExpression> const& Cge;
  cmGeneratorFileSet const* FileSet;
  mutable std::string Value;
};

void CreatePropertyGeneratorExpressions(
  cmake& cmakeInstance, cmBTStringRange entries,
  std::vector<std::unique_ptr<cm::TargetPropertyEntry>>& items)
{
  for (auto const& entry : entries) {
    items.emplace_back(
      cm::TargetPropertyEntry::Create(cmakeInstance, entry, false));
  }
}

enum class OptionsParse
{
  None,
  Shell
};

std::vector<BT<std::string>> ProcessOptions(
  cm::EvaluatedTargetPropertyEntries const& entries,
  OptionsParse parse = OptionsParse::None)
{
  std::vector<BT<std::string>> options;
  std::unordered_set<std::string> uniqueOptions;

  for (cm::EvaluatedTargetPropertyEntry const& entry : entries.Entries) {
    for (std::string const& opt : entry.Values) {
      if (uniqueOptions.insert(opt).second) {
        if (parse == OptionsParse::Shell &&
            cmHasLiteralPrefix(opt, "SHELL:")) {
          std::vector<std::string> tmp;
          cmSystemTools::ParseUnixCommandLine(opt.c_str() + 6, tmp);
          for (std::string& o : tmp) {
            options.emplace_back(std::move(o), entry.Backtrace);
          }
        } else {
          options.emplace_back(opt, entry.Backtrace);
        }
      }
    }
  }
  return options;
}
std::vector<BT<std::string>> ProcessIncludes(
  cmGeneratorTarget const* target, std::string const& fileSetName,
  cm::string_view property, cm::EvaluatedTargetPropertyEntries& entries)
{
  std::vector<BT<std::string>> includes;
  std::unordered_set<std::string> uniqueIncludes;

  for (cm::EvaluatedTargetPropertyEntry& entry : entries.Entries) {
    for (std::string& include : entry.Values) {
      if (!cmValue::IsOff(include)) {
        cmSystemTools::ConvertToUnixSlashes(include);
      }

      if (!cmSystemTools::FileIsFullPath(include)) {
        target->GetLocalGenerator()->IssueMessage(
          MessageType::FATAL_ERROR,
          cmStrCat("File set \"", fileSetName, "\" from the target \"",
                   target->GetName(), "\" contains relative path in its ",
                   property, ":\n  \"", include, "\""));
        return includes;
      }

      if (uniqueIncludes.insert(include).second) {
        includes.emplace_back(include, entry.Backtrace);
      }
    }
  }
  return includes;
}
}

//
// Class cmGeneratorFileSet
//
cmGeneratorFileSet::cmGeneratorFileSet(cmGeneratorTarget const* target,
                                       cmFileSet const* fileSet)
  : Target(target)
  , FileSet(fileSet)
{
  auto& cmake = *target->GetLocalGenerator()->GetCMakeInstance();

  CreatePropertyGeneratorExpressions(cmake, fileSet->GetIncludeDirectories(),
                                     this->IncludeDirectories);
  CreatePropertyGeneratorExpressions(cmake,
                                     fileSet->GetInterfaceIncludeDirectories(),
                                     this->InterfaceIncludeDirectories);

  CreatePropertyGeneratorExpressions(cmake, fileSet->GetCompileOptions(),
                                     this->CompileOptions);
  CreatePropertyGeneratorExpressions(cmake,
                                     fileSet->GetInterfaceCompileOptions(),
                                     this->InterfaceCompileOptions);

  CreatePropertyGeneratorExpressions(cmake, fileSet->GetCompileDefinitions(),
                                     this->CompileDefinitions);
  CreatePropertyGeneratorExpressions(cmake,
                                     fileSet->GetInterfaceCompileDefinitions(),
                                     this->InterfaceCompileDefinitions);
}

std::string const& cmGeneratorFileSet::GetName() const
{
  return this->FileSet->GetName();
}
std::string const& cmGeneratorFileSet::GetType() const
{
  return this->FileSet->GetType();
}
cm::FileSetMetadata::Visibility cmGeneratorFileSet::GetVisibility() const
{
  return this->FileSet->GetVisibility();
}

bool cmGeneratorFileSet::IsForSelf() const
{
  return this->FileSet->IsForSelf();
}
bool cmGeneratorFileSet::IsForInterface() const
{
  return this->FileSet->IsForInterface();
}
bool cmGeneratorFileSet::CanBeIncluded() const
{
  return this->FileSet->CanBeIncluded();
}

cmValue cmGeneratorFileSet::GetProperty(std::string const& prop) const
{
  return this->FileSet->GetProperty(prop);
}

std::vector<BT<std::string>> cmGeneratorFileSet::GetIncludeDirectories(
  std::string const& config, std::string const& lang) const
{
  ConfigAndLanguage cacheKey(config, lang);
  {
    auto it = this->IncludeDirectoriesCache.find(cacheKey);
    if (it != this->IncludeDirectoriesCache.end()) {
      return it->second;
    }
  }

  cm::GenEx::Context context(this->Target->GetLocalGenerator(), config, lang);
  cmGeneratorExpressionDAGChecker dagChecker{
    this->Target, "INCLUDE_DIRECTORIES", nullptr, nullptr, context,
  };

  cm::EvaluatedTargetPropertyEntries entries =
    cm::EvaluateTargetPropertyEntries(this->Target, context, &dagChecker,
                                      this->IncludeDirectories);
  auto includes = ProcessIncludes(this->Target, this->GetName(),
                                  "INCLUDE_DIRECTORIES"_s, entries);
  this->IncludeDirectoriesCache.emplace(cacheKey, includes);

  return includes;
}
std::vector<BT<std::string>>
cmGeneratorFileSet::GetInterfaceIncludeDirectories(
  std::string const& config, std::string const& lang) const
{
  ConfigAndLanguage cacheKey(config, lang);
  {
    auto it = this->InterfaceIncludeDirectoriesCache.find(cacheKey);
    if (it != this->InterfaceIncludeDirectoriesCache.end()) {
      return it->second;
    }
  }

  cm::GenEx::Context context(this->Target->GetLocalGenerator(), config, lang);
  cmGeneratorExpressionDAGChecker dagChecker{
    this->Target, "INCLUDE_DIRECTORIES", nullptr, nullptr, context,
  };

  cm::EvaluatedTargetPropertyEntries entries =
    cm::EvaluateTargetPropertyEntries(this->Target, context, &dagChecker,
                                      this->InterfaceIncludeDirectories);
  auto includes = ProcessIncludes(this->Target, this->GetName(),
                                  "INTERFACE_INCLUDE_DIRECTORIES"_s, entries);
  this->InterfaceIncludeDirectoriesCache.emplace(cacheKey, includes);

  return includes;
}

std::vector<BT<std::string>> cmGeneratorFileSet::GetCompileOptions(
  std::string const& config, std::string const& language) const
{
  ConfigAndLanguage cacheKey(config, language);
  {
    auto it = this->CompileOptionsCache.find(cacheKey);
    if (it != this->CompileOptionsCache.end()) {
      return it->second;
    }
  }

  cm::GenEx::Context context(this->Target->GetLocalGenerator(), config,
                             language);
  cmGeneratorExpressionDAGChecker dagChecker{
    this->Target, "COMPILE_OPTIONS", nullptr, nullptr, context,
  };

  cm::EvaluatedTargetPropertyEntries entries =
    cm::EvaluateTargetPropertyEntries(this->Target, context, &dagChecker,
                                      this->CompileOptions);
  auto options = ProcessOptions(entries, OptionsParse::Shell);
  this->CompileOptionsCache.emplace(cacheKey, options);

  return options;
}
std::vector<BT<std::string>> cmGeneratorFileSet::GetInterfaceCompileOptions(
  std::string const& config, std::string const& language) const
{
  ConfigAndLanguage cacheKey(config, language);
  {
    auto it = this->InterfaceCompileOptionsCache.find(cacheKey);
    if (it != this->InterfaceCompileOptionsCache.end()) {
      return it->second;
    }
  }

  cm::GenEx::Context context(this->Target->GetLocalGenerator(), config,
                             language);
  cmGeneratorExpressionDAGChecker dagChecker{
    this->Target, "COMPILE_OPTIONS", nullptr, nullptr, context,
  };

  cm::EvaluatedTargetPropertyEntries entries =
    cm::EvaluateTargetPropertyEntries(this->Target, context, &dagChecker,
                                      this->InterfaceCompileOptions);
  auto options = ProcessOptions(entries, OptionsParse::Shell);
  this->InterfaceCompileOptionsCache.emplace(cacheKey, options);

  return options;
}

std::vector<BT<std::string>> cmGeneratorFileSet::GetCompileDefinitions(
  std::string const& config, std::string const& language) const
{
  ConfigAndLanguage cacheKey(config, language);
  {
    auto it = this->CompileDefinitionsCache.find(cacheKey);
    if (it != this->CompileDefinitionsCache.end()) {
      return it->second;
    }
  }

  cm::GenEx::Context context(this->Target->GetLocalGenerator(), config,
                             language);
  cmGeneratorExpressionDAGChecker dagChecker{
    this->Target, "COMPILE_DEFINITIONS", nullptr, nullptr, context,
  };

  cm::EvaluatedTargetPropertyEntries entries =
    cm::EvaluateTargetPropertyEntries(this->Target, context, &dagChecker,
                                      this->CompileDefinitions);
  auto defines = ProcessOptions(entries);
  this->CompileDefinitionsCache.emplace(cacheKey, defines);

  return defines;
}
std::vector<BT<std::string>>
cmGeneratorFileSet::GetInterfaceCompileDefinitions(
  std::string const& config, std::string const& language) const
{
  ConfigAndLanguage cacheKey(config, language);
  {
    auto it = this->InterfaceCompileDefinitionsCache.find(cacheKey);
    if (it != this->InterfaceCompileDefinitionsCache.end()) {
      return it->second;
    }
  }

  cm::GenEx::Context context(this->Target->GetLocalGenerator(), config,
                             language);
  cmGeneratorExpressionDAGChecker dagChecker{
    this->Target, "COMPILE_DEFINITIONS", nullptr, nullptr, context,
  };

  cm::EvaluatedTargetPropertyEntries entries =
    cm::EvaluateTargetPropertyEntries(this->Target, context, &dagChecker,
                                      this->InterfaceCompileDefinitions);
  auto defines = ProcessOptions(entries);
  this->InterfaceCompileDefinitionsCache.emplace(cacheKey, defines);

  return defines;
}

std::vector<BT<std::string>> const& cmGeneratorFileSet::GetDirectoryEntries()
  const
{
  return this->FileSet->GetDirectoryEntries();
}

std::vector<BT<std::string>> const& cmGeneratorFileSet::GetFileEntries() const
{
  return this->FileSet->GetFileEntries();
}

std::vector<std::unique_ptr<cmCompiledGeneratorExpression>> const&
cmGeneratorFileSet::CompileFileEntries() const
{
  std::unordered_set<std::string> uniqueSrcs;

  if (this->CompiledFileEntries.empty() &&
      !this->FileSet->GetFileEntries().empty()) {
    for (auto const& entry : this->FileSet->GetFileEntries()) {
      for (auto const& ex : cmList{ entry.Value }) {
        if (uniqueSrcs.insert(ex).second) {
          cmGeneratorExpression ge(
            *this->FileSet->GetMakefile()->GetCMakeInstance(),
            entry.Backtrace);
          auto cge = ge.Parse(ex);
          this->CompiledFileEntries.push_back(std::move(cge));
        }
      }
    }
  }

  return this->CompiledFileEntries;
}

std::vector<std::unique_ptr<cmCompiledGeneratorExpression>> const&
cmGeneratorFileSet::CompileDirectoryEntries() const
{
  if (this->CompiledDirectoryEntries.empty() &&
      !this->FileSet->GetDirectoryEntries().empty()) {
    for (auto const& entry : this->FileSet->GetDirectoryEntries()) {
      for (auto const& ex : cmList{ entry.Value }) {
        cmGeneratorExpression ge(
          *this->FileSet->GetMakefile()->GetCMakeInstance(), entry.Backtrace);
        auto cge = ge.Parse(ex);
        this->CompiledDirectoryEntries.push_back(std::move(cge));
      }
    }
  }

  return this->CompiledDirectoryEntries;
}

std::vector<std::string> cmGeneratorFileSet::EvaluateDirectoryEntries(
  std::vector<std::unique_ptr<cmCompiledGeneratorExpression>> const& cges,
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  struct DirCacheEntry
  {
    std::string collapsedDir;
    cm::optional<cmSystemTools::FileId> fileId;
  };

  std::unordered_map<std::string, DirCacheEntry> dirCache;
  std::vector<std::string> result;
  for (auto const& cge : cges) {
    auto entry = cge->Evaluate(context, dagChecker, target);
    cmList dirs{ entry };
    for (std::string dir : dirs) {
      if (!cmSystemTools::FileIsFullPath(dir)) {
        dir = cmStrCat(context.LG->GetCurrentSourceDirectory(), '/', dir);
      }

      auto dirCacheResult = dirCache.emplace(dir, DirCacheEntry());
      auto& dirCacheEntry = dirCacheResult.first->second;
      auto const isNewCacheEntry = dirCacheResult.second;

      if (isNewCacheEntry) {
        cmSystemTools::FileId fileId;
        auto isFileIdValid = cmSystemTools::GetFileId(dir, fileId);
        dirCacheEntry.collapsedDir = cmSystemTools::CollapseFullPath(dir);
        dirCacheEntry.fileId =
          isFileIdValid ? cm::optional<decltype(fileId)>(fileId) : cm::nullopt;
      }

      for (auto const& priorDir : result) {
        auto priorDirCacheEntry = dirCache.at(priorDir);
        bool sameFile = dirCacheEntry.fileId.has_value() &&
          priorDirCacheEntry.fileId.has_value() &&
          (*dirCacheEntry.fileId == *priorDirCacheEntry.fileId);
        if (!sameFile &&
            (cmSystemTools::IsSubDirectory(dirCacheEntry.collapsedDir,
                                           priorDirCacheEntry.collapsedDir) ||
             cmSystemTools::IsSubDirectory(priorDirCacheEntry.collapsedDir,
                                           dirCacheEntry.collapsedDir))) {
          context.LG->GetCMakeInstance()->IssueMessage(
            MessageType::FATAL_ERROR,
            cmStrCat(
              "Base directories in file set cannot be subdirectories of each "
              "other:\n  ",
              priorDir, "\n  ", dir),
            cge->GetBacktrace());
          return {};
        }
      }
      result.push_back(dir);
    }
  }
  return result;
}

void cmGeneratorFileSet::EvaluateFileEntry(
  std::vector<std::string> const& dirs,
  std::map<std::string, std::vector<std::string>>& filesPerDir,
  std::unique_ptr<cmCompiledGeneratorExpression> const& cge,
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  auto files = cge->Evaluate(context, dagChecker, target);
  for (std::string file : cmList{ files }) {
    if (!cmSystemTools::FileIsFullPath(file)) {
      file = cmStrCat(context.LG->GetCurrentSourceDirectory(), '/', file);
    }
    auto collapsedFile = cmSystemTools::CollapseFullPath(file);
    bool found = false;
    std::string relDir;
    for (auto const& dir : dirs) {
      auto collapsedDir = cmSystemTools::CollapseFullPath(dir);
      if (cmSystemTools::IsSubDirectory(collapsedFile, collapsedDir)) {
        found = true;
        relDir = cmSystemTools::GetParentDirectory(
          cmSystemTools::RelativePath(collapsedDir, collapsedFile));
        break;
      }
    }
    if (!found) {
      std::ostringstream e;
      e << "File:\n  " << file
        << "\nmust be in one of the file set's base directories:";
      for (auto const& dir : dirs) {
        e << "\n  " << dir;
      }
      context.LG->GetCMakeInstance()->IssueMessage(
        MessageType::FATAL_ERROR, e.str(), cge->GetBacktrace());
      return;
    }

    filesPerDir[relDir].push_back(file);
  }
}

namespace {
bool EntryIsContextSensitive(
  std::unique_ptr<cmCompiledGeneratorExpression> const& cge)
{
  return cge->GetHadContextSensitiveCondition();
}
}

std::vector<std::unique_ptr<cm::TargetPropertyEntry>>
cmGeneratorFileSet::GetSources(
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  std::vector<std::unique_ptr<TargetPropertyEntry>> entries;

  auto directories = this->GetDirectories(context, target, dagChecker);
  bool contextSensitive = directories.second;

  for (auto const& entry : this->CompileFileEntries()) {
    auto propEntry = FileSetPropertyEntry::CreateFileSetEntry(
      directories.first, contextSensitive, entry, this);
    entries.push_back(std::move(propEntry));
  }

  return entries;
}

std::pair<std::vector<std::string>, bool> cmGeneratorFileSet::GetDirectories(
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  auto const& directoryEntries = this->CompileDirectoryEntries();
  auto directories = this->EvaluateDirectoryEntries(directoryEntries, context,
                                                    target, dagChecker);
  bool contextSensitive = std::any_of(
    directoryEntries.begin(), directoryEntries.end(), EntryIsContextSensitive);

  return std::make_pair(std::move(directories), contextSensitive);
}

std::pair<std::map<std::string, std::vector<std::string>>, bool>
cmGeneratorFileSet::GetFiles(cm::GenEx::Context const& context,
                             cmGeneratorTarget const* target,
                             cmGeneratorExpressionDAGChecker* dagChecker) const
{
  auto directories = this->GetDirectories(context, target, dagChecker);

  auto const& fileEntries = this->CompileFileEntries();
  std::map<std::string, std::vector<std::string>> files;
  for (auto const& entry : fileEntries) {
    this->EvaluateFileEntry(directories.first, files, entry, context, target,
                            dagChecker);
  }
  bool contextSensitive = directories.second ||
    std::any_of(fileEntries.begin(), fileEntries.end(),
                EntryIsContextSensitive);

  return std::make_pair(std::move(files), contextSensitive);
}