/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#include "cmCPackBundleGenerator.h"

#include <sstream>
#include <vector>

#include "cmCPackLog.h"
#include "cmSystemTools.h"

cmCPackBundleGenerator::cmCPackBundleGenerator()
{
}

cmCPackBundleGenerator::~cmCPackBundleGenerator()
{
}

int cmCPackBundleGenerator::InitializeInternal()
{
  const char* name = this->GetOption("CPACK_BUNDLE_NAME");
  if (nullptr == name) {
    cmCPackLogger(cmCPackLog::LOG_ERROR,
                  "CPACK_BUNDLE_NAME must be set to use the Bundle generator."
                    << std::endl);

    return 0;
  }

  if (this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")) {
    const std::string codesign_path = cmSystemTools::FindProgram(
      "codesign", std::vector<std::string>(), false);

    if (codesign_path.empty()) {
      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate codesign command"
                      << std::endl);
      return 0;
    }
    this->SetOptionIfNotSet("CPACK_COMMAND_CODESIGN", codesign_path.c_str());
  }

  return this->Superclass::InitializeInternal();
}

const char* cmCPackBundleGenerator::GetPackagingInstallPrefix()
{
  this->InstallPrefix = "/";
  this->InstallPrefix += this->GetOption("CPACK_BUNDLE_NAME");
  this->InstallPrefix += ".app/Contents/Resources";

  return this->InstallPrefix.c_str();
}

int cmCPackBundleGenerator::ConstructBundle()
{

  // Get required arguments ...
  const std::string cpack_bundle_name = this->GetOption("CPACK_BUNDLE_NAME")
    ? this->GetOption("CPACK_BUNDLE_NAME")
    : "";
  if (cpack_bundle_name.empty()) {
    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_NAME must be set."
                    << std::endl);

    return 0;
  }

  const std::string cpack_bundle_plist = this->GetOption("CPACK_BUNDLE_PLIST")
    ? this->GetOption("CPACK_BUNDLE_PLIST")
    : "";
  if (cpack_bundle_plist.empty()) {
    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_PLIST must be set."
                    << std::endl);

    return 0;
  }

  const std::string cpack_bundle_icon = this->GetOption("CPACK_BUNDLE_ICON")
    ? this->GetOption("CPACK_BUNDLE_ICON")
    : "";
  if (cpack_bundle_icon.empty()) {
    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_ICON must be set."
                    << std::endl);

    return 0;
  }

  // Get optional arguments ...
  const std::string cpack_bundle_startup_command =
    this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND")
    ? this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND")
    : "";

  // The staging directory contains everything that will end-up inside the
  // final disk image ...
  std::ostringstream staging;
  staging << toplevel;

  std::ostringstream contents;
  contents << staging.str() << "/" << cpack_bundle_name << ".app/"
           << "Contents";

  std::ostringstream application;
  application << contents.str() << "/"
              << "MacOS";

  std::ostringstream resources;
  resources << contents.str() << "/"
            << "Resources";

  // Install a required, user-provided bundle metadata file ...
  std::ostringstream plist_source;
  plist_source << cpack_bundle_plist;

  std::ostringstream plist_target;
  plist_target << contents.str() << "/"
               << "Info.plist";

  if (!this->CopyFile(plist_source, plist_target)) {
    cmCPackLogger(
      cmCPackLog::LOG_ERROR,
      "Error copying plist.  Check the value of CPACK_BUNDLE_PLIST."
        << std::endl);

    return 0;
  }

  // Install a user-provided bundle icon ...
  std::ostringstream icon_source;
  icon_source << cpack_bundle_icon;

  std::ostringstream icon_target;
  icon_target << resources.str() << "/" << cpack_bundle_name << ".icns";

  if (!this->CopyFile(icon_source, icon_target)) {
    cmCPackLogger(
      cmCPackLog::LOG_ERROR,
      "Error copying bundle icon.  Check the value of CPACK_BUNDLE_ICON."
        << std::endl);

    return 0;
  }

  // Optionally a user-provided startup command (could be an
  // executable or a script) ...
  if (!cpack_bundle_startup_command.empty()) {
    std::ostringstream command_source;
    command_source << cpack_bundle_startup_command;

    std::ostringstream command_target;
    command_target << application.str() << "/" << cpack_bundle_name;

    if (!this->CopyFile(command_source, command_target)) {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
                    "Error copying startup command. "
                    " Check the value of CPACK_BUNDLE_STARTUP_COMMAND."
                      << std::endl);

      return 0;
    }

    cmSystemTools::SetPermissions(command_target.str().c_str(), 0777);
  }

  return 1;
}

