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

#include <algorithm>
#include <iterator>
#include <map>
#include <unordered_set>
#include <utility>
#include <vector>

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

#include "cmFileSet.h"
#include "cmGenExContext.h"
#include "cmGenExEvaluation.h"
#include "cmGeneratorExpression.h"
#include "cmGeneratorExpressionDAGChecker.h"
#include "cmGeneratorExpressionNode.h"
#include "cmGeneratorFileSet.h"
#include "cmGeneratorTarget.h"
#include "cmLinkItem.h"
#include "cmList.h"
#include "cmListFileCache.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmSourceFile.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include "cmValue.h"

cmGeneratorFileSets::cmGeneratorFileSets(cmGeneratorTarget* target,
                                         cmLocalGenerator* lg)
  : Target(target)
  , LocalGenerator(lg)
{
  bool isFramework = target->IsFrameworkOnApple();
  auto issueMessage = [&target](cmFileSet const* fileSet) {
    target->Makefile->IssueMessage(
      MessageType::FATAL_ERROR,
      cmStrCat(R"(The file set ")", fileSet->GetName(), R"(",  of type ")",
               fileSet->GetType(),
               R"(", is incompatible with the "FRAMEWORK" target ")",
               target->GetName(), R"(".)"));
  };

  for (auto domain : cm::FileSetMetadata::AllFileSetDomains) {
    for (auto const& name : target->Target->GetAllPrivateFileSets(domain)) {
      cmFileSet const* fileSet = target->Target->GetFileSet(name);
      if (isFramework &&
          !cm::FileSetMetadata::IsFrameworkSupported(fileSet->GetType())) {
        issueMessage(fileSet);
        continue;
      }
      auto entry = this->FileSets.emplace(
        name, cm::make_unique<cmGeneratorFileSet>(target, fileSet, domain));
      auto const* genFileSet = entry.first->second.get();
      this->AllFileSets.push_back(genFileSet);
      this->SelfFileSets[genFileSet->GetType()].push_back(genFileSet);
    }
    for (auto const& name : target->Target->GetAllInterfaceFileSets(domain)) {
      auto it = this->FileSets.find(name);
      cmGeneratorFileSet const* genFileSet = nullptr;
      if (it == this->FileSets.end()) {
        cmFileSet const* fileSet = target->Target->GetFileSet(name);
        if (isFramework &&
            !cm::FileSetMetadata::IsFrameworkSupported(fileSet->GetType())) {
          issueMessage(fileSet);
          continue;
        }
        auto entry = this->FileSets.emplace(
          name, cm::make_unique<cmGeneratorFileSet>(target, fileSet, domain));
        genFileSet = entry.first->second.get();
        this->AllFileSets.push_back(genFileSet);
      } else {
        genFileSet = it->second.get();
      }
      this->InterfaceFileSets[genFileSet->GetType()].push_back(genFileSet);
    }
  }
}
cmGeneratorFileSets::~cmGeneratorFileSets() = default;

std::vector<cm::string_view> cmGeneratorFileSets::GetFileSetTypes() const
{
  return cm::keys(this->SelfFileSets);
}

std::vector<cm::string_view> cmGeneratorFileSets::GetInterfaceFileSetTypes()
  const
{
  return cm::keys(this->InterfaceFileSets);
}

std::vector<cmGeneratorFileSet const*> const&
cmGeneratorFileSets::GetAllFileSets() const
{
  return this->AllFileSets;
}

namespace {
std::vector<cmGeneratorFileSet const*> NoFileSets;
}

std::vector<cmGeneratorFileSet const*> const& cmGeneratorFileSets::GetFileSets(
  cm::string_view type) const
{
  auto it = this->SelfFileSets.find(type);
  if (it != this->SelfFileSets.end()) {
    return it->second;
  }
  return NoFileSets;
}
std::vector<cmGeneratorFileSet const*> const&
cmGeneratorFileSets::GetInterfaceFileSets(cm::string_view type) const
{
  auto it = this->InterfaceFileSets.find(type);
  if (it != this->InterfaceFileSets.end()) {
    return it->second;
  }
  return NoFileSets;
}

