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

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

#include "cmExportInstallPackageInfoGenerator.h"

#include <functional>

#include <map>

#include <memory>

#include <set>

#include <sstream>

#include <utility>

#include <vector>

#include <cm/optional>

#include <cm/string_view>

#include <cmext/algorithm>

#include <cmext/string_view>

#include <cm3p/json/value.h>

#include "cmAlgorithms.h"

#include "cmExportSet.h"

#include "cmFileSet.h"

#include "cmGeneratorExpression.h"

#include "cmGeneratorTarget.h"

#include "cmInstallExportGenerator.h"

#include "cmInstallFileSetGenerator.h"

#include "cmList.h"

#include "cmLocalGenerator.h"

#include "cmMakefile.h"

#include "cmMessageType.h"

#include "cmOutputConverter.h"

#include "cmPackageInfoArguments.h"

#include "cmStateTypes.h"

#include "cmStringAlgorithms.h"

#include "cmSystemTools.h"

#include "cmTarget.h"

#include "cmTargetExport.h"

cmExportInstallPackageInfoGenerator::cmExportInstallPackageInfoGenerator(

  cmInstallExportGenerator* iegen, cmPackageInfoArguments arguments)

  : cmExportPackageInfoGenerator(std::move(arguments))

  , cmExportInstallFileGenerator(iegen)

{

}

Unexecuted instantiation: cmExportInstallPackageInfoGenerator::cmExportInstallPackageInfoGenerator(cmInstallExportGenerator*, cmPackageInfoArguments)

Unexecuted instantiation: cmExportInstallPackageInfoGenerator::cmExportInstallPackageInfoGenerator(cmInstallExportGenerator*, cmPackageInfoArguments)

std::string cmExportInstallPackageInfoGenerator::GetConfigImportFileGlob()

  const

{

  std::string glob = cmStrCat(this->FileBase, "@*", this->FileExt);

  return glob;

}

std::string const& cmExportInstallPackageInfoGenerator::GetExportName() const

{

  return this->GetPackageName();

}

bool cmExportInstallPackageInfoGenerator::GenerateMainFile(std::ostream& os)

{

  std::vector<cmTargetExport const*> allTargets;

  {

    auto visitor = [&](cmTargetExport const* te) { allTargets.push_back(te); };

    if (!this->CollectExports(visitor)) {

      return false;

    }

  }

  if (!this->CheckPackage()) {

    return false;

  }

  Json::Value root = this->GeneratePackageInfo();

  Json::Value& components = root["components"];

  // Compute the relative import prefix for the file

  std::string const& packagePath = this->GenerateImportPrefix();

  if (packagePath.empty()) {

    return false;

  }

  root["cps_path"] = packagePath;

  // Create all the imported targets.

  for (cmTargetExport const* te : allTargets) {

    cmGeneratorTarget* gt = te->Target;

    cmStateEnums::TargetType targetType = this->GetExportTargetType(te);

    Json::Value* const component =

      this->GenerateImportTarget(components, gt, targetType);

    if (!component) {

      return false;

    }

    ImportPropertyMap properties;

    if (!this->PopulateInterfaceProperties(te, properties)) {

      return false;

    }

    this->PopulateInterfaceLinkLibrariesProperty(

      gt, cmGeneratorExpression::InstallInterface, properties);

    if (targetType != cmStateEnums::INTERFACE_LIBRARY) {

      this->RequiresConfigFiles = true;

    }

    // De-duplicate include directories prior to generation.

    auto it = properties.find("INTERFACE_INCLUDE_DIRECTORIES");

    if (it != properties.end()) {

      auto list = cmList{ it->second };

      list = cmList{ list.begin(), cmRemoveDuplicates(list) };

      properties["INTERFACE_INCLUDE_DIRECTORIES"] = list.to_string();

    }

    // Set configuration-agnostic properties for component.

    this->GenerateInterfaceProperties(*component, gt, properties);

    if (!this->GenerateFileSetProperties(*component, gt, te, packagePath)) {

      return false;

    }

  }

  this->GeneratePackageRequires(root);

  // Write the primary packing information file.

  this->WritePackageInfo(root, os);

  bool result = true;

  // Generate an import file for each configuration.

  if (this->RequiresConfigFiles) {

    for (std::string const& c : this->Configurations) {

      if (!this->GenerateImportFileConfig(c)) {

        result = false;

      }

    }

  }

  return result;

}

void cmExportInstallPackageInfoGenerator::GenerateImportTargetsConfig(

  std::ostream& os, std::string const& config, std::string const& suffix)

{

  Json::Value root;

  root["name"] = this->GetPackageName();

  root["configuration"] = (config.empty() ? "noconfig" : config);

  std::string const& packagePath = this->GenerateImportPrefix();

  Json::Value& components = root["components"];

  for (auto const& te : this->GetExportSet()->GetTargetExports()) {

    // Collect import properties for this target.

    ImportPropertyMap properties;

    std::set<std::string> importedLocations;

    if (this->GetExportTargetType(te.get()) !=

        cmStateEnums::INTERFACE_LIBRARY) {

      this->PopulateImportProperties(config, suffix, te.get(), properties,

                                     importedLocations);

    }

    Json::Value component =

      this->GenerateInterfaceConfigProperties(suffix, properties);

    this->GenerateFileSetProperties(component, te->Target, te.get(),

                                    packagePath, config);

    if (!component.empty()) {

      components[te->Target->GetExportName()] = std::move(component);

    }

  }

  this->WritePackageInfo(root, os);

}

