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

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

/* clang-format off */

#include "cmGeneratorTarget.h"

/* clang-format on */

#include <map>

#include <string>

#include <unordered_set>

#include <utility>

#include <vector>

#include <cmext/algorithm>

#include "cmEvaluatedTargetProperty.h"

#include "cmGenExContext.h"

#include "cmGeneratorExpressionDAGChecker.h"

#include "cmLinkItem.h"

#include "cmList.h"

#include "cmListFileCache.h"

#include "cmLocalGenerator.h"

#include "cmMakefile.h"

#include "cmMessageType.h"

#include "cmPolicies.h"

#include "cmStringAlgorithms.h"

#include "cmSystemTools.h"

#include "cmValue.h"

#include "cmake.h"

namespace {

void processLinkDirectories(cmGeneratorTarget const* tgt,

                            cm::EvaluatedTargetPropertyEntries& entries,

                            std::vector<BT<std::string>>& directories,

                            std::unordered_set<std::string>& uniqueDirectories,

                            bool debugDirectories)

{

  for (cm::EvaluatedTargetPropertyEntry& entry : entries.Entries) {

    cmLinkItem const& item = entry.LinkItem;

    std::string const& targetName = item.AsStr();

    std::string usedDirectories;

    for (std::string& entryDirectory : entry.Values) {

      if (!cmSystemTools::FileIsFullPath(entryDirectory)) {

        if (!targetName.empty()) {

          tgt->GetLocalGenerator()->IssueMessage(

            MessageType::FATAL_ERROR,

            cmStrCat("Target \"", targetName,

                     "\" contains relative path"

                     " in its INTERFACE_LINK_DIRECTORIES:\n  \"",

                     entryDirectory, "\""));

          return;

        }

        switch (tgt->GetPolicyStatusCMP0081()) {

          case cmPolicies::WARN:

            tgt->GetLocalGenerator()->IssuePolicyWarning(

              cmPolicies::CMP0081, {},

              cmStrCat("Found relative path while evaluating"

                       " link directories of \"",

                       tgt->GetName(), "\":\n  \"", entryDirectory, "\"\n"));

            break;

          case cmPolicies::OLD:

            break;

          case cmPolicies::NEW:

            tgt->GetLocalGenerator()->IssueMessage(

              MessageType::FATAL_ERROR,

              cmStrCat("Found relative path while evaluating"

                       " link directories of \"",

                       tgt->GetName(), "\":\n  \"", entryDirectory, "\"\n"));

            return;

        }

      }

      // Sanitize the path the same way the link_directories command does

      // in case projects set the LINK_DIRECTORIES property directly.

      cmSystemTools::ConvertToUnixSlashes(entryDirectory);

      if (uniqueDirectories.insert(entryDirectory).second) {

        directories.emplace_back(entryDirectory, entry.Backtrace);

        if (debugDirectories) {

          usedDirectories += cmStrCat(" * ", entryDirectory, '\n');

        }

      }

    }

    if (!usedDirectories.empty()) {

      tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(

        MessageType::LOG,

        cmStrCat("Used link directories for target ", tgt->GetName(), ":\n",

                 usedDirectories),

        entry.Backtrace);

    }

  }

}

}

void cmGeneratorTarget::GetLinkDirectories(std::vector<std::string>& result,

                                           std::string const& config,

                                           std::string const& language) const

{

  std::vector<BT<std::string>> tmp =

    this->GetLinkDirectories(config, language);

  result.reserve(tmp.size());

  for (BT<std::string>& v : tmp) {

    result.emplace_back(std::move(v.Value));

  }

}

std::vector<BT<std::string>> cmGeneratorTarget::GetLinkDirectories(

  std::string const& config, std::string const& language) const

{

  ConfigAndLanguage cacheKey(

    config, cmStrCat(language, this->IsDeviceLink() ? "-device" : ""));

  {

    auto it = this->LinkDirectoriesCache.find(cacheKey);

    if (it != this->LinkDirectoriesCache.end()) {

      return it->second;

    }

  }

  std::vector<BT<std::string>> result;

  std::unordered_set<std::string> uniqueDirectories;

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

  cmGeneratorExpressionDAGChecker dagChecker{

    this, "LINK_DIRECTORIES", nullptr, nullptr, context,

  };

  cmList debugProperties{ this->Makefile->GetDefinition(

    "CMAKE_DEBUG_TARGET_PROPERTIES") };

  bool debugDirectories = !this->DebugLinkDirectoriesDone &&

    cm::contains(debugProperties, "LINK_DIRECTORIES");

  this->DebugLinkDirectoriesDone = true;

  cm::EvaluatedTargetPropertyEntries entries =

    cm::EvaluateTargetPropertyEntries(this, context, &dagChecker,

                                      this->LinkDirectoriesEntries);

  AddInterfaceEntries(this, "INTERFACE_LINK_DIRECTORIES", context, &dagChecker,

                      entries, cm::IncludeRuntimeInterface::Yes,

                      this->GetPolicyStatusCMP0099() == cmPolicies::NEW

                        ? UseTo::Link

                        : UseTo::Compile);

  processLinkDirectories(this, entries, result, uniqueDirectories,

                         debugDirectories);

  this->LinkDirectoriesCache.emplace(cacheKey, result);

  return result;

}