# Copyright (C) 2025 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause

__qt_internal_cmake_include_guard(GLOBAL GUARD_KEY "QtPublicSbomCommonGenerationHelpers")

# Save the 'macros base dir' in a global property instead of a variable, to allow access in a
# deferred function where the variable might not be accessible by the function scope.
# We explicitly don't set CMAKE_CURRENT_FUNCTION_LIST_DIR as we do in some other cases, because
# that can be overridden by a different file depending on the inclusion order of the
# cmake files, and thus pointing to a different dir.
set_property(GLOBAL PROPERTY __qt_sbom_generation_helpers_base_dir "${CMAKE_CURRENT_LIST_DIR}")

# Helper function to get common project related variables for SBOM generation for both SPDX and
# CycloneDX formats.
function(_qt_internal_sbom_get_common_project_variables)
    set(opt_args "")
    set(single_args
        # Forwarded
        OUTPUT
        OUTPUT_RELATIVE_PATH
        COPYRIGHT
        PROJECT
        PROJECT_FOR_SPDX_ID
        SUPPLIER
        SUPPLIER_URL

        # Custom inputs
        DEFAULT_SBOM_FILE_NAME_EXTENSION

        # Out vars
        OUT_VAR_PROJECT_NAME
        OUT_VAR_CURRENT_UTC
        OUT_VAR_CURRENT_YEAR
        OUT_VAR_OUTPUT
        OUT_VAR_OUTPUT_RELATIVE_PATH
        OUT_VAR_PROJECT_FOR_SPDX_ID
        OUT_VAR_COPYRIGHT
        OUT_VAR_SUPPLIER
        OUT_VAR_SUPPLIER_URL
        OUT_VAR_DEFAULT_PROJECT_COMMENT
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")

    if(QT_SBOM_FAKE_TIMESTAMP)
        set(current_utc "2590-01-01T11:33:55Z")
        set(current_year "2590")
    else()
        string(TIMESTAMP current_utc UTC)
        string(TIMESTAMP current_year "%Y" UTC)
    endif()

    set(${arg_OUT_VAR_CURRENT_UTC} "${current_utc}" PARENT_SCOPE)
    set(${arg_OUT_VAR_CURRENT_YEAR} "${current_year}" PARENT_SCOPE)

    _qt_internal_sbom_set_default_option_value(PROJECT "${PROJECT_NAME}")
    set(${arg_OUT_VAR_PROJECT_NAME} "${arg_PROJECT}" PARENT_SCOPE)

    _qt_internal_sbom_get_git_version_vars()

    _qt_internal_path_join(default_sbom_file_name
        "${arg_PROJECT}"
        "${arg_PROJECT}-sbom-${QT_SBOM_GIT_VERSION_PATH}.${arg_DEFAULT_SBOM_FILE_NAME_EXTENSION}")
    _qt_internal_path_join(default_install_sbom_path
        "\${CMAKE_INSTALL_PREFIX}/" "${CMAKE_INSTALL_DATAROOTDIR}" "${default_sbom_file_name}"
    )

    _qt_internal_sbom_set_default_option_value(OUTPUT "${default_install_sbom_path}")
    _qt_internal_sbom_set_default_option_value(OUTPUT_RELATIVE_PATH
        "${default_sbom_file_name}")

    set(${arg_OUT_VAR_OUTPUT} "${arg_OUTPUT}" PARENT_SCOPE)
    set(${arg_OUT_VAR_OUTPUT_RELATIVE_PATH} "${arg_OUTPUT_RELATIVE_PATH}" PARENT_SCOPE)

    _qt_internal_sbom_set_default_option_value(PROJECT_FOR_SPDX_ID "Package-${arg_PROJECT}")
    string(REGEX REPLACE "[^A-Za-z0-9.]+" "-" arg_PROJECT_FOR_SPDX_ID "${arg_PROJECT_FOR_SPDX_ID}")
    string(REGEX REPLACE "-+$" "" arg_PROJECT_FOR_SPDX_ID "${arg_PROJECT_FOR_SPDX_ID}")

    # Prevent collision with other generated SPDXID with -[0-9]+ suffix.
    string(REGEX REPLACE "-([0-9]+)$" "\\1" arg_PROJECT_FOR_SPDX_ID "${arg_PROJECT_FOR_SPDX_ID}")

    _qt_internal_sbom_get_spdx_id_unique_suffix(spdx_id_unique_suffix)
    set(project_spdx_id "SPDXRef-${arg_PROJECT_FOR_SPDX_ID}${spdx_id_unique_suffix}")

    set(${arg_OUT_VAR_PROJECT_FOR_SPDX_ID} "${project_spdx_id}" PARENT_SCOPE)

    _qt_internal_sbom_set_default_option_value_and_error_if_empty(SUPPLIER "")
    set(${arg_OUT_VAR_SUPPLIER} "${arg_SUPPLIER}" PARENT_SCOPE)

    _qt_internal_sbom_set_default_option_value_and_error_if_empty(SUPPLIER_URL
        "${PROJECT_HOMEPAGE_URL}")
    set(${arg_OUT_VAR_SUPPLIER_URL} "${arg_SUPPLIER_URL}" PARENT_SCOPE)

    _qt_internal_sbom_set_default_option_value(COPYRIGHT "${current_year} ${arg_SUPPLIER}")
    set(${arg_OUT_VAR_COPYRIGHT} "${arg_COPYRIGHT}" PARENT_SCOPE)

    get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
    if(is_multi_config)
        set(cmake_configs "${CMAKE_CONFIGURATION_TYPES}")
    else()
        set(cmake_configs "${CMAKE_BUILD_TYPE}")
    endif()

    set(cmake_version "Built by CMake ${CMAKE_VERSION}")
    set(system_name_and_processor "${CMAKE_SYSTEM_NAME} (${CMAKE_SYSTEM_PROCESSOR})")
    set(default_project_comment
        "${cmake_version} with ${cmake_configs} configuration for ${system_name_and_processor}")
    set(${arg_OUT_VAR_DEFAULT_PROJECT_COMMENT} "${default_project_comment}" PARENT_SCOPE)
endfunction()

# Helper function to save SBOM project path values like relative build and install dirs,
# in global properties.
function(_qt_internal_sbom_save_common_path_variables_in_global_properties)
    set(opt_args "")
    set(single_args
        OUTPUT
        OUTPUT_RELATIVE_PATH
        SBOM_DIR
        SBOM_FORMAT
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    get_filename_component(output_file_name_without_ext "${arg_OUTPUT}" NAME_WLE)
    get_filename_component(output_file_ext "${arg_OUTPUT}" LAST_EXT)

    set(computed_sbom_file_name_without_ext "${output_file_name_without_ext}${multi_config_suffix}")
    set(computed_sbom_file_name "${output_file_name_without_ext}${output_file_ext}")

    # In a super build and in a no-prefix build, put all the build time sboms into the same dir in,
    # in the qtbase build dir.
    if(QT_BUILDING_QT AND (QT_SUPERBUILD OR (NOT QT_WILL_INSTALL)))
        set(build_sbom_root_dir "${QT_BUILD_DIR}")
    else()
        set(build_sbom_root_dir "${arg_SBOM_DIR}")
    endif()

    get_filename_component(output_relative_dir "${arg_OUTPUT_RELATIVE_PATH}" DIRECTORY)

    set(build_sbom_dir "${build_sbom_root_dir}/${output_relative_dir}")
    set(build_sbom_path "${build_sbom_dir}/${computed_sbom_file_name}")
    set(build_sbom_path_without_ext
        "${build_sbom_dir}/${computed_sbom_file_name_without_ext}")

    set(install_sbom_path "${arg_OUTPUT}")

    get_filename_component(install_sbom_dir "${install_sbom_path}" DIRECTORY)
    set(install_sbom_path_without_ext "${install_sbom_dir}/${output_file_name_without_ext}")

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(suffix "")
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(suffix "_cydx")
    else()
        message(FATAL_ERROR "Unknown SBOM_FORMAT: ${arg_SBOM_FORMAT}")
    endif()

    set_property(GLOBAL PROPERTY _qt_sbom_build_output_path${suffix} "${build_sbom_path}")
    set_property(GLOBAL PROPERTY _qt_sbom_build_output_path_without_ext${suffix}
        "${build_sbom_path_without_ext}")
    set_property(GLOBAL PROPERTY _qt_sbom_build_output_dir${suffix} "${build_sbom_dir}")

    set_property(GLOBAL PROPERTY _qt_sbom_install_output_path${suffix} "${install_sbom_path}")
    set_property(GLOBAL PROPERTY _qt_sbom_install_output_path_without_ext${suffix}
        "${install_sbom_path_without_ext}")
    set_property(GLOBAL PROPERTY _qt_sbom_install_output_dir${suffix} "${install_sbom_dir}")
endfunction()

# Helper function to get SBOM project path values like relative build and install dirs,
function(_qt_internal_sbom_get_common_path_variables_from_global_properties)
    set(opt_args "")
    set(single_args
        SBOM_FORMAT
        OUT_VAR_SBOM_BUILD_OUTPUT_PATH
        OUT_VAR_SBOM_BUILD_OUTPUT_PATH_WITHOUT_EXT
        OUT_VAR_SBOM_BUILD_OUTPUT_DIR
        OUT_VAR_SBOM_INSTALL_OUTPUT_PATH
        OUT_VAR_SBOM_INSTALL_OUTPUT_PATH_WITHOUT_EXT
        OUT_VAR_SBOM_INSTALL_OUTPUT_DIR
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(suffix "")
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(suffix "_cydx")
    endif()

    get_property(sbom_build_output_path GLOBAL PROPERTY _qt_sbom_build_output_path${suffix})
    get_property(sbom_build_output_path_without_ext GLOBAL PROPERTY
        _qt_sbom_build_output_path_without_ext${suffix})
    get_property(sbom_build_output_dir GLOBAL PROPERTY _qt_sbom_build_output_dir${suffix})

    get_property(sbom_install_output_path GLOBAL PROPERTY _qt_sbom_install_output_path${suffix})
    get_property(sbom_install_output_path_without_ext GLOBAL PROPERTY
        _qt_sbom_install_output_path_without_ext${suffix})
    get_property(sbom_install_output_dir GLOBAL PROPERTY _qt_sbom_install_output_dir${suffix})

    if(arg_OUT_VAR_SBOM_BUILD_OUTPUT_PATH)
        set(${arg_OUT_VAR_SBOM_BUILD_OUTPUT_PATH} "${sbom_build_output_path}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_SBOM_BUILD_OUTPUT_PATH_WITHOUT_EXT)
        set(${arg_OUT_VAR_SBOM_BUILD_OUTPUT_PATH_WITHOUT_EXT}
            "${sbom_build_output_path_without_ext}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_SBOM_BUILD_OUTPUT_DIR)
        set(${arg_OUT_VAR_SBOM_BUILD_OUTPUT_DIR} "${sbom_build_output_dir}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_SBOM_INSTALL_OUTPUT_PATH)
        set(${arg_OUT_VAR_SBOM_INSTALL_OUTPUT_PATH} "${sbom_install_output_path}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_SBOM_INSTALL_OUTPUT_PATH_WITHOUT_EXT)
        set(${arg_OUT_VAR_SBOM_INSTALL_OUTPUT_PATH_WITHOUT_EXT}
            "${sbom_install_output_path_without_ext}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_SBOM_INSTALL_OUTPUT_DIR)
        set(${arg_OUT_VAR_SBOM_INSTALL_OUTPUT_DIR} "${sbom_install_output_dir}" PARENT_SCOPE)
    endif()
endfunction()

# Create the build directory that will contain all the intermediate generated sbom files.
function(_qt_internal_sbom_create_sbom_staging_dir)
    set(opt_args "")
    set(single_args
        OUT_VAR_SBOM_DIR
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    if(NOT arg_OUT_VAR_SBOM_DIR)
        message(FATAL_ERROR "OUT_VAR_SBOM_DIR argument is required.")
    endif()

    _qt_internal_get_current_project_sbom_dir(sbom_dir)
    file(MAKE_DIRECTORY "${sbom_dir}")
    set(${arg_OUT_VAR_SBOM_DIR} "${sbom_dir}" PARENT_SCOPE)
endfunction()

# Helper function to create a staging file for SBOM generation.
# It is the file that will be incrementally assembled by having content appended to it.
# Also creates the intro file that will add the assembled content for the SBOM project, aka for the
# main SPDX package or root CycloneDX component.
function(_qt_internal_sbom_create_sbom_staging_file)
    set(opt_args "")
    set(single_args
        SBOM_FORMAT
        REPO_PROJECT_NAME_LOWERCASE
        SBOM_DIR
    )
    set(multi_args
        RELATIONSHIP_STRINGS
    )
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    if(NOT arg_SBOM_DIR)
        message(FATAL_ERROR "SBOM_DIR argument is required")
    endif()
    set(sbom_dir "${arg_SBOM_DIR}")

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(doc_base_name "SPDXRef-DOCUMENT")
        set(doc_extension "spdx.in")
        set(suffix "")
        set(extra_content "
        set(QT_SBOM_EXTERNAL_DOC_REFS \"\")
")
        _qt_internal_get_staging_area_spdx_file_path(staging_area_file)
        set(starting_message "Starting SPDX SBOM generation in build dir: ${staging_area_file}")
        set(extra_intro_content "")
        set(project_relationship_strings "")
        if(arg_RELATIONSHIP_STRINGS)
            list(JOIN arg_RELATIONSHIP_STRINGS "\n" arg_RELATIONSHIP_STRINGS)

            # Prepend a newline to separate from the very first always there relationship.
            string(APPEND extra_intro_content "\n${arg_RELATIONSHIP_STRINGS}")
        endif()
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(doc_base_name "cydx-document")
        set(doc_extension "cdx.in.toml")
        set(suffix "_cydx")
        set(extra_content "")
        _qt_internal_get_staging_area_cydx_file_path(staging_area_file)
        set(starting_message
            "Starting CycloneDX SBOM TOML file generation in build dir: ${staging_area_file}")
        set(extra_intro_content "")

        if(arg_RELATIONSHIP_STRINGS)
            list(JOIN arg_RELATIONSHIP_STRINGS "\n" arg_RELATIONSHIP_STRINGS)
            set(project_relationship_strings "${arg_RELATIONSHIP_STRINGS}")
        else()
            set(project_relationship_strings "")
        endif()
    endif()

    # Assemble final intro content.
    get_property(intro_content GLOBAL PROPERTY _qt_sbom_project_intro_content${suffix})
    if(NOT intro_content)
        message(FATAL_ERROR "Missing intro content for SBOM generation.")
    endif()

    if(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        string(REPLACE "<PROJECT_RELATIONSHIP_PLACEHOLDER>" "${project_relationship_strings}"
            intro_content "${intro_content}")
    endif()

    if(extra_intro_content)
        string(APPEND intro_content "${extra_intro_content}")
    endif()

    # Final new line to separate the main package from rest of info.
    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        string(APPEND intro_content "\n")
    endif()

    # Generate project document intro file.
    set(document_intro_file_name
        "${sbom_dir}/${doc_base_name}-${arg_REPO_PROJECT_NAME_LOWERCASE}.${doc_extension}")
    file(GENERATE OUTPUT "${document_intro_file_name}" CONTENT "${intro_content}")

    get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
    if(is_multi_config)
        set(multi_config_suffix "-$<CONFIG>")
    else()
        set(multi_config_suffix "")
    endif()

    # Create cmake file to append the document intro to the staging file.
    set(create_staging_file
        "${sbom_dir}/append_document_to_staging${suffix}${multi_config_suffix}.cmake")

    set(content "
        cmake_minimum_required(VERSION 3.16)
        message(STATUS \"${starting_message}\")
        ${extra_content}
        file(READ \"${document_intro_file_name}\" content)
        # Override any previous file because we're starting from scratch.
        file(WRITE \"${staging_area_file}\" \"\${content}\")
")
    file(GENERATE OUTPUT "${create_staging_file}" CONTENT "${content}")
    set_property(GLOBAL PROPERTY _qt_sbom_cmake_intro_file${suffix} "${create_staging_file}")
endfunction()

# Helper function to save common project info like supplier, project name, spdx id in global
# properties.
function(_qt_internal_sbom_save_project_info_in_global_properties)
    set(opt_args "")
    set(single_args
        SUPPLIER
        SUPPLIER_URL
        NAMESPACE
        PROJECT
        PROJECT_SPDX_ID
    )
    set(multi_args
        EXTERNAL_REFERENCE_SBOM_DIRS
    )
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    set_property(GLOBAL PROPERTY _qt_sbom_project_supplier "${arg_SUPPLIER}")
    set_property(GLOBAL PROPERTY _qt_sbom_project_supplier_url "${arg_SUPPLIER_URL}")
    set_property(GLOBAL PROPERTY _qt_sbom_project_namespace "${arg_NAMESPACE}")

    set_property(GLOBAL PROPERTY _qt_sbom_project_name "${arg_PROJECT}")
    set_property(GLOBAL PROPERTY _qt_sbom_project_spdx_id "${arg_PROJECT_SPDX_ID}")

    # Used for finding external reference spdx documents.
    if(arg_EXTERNAL_REFERENCE_SBOM_DIRS)
        set_property(GLOBAL APPEND PROPERTY _qt_internal_sbom_dirs
            ${arg_EXTERNAL_REFERENCE_SBOM_DIRS})
    endif()
endfunction()

# Helper function to save sbom intro content (per sbom format) in a global property.
function(_qt_internal_sbom_save_intro_content)
    set(opt_args "")
    set(single_args
        SBOM_FORMAT
        CONTENT
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(suffix "")
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(suffix "_cydx")
    else()
        message(FATAL_ERROR "Unknown SBOM_FORMAT: ${arg_SBOM_FORMAT}")
    endif()

    set_property(GLOBAL PROPERTY _qt_sbom_project_intro_content${suffix} "${content}")
endfunction()

# Helper function to get cmake include files for SBOM generation from global properties.
function(_qt_internal_sbom_get_cmake_include_files)
    set(opt_args "")
    set(single_args
        SBOM_FORMAT
        OUT_VAR_INCLUDES
        OUT_VAR_BEFORE_CHECKSUM_INCLUDES
        OUT_VAR_AFTER_CHECKSUM_INCLUDES
        OUT_VAR_POST_GENERATION_INCLUDES
        OUT_VAR_VERIFY_INCLUDES
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(suffix "")
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(suffix "_cydx")
    endif()

    _qt_internal_sbom_collect_cmake_include_files(includes
        JOIN_WITH_NEWLINES
        PROPERTIES
            _qt_sbom_cmake_intro_file${suffix}
            _qt_sbom_cmake_include_files${suffix}
            _qt_sbom_cmake_end_include_files${suffix}
    )

    # Before checksum includes are included after the verification codes have been collected
    # and before their merged checksum(s) has been computed.
    _qt_internal_sbom_collect_cmake_include_files(before_checksum_includes
        JOIN_WITH_NEWLINES
        PROPERTIES _qt_sbom_cmake_before_checksum_include_files${suffix}
    )

    # After checksum includes are included after the checksum has been computed and written to the
    # QT_SBOM_VERIFICATION_CODE variable.
    _qt_internal_sbom_collect_cmake_include_files(after_checksum_includes
        JOIN_WITH_NEWLINES
        PROPERTIES _qt_sbom_cmake_after_checksum_include_files${suffix}
    )

    # Post generation includes are included for both build and install time sboms, after
    # sbom generation has finished.
    _qt_internal_sbom_collect_cmake_include_files(post_generation_includes
        JOIN_WITH_NEWLINES
        PROPERTIES _qt_sbom_cmake_post_generation_include_files${suffix}
    )

    # Verification only makes sense on installation, where the checksums are present.
    _qt_internal_sbom_collect_cmake_include_files(verify_includes
        JOIN_WITH_NEWLINES
        PROPERTIES _qt_sbom_cmake_verify_include_files${suffix}
    )

    if(arg_OUT_VAR_INCLUDES)
        set(${arg_OUT_VAR_INCLUDES} "${includes}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_INCLUDES)
        set(${arg_OUT_VAR_BEFORE_CHECKSUM_INCLUDES} "${before_checksum_includes}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_INCLUDES)
        set(${arg_OUT_VAR_AFTER_CHECKSUM_INCLUDES} "${after_checksum_includes}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_INCLUDES)
        set(${arg_OUT_VAR_POST_GENERATION_INCLUDES} "${post_generation_includes}" PARENT_SCOPE)
    endif()
    if(arg_OUT_VAR_INCLUDES)
        set(${arg_OUT_VAR_VERIFY_INCLUDES} "${verify_includes}" PARENT_SCOPE)
    endif()
endfunction()

# Clears cmake include files for the current project from the global properties.
function(_qt_internal_sbom_clear_cmake_include_files)
    set(opt_args "")
    set(single_args
        SBOM_FORMAT
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(suffix "")
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(suffix "_cydx")
    endif()

    # Clean up properties, so that they are empty for possible next repo in a top-level build.
    set_property(GLOBAL PROPERTY _qt_sbom_cmake_include_files${suffix} "")
    set_property(GLOBAL PROPERTY _qt_sbom_cmake_end_include_files${suffix} "")
    set_property(GLOBAL PROPERTY _qt_sbom_cmake_before_checksum_include_files${suffix} "")
    set_property(GLOBAL PROPERTY _qt_sbom_cmake_after_checksum_include_files${suffix} "")
    set_property(GLOBAL PROPERTY _qt_sbom_cmake_post_generation_include_files${suffix} "")
    set_property(GLOBAL PROPERTY _qt_sbom_cmake_verify_include_files${suffix} "")
endfunction()

# Creates cmake build targets to create build-time SBOMs (for testing purposes only, because they
# lack checksums for installed files).
# Also creates the assemble_sbom cmake file that is used by both build-time and install-time
# sbom generation.
function(_qt_internal_sbom_create_build_time_sbom_targets)
    set(opt_args "")
    set(single_args
        SBOM_FORMAT
        REPO_PROJECT_NAME_LOWERCASE
        REAL_QT_REPO_PROJECT_NAME_LOWERCASE
        SBOM_BUILD_OUTPUT_PATH
        SBOM_BUILD_OUTPUT_PATH_WITHOUT_EXT
        SBOM_BUILD_OUTPUT_DIR
        INCLUDES
        POST_GENERATION_INCLUDES
        OUT_VAR_ASSEMBLE_SBOM_INCLUDE_PATH
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(suffix "")
        set(extra_content "
        set(QT_SBOM_PACKAGES \"\")
        set(QT_SBOM_PACKAGES_WITH_VERIFICATION_CODES \"\")
")
        _qt_internal_get_staging_area_spdx_file_path(staging_area_file)
        set(final_message "Finalizing SPDX SBOM generation in build dir")
        set(build_comment "SPDX document")
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(suffix "_cydx")
        set(extra_content "")
        _qt_internal_get_staging_area_cydx_file_path(staging_area_file)
        set(final_message "Finalizing Cyclone DX SBOM TOML generation in build dir")
        set(build_comment "Cyclone DX document")
    endif()

    get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
    if(is_multi_config)
        set(multi_config_suffix "-$<CONFIG>")
    else()
        set(multi_config_suffix "")
    endif()

    if(QT_BUILD_DIR)
        set(build_sbom_install_prefix "${QT_BUILD_DIR}")
    else()
        set(build_sbom_install_prefix "${CMAKE_BINARY_DIR}")
    endif()

    get_property(macro_module_base_dir GLOBAL PROPERTY __qt_sbom_generation_helpers_base_dir)
    _qt_internal_get_current_project_sbom_dir(sbom_dir)
    set(content "
        # Include helpers functions.
        include(\"${macro_module_base_dir}/QtPublicCMakeIncludeGuardHelpers.cmake\")
        include(\"${macro_module_base_dir}/QtPublicCMakeHelpers.cmake\")
        include(\"${macro_module_base_dir}/QtPublicSbomExternalReferenceHelpers.cmake\")
        include(\"${macro_module_base_dir}/QtPublicSbomOpsHelpers.cmake\")

        # QT_SBOM_BUILD_TIME be set to FALSE at install time, so don't override if it's set.
        # This allows reusing the same cmake file for both build and install.
        if(NOT DEFINED QT_SBOM_BUILD_TIME)
            set(QT_SBOM_BUILD_TIME TRUE)

            # Set CMAKE_INSTALL_PREFIX for build time SBOMs to the build dir,
            # because a repo's SBOM generation might refer to it, and when it is empty,
            # it will try to write into a subdirectory of the root dir, e.g. '/sbom' dir,
            # failing due to lack of permissions.
            if(NOT DEFINED CMAKE_INSTALL_PREFIX OR NOT CMAKE_INSTALL_PREFIX)
                set(QT_SBOM_BUILD_SBOM_INSTALL_PREFIX \"${build_sbom_install_prefix}\")
                set(CMAKE_INSTALL_PREFIX \"\${QT_SBOM_BUILD_SBOM_INSTALL_PREFIX}\")
            endif()
        endif()
        if(NOT QT_SBOM_OUTPUT_PATH)
            set(QT_SBOM_OUTPUT_DIR \"${arg_SBOM_BUILD_OUTPUT_DIR}\")
            set(QT_SBOM_OUTPUT_PATH \"${arg_SBOM_BUILD_OUTPUT_PATH}\")
            set(QT_SBOM_OUTPUT_PATH_WITHOUT_EXT \"${arg_SBOM_BUILD_OUTPUT_PATH_WITHOUT_EXT}\")
            file(MAKE_DIRECTORY \"${arg_SBOM_BUILD_OUTPUT_DIR}\")
        endif()
        ${extra_content}
        ${arg_INCLUDES}
        if(QT_SBOM_BUILD_TIME)
            message(STATUS \"${final_message}: \${QT_SBOM_OUTPUT_PATH}\")
            configure_file(\"${staging_area_file}\" \"\${QT_SBOM_OUTPUT_PATH}\")
            ${arg_POST_GENERATION_INCLUDES}
        endif()
")
    set(assemble_sbom "${sbom_dir}/assemble_sbom${suffix}${multi_config_suffix}.cmake")
    file(GENERATE OUTPUT "${assemble_sbom}" CONTENT "${content}")

    if(NOT TARGET sbom)
        add_custom_target(sbom)
    endif()

    # Create a build target to create a build-time sbom (no verification codes or sha1s).
    set(repo_sbom_target "sbom_${arg_REPO_PROJECT_NAME_LOWERCASE}${suffix}")
    set(comment "")
    string(APPEND comment "Assembling build time ${build_comment} without checksums for "
        "${arg_REPO_PROJECT_NAME_LOWERCASE}. Just for testing.")
    add_custom_target(${repo_sbom_target}
        COMMAND "${CMAKE_COMMAND}" -P "${assemble_sbom}"
        COMMENT "${comment}"
        VERBATIM
        USES_TERMINAL # To avoid running two configs of the command in parallel
    )

    get_cmake_property(qt_repo_deps _qt_repo_deps_${arg_REAL_QT_REPO_PROJECT_NAME_LOWERCASE})
    if(qt_repo_deps)
        foreach(repo_dep IN LISTS qt_repo_deps)
            set(repo_dep_sbom "sbom_${repo_dep}${suffix}")
            if(TARGET "${repo_dep_sbom}")
                add_dependencies(${repo_sbom_target} ${repo_dep_sbom})
            endif()
        endforeach()
    endif()

    add_dependencies(sbom ${repo_sbom_target})

    set(${arg_OUT_VAR_ASSEMBLE_SBOM_INCLUDE_PATH} "${assemble_sbom}" PARENT_SCOPE)
endfunction()

# Helper function to setup install markers for multi-config generators.
# Makes sure to wait for all configurations to finish installation before actually generating
# the SBOM and removing the markers.
function(_qt_internal_sbom_setup_multi_config_install_markers)
    set(opt_args "")
    set(single_args
        SBOM_DIR
        SBOM_FORMAT
        REPO_PROJECT_NAME_LOWERCASE
        OUT_VAR_EXTRA_CODE_BEGIN
        OUT_VAR_EXTRA_CODE_INNER_END
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    set(extra_code_begin "")
    set(extra_code_inner_end "")

    get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
    if(NOT is_multi_config)
        set(${arg_OUT_VAR_EXTRA_CODE_BEGIN} "${extra_code_begin}" PARENT_SCOPE)
        set(${arg_OUT_VAR_EXTRA_CODE_INNER_END} "${extra_code_inner_end}" PARENT_SCOPE)
        return()
    endif()

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(suffix "_spdx")
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(suffix "_cydx")
    endif()

    set(configs ${CMAKE_CONFIGURATION_TYPES})

    set(install_markers_dir "${arg_SBOM_DIR}")
    set(install_marker_path "${install_markers_dir}/finished_install${suffix}-$<CONFIG>.cmake")

    set(install_marker_code "
        message(STATUS \"Writing install marker for config $<CONFIG>: ${install_marker_path} \")
        file(WRITE \"${install_marker_path}\" \"\")
")

    install(CODE "${install_marker_code}" COMPONENT sbom)
    if(QT_SUPERBUILD)
        install(CODE "${install_marker_code}"
            COMPONENT "sbom_${arg_REPO_PROJECT_NAME_LOWERCASE}${suffix}"
            EXCLUDE_FROM_ALL)
    endif()

    set(install_markers "")
    foreach(config IN LISTS configs)
        set(marker_path "${install_markers_dir}/finished_install${suffix}-${config}.cmake")
        list(APPEND install_markers "${marker_path}")
        # Remove the markers on reconfiguration, just in case there are stale ones.
        if(EXISTS "${marker_path}")
            file(REMOVE "${marker_path}")
        endif()
    endforeach()

    # Escape the semicolons in install_makers, so they don't break argument parsing in
    # _qt_internal_sbom_setup_sbom_install_code when they are forwarded there.
    string(REPLACE ";" "\\;" install_markers "${install_markers}")

    set(extra_code_begin "
    set(QT_SBOM_INSTALL_MARKERS${suffix} \"${install_markers}\")
    foreach(QT_SBOM_INSTALL_MARKER IN LISTS QT_SBOM_INSTALL_MARKERS${suffix})
        if(NOT EXISTS \"\${QT_SBOM_INSTALL_MARKER}\")
            set(QT_SBOM_INSTALLED_ALL_CONFIGS${suffix} FALSE)
        endif()
    endforeach()
")
    set(extra_code_inner_end "
        foreach(QT_SBOM_INSTALL_MARKER IN LISTS QT_SBOM_INSTALL_MARKERS${suffix})
            message(STATUS
                \"Removing install marker: \${QT_SBOM_INSTALL_MARKER} \")
            file(REMOVE \"\${QT_SBOM_INSTALL_MARKER}\")
        endforeach()
")

    set(${arg_OUT_VAR_EXTRA_CODE_BEGIN} "${extra_code_begin}" PARENT_SCOPE)
    set(${arg_OUT_VAR_EXTRA_CODE_INNER_END} "${extra_code_inner_end}" PARENT_SCOPE)
endfunction()

# Helper function to setup the fake checksum code snippet.
function(_qt_internal_sbom_setup_fake_checksum)
    set(opt_args "")
    set(single_args
        OUT_VAR_FAKE_CHECKSUM_CODE
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    # Allow skipping checksum computation for testing purposes, while installing just the sbom
    # documents, without requiring to build and install all the actual files.
    set(extra_code "")
    if(QT_SBOM_FAKE_CHECKSUM)
        string(APPEND extra_code "
            set(QT_SBOM_FAKE_CHECKSUM TRUE)")
    endif()

    set(${arg_OUT_VAR_FAKE_CHECKSUM_CODE} "${extra_code}" PARENT_SCOPE)
endfunction()

# Helper function to setup the install-time SBOM generation code.
function(_qt_internal_sbom_setup_sbom_install_code)
    set(opt_args "")
    set(single_args
        SBOM_FORMAT
        REPO_PROJECT_NAME_LOWERCASE

        SBOM_INSTALL_OUTPUT_PATH
        SBOM_INSTALL_OUTPUT_PATH_WITHOUT_EXT
        SBOM_INSTALL_OUTPUT_DIR

        ASSEMBLE_SBOM_INCLUDE_PATH

        EXTRA_CODE_BEGIN
        EXTRA_CODE_INNER_END
        PROCESS_VERIFICATION_CODES

        BEFORE_CHECKSUM_INCLUDES
        AFTER_CHECKSUM_INCLUDES
        POST_GENERATION_INCLUDES
        VERIFY_INCLUDES
    )
    set(multi_args "")
    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
    _qt_internal_validate_all_args_are_parsed(arg)

    if(arg_SBOM_FORMAT STREQUAL "SPDX_V2")
        set(suffix "_spdx")
        _qt_internal_get_staging_area_spdx_file_path(staging_area_file)
        set(final_message "Finalizing SBOM generation in install dir")
        set(process_verification_codes "
            include(\"${arg_PROCESS_VERIFICATION_CODES}\")
")
    elseif(arg_SBOM_FORMAT STREQUAL "CYDX_V1_6")
        set(suffix "_cydx")
        set(final_message "Finalizing intermediate TOML generation in install dir")

        set(process_verification_codes "")
        _qt_internal_get_staging_area_cydx_file_path(staging_area_file)
    endif()

    set(assemble_sbom_install "
        set(QT_SBOM_INSTALLED_ALL_CONFIGS${suffix} TRUE)
        ${arg_EXTRA_CODE_BEGIN}
        if(QT_SBOM_INSTALLED_ALL_CONFIGS${suffix})
            set(QT_SBOM_BUILD_TIME FALSE)
            set(QT_SBOM_OUTPUT_DIR \"${arg_SBOM_INSTALL_OUTPUT_DIR}\")
            set(QT_SBOM_OUTPUT_PATH \"${arg_SBOM_INSTALL_OUTPUT_PATH}\")
            set(QT_SBOM_OUTPUT_PATH_WITHOUT_EXT \"${arg_SBOM_INSTALL_OUTPUT_PATH_WITHOUT_EXT}\")
            file(MAKE_DIRECTORY \"${arg_SBOM_INSTALL_OUTPUT_DIR}\")
            include(\"${arg_ASSEMBLE_SBOM_INCLUDE_PATH}\")
            ${arg_BEFORE_CHECKSUM_INCLUDES}
            ${process_verification_codes}
            ${arg_AFTER_CHECKSUM_INCLUDES}
            message(STATUS \"${final_message}: \${QT_SBOM_OUTPUT_PATH}\")
            configure_file(\"${staging_area_file}\" \"\${QT_SBOM_OUTPUT_PATH}\")
            ${arg_POST_GENERATION_INCLUDES}
            ${arg_VERIFY_INCLUDES}
            ${arg_EXTRA_CODE_INNER_END}
        else()
            message(STATUS \"Skipping SBOM finalization because not all configs were installed.\")
        endif()
")

    install(CODE "${assemble_sbom_install}" COMPONENT sbom)
    if(QT_SUPERBUILD)
        install(CODE "${assemble_sbom_install}" COMPONENT "sbom_${arg_REPO_PROJECT_NAME_LOWERCASE}"
            EXCLUDE_FROM_ALL)
    endif()
endfunction()