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

#include "cmInstallScriptHandler.h"

#include <algorithm>
#include <cstddef>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include <cm/memory>

#include <cm3p/json/reader.h>
#include <cm3p/json/value.h>
#include <cm3p/uv.h>

#include "cmsys/FStream.hxx"
#include "cmsys/RegularExpression.hxx"

#include "cmCryptoHash.h"
#include "cmGeneratedFileStream.h"
#include "cmInstrumentation.h"
#include "cmJSONState.h"
#include "cmProcessOutput.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmUVHandlePtr.h"
#include "cmUVProcessChain.h"
#include "cmUVStream.h"

using InstallScript = cmInstallScriptHandler::InstallScript;
using InstallScriptRunner = cmInstallScriptHandler::InstallScriptRunner;

cmInstallScriptHandler::cmInstallScriptHandler(
  std::string binaryDir, std::vector<std::string> components,
  std::string installConfig, std::vector<std::string>& args)
  : Components(std::move(components))
  , BinaryDir(std::move(binaryDir))
{
  if (this->Components.empty()) {
    this->Components.emplace_back(std::string{});
  }

  std::string const& file =
    cmStrCat(this->BinaryDir, "/CMakeFiles/InstallScripts.json");
  this->Parallel = false;

  auto addScript = [this, &args](std::string script, std::string component,
                                 std::string config) -> void {
    this->Scripts.push_back({ script, config, args });
    if (!component.empty()) {
      this->Scripts.back().command.insert(
        this->Scripts.back().command.end() - 1,
        cmStrCat("-DCMAKE_INSTALL_COMPONENT=", component));
    }
    if (!config.empty()) {
      this->Scripts.back().command.insert(
        this->Scripts.back().command.end() - 1,
        cmStrCat("-DCMAKE_INSTALL_CONFIG_NAME=", config));
    }
    this->Scripts.back().command.emplace_back(script);
    this->Directories.push_back(cmSystemTools::GetFilenamePath(script));
  };

  int compare = 1;
  if (cmSystemTools::FileExists(file)) {
    cmSystemTools::FileTimeCompare(
      cmStrCat(this->BinaryDir, "/CMakeFiles/cmake.check_cache"), file,
      &compare);
  }
  if (compare < 1) {
    Json::CharReaderBuilder rbuilder;
    auto jsonReader =
      std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
    std::vector<char> content;
    Json::Value value;
    cmJSONState state(file, &value);
    this->Parallel = value["Parallel"].asBool();
    if (this->Parallel) {
      args.insert(args.end() - 1, "-DCMAKE_INSTALL_LOCAL_ONLY=1");
    }
    if (installConfig.empty() && value.isMember("Configs")) {
      for (auto const& config : value["Configs"]) {
        this->Configs.push_back(config.asCString());
      }
    } else {
      this->Configs.push_back(installConfig);
    }
    for (auto const& script : value["InstallScripts"]) {
      for (auto const& component : Components) {
        for (auto const& config : Configs) {
          addScript(script.asCString(), component, config);
        }
      }
      if (!this->Parallel) {
        break;
      }
    }
  } else {
    for (auto const& component : Components) {
      addScript(cmStrCat(this->BinaryDir, "/cmake_install.cmake"), component,
                installConfig);
    }
  }
}

bool cmInstallScriptHandler::IsParallel()
{
  return this->Parallel;
}

std::vector<InstallScript> cmInstallScriptHandler::GetScripts() const
{
  return this->Scripts;
}

int cmInstallScriptHandler::Install(unsigned int j,
                                    cmInstrumentation& instrumentation)
{
  cm::uv_loop_ptr loop;
  loop.init();
  std::vector<InstallScriptRunner> runners;
  runners.reserve(this->Scripts.size());

  std::vector<std::string> instrumentArg;
  if (instrumentation.HasQuery()) {
    instrumentArg = { cmSystemTools::GetCTestCommand(),
                      "--instrument",
                      "--command-type",
                      "install",
                      "--build-dir",
                      this->BinaryDir,
                      "--config",
                      "",
                      "--" };
  }

  for (auto& script : this->Scripts) {
    if (!instrumentArg.empty()) {
      instrumentArg[7] = script.config; // --config <script.config>
    }
    script.command.insert(script.command.begin(), instrumentArg.begin(),
                          instrumentArg.end());
    runners.emplace_back(script);
  }
  std::size_t working = 0;
  std::size_t installed = 0;
  std::size_t i = 0;

  std::function<void()> queueScripts;
  queueScripts = [&runners, &working, &installed, &i, &loop, j,
                  &queueScripts]() {
    for (auto queue = std::min(j - working, runners.size() - i); queue > 0;
         --queue) {
      ++working;
      runners[i].start(loop,
                       [&runners, &working, &installed, i, &queueScripts]() {
                         runners[i].printResult(++installed, runners.size());
                         --working;
                         queueScripts();
                       });
      ++i;
    }
  };
  queueScripts();
  uv_run(loop, UV_RUN_DEFAULT);

  // Write install manifest
  std::string installManifest;
  for (auto const& component : this->Components) {
    if (component.empty()) {
      installManifest = "install_manifest.txt";
    } else {
      cmsys::RegularExpression regEntry;
      if (regEntry.compile("^[a-zA-Z0-9_.+-]+$") && regEntry.find(component)) {
        installManifest = cmStrCat("install_manifest_", component, ".txt");
      } else {
        cmCryptoHash md5(cmCryptoHash::AlgoMD5);
        md5.Initialize();
        installManifest =
          cmStrCat("install_manifest_", md5.HashString(component), ".txt");
      }
    }
    cmGeneratedFileStream fout(
      cmStrCat(this->BinaryDir, '/', installManifest));
    fout.SetCopyIfDifferent(true);
    for (auto const& dir : this->Directories) {
      auto localManifest = cmStrCat(dir, "/install_local_manifest.txt");
      if (cmSystemTools::FileExists(localManifest)) {
        cmsys::ifstream fin(localManifest.c_str());
        std::string line;
        while (std::getline(fin, line)) {
          fout << line << "\n";
        }
      }
    }
  }
  return 0;
}

InstallScriptRunner::InstallScriptRunner(InstallScript const& script)
{
  this->Name = cmSystemTools::RelativePath(
    cmSystemTools::GetLogicalWorkingDirectory(), script.path);
  this->Command = script.command;
}

void InstallScriptRunner::start(cm::uv_loop_ptr& loop,
                                std::function<void()> callback)
{
  cmUVProcessChainBuilder builder;
  builder.AddCommand(this->Command)
    .SetExternalLoop(*loop)
    .SetMergedBuiltinStreams();
  this->Chain = cm::make_unique<cmUVProcessChain>(builder.Start());
  this->StreamHandler = cmUVStreamRead(
    this->Chain->OutputStream(),
    [this](std::vector<char> data) {
      std::string strdata;
      cmProcessOutput(cmProcessOutput::Auto)
        .DecodeText(data.data(), data.size(), strdata);
      this->Output.push_back(strdata);
    },
    std::move(callback));
}

void InstallScriptRunner::printResult(std::size_t n, std::size_t total)
{
  cmSystemTools::Stdout(cmStrCat('[', n, '/', total, "] ", this->Name, '\n'));
  for (auto const& line : this->Output) {
    cmSystemTools::Stdout(line);
  }
}