# ~~~
# Copyright (c) 2020-2026 LunarG, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Authors:
# - Christophe Riccio <christophe@lunarg.com>
# - Charles Giessen <charles@lunarg.com>
# ~~~

cmake_minimum_required(VERSION 3.22.1)

project(VULKAN_PROFILES LANGUAGES CXX C)

# Enable GUI folders
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

include(GNUInstallDirs)

# This variable enables downstream users to customize the target API variant (e.g. Vulkan SC)
set(API_TYPE "vulkan")

set(PROFILES_CPP_STANDARD 17 CACHE STRING "Set the C++ standard to build against.")
set(CMAKE_CXX_STANDARD ${PROFILES_CPP_STANDARD})
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_CXX_VISIBILITY_PRESET "hidden")
set(CMAKE_C_VISIBILITY_PRESET "hidden")
set(CMAKE_VISIBILITY_INLINES_HIDDEN "YES")

add_subdirectory(scripts)
set(MERGE_SCRIPT ${PROJECT_SOURCE_DIR}/scripts/gen_profiles_file.py)
set(SOLUTION_SCRIPT ${PROJECT_SOURCE_DIR}/scripts/gen_profiles_solution.py)
set(PROFILES_SCRIPT ${PROJECT_SOURCE_DIR}/scripts/vkprofiles.py)

# We need Python 3.10 or better to use pyinstaller 6.
find_package(Python3 3.10 REQUIRED COMPONENTS Interpreter)

# Some Python-based build operations (e.g. turning a Python script into a standalone
# executable) require custom Python modules. Here we'll create a custom
# Python virtual environment with the modules we need.
set(VENV_DIR "${CMAKE_CURRENT_BINARY_DIR}/python-venv")
if(WIN32)
    set(VENV_PYTHON_EXECUTABLE "${VENV_DIR}/Scripts/python.exe")
else()
    set(VENV_PYTHON_EXECUTABLE "${VENV_DIR}/bin/python3")
endif()

# VENV_STAMP is used as a dependency for any target using the venv, to ensure
# that if the venv's dependencies are changed, the venv will be updated.
set(VENV_STAMP "${VENV_DIR}/venv.stamp")

add_custom_command(
    OUTPUT "${VENV_STAMP}"
    COMMAND ${Python3_EXECUTABLE} -m venv "${VENV_DIR}"
    COMMAND "${VENV_PYTHON_EXECUTABLE}" -m pip install --no-cache-dir -r "${CMAKE_CURRENT_SOURCE_DIR}/requirements.txt"
    COMMAND ${CMAKE_COMMAND} -E touch "${VENV_STAMP}"
    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/requirements.txt"
    COMMENT "Creating Python virtual environment and installing dependencies..."
    VERBATIM
)

# This target works in subdirectories as a dependency.
add_custom_target(python_venv DEPENDS "${VENV_STAMP}")

# ==============================================================================

find_package(VulkanHeaders REQUIRED CONFIG QUIET)
find_package(VulkanUtilityLibraries REQUIRED CONFIG QUIET)
find_package(valijson REQUIRED CONFIG)
find_package(jsoncpp REQUIRED CONFIG)

# Write baked_version.py immediately after VulkanHeaders is found, BEFORE file(GLOB) is executed
file(WRITE "${CMAKE_CURRENT_SOURCE_DIR}/scripts/source/baked_version.py" "BAKED_VERSION = \"${VulkanHeaders_VERSION}\"\n")

# Workaround AppleClang using the wrong headers when there are headers in /usr/local/include
if (CMAKE_CXX_COMPILER_ID STREQUAL AppleClang AND TARGET Vulkan::Headers AND TARGET Vulkan::LayerSettings AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.25)
    set_target_properties(Vulkan::Headers PROPERTIES SYSTEM OFF)
    set_target_properties(Vulkan::LayerSettings PROPERTIES SYSTEM OFF)
    set_target_properties(Vulkan::UtilityHeaders PROPERTIES SYSTEM OFF)
endif()

option(BUILD_TESTS "Build the tests")
if (BUILD_TESTS)
    enable_testing()
    find_package(GTest REQUIRED CONFIG)

    if(NOT ANDROID)
        find_package(VulkanLoader REQUIRED CONFIG)
    endif()

    add_subdirectory(scripts/tests)
endif()

option(BUILD_TESTS_EXTRA "Build the extra tests, for developers only")
if (BUILD_TESTS_EXTRA)
    add_definitions(-DVKU_FORCE_EXTRA_TESTS)
endif()

set(PROFILES_SCHEMA_FILENAME "profiles-0.8-latest.json")

