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

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

#include "cmInstallGenerator.h"

#include <algorithm>

#include <sstream>

#include <utility>

#include <cm/string_view>

#include "cmDiagnostics.h"

#include "cmGeneratorTarget.h"

#include "cmGlobalGenerator.h"

#include "cmLocalGenerator.h"

#include "cmMakefile.h"

#include "cmMessageType.h"

#include "cmStringAlgorithms.h"

#include "cmSystemTools.h"

cmInstallGenerator::cmInstallGenerator(

  std::string destination, std::vector<std::string> const& configurations,

  std::string component, MessageLevel message, bool excludeFromAll,

  bool allComponents, cmDiagnosticContext context)

  : cmScriptGenerator("CMAKE_INSTALL_CONFIG_NAME", configurations)

  , Destination(std::move(destination))

  , Component(std::move(component))

  , Message(message)

  , ExcludeFromAll(excludeFromAll)

  , AllComponents(allComponents)

  , Context{ std::move(context) }

{

}

cmInstallGenerator::~cmInstallGenerator() = default;

bool cmInstallGenerator::HaveInstall()

{

  return true;

}

void cmInstallGenerator::CheckCMP0082(bool& haveSubdirectoryInstall,

                                      bool& haveInstallAfterSubdirectory)

{

  if (haveSubdirectoryInstall) {

    haveInstallAfterSubdirectory = true;

  }

}

void cmInstallGenerator::AddInstallRule(

  std::ostream& os, std::string const& dest, cmInstallType type,

  std::vector<std::string> const& files, bool optional /* = false */,

  char const* permissionsFile /* = nullptr */,

  char const* permissionsDir /* = nullptr */,

  char const* rename /* = nullptr */, char const* literalArgs /* = nullptr */,

  Indent indent, char const* filesVar /* = nullptr */)

{

  // Use the FILE command to install the file.

  std::string stype;

  switch (type) {

    case cmInstallType_DIRECTORY:

      stype = "DIRECTORY";

      break;

    case cmInstallType_PROGRAMS:

      stype = "PROGRAM";

      break;

    case cmInstallType_EXECUTABLE:

      stype = "EXECUTABLE";

      break;

    case cmInstallType_STATIC_LIBRARY:

      stype = "STATIC_LIBRARY";

      break;

    case cmInstallType_SHARED_LIBRARY:

      stype = "SHARED_LIBRARY";

      break;

    case cmInstallType_MODULE_LIBRARY:

      stype = "MODULE";

      break;

    case cmInstallType_FILES:

      stype = "FILE";

      break;

  }

  if (cmSystemTools::FileIsFullPath(dest)) {

    if (!files.empty()) {

      os << indent << "list(APPEND CMAKE_ABSOLUTE_DESTINATION_FILES\n";

      os << indent << " \"";

      bool firstIteration = true;

      for (std::string const& file : files) {

        if (!firstIteration) {

          os << ";";

        }

        os << dest << "/";

        if (rename && *rename) {

          os << rename;

        } else {

          os << cmSystemTools::GetFilenameNameView(file);

        }

        firstIteration = false;

      }

      os << "\")\n";

    }

    if (filesVar) {

      os << indent << "foreach(_cmake_abs_file IN LISTS " << filesVar << ")\n";

      os << indent.Next()

         << "get_filename_component(_cmake_abs_file_name "

            "\"${_cmake_abs_file}\" NAME)\n";

      os << indent.Next() << "list(APPEND CMAKE_ABSOLUTE_DESTINATION_FILES \""

         << dest << "/${_cmake_abs_file_name}\")\n";

      os << indent << "endforeach()\n";

      os << indent << "unset(_cmake_abs_file_name)\n";

      os << indent << "unset(_cmake_abs_file)\n";

    }

    os << indent << "if(CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION)\n";

    os << indent.Next()

       << "message(WARNING \"ABSOLUTE path INSTALL "

          "DESTINATION : ${CMAKE_ABSOLUTE_DESTINATION_FILES}\")\n";

    os << indent << "endif()\n";

    os << indent << "if(CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION)\n";

    os << indent.Next()

       << "message(FATAL_ERROR \"ABSOLUTE path INSTALL "

          "DESTINATION forbidden (by caller): "

          "${CMAKE_ABSOLUTE_DESTINATION_FILES}\")\n";

    os << indent << "endif()\n";

  }

  std::string absDest = ConvertToAbsoluteDestination(dest);

  os << indent << "file(INSTALL DESTINATION \"" << absDest << "\" TYPE "

     << stype;

  if (optional) {

    os << " OPTIONAL";

  }

  switch (this->Message) {

    case MessageDefault:

      break;

    case MessageAlways:

      os << " MESSAGE_ALWAYS";

      break;

    case MessageLazy:

      os << " MESSAGE_LAZY";

      break;

    case MessageNever:

      os << " MESSAGE_NEVER";

      break;

  }

  if (permissionsFile && *permissionsFile) {

    os << " PERMISSIONS" << permissionsFile;

  }

  if (permissionsDir && *permissionsDir) {

    os << " DIR_PERMISSIONS" << permissionsDir;

  }

  if (rename && *rename) {

    os << " RENAME \"" << rename << "\"";

  }

  os << " FILES";

  if (files.size() == 1) {

    os << " \"" << files[0] << "\"";

  } else {

    for (std::string const& f : files) {

      os << "\n" << indent << "  \"" << f << "\"";

    }

    if (filesVar) {

      os << " ${" << filesVar << "}";

    }

    os << "\n" << indent << " ";

    if (!(literalArgs && *literalArgs)) {

      os << " ";

    }

  }

  if (literalArgs && *literalArgs) {

    os << literalArgs;

  }

  os << ")\n";

}

