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

#include "cmsys/FStream.hxx"
#include "cmsys/RegularExpression.hxx"
#include <assert.h>
#include <map>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>

#include "cmCPackComponentGroup.h"
#include "cmCPackLog.h"
#include "cmDuration.h"
#include "cmGeneratedFileStream.h"
#include "cmSystemTools.h"
#include "cmXMLWriter.h"

static inline unsigned int
getVersion(unsigned int major, unsigned int minor)
{
    assert(major < 256 && minor < 256);
    return ((major & 0xFF) << 16 | minor);
}

cmCPackPackageMakerGenerator::cmCPackPackageMakerGenerator()
{
    this->PackageMakerVersion         = 0.0;
    this->PackageCompatibilityVersion = getVersion(10, 4);
}

cmCPackPackageMakerGenerator::~cmCPackPackageMakerGenerator() {}

bool
cmCPackPackageMakerGenerator::SupportsComponentInstallation() const
{
    return this->PackageCompatibilityVersion >= getVersion(10, 4);
}

int
cmCPackPackageMakerGenerator::PackageFiles()
{
    // TODO: Use toplevel
    //       It is used! Is this an obsolete comment?

    std::string resDir;  // Where this package's resources will go.
    std::string packageDirFileName =
        this->GetOption("CPACK_TEMPORARY_DIRECTORY");
    if(this->Components.empty())
    {
        packageDirFileName += ".pkg";
        resDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
        resDir += "/Resources";
    } else
    {
        packageDirFileName += ".mpkg";
        if(!cmsys::SystemTools::MakeDirectory(packageDirFileName.c_str()))
        {
            cmCPackLogger(cmCPackLog::LOG_ERROR,
                          "unable to create package directory "
                              << packageDirFileName << std::endl);
            return 0;
        }

        resDir = packageDirFileName;
        resDir += "/Contents";
        if(!cmsys::SystemTools::MakeDirectory(resDir.c_str()))
        {
            cmCPackLogger(cmCPackLog::LOG_ERROR,
                          "unable to create package subdirectory "
                              << resDir << std::endl);
            return 0;
        }

        resDir += "/Resources";
        if(!cmsys::SystemTools::MakeDirectory(resDir.c_str()))
        {
            cmCPackLogger(cmCPackLog::LOG_ERROR,
                          "unable to create package subdirectory "
                              << resDir << std::endl);
            return 0;
        }

        resDir += "/en.lproj";
    }

    const char* preflight   = this->GetOption("CPACK_PREFLIGHT_SCRIPT");
    const char* postflight  = this->GetOption("CPACK_POSTFLIGHT_SCRIPT");
    const char* postupgrade = this->GetOption("CPACK_POSTUPGRADE_SCRIPT");

    if(this->Components.empty())
    {
        // Create directory structure
        std::string preflightDirName  = resDir + "/PreFlight";
        std::string postflightDirName = resDir + "/PostFlight";
        // if preflight or postflight scripts not there create directories
        // of the same name, I think this makes it work
        if(!preflight)
        {
            if(!cmsys::SystemTools::MakeDirectory(preflightDirName.c_str()))
            {
                cmCPackLogger(cmCPackLog::LOG_ERROR,
                              "Problem creating installer directory: "
                                  << preflightDirName << std::endl);
                return 0;
            }
        }
        if(!postflight)
        {
            if(!cmsys::SystemTools::MakeDirectory(postflightDirName.c_str()))
            {
                cmCPackLogger(cmCPackLog::LOG_ERROR,
                              "Problem creating installer directory: "
                                  << postflightDirName << std::endl);
                return 0;
            }
        }
        // if preflight, postflight, or postupgrade are set
        // then copy them into the resource directory and make
        // them executable
        if(preflight)
        {
            this->CopyInstallScript(resDir, preflight, "preflight");
        }
        if(postflight)
        {
            this->CopyInstallScript(resDir, postflight, "postflight");
        }
        if(postupgrade)
        {
            this->CopyInstallScript(resDir, postupgrade, "postupgrade");
        }
    } else if(postflight)
    {
        // create a postflight component to house the script
        this->PostFlightComponent.Name        = "PostFlight";
        this->PostFlightComponent.DisplayName = "PostFlight";
        this->PostFlightComponent.Description = "PostFlight";
        this->PostFlightComponent.IsHidden    = true;

        // empty directory for pkg contents
        std::string packageDir = toplevel + "/" + PostFlightComponent.Name;
        if(!cmsys::SystemTools::MakeDirectory(packageDir.c_str()))
        {
            cmCPackLogger(cmCPackLog::LOG_ERROR,
                          "Problem creating component packages directory: "
                              << packageDir << std::endl);
            return 0;
        }

        // create package
        std::string packageFileDir = packageDirFileName + "/Contents/Packages/";
        if(!cmsys::SystemTools::MakeDirectory(packageFileDir.c_str()))
        {
            cmCPackLogger(
                cmCPackLog::LOG_ERROR,
                "Problem creating component PostFlight Packages directory: "
                    << packageFileDir << std::endl);
            return 0;
        }
        std::string packageFile =
            packageFileDir + this->GetPackageName(PostFlightComponent);
        if(!this->GenerateComponentPackage(
               packageFile.c_str(), packageDir.c_str(), PostFlightComponent))
        {
            return 0;
        }

        // copy postflight script into resource directory of .pkg
        std::string resourceDir = packageFile + "/Contents/Resources";
        this->CopyInstallScript(resourceDir, postflight, "postflight");
    }

    if(!this->Components.empty())
    {
        // Create the directory where component packages will be built.
        std::string basePackageDir = packageDirFileName;
        basePackageDir += "/Contents/Packages";
        if(!cmsys::SystemTools::MakeDirectory(basePackageDir.c_str()))
        {
            cmCPackLogger(cmCPackLog::LOG_ERROR,
                          "Problem creating component packages directory: "
                              << basePackageDir << std::endl);
            return 0;
        }

        // Create the directory where downloaded component packages will
        // be placed.
        const char* userUploadDirectory =
            this->GetOption("CPACK_UPLOAD_DIRECTORY");
        std::string uploadDirectory;
        if(userUploadDirectory && *userUploadDirectory)
        {
            uploadDirectory = userUploadDirectory;
        } else
        {
            uploadDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
            uploadDirectory += "/CPackUploads";
        }

        // Create packages for each component
        bool warnedAboutDownloadCompatibility = false;

        std::map<std::string, cmCPackComponent>::iterator compIt;
        for(compIt = this->Components.begin(); compIt != this->Components.end();
            ++compIt)
        {
            std::string packageFile;
            if(compIt->second.IsDownloaded)
            {
                if(this->PackageCompatibilityVersion >= getVersion(10, 5) &&
                   this->PackageMakerVersion >= 3.0)
                {
                    // Build this package within the upload directory.
                    packageFile = uploadDirectory;

                    if(!cmSystemTools::FileExists(uploadDirectory.c_str()))
                    {
                        if(!cmSystemTools::MakeDirectory(
                               uploadDirectory.c_str()))
                        {
                            cmCPackLogger(
                                cmCPackLog::LOG_ERROR,
                                "Unable to create package upload directory "
                                    << uploadDirectory << std::endl);
                            return 0;
                        }
                    }
                } else if(!warnedAboutDownloadCompatibility)
                {
                    if(this->PackageCompatibilityVersion < getVersion(10, 5))
                    {
                        cmCPackLogger(cmCPackLog::LOG_WARNING,
                                      "CPack warning: please set "
                                      "CPACK_OSX_PACKAGE_VERSION to 10.5 "
                                      "or greater enable downloaded packages. "
                                      "CPack will build a "
                                      "non-downloaded package."
                                          << std::endl);
                    }

                    if(this->PackageMakerVersion < 3)
                    {
                        cmCPackLogger(
                            cmCPackLog::LOG_WARNING,
                            "CPack warning: unable to build downloaded "
                            "packages with PackageMaker versions prior "
                            "to 3.0. CPack will build a non-downloaded package."
                                << std::endl);
                    }

                    warnedAboutDownloadCompatibility = true;
                }
            }

            if(packageFile.empty())
            {
                // Build this package within the overall distribution
                // metapackage.
                packageFile = basePackageDir;

                // We're not downloading this component, even if the user
                // requested it.
                compIt->second.IsDownloaded = false;
            }

            packageFile += '/';
            packageFile += GetPackageName(compIt->second);

            std::string packageDir = toplevel;
            packageDir += '/';
            packageDir += compIt->first;
            if(!this->GenerateComponentPackage(
                   packageFile.c_str(), packageDir.c_str(), compIt->second))
            {
                return 0;
            }
        }
    }
    this->SetOption("CPACK_MODULE_VERSION_SUFFIX", "");

    // Copy or create all of the resource files we need.
    if(!this->CopyCreateResourceFile("License", resDir) ||
       !this->CopyCreateResourceFile("ReadMe", resDir) ||
       !this->CopyCreateResourceFile("Welcome", resDir) ||
       !this->CopyResourcePlistFile("Info.plist") ||
       !this->CopyResourcePlistFile("Description.plist"))
    {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Problem copying the resource files" << std::endl);
        return 0;
    }

    if(this->Components.empty())
    {
        // Use PackageMaker to build the package.
        std::ostringstream pkgCmd;
        pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
               << "\" -build -p \"" << packageDirFileName << "\"";
        if(this->Components.empty())
        {
            pkgCmd << " -f \"" << this->GetOption("CPACK_TEMPORARY_DIRECTORY");
        } else
        {
            pkgCmd << " -mi \"" << this->GetOption("CPACK_TEMPORARY_DIRECTORY")
                   << "/packages/";
        }
        pkgCmd << "\" -r \"" << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
               << "/Resources\" -i \""
               << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
               << "/Info.plist\" -d \""
               << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
               << "/Description.plist\"";
        if(this->PackageMakerVersion > 2.0)
        {
            pkgCmd << " -v";
        }
        if(!RunPackageMaker(pkgCmd.str().c_str(), packageDirFileName.c_str()))
        {
            return 0;
        }
    } else
    {
        // We have built the package in place. Generate the
        // distribution.dist file to describe it for the installer.
        WriteDistributionFile(packageDirFileName.c_str());
    }

    std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
    tmpFile += "/hdiutilOutput.log";
    std::ostringstream dmgCmd;
    dmgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM_DISK_IMAGE")
           << "\" create -ov -fs HFS+ -format UDZO -srcfolder \""
           << packageDirFileName << "\" \"" << packageFileNames[0] << "\"";
    std::string output;
    int         retVal   = 1;
    int         numTries = 10;
    bool        res      = false;
    while(numTries > 0)
    {
        res = cmSystemTools::RunSingleCommand(
            dmgCmd.str().c_str(), &output, &output, &retVal, nullptr,
            this->GeneratorVerbose, cmDuration::zero());
        if(res && !retVal)
        {
            numTries = -1;
            break;
        }
        cmSystemTools::Delay(500);
        numTries--;
    }
    if(!res || retVal)
    {
        cmGeneratedFileStream ofs(tmpFile.c_str());
        ofs << "# Run command: " << dmgCmd.str() << std::endl
            << "# Output:" << std::endl
            << output << std::endl;
        cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running hdiutil command: "
                                                 << dmgCmd.str() << std::endl
                                                 << "Please check " << tmpFile
                                                 << " for errors" << std::endl);
        return 0;
    }

    return 1;
}

