/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#ifndef cmExportInstallFileGenerator_h
#define cmExportInstallFileGenerator_h

#include "cmConfigure.h"  // IWYU pragma: keep

#include "cmExportFileGenerator.h"
#include "cmStateTypes.h"

#include <iosfwd>
#include <map>
#include <set>
#include <string>
#include <vector>

class cmGeneratorTarget;
class cmGlobalGenerator;
class cmInstallExportGenerator;
class cmInstallTargetGenerator;
class cmTargetExport;

/** \class cmExportInstallFileGenerator
 * \brief Generate a file exporting targets from an install tree.
 *
 * cmExportInstallFileGenerator generates files exporting targets from
 * install an installation tree.  The files are placed in a temporary
 * location for installation by cmInstallExportGenerator.  One main
 * file is generated that creates the imported targets and loads
 * per-configuration files.  Target locations and settings for each
 * configuration are written to these per-configuration files.  After
 * installation the main file loads the configurations that have been
 * installed.
 *
 * This is used to implement the INSTALL(EXPORT) command.
 */
class cmExportInstallFileGenerator : public cmExportFileGenerator
{
public:
    /** Construct with the export installer that will install the
        files.  */
    cmExportInstallFileGenerator(cmInstallExportGenerator* iegen);

    /** Get the per-config file generated for each configuration.  This
        maps from the configuration name to the file temporary location
        for installation.  */
    std::map<std::string, std::string> const& GetConfigImportFiles()
    {
        return this->ConfigImportFiles;
    }

    /** Compute the globbing expression used to load per-config import
        files from the main file.  */
    std::string GetConfigImportFileGlob();

protected:
    // Implement virtual methods from the superclass.
    bool GenerateMainFile(std::ostream& os) override;
    void GenerateImportTargetsConfig(
        std::ostream& os, const std::string& config, std::string const& suffix,
        std::vector<std::string>& missingTargets) override;
    cmStateEnums::TargetType GetExportTargetType(
        cmTargetExport const* targetExport) const;
    void HandleMissingTarget(std::string&              link_libs,
                             std::vector<std::string>& missingTargets,
                             cmGeneratorTarget*        depender,
                             cmGeneratorTarget*        dependee) override;

    void ReplaceInstallPrefix(std::string& input) override;

    void ComplainAboutMissingTarget(cmGeneratorTarget* depender,
                                    cmGeneratorTarget* dependee,
                                    int                occurrences);

    std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg,
                                            const std::string& name);

    /** Generate the relative import prefix.  */
    virtual void GenerateImportPrefix(std::ostream&);

    /** Generate the relative import prefix.  */
    virtual void LoadConfigFiles(std::ostream&);

    virtual void CleanupTemporaryVariables(std::ostream&);

    /** Generate a per-configuration file for the targets.  */
    virtual bool GenerateImportFileConfig(
        const std::string& config, std::vector<std::string>& missingTargets);

    /** Fill in properties indicating installed file locations.  */
    void SetImportLocationProperty(const std::string&        config,
                                   std::string const&        suffix,
                                   cmInstallTargetGenerator* itgen,
                                   ImportPropertyMap&        properties,
                                   std::set<std::string>&    importedLocations);

    std::string InstallNameDir(cmGeneratorTarget* target,
                               const std::string& config) override;

    cmInstallExportGenerator* IEGen;

    // The import file generated for each configuration.
    std::map<std::string, std::string> ConfigImportFiles;
};

#endif