std::string cmInstallGenerator::CreateComponentTest(

  std::string const& component, bool excludeFromAll, bool allComponents)

{

  if (allComponents) {

    if (excludeFromAll) {

      return "CMAKE_INSTALL_COMPONENT";

    }

    return {};

  }

  std::string result = "CMAKE_INSTALL_COMPONENT STREQUAL \"";

  result += component;

  result += "\"";

  if (!excludeFromAll) {

    result += " OR NOT CMAKE_INSTALL_COMPONENT";

  }

  return result;

}

void cmInstallGenerator::GenerateScript(std::ostream& os)

{

  // Track indentation.

  Indent indent;

  std::string componentTest = this->CreateComponentTest(

    this->Component, this->ExcludeFromAll, this->AllComponents);

  // Begin this block of installation.

  if (!componentTest.empty()) {

    os << indent << "if(" << componentTest << ")\n";

  }

  // Generate the script possibly with per-configuration code.

  this->GenerateScriptConfigs(os,

                              this->AllComponents ? indent : indent.Next());

  // End this block of installation.

  if (!componentTest.empty()) {

    os << indent << "endif()\n\n";

  }

}

bool cmInstallGenerator::InstallsForConfig(std::string const& config)

{

  return this->GeneratesForConfig(config);

}

std::string cmInstallGenerator::ConvertToAbsoluteDestination(

  std::string const& dest)

{

  if (dest == ".") {

    return "${CMAKE_INSTALL_PREFIX}";

  }

  std::string result;

  if (!dest.empty() && !cmSystemTools::FileIsFullPath(dest)) {

    result = "${CMAKE_INSTALL_PREFIX}/";

  }

  result += dest;

  return result;

}

void cmInstallGenerator::CheckAbsoluteDestination(

  std::string const& dest, cmLocalGenerator const* lg) const

{

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

    return;

  }

  lg->IssueDiagnostic(

    cmDiagnostics::CMD_INSTALL_ABSOLUTE_DESTINATION,

    cmStrCat("INSTALL command given absolute DESTINATION path:\n  ", dest),

    this->Context);

}

cmInstallGenerator::MessageLevel cmInstallGenerator::SelectMessageLevel(

  cmMakefile* mf, bool never)

{

  if (never) {

    return MessageNever;

  }

  std::string m = mf->GetSafeDefinition("CMAKE_INSTALL_MESSAGE");

  if (m == "ALWAYS") {

    return MessageAlways;

  }

  if (m == "LAZY") {

    return MessageLazy;

  }

  if (m == "NEVER") {

    return MessageNever;

  }

  return MessageDefault;

}

cmDiagnosticContext cmInstallGenerator::CaptureContext(cmMakefile const& mf)

{

  cmDiagnosticContext context{ mf.GetBacktrace() };

  context.RecordDiagnostic(cmDiagnostics::CMD_AUTHOR, mf.GetStateSnapshot());

  context.RecordDiagnostic(cmDiagnostics::CMD_INSTALL_ABSOLUTE_DESTINATION,

                           mf.GetStateSnapshot());

  return context;

}

bool cmInstallGenerator::ResolveBuildDepends(

  cmLocalGenerator* lg, std::string const& signature,

  std::vector<std::string> const& names, BuildDependsEntries& entries)