int
cmCPackPackageMakerGenerator::InitializeInternal()
{
    this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");

    // Starting with Xcode 4.3, PackageMaker is a separate app, and you
    // can put it anywhere you want. So... use a variable for its location.
    // People who put it in unexpected places can use the variable to tell
    // us where it is.
    //
    // Use the following locations, in "most recent installation" order,
    // to search for the PackageMaker app. Assume people who copy it into
    // the new Xcode 4.3 app in "/Applications" will copy it into the nested
    // Applications folder inside the Xcode bundle itself. Or directly in
    // the "/Applications" directory.
    //
    // If found, save result in the CPACK_INSTALLER_PROGRAM variable.

    std::vector<std::string> paths;
    paths.push_back("/Applications/Xcode.app/Contents/Applications"
                    "/PackageMaker.app/Contents/MacOS");
    paths.push_back("/Applications/Utilities"
                    "/PackageMaker.app/Contents/MacOS");
    paths.push_back("/Applications"
                    "/PackageMaker.app/Contents/MacOS");
    paths.push_back("/Developer/Applications/Utilities"
                    "/PackageMaker.app/Contents/MacOS");
    paths.push_back("/Developer/Applications"
                    "/PackageMaker.app/Contents/MacOS");

    std::string pkgPath;
    const char* inst_program = this->GetOption("CPACK_INSTALLER_PROGRAM");
    if(inst_program && *inst_program)
    {
        pkgPath = inst_program;
    } else
    {
        pkgPath = cmSystemTools::FindProgram("PackageMaker", paths, false);
        if(pkgPath.empty())
        {
            cmCPackLogger(cmCPackLog::LOG_ERROR,
                          "Cannot find PackageMaker compiler" << std::endl);
            return 0;
        }
        this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM", pkgPath.c_str());
    }

    // Get path to the real PackageMaker, not a symlink:
    pkgPath = cmSystemTools::GetRealPath(pkgPath);
    // Up from there to find the version.plist file in the "Contents" dir:
    std::string contents_dir;
    contents_dir = cmSystemTools::GetFilenamePath(pkgPath);
    contents_dir = cmSystemTools::GetFilenamePath(contents_dir);

    std::string versionFile = contents_dir + "/version.plist";

    if(!cmSystemTools::FileExists(versionFile.c_str()))
    {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Cannot find PackageMaker compiler version file: "
                          << versionFile << std::endl);
        return 0;
    }

    cmsys::ifstream ifs(versionFile.c_str());
    if(!ifs)
    {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Cannot open PackageMaker compiler version file"
                          << std::endl);
        return 0;
    }

    // Check the PackageMaker version
    cmsys::RegularExpression rexKey("<key>CFBundleShortVersionString</key>");
    cmsys::RegularExpression rexVersion("<string>([0-9]+.[0-9.]+)</string>");
    std::string              line;
    bool                     foundKey = false;
    while(cmSystemTools::GetLineFromStream(ifs, line))
    {
        if(rexKey.find(line))
        {
            foundKey = true;
            break;
        }
    }
    if(!foundKey)
    {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Cannot find CFBundleShortVersionString in the "
                      "PackageMaker compiler "
                      "version file"
                          << std::endl);
        return 0;
    }
    if(!cmSystemTools::GetLineFromStream(ifs, line) || !rexVersion.find(line))
    {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Problem reading the PackageMaker compiler version file: "
                          << versionFile << std::endl);
        return 0;
    }
    this->PackageMakerVersion = atof(rexVersion.match(1).c_str());
    if(this->PackageMakerVersion < 1.0)
    {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Require PackageMaker 1.0 or higher" << std::endl);
        return 0;
    }
    cmCPackLogger(cmCPackLog::LOG_DEBUG,
                  "PackageMaker version is: " << this->PackageMakerVersion
                                              << std::endl);

    // Determine the package compatibility version. If it wasn't
    // specified by the user, we define it based on which features the
    // user requested.
    const char* packageCompat = this->GetOption("CPACK_OSX_PACKAGE_VERSION");
    if(packageCompat && *packageCompat)
    {
        unsigned int majorVersion = 10;
        unsigned int minorVersion = 5;
        int res = sscanf(packageCompat, "%u.%u", &majorVersion, &minorVersion);
        if(res == 2)
        {
            this->PackageCompatibilityVersion =
                getVersion(majorVersion, minorVersion);
        }
    } else if(this->GetOption("CPACK_DOWNLOAD_SITE"))
    {
        this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.5");
        this->PackageCompatibilityVersion = getVersion(10, 5);
    } else if(this->GetOption("CPACK_COMPONENTS_ALL"))
    {
        this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.4");
        this->PackageCompatibilityVersion = getVersion(10, 4);
    } else
    {
        this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.3");
        this->PackageCompatibilityVersion = getVersion(10, 3);
    }

    std::vector<std::string> no_paths;
    pkgPath = cmSystemTools::FindProgram("hdiutil", no_paths, false);
    if(pkgPath.empty())
    {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Cannot find hdiutil compiler" << std::endl);
        return 0;
    }
    this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM_DISK_IMAGE",
                            pkgPath.c_str());

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