cmGeneratorFileSet const* cmGeneratorFileSets::GetFileSet(
  std::string const& name) const
{
  auto const it = this->FileSets.find(name);
  if (it != this->FileSets.end()) {
    return it->second.get();
  }
  return nullptr;
}

std::unordered_set<cmGeneratorFileSet const*> const&
cmGeneratorFileSets::GetAllFileSetsForSource(std::string const& config,
                                             std::string const& path) const
{
  this->BuildInfoCache(config);

  auto const& info = this->Configs[config];

  auto const it = info.FileSetCache.find(path);
  if (it != info.FileSetCache.end()) {
    return it->second;
  }

  // search in all the dependents
  auto const it2 = info.InterfaceFileSetCache.find(path);
  if (it2 != info.InterfaceFileSetCache.end()) {
    return it2->second;
  }

  static std::unordered_set<cmGeneratorFileSet const*> emptySet;
  return emptySet;
}
std::unordered_set<cmGeneratorFileSet const*> const&
cmGeneratorFileSets::GetAllFileSetsForSource(std::string const& config,
                                             cmSourceFile const* sf) const
{
  return this->GetAllFileSetsForSource(config, sf->GetFullPath());
}

cmGeneratorFileSet const* cmGeneratorFileSets::GetFileSetForSource(
  std::string const& config, std::string const& file) const
{
  this->BuildInfoCache(config);
  auto const& info = this->Configs[config];

  using FileSetCache =
    std::map<std::string, std::unordered_set<cmGeneratorFileSet const*>>;
  auto lookup = [&file](FileSetCache const& cache, bool nonHeaderOnly) {
    auto const entry = cache.find(file);
    if (entry == cache.end()) {
      return static_cast<cmGeneratorFileSet const*>(nullptr);
    }
    auto const fileSet =
      std::find_if(entry->second.begin(), entry->second.end(),
                   [nonHeaderOnly](cmGeneratorFileSet const* candidate) {
                     return !nonHeaderOnly ||
                       candidate->GetType() != cm::FileSetMetadata::HEADERS;
                   });
    return fileSet == entry->second.end() ? nullptr : *fileSet;
  };

  if (auto const* fileSet = lookup(info.FileSetCache, true)) {
    return fileSet;
  }
  if (auto const* fileSet = lookup(info.InterfaceFileSetCache, true)) {
    return fileSet;
  }
  if (auto const* fileSet = lookup(info.FileSetCache, false)) {
    return fileSet;
  }
  return lookup(info.InterfaceFileSetCache, false);
}
cmGeneratorFileSet const* cmGeneratorFileSets::GetFileSetForSource(
  std::string const& config, cmSourceFile const* sf) const
{
  return this->GetFileSetForSource(config, sf->GetFullPath());
}

cm::optional<std::string> cmGeneratorFileSets::GetLanguageForSource(
  std::string const& config, cmSourceFile const* sf) const
{
  this->BuildInfoCache(config);
  auto const& languages = this->Configs[config].LanguageCache;
  auto const language = languages.find(sf->GetFullPath());
  if (language == languages.end()) {
    return cm::nullopt;
  }
  return language->second;
}

bool cmGeneratorFileSets::HasSyclHeaders(std::string const& config) const
{
  this->BuildInfoCache(config);
  return this->Configs[config].HasSyclHeaders;
}

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

  for (auto const& entry : this->FileSets) {
    auto const* fileSet = entry.second.get();
    if (include(fileSet)) {
      auto sources = fileSet->GetSources(context, target, dagChecker);
      std::move(sources.begin(), sources.end(), std::back_inserter(entries));
    }
  }

  return entries;
}