{

  entries = BuildDependsEntries();

  cmGlobalGenerator* gg = lg->GetGlobalGenerator();

  std::vector<std::string> const configs =

    lg->GetMakefile()->GetGeneratorConfigs(cmMakefile::IncludeEmptyConfig);

  auto const isArtifact = [gg, &configs](std::string const& file) {

    return std::any_of(configs.begin(), configs.end(),

                       [gg, &file](std::string const& config) {

                         return gg->FindArtifactOwningTarget(file, config);

                       });

  };

  for (std::string const& name : names) {

    if (cmGeneratorTarget const* target = lg->FindGeneratorTargetToUse(name)) {

      entries.Targets.push_back(target);

      continue;

    }

    // A relative path is interpreted with respect to the current source

    // directory if the file exists there, and otherwise the current binary

    // directory.

    std::string file = lg->GetRealFileDependency(name);

    if (gg->IsGeneratedByBuild(file) || isArtifact(file) ||

        cmSystemTools::FileExists(file)) {

      entries.Files.push_back(std::move(file));

    } else {

      lg->IssueMessage(

        MessageType::FATAL_ERROR,

        cmStrCat("install(", signature, ") BUILD_DEPENDS entry \"", name,

                 "\" is neither a target nor a file that exists or is "

                 "generated by the build."),

        this->GetBacktrace());

      return false;

    }

  }

  return true;

}

void cmInstallGenerator::AddBuildDependsDependencies(

  cmLocalGenerator* lg, std::string const& config,

  BuildDependsEntries const& entries,

  std::vector<BuildDependency>& dependencies)

{

  for (cmGeneratorTarget const* target : entries.Targets) {

    dependencies.push_back({ target, BuildDependencyType::Normal });

  }

  AddGeneratedFileDependencies(lg->GetGlobalGenerator(), config, nullptr,

                               entries.Files, dependencies);

}

std::string cmInstallGenerator::GetDestDirPath(std::string const& file)

{

  // Construct the path of the file on disk after installation on

  // which tweaks may be performed.

  std::string toDestDirPath = "$ENV{DESTDIR}";

  if (file[0] != '/' && file[0] != '$') {

    toDestDirPath += "/";

  }

  toDestDirPath += file;

  return toDestDirPath;

}

void cmInstallGenerator::AddGeneratedFileDependencies(

  cmGlobalGenerator* gg, std::string const& config,

  cmGeneratorTarget const* target, std::vector<std::string> const& files,

  std::vector<BuildDependency>& dependencies)

{

  for (std::string const& file : files) {

    if (cmGeneratorTarget const* owner = gg->FindOutputOwningTarget(file)) {

      dependencies.push_back(

        { owner, BuildDependencyType::GeneratedFile, file });

    } else if (cmGeneratorTarget const* linker =

                 gg->FindArtifactOwningTarget(file, config)) {

      dependencies.push_back({ linker, BuildDependencyType::Normal });

    } else if (gg->IsGeneratedByBuild(file)) {

      dependencies.push_back(

        { target, BuildDependencyType::GeneratedFile, file });

    }

  }

}

void cmInstallGenerator::AddTweak(std::ostream& os, Indent indent,

                                  std::string const& config,

                                  std::string const& file,

                                  TweakMethod const& tweak)

{

  std::ostringstream tw;

  tweak(tw, indent.Next(), config, file);

  std::string tws = tw.str();

  if (!tws.empty()) {

    os << indent << "if(EXISTS \"" << file << "\" AND\n"

       << indent << "   NOT IS_SYMLINK \"" << file << "\")\n";

    os << tws;

    os << indent << "endif()\n";

  }

}

void cmInstallGenerator::AddTweak(std::ostream& os, Indent indent,

                                  std::string const& config,

                                  std::string const& dir,

                                  std::vector<std::string> const& files,

                                  TweakMethod const& tweak)

{

  if (files.size() == 1) {

    // Tweak a single file.

    AddTweak(os, indent, config, GetDestDirPath(cmStrCat(dir, files[0])),

             tweak);

  } else {

    // Generate a foreach loop to tweak multiple files.

    std::ostringstream tw;

    AddTweak(tw, indent.Next(), config, "${file}", tweak);

    std::string tws = tw.str();

    if (!tws.empty()) {

      Indent indent2 = indent.Next().Next();

      os << indent << "foreach(file\n";

      for (std::string const& f : files) {

        os << indent2 << "\"" << GetDestDirPath(cmStrCat(dir, f)) << "\"\n";

      }

      os << indent2 << ")\n";

      os << tws;

      os << indent << "endforeach()\n";

    }

  }

}