bool
cmCPackPackageMakerGenerator::RunPackageMaker(const char* command,
                                              const char* packageFile)
{
    std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
    tmpFile += "/PackageMakerOutput.log";

    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << command << std::endl);
    std::string output;
    int         retVal = 1;
    bool        res    = cmSystemTools::RunSingleCommand(
        command, &output, &output, &retVal, nullptr, this->GeneratorVerbose,
        cmDuration::zero());
    cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                  "Done running package maker" << std::endl);
    if(!res || retVal)
    {
        cmGeneratedFileStream ofs(tmpFile.c_str());
        ofs << "# Run command: " << command << std::endl
            << "# Output:" << std::endl
            << output << std::endl;
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Problem running PackageMaker command: "
                          << command << std::endl
                          << "Please check " << tmpFile << " for errors"
                          << std::endl);
        return false;
    }
    // sometimes the command finishes but the directory is not yet
    // created, so try 10 times to see if it shows up
    int tries = 10;
    while(tries > 0 && !cmSystemTools::FileExists(packageFile))
    {
        cmSystemTools::Delay(500);
        tries--;
    }
    if(!cmSystemTools::FileExists(packageFile))
    {
        cmCPackLogger(cmCPackLog::LOG_ERROR,
                      "Problem running PackageMaker command: "
                          << command << std::endl
                          << "Package not created: " << packageFile
                          << std::endl);
        return false;
    }

    return true;
}