std::string cmExportInstallPackageInfoGenerator::GenerateImportPrefix() const

{

  std::string expDest = this->IEGen->GetDestination();

  if (cmSystemTools::FileIsFullPath(expDest)) {

    std::string const& installPrefix =

      this->IEGen->GetLocalGenerator()->GetMakefile()->GetSafeDefinition(

        "CMAKE_INSTALL_PREFIX");

    if (cmHasPrefix(expDest, installPrefix)) {

      auto n = installPrefix.length();

      while (n < expDest.length() && expDest[n] == '/') {

        ++n;

      }

      expDest = expDest.substr(n);

    } else {

      this->ReportError(

        cmStrCat("install(PACKAGE_INFO \"", this->GetExportName(),

                 "\" ...) specifies DESTINATION \"", expDest,

                 "\" which is not a subdirectory of the install prefix."));

      return {};

    }

  }

  if (expDest.empty()) {

    return this->GetInstallPrefix();

  }

  return cmStrCat(this->GetImportPrefixWithSlash(), expDest);

}

std::string cmExportInstallPackageInfoGenerator::InstallNameDir(

  cmGeneratorTarget const* target, std::string const& config)

{

  std::string install_name_dir;

  cmMakefile* mf = target->Target->GetMakefile();

  if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {

    install_name_dir =

      target->GetInstallNameDirForInstallTree(config, "@prefix@");

  }

  return install_name_dir;

}

std::string cmExportInstallPackageInfoGenerator::GetCxxModulesDirectory() const

{

  return IEGen->GetCxxModuleDirectory();

}

cm::optional<std::string>

cmExportInstallPackageInfoGenerator::GetFileSetDirectory(

  cmGeneratorTarget* gte, cmTargetExport const* te, cmFileSet* fileSet,

  cm::optional<std::string> const& config)

{

  cmGeneratorExpression ge(*gte->Makefile->GetCMakeInstance());

  auto cge =

    ge.Parse(te->FileSetGenerators.at(fileSet->GetName())->GetDestination());

  std::string const unescapedDest =

    cge->Evaluate(gte->LocalGenerator, config.value_or(""), gte);

  bool const isConfigDependent = cge->GetHadContextSensitiveCondition();

  if (config && !isConfigDependent) {

    return {};

  }

  if (!config && isConfigDependent) {

    this->RequiresConfigFiles = true;

    return {};

  }

  std::string const& type = fileSet->GetType();

  if (config && (type == "CXX_MODULES"_s)) {

    // C++ modules do not support interface file sets which are dependent

    // upon the configuration.

    cmMakefile* mf = gte->LocalGenerator->GetMakefile();

    std::ostringstream e;

    e << "The \"" << gte->GetName() << "\" target's interface file set \""

      << fileSet->GetName() << "\" of type \"" << type

      << "\" contains context-sensitive base file entries which is not "

         "supported.";

    mf->IssueMessage(MessageType::FATAL_ERROR, e.str());

    return {};

  }

  cm::optional<std::string> dest = cmOutputConverter::EscapeForCMake(

    unescapedDest, cmOutputConverter::WrapQuotes::NoWrap);

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

    dest = cmStrCat("@prefix@/"_s, *dest);

  }

  return dest;

}

bool cmExportInstallPackageInfoGenerator::GenerateFileSetProperties(

  Json::Value& component, cmGeneratorTarget* gte, cmTargetExport const* te,

  std::string const& packagePath, cm::optional<std::string> config)

{

  bool hasModules = false;

  std::set<std::string> seenIncludeDirectories;

  for (auto const& name : gte->Target->GetAllInterfaceFileSets()) {

    cmFileSet* fileSet = gte->Target->GetFileSet(name);

    if (!fileSet) {

      gte->Makefile->IssueMessage(

        MessageType::FATAL_ERROR,

        cmStrCat("File set \"", name,

                 "\" is listed in interface file sets of ", gte->GetName(),

                 " but has not been created"));

      return false;

    }

    cm::optional<std::string> const& fileSetDirectory =

      this->GetFileSetDirectory(gte, te, fileSet, config);

    if (fileSet->GetType() == "HEADERS"_s) {

      if (fileSetDirectory &&

          !cm::contains(seenIncludeDirectories, *fileSetDirectory)) {

        component["includes"].append(*fileSetDirectory);

        seenIncludeDirectories.insert(*fileSetDirectory);

      }

    } else if (fileSet->GetType() == "CXX_MODULES"_s) {

      hasModules = true;

      this->RequiresConfigFiles = true;

    }

  }

  if (hasModules && config) {

    std::string const manifestPath =

      this->GenerateCxxModules(component, gte, packagePath, *config);

    if (!manifestPath.empty()) {

      this->ConfigCxxModuleFiles[*config] =

        cmStrCat(this->FileDir, '/', manifestPath);

    }

  }

  return true;

}