std::vector<std::unique_ptr<cm::TargetPropertyEntry>>
cmGeneratorFileSets::GetSources(
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cm::FileSetMetadata::FileSetDomainSet domains,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  return this->GetSources(
    [&domains](cmGeneratorFileSet const* fileSet) -> bool {
      return fileSet->IsForSelf() && domains.contains(fileSet->GetDomain());
    },
    context, target, dagChecker);
}
std::vector<std::unique_ptr<cm::TargetPropertyEntry>>
cmGeneratorFileSets::GetSources(
  std::string type, cm::GenEx::Context const& context,
  cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  return this->GetSources(
    [&type](cmGeneratorFileSet const* fileSet) -> bool {
      return fileSet->IsForSelf() && fileSet->GetType() == type;
    },
    context, target, dagChecker);
}

std::vector<std::unique_ptr<cm::TargetPropertyEntry>>
cmGeneratorFileSets::GetInterfaceSources(
  cm::GenEx::Context const& context, cmGeneratorTarget const* target,
  cm::FileSetMetadata::FileSetDomainSet domains,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  return this->GetSources(
    [&domains](cmGeneratorFileSet const* fileSet) -> bool {
      return fileSet->IsForInterface() &&
        domains.contains(fileSet->GetDomain());
    },
    context, target, dagChecker);
}
std::vector<std::unique_ptr<cm::TargetPropertyEntry>>
cmGeneratorFileSets::GetInterfaceSources(
  std::string type, cm::GenEx::Context const& context,
  cmGeneratorTarget const* target,
  cmGeneratorExpressionDAGChecker* dagChecker) const
{
  return this->GetSources(
    [&type](cmGeneratorFileSet const* fileSet) -> bool {
      return fileSet->IsForInterface() && fileSet->GetType() == type;
    },
    context, target, dagChecker);
}

bool cmGeneratorFileSets::MaybeHaveInterfaceProperty(
  cm::string_view type, std::string const& prop,
  cm::GenEx::Evaluation* eval) const
{
  std::string const key =
    cmStrCat(type, "::", prop, '@', eval->Context.Config);
  auto i = this->MaybeInterfacePropertyExists.find(key);
  if (i == this->MaybeInterfacePropertyExists.end()) {
    // Insert an entry now in case there is a cycle.
    i = this->MaybeInterfacePropertyExists.emplace(key, false).first;
    bool& maybeInterfaceProp = i->second;

    for (auto const* fileSet : this->GetInterfaceFileSets(type)) {
      // If this file set itself has a non-empty property value, we are done.
      maybeInterfaceProp = !fileSet->GetProperty(prop).IsEmpty();
      if (maybeInterfaceProp) {
        break;
      }
    }

    // Otherwise, recurse to interface dependencies.
    if (!maybeInterfaceProp) {
      cmGeneratorTarget const* headTarget =
        eval->HeadTarget ? eval->HeadTarget : this->Target;
      if (cmLinkInterfaceLibraries const* iface =
            this->Target->GetLinkInterfaceLibraries(
              eval->Context.Config, headTarget,
              cmGeneratorTarget::UseTo::Compile)) {
        if (iface->HadHeadSensitiveCondition) {
          // With a different head target we may get to a library with
          // this interface property.
          maybeInterfaceProp = true;
        } else {
          // The transitive interface libraries do not depend on the
          // head target, so we can follow them.
          for (cmLinkItem const& lib : iface->Libraries) {
            if (lib.Target &&
                lib.Target->GetGeneratorFileSets()->MaybeHaveInterfaceProperty(
                  type, prop, eval)) {
              maybeInterfaceProp = true;
              break;
            }
          }
        }
      }
    }
  }
  return i->second;
}