bool
cmCPackPackageMakerGenerator::GenerateComponentPackage(
    const char* packageFile, const char* packageDir,
    const cmCPackComponent& component)
{
    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "-   Building component package: "
                                              << packageFile << std::endl);

    // The command that will be used to run PackageMaker
    std::ostringstream pkgCmd;

    if(this->PackageCompatibilityVersion < getVersion(10, 5) ||
       this->PackageMakerVersion < 3.0)
    {
        // Create Description.plist and Info.plist files for normal Mac OS
        // X packages, which work on Mac OS X 10.3 and newer.
        std::string descriptionFile =
            this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
        descriptionFile += '/' + component.Name + "-Description.plist";
        cmsys::ofstream out(descriptionFile.c_str());
        cmXMLWriter     xout(out);
        xout.StartDocument();
        xout.Doctype("plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
                     "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\"");
        xout.StartElement("plist");
        xout.Attribute("version", "1.4");
        xout.StartElement("dict");
        xout.Element("key", "IFPkgDescriptionTitle");
        xout.Element("string", component.DisplayName);
        xout.Element("key", "IFPkgDescriptionVersion");
        xout.Element("string", this->GetOption("CPACK_PACKAGE_VERSION"));
        xout.Element("key", "IFPkgDescriptionDescription");
        xout.Element("string", component.Description);
        xout.EndElement();  // dict
        xout.EndElement();  // plist
        xout.EndDocument();
        out.close();

        // Create the Info.plist file for this component
        std::string moduleVersionSuffix = ".";
        moduleVersionSuffix += component.Name;
        this->SetOption("CPACK_MODULE_VERSION_SUFFIX",
                        moduleVersionSuffix.c_str());
        std::string infoFileName = component.Name;
        infoFileName += "-Info.plist";
        if(!this->CopyResourcePlistFile("Info.plist", infoFileName.c_str()))
        {
            return false;
        }

        pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
               << "\" -build -p \"" << packageFile << "\""
               << " -f \"" << packageDir << "\""
               << " -i \"" << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "/"
               << infoFileName << "\""
               << " -d \"" << descriptionFile << "\"";
    } else
    {
        // Create a "flat" package on Mac OS X 10.5 and newer. Flat
        // packages are stored in a single file, rather than a directory
        // like normal packages, and can be downloaded by the installer
        // on-the-fly in Mac OS X 10.5 or newer. Thus, we need to create
        // flat packages when the packages will be downloaded on the fly.
        std::string pkgId = "com.";
        pkgId += this->GetOption("CPACK_PACKAGE_VENDOR");
        pkgId += '.';
        pkgId += this->GetOption("CPACK_PACKAGE_NAME");
        pkgId += '.';
        pkgId += component.Name;

        pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
               << "\" --root \"" << packageDir << "\""
               << " --id " << pkgId << " --target "
               << this->GetOption("CPACK_OSX_PACKAGE_VERSION") << " --out \""
               << packageFile << "\"";
    }

    // Run PackageMaker
    return RunPackageMaker(pkgCmd.str().c_str(), packageFile);
}