int cmCPackBundleGenerator::PackageFiles()
{
  if (!this->ConstructBundle()) {
    return 0;
  }

  if (!this->SignBundle(toplevel)) {
    return 0;
  }

  return this->CreateDMG(toplevel, packageFileNames[0]);
}

bool cmCPackBundleGenerator::SupportsComponentInstallation() const
{
  return false;
}

int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
{
  const std::string cpack_apple_cert_app =
    this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")
    ? this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")
    : "";

  // codesign the application.
  if (!cpack_apple_cert_app.empty()) {
    std::string output;
    std::string bundle_path;
    bundle_path = src_dir + "/";
    bundle_path += this->GetOption("CPACK_BUNDLE_NAME");
    bundle_path += ".app";

    // A list of additional files to sign, ie. frameworks and plugins.
    const std::string sign_parameter =
      this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_PARAMETER")
      ? this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_PARAMETER")
      : "--deep -f";

    const std::string sign_files =
      this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES")
      ? this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES")
      : "";

    std::vector<std::string> relFiles;
    cmSystemTools::ExpandListArgument(sign_files, relFiles);

    // sign the files supplied by the user, ie. frameworks.
    for (auto const& file : relFiles) {
      std::ostringstream temp_sign_file_cmd;
      temp_sign_file_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
      temp_sign_file_cmd << " " << sign_parameter << " -s \""
                         << cpack_apple_cert_app;
      temp_sign_file_cmd << "\" -i ";
      temp_sign_file_cmd << this->GetOption("CPACK_APPLE_BUNDLE_ID");
      temp_sign_file_cmd << " \"";
      temp_sign_file_cmd << bundle_path;
      temp_sign_file_cmd << file << "\"";

      if (!this->RunCommand(temp_sign_file_cmd, &output)) {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Error signing file:" << bundle_path << file << std::endl
                                            << output << std::endl);

        return 0;
      }
    }

    // sign main binary
    std::ostringstream temp_sign_binary_cmd;
    temp_sign_binary_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
    temp_sign_binary_cmd << " " << sign_parameter << " -s \""
                         << cpack_apple_cert_app;
    temp_sign_binary_cmd << "\" \"" << bundle_path << "\"";

    if (!this->RunCommand(temp_sign_binary_cmd, &output)) {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
                    "Error signing the application binary." << std::endl
                                                            << output
                                                            << std::endl);

      return 0;
    }

    // sign app bundle
    std::ostringstream temp_codesign_cmd;
    temp_codesign_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
    temp_codesign_cmd << " " << sign_parameter << " -s \""
                      << cpack_apple_cert_app << "\"";
    if (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")) {
      temp_codesign_cmd << " --entitlements ";
      temp_codesign_cmd << this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS");
    }
    temp_codesign_cmd << " \"" << bundle_path << "\"";

    if (!this->RunCommand(temp_codesign_cmd, &output)) {
      cmCPackLogger(cmCPackLog::LOG_ERROR,
                    "Error signing the application package." << std::endl
                                                             << output
                                                             << std::endl);

      return 0;
    }

    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Application has been codesigned"
                    << std::endl);
    cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                  (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")
                     ? "with entitlement sandboxing"
                     : "without entitlement sandboxing")
                    << std::endl);
  }

  return 1;
}