# Generate profiles executable
function(add_pyinstaller_target TARGET_NAME)
    # Define the arguments the function accepts
    set(options)
    set(oneValueArgs SCRIPT OUTPUT_DIR FOLDER OUTPUT_NAME)
    set(multiValueArgs DEPENDS PATHS)
    cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

    if(NOT ARG_SCRIPT)
        message(FATAL_ERROR "add_pyinstaller_target: SCRIPT argument is required for target ${TARGET_NAME}")
    endif()

    if(NOT ARG_OUTPUT_DIR)
        set(ARG_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
    endif()

    if(NOT ARG_OUTPUT_NAME)
        set(ARG_OUTPUT_NAME "${TARGET_NAME}")
    endif()

    # Handle OS-specific executable extension
    if(WIN32)
        set(EXE_NAME "${ARG_OUTPUT_NAME}.exe")
    else()
        set(EXE_NAME "${ARG_OUTPUT_NAME}")
    endif()
    set(FINAL_EXECUTABLE "${ARG_OUTPUT_DIR}/${EXE_NAME}")

    set(PYINSTALLER_PATH_FLAGS)
    foreach(p ${ARG_PATHS})
        list(APPEND PYINSTALLER_PATH_FLAGS "--paths" "${p}")
    endforeach()

    # Generate the executable via PyInstaller using the VENV python executable
    add_custom_command(
        OUTPUT "${FINAL_EXECUTABLE}"
        COMMAND "${VENV_PYTHON_EXECUTABLE}" -m PyInstaller --onefile --clean ${PYINSTALLER_PATH_FLAGS} --name "${ARG_OUTPUT_NAME}" --distpath "${ARG_OUTPUT_DIR}" "${ARG_SCRIPT}"
        DEPENDS ${ARG_DEPENDS} python_venv
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        COMMENT "Packaging ${TARGET_NAME} into a standalone executable..."
        VERBATIM
    )

    # Create the custom target to hook into the build system
    add_custom_target(
        ${TARGET_NAME}
        DEPENDS "${FINAL_EXECUTABLE}"
    )

    # Set IDE folder property if provided
    if(ARG_FOLDER)
        set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "${ARG_FOLDER}")
    endif()
endfunction()

# GLOB is evaluated here - after baked_version.py has already been created on disk
file(GLOB PYTHON_SOURCE_FILES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/scripts/source/*.py")

set(PYTHON_DEPENDENCIES
    "${PROFILES_SCRIPT}"
    "${CMAKE_CURRENT_SOURCE_DIR}/scripts/gen_profiles_file.py"
    "${CMAKE_CURRENT_SOURCE_DIR}/scripts/gen_profiles_layer.py"
    "${CMAKE_CURRENT_SOURCE_DIR}/scripts/gen_profiles_solution.py"
    "${CMAKE_CURRENT_SOURCE_DIR}/scripts/gen_profiles_tests.py"
    "${CMAKE_CURRENT_SOURCE_DIR}/scripts/vkprofiles.py"
    ${PYTHON_SOURCE_FILES}
)

if(VULKAN_HEADERS_INSTALL_DIR)
    set(VULKAN_REGISTRY_DIR "${VULKAN_HEADERS_INSTALL_DIR}/registry")
    set(VULKAN_REGISTRY_SHARE_DIR "${VULKAN_HEADERS_INSTALL_DIR}/share/vulkan/registry")
elseif(TARGET Vulkan::Registry)
    get_target_property(VULKAN_REGISTRY_DIR Vulkan::Registry INTERFACE_INCLUDE_DIRECTORIES)
    set(VULKAN_REGISTRY_SHARE_DIR "${VULKAN_REGISTRY_DIR}")
endif()

add_pyinstaller_target(VpProfilesProcessor
    OUTPUT_NAME "vkprofiles"
    SCRIPT "${PROFILES_SCRIPT}"
    OUTPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/scripts"
    PATHS
        "${VULKAN_REGISTRY_DIR}"
        "${VULKAN_REGISTRY_SHARE_DIR}"
        "${CMAKE_CURRENT_SOURCE_DIR}/scripts/source"
    DEPENDS ${PYTHON_DEPENDENCIES}
    FOLDER "Profiles generator"
)
add_dependencies(VpProfilesProcessor python_venv)

if(WIN32)
    set(VKPROFILES_INSTALL_DIR "Bin")
else()
    set(VKPROFILES_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}")
endif()

install(PROGRAMS "${CMAKE_CURRENT_SOURCE_DIR}/scripts/vkprofiles${CMAKE_EXECUTABLE_SUFFIX}"
    DESTINATION "${VKPROFILES_INSTALL_DIR}"
)

# The profiles directory regenerates the Profiles source and headers.
add_subdirectory(profiles)
add_subdirectory(library)
add_subdirectory(layer)
