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

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

#include "cmInstallFilesGenerator.h"

#include <utility>

#include "cmDiagnosticContext.h"

#include "cmGeneratorExpression.h"

#include "cmInstallType.h"

#include "cmList.h"

#include "cmLocalGenerator.h"

cmInstallFilesGenerator::cmInstallFilesGenerator(

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

  bool programs, std::string filePermissions,

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

  std::vector<std::string> buildDepends, MessageLevel message,

  bool excludeFromAll, std::string rename, bool optional,

  cmDiagnosticContext context)

  : cmInstallGenerator(dest, configurations, component, message,

                       excludeFromAll, false, std::move(context))

  , Files(files)

  , FilePermissions(std::move(filePermissions))

  , Rename(std::move(rename))

  , BuildDepends(std::move(buildDepends))

  , Programs(programs)

  , Optional(optional)

{

  // We need per-config actions if the destination and rename have generator

  // expressions.

  if (cmGeneratorExpression::Find(this->Destination) != std::string::npos) {

    this->ActionsPerConfig = true;

  }

  if (cmGeneratorExpression::Find(this->Rename) != std::string::npos) {

    this->ActionsPerConfig = true;

  }

  // We need per-config actions if any directories have generator expressions.

  if (!this->ActionsPerConfig) {

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

      if (cmGeneratorExpression::Find(file) != std::string::npos) {

        this->ActionsPerConfig = true;

        break;

      }

    }

  }

}

cmInstallFilesGenerator::~cmInstallFilesGenerator() = default;

bool cmInstallFilesGenerator::Compute(cmLocalGenerator* lg)

{

  this->LocalGenerator = lg;

  if (!this->OwningTargetName.empty()) {

    this->OwningTarget = lg->FindGeneratorTargetToUse(this->OwningTargetName);

  }

  return this->ResolveBuildDepends(lg, this->Programs ? "PROGRAMS" : "FILES",

                                   this->BuildDepends,

                                   this->ResolvedBuildDepends);

}

void cmInstallFilesGenerator::GetInstallBuildDependencies(

  std::string const& config, std::vector<BuildDependency>& dependencies) const

{

  AddBuildDependsDependencies(this->LocalGenerator, config,

                              this->ResolvedBuildDepends, dependencies);

  std::vector<BuildDependency> generated;

  AddGeneratedFileDependencies(this->LocalGenerator->GetGlobalGenerator(),

                               config, this->OwningTarget,

                               this->GetFiles(config), generated);

  for (BuildDependency& dependency : generated) {

    // A generated file that no target prepares is assumed to be produced by

    // the targets named by BUILD_DEPENDS, if any.

    if (dependency.Target || this->ResolvedBuildDepends.Targets.empty()) {

      dependencies.push_back(std::move(dependency));

    }

  }

}

std::string cmInstallFilesGenerator::GetDestination(

  std::string const& config) const

{

  std::string dest = cmGeneratorExpression::Evaluate(

    this->Destination, this->LocalGenerator, config);

  this->CheckAbsoluteDestination(dest, this->LocalGenerator);

  return dest;

}

std::string cmInstallFilesGenerator::GetRename(std::string const& config) const

{

  return cmGeneratorExpression::Evaluate(this->Rename, this->LocalGenerator,

                                         config);

}

std::vector<std::string> cmInstallFilesGenerator::GetFiles(

  std::string const& config) const

{

  if (this->ActionsPerConfig) {

    cmList files;

    for (std::string const& f : this->Files) {

      files.append(

        cmGeneratorExpression::Evaluate(f, this->LocalGenerator, config));

    }

    return std::move(files.data());

  }

  return this->Files;

}

void cmInstallFilesGenerator::AddFilesInstallRule(

  std::ostream& os, std::string const& config, Indent indent,

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

{

  // Write code to install the files.

  char const* noDirPermissions = nullptr;

  this->AddInstallRule(

    os, this->GetDestination(config),

    (this->Programs ? cmInstallType_PROGRAMS : cmInstallType_FILES), files,

    this->Optional, this->FilePermissions.c_str(), noDirPermissions,

    this->GetRename(config).c_str(), nullptr, indent);

}

void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os,

                                                    Indent indent)

{

  if (this->ActionsPerConfig) {

    this->cmInstallGenerator::GenerateScriptActions(os, indent);

  } else {

    this->AddFilesInstallRule(os, "", indent, this->Files);

  }

}

void cmInstallFilesGenerator::GenerateScriptForConfig(

  std::ostream& os, std::string const& config, Indent indent)

{

  std::vector<std::string> files = this->GetFiles(config);

  this->AddFilesInstallRule(os, config, indent, files);

}