std::string cmGeneratorFileSets::EvaluateInterfaceProperty(
  cm::string_view type, std::string const& prop, cm::GenEx::Evaluation* eval,
  cmGeneratorExpressionDAGChecker* dagCheckerParent) const
{
  // If the property does not appear transitively at all, we are done.
  if (!this->MaybeHaveInterfaceProperty(type, prop, eval)) {
    return std::string{};
  }

  cmList result;
  cmGeneratorExpressionDAGChecker dagChecker{
    this->Target,     prop,          nullptr,
    dagCheckerParent, eval->Context, eval->Backtrace,
  };
  switch (dagChecker.Check()) {
    case cmGeneratorExpressionDAGChecker::SELF_REFERENCE:
      dagChecker.ReportError(
        eval,
        cmStrCat("$<FILE_SET_PROPERTY:*,TARGET:", this->Target->GetName(), ',',
                 prop, '>'));
      return std::string{};
    case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE:
      // No error. We just skip cyclic references.
    case cmGeneratorExpressionDAGChecker::ALREADY_SEEN:
      // No error. We have already seen this transitive property.
      return std::string{};
    case cmGeneratorExpressionDAGChecker::DAG:
      break;
  }

  cmGeneratorTarget const* headTarget =
    eval->HeadTarget ? eval->HeadTarget : this->Target;

  for (auto const* fileSet : this->GetInterfaceFileSets(type)) {
    if (cmValue p = fileSet->GetProperty(prop)) {
      result.append(cmGeneratorExpressionNode::EvaluateDependentExpression(
        *p, eval, headTarget, &dagChecker, this->Target));
    }
  }

  if (cmLinkInterfaceLibraries const* iface =
        this->Target->GetLinkInterfaceLibraries(
          eval->Context.Config, headTarget,
          cmGeneratorTarget::UseTo::Compile)) {
    eval->HadContextSensitiveCondition = eval->HadContextSensitiveCondition ||
      iface->HadContextSensitiveCondition;
    for (cmLinkItem const& lib : iface->Libraries) {
      // Broken code can have a target in its own link interface.
      // Don't follow such link interface entries so as not to create a
      // self-referencing loop.
      if (lib.Target && lib.Target != this->Target) {
        // Pretend $<FILE_SET__PROPERTY:fileSet,TARGET:lib.Target,prop>
        // appeared in the above property and hand-evaluate it as if it were
        // compiled.
        // Create a context as cmCompiledGeneratorExpression::Evaluate does.
        cm::GenEx::Evaluation libEval(
          eval->Context, eval->Quiet, headTarget, this->Target,
          eval->EvaluateForBuildsystem, eval->Backtrace);
        std::string libResult = cmGeneratorExpression::StripEmptyListElements(
          lib.Target->GetGeneratorFileSets()->EvaluateInterfaceProperty(
            type, prop, &libEval, &dagChecker));
        if (!libResult.empty()) {
          result.append(libResult);
        }
        eval->HadContextSensitiveCondition =
          eval->HadContextSensitiveCondition ||
          libEval.HadContextSensitiveCondition;
        eval->HadHeadSensitiveCondition =
          eval->HadHeadSensitiveCondition || libEval.HadHeadSensitiveCondition;
      }
    }
  }

  return result.to_string();
}

namespace {
void GetInterfaceFiles(
  cmGeneratorTarget const* target, cmGeneratorTarget const* headTarget,
  cm::GenEx::Context const& context,
  std::unordered_set<cmGeneratorTarget const*>& targets,
  std::map<std::string, std::unordered_set<cmGeneratorFileSet const*>>& cache)
{
  namespace Metadata = cm::FileSetMetadata;

  for (auto const& type : Metadata::GetKnownTypes()) {
    auto fileSetDescriptor = Metadata::GetFileSetDescriptor(type);
    if (fileSetDescriptor &&
        fileSetDescriptor->Lookup == Metadata::FileSetLookup::Dependencies) {
      for (auto const* fileSet : target->GetInterfaceFileSets(type)) {
        auto files = fileSet->GetFiles(context, headTarget);

        for (auto const& it : files.first) {
          for (auto const& filename : it.second) {
            auto collapsedFile = cmSystemTools::CollapseFullPath(filename);
            cache[collapsedFile].insert(fileSet);
          }
        }
      }
    }
  }

  if (cmLinkInterfaceLibraries const* iface =
        target->GetLinkInterfaceLibraries(context.Config, headTarget,
                                          cmGeneratorTarget::UseTo::Compile)) {
    for (cmLinkItem const& lib : iface->Libraries) {
      if (lib.Target && lib.Target != target &&
          targets.insert(lib.Target).second) {
        GetInterfaceFiles(lib.Target, headTarget, context, targets, cache);
      }
    }
  }
}

bool HasInterfaceSyclHeaders(
  cmGeneratorTarget const* target, cmGeneratorTarget const* headTarget,
  std::string const& config,
  std::unordered_set<cmGeneratorTarget const*>& targets)
{
  for (auto const* fileSet :
       target->GetInterfaceFileSets(cm::FileSetMetadata::HEADERS)) {
    if (fileSet->GetProperty("LANGUAGE") == cm::FileSetMetadata::SYCL) {
      return true;
    }
  }

  if (cmLinkInterfaceLibraries const* iface =
        target->GetLinkInterfaceLibraries(config, headTarget,
                                          cmGeneratorTarget::UseTo::Compile)) {
    for (cmLinkItem const& lib : iface->Libraries) {
      if (lib.Target && lib.Target != target &&
          targets.insert(lib.Target).second &&
          HasInterfaceSyclHeaders(lib.Target, headTarget, config, targets)) {
        return true;
      }
    }
  }
  return false;
}
}

void cmGeneratorFileSets::BuildInfoCache(std::string const& config) const
{
  auto& info = this->Configs[config];

  if (info.BuiltCache) {
    return;
  }

  cm::GenEx::Context context(this->LocalGenerator, config);

  info.HasSyclHeaders = std::any_of(
    this->GetFileSets(cm::FileSetMetadata::HEADERS).begin(),
    this->GetFileSets(cm::FileSetMetadata::HEADERS).end(),
    [](cmGeneratorFileSet const* fileSet) {
      return fileSet->GetProperty("LANGUAGE") == cm::FileSetMetadata::SYCL;
    });

  for (auto const& item : this->FileSets) {
    auto const* fileSet = item.second.get();
    if (!fileSet->IsForSelf()) {
      continue;
    }

    auto files = fileSet->GetFiles(context, this->Target);

    for (auto const& it : files.first) {
      for (auto const& filename : it.second) {
        auto collapsedFile = cmSystemTools::CollapseFullPath(filename);
        info.FileSetCache[collapsedFile].insert(fileSet);
      }
    }
  }

  // retrieve all files inherited from dependent targets
  std::unordered_set<cmGeneratorTarget const*> targets;
  std::unordered_set<cmGeneratorTarget const*> syclHeaderTargets;

  if (cmLinkImplementationLibraries const* impl =
        this->Target->GetLinkImplementationLibraries(
          config, cmGeneratorTarget::UseTo::Compile)) {
    for (cmLinkItem const& lib : impl->Libraries) {
      if (!info.HasSyclHeaders && lib.Target &&
          syclHeaderTargets.insert(lib.Target).second) {
        info.HasSyclHeaders = HasInterfaceSyclHeaders(
          lib.Target, this->Target, config, syclHeaderTargets);
      }
      if (lib.Target && targets.insert(lib.Target).second) {
        GetInterfaceFiles(lib.Target, this->Target, context, targets,
                          info.InterfaceFileSetCache);
      }
    }
  }

  auto indexLanguages =
    [this,
     &info](std::map<std::string,
                     std::unordered_set<cmGeneratorFileSet const*>> const&
              fileSets) {
      for (auto const& file : fileSets) {
        for (auto const* fileSet : file.second) {
          if (fileSet->GetType() != cm::FileSetMetadata::SOURCES) {
            continue;
          }
          cmValue const language = fileSet->GetProperty("LANGUAGE");
          if (language.IsEmpty()) {
            continue;
          }
          auto const inserted =
            info.LanguageCache.emplace(file.first, *language);
          if (!inserted.second && inserted.first->second != *language) {
            this->LocalGenerator->IssueMessage(
              MessageType::FATAL_ERROR,
              cmStrCat("Source file\n  ", file.first,
                       "\nbelongs to multiple SOURCES file sets with "
                       "conflicting LANGUAGE properties."));
          }
        }
      }
    };
  indexLanguages(info.FileSetCache);
  indexLanguages(info.InterfaceFileSetCache);

  info.BuiltCache = true;
}