add_compile_definitions(LC_VERSION=2.2.2.3-alpha)

add_custom_command(OUTPUT ${ANDROID_BINARY_DIR}/${ANDROID_LIBNAME} ${ANDROID_BINARY_DIR}/libncine_main.a
			COMMAND ${MSYS2_DISABLE_PATH_CONV} ${CMAKE_COMMAND} -H${CMAKE_BINARY_DIR}/android/app/src/main/cpp/ -B${ANDROID_BINARY_DIR}
				-DCMAKE_TOOLCHAIN_FILE=${NDK_DIR}/build/cmake/android.toolchain.cmake
				-DANDROID_PLATFORM=${GRADLE_MINSDK_VERSION} -DANDROID_ABI=${ARCHITECTURE}
				${RESET_FLAGS_ARGS} ${ANDROID_PASSTHROUGH_ARGS} ${ANDROID_CMAKE_ARGS} ${ANDROID_ARCH_ARGS}
			COMMAND ${CMAKE_COMMAND} --build ${ANDROID_BINARY_DIR}
			COMMENT "Compiling the Android library for ${ARCHITECTURE}")

if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)

write_basic_package_version_file(${version_file} VERSION ${GOOGLETEST_VERSION} COMPATIBILITY AnyNewerVersion)

message(FATAL_ERROR "The linked FastScape version is ${FASTSCAPE_VERSION}, however at least 2.8.0 is required.")

execute_process (COMMAND ${EMSCRIPTEN_ROOT_PATH}/emcc${TOOL_EXT} --version RESULT_VARIABLE EXIT_CODE OUTPUT_VARIABLE EMCC_VERSION ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)

string (REGEX REPLACE "^.*ARTS_VERSION.+\"([^\"]*)\".*$" \\1 ARTS_VERSION "${ARTS_VERSION}")

math(EXPR SFML_REQUESTED_VERSION "${SFML_FIND_VERSION_MAJOR} * 10 + ${SFML_FIND_VERSION_MINOR}")

write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/ImathConfigVersion.cmake"
  VERSION ${IMATH_VERSION}
  COMPATIBILITY SameMajorVersion
)

set_target_properties(EcsPipeline
    PROPERTIES
      BUNDLE True
      MACOSX_BUNDLE_GUI_IDENTIFIER dev.novelrt.samples.EcsPipeline
      MACOS_BUNDLE_BUNDLE_NAME EcsPipeline
      MACOSX_BUNDLE_BUNDLE_VERSION "${PROJECT_VERSION}"
      MACOSX_BUNDLE_SHORT_VERION_STRING "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
  )

SET(CPACK_PACKAGE_VERSION_PATCH "${PATCH_VERSION}")

add_link_options("-L${CROSS_ROOTFS}/usr/lib/gcc/${TOOLCHAIN}/${TOOLCHAIN_VERSION}")

add_definitions(-DBOOST_USE_WINAPI_VERSION=BOOST_WINAPI_VERSION_WIN10)

write_basic_package_version_file(
        "${CMAKE_CURRENT_BINARY_DIR}/osgearth-config-version.cmake"
        VERSION ${OSGEARTH_VERSION}
        COMPATIBILITY AnyNewerVersion)

write_basic_package_version_file(
  "${CMAKE_BINARY_DIR}/cmake/f3dConfigVersion.cmake"
  VERSION "${F3D_VERSION}"
  COMPATIBILITY SameMajorVersion)

find_package(Python ${LY_PYTHON_VERSION} REQUIRED)

find_package(Boost ${MINIMUM_BOOST_VERSION} REQUIRED COMPONENTS ${_boost_components})

string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match "${_eigen3_version_header}")

write_basic_package_version_file(
    ${PROJECT_BINARY_DIR}/cmake/OGREConfigVersion.cmake 
    VERSION ${OGRE_VERSION} 
    COMPATIBILITY SameMajorVersion)

set(SDL_MICRO_VERSION 22)

find_package(Boost ${MINIMUM_BOOST_VERSION} REQUIRED COMPONENTS ${_boost_components})

string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen_major_version_match "${_eigen_version_header}")

write_basic_package_version_file(${PROJECT_NAME}-config-version.cmake
  VERSION
  ${TINYOBJLOADER_VERSION}
  COMPATIBILITY
  SameMajorVersion
  )

add_definitions(-DBOOST_ALL_NO_LIB -DBOOST_USE_WINAPI_VERSION=0x602 -DBOOST_SYSTEM_USE_UTF8 )

write_basic_package_version_file( harfangConfigVersion.cmake VERSION ${HG_VERSION} COMPATIBILITY SameMajorVersion )

function(DetermineOSVersion OS_VERSION)

add_jar(SDL3-jar
        SOURCES ${SDL_JAVA_SOURCES}
        INCLUDE_JARS "${path_android_jar}"
        OUTPUT_NAME "SDL3"
        VERSION "${SDL3_VERSION}"
      )

EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)

write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/glslang-config-version.cmake"
        VERSION ${GLSLANG_VERSION}
        COMPATIBILITY SameMajorVersion
    )

write_basic_package_version_file(
            "${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_FILE_NAME}Version.cmake"
            VERSION ${ARGS_PACKAGE_VERSION} COMPATIBILITY SameMajorVersion
        )

EXEC_PROGRAM(uname ARGS -v  OUTPUT_VARIABLE DARWIN_VERSION)

ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.exp	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.exp VERBATIM)

SET_TARGET_PROPERTIES(cli PROPERTIES LINK_FLAGS "-framework CoreFoundation -framework Security -framework SystemConfiguration -ldl ${HOMEBREW_CELLAR}/glfw/${GLFW_VERSION}/lib/libglfw.dylib ${HOMEBREW_CELLAR}/freetype/${FREETYPE_VERSION}/lib/libfreetype.dylib ${HOMEBREW_CELLAR}/xz/${XZ_VERSION}/lib/liblzma.a")

find_package_handle_standard_args(GMP
                                  REQUIRED_VARS GMP_INCLUDE_DIR GMP_LIBRARY
                                  VERSION_VAR GMP_VERSION)

write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/${configmodule}ConfigVersion.cmake"
            VERSION ${RAMSES_VERSION}
            COMPATIBILITY SameMajorVersion)

find_package(Boost ${MINIMUM_BOOST_VERSION}
    QUIET COMPONENTS python${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}
  )

write_basic_package_version_file(
    ${version_config}
    VERSION ${FMT_VERSION}
    COMPATIBILITY AnyNewerVersion)

exec_program(sw_vers ARGS -productVersion  OUTPUT_VARIABLE OSX_VERSION)

add_compile_definitions(PRODUCT_VERSION=${PRODUCT_VERSION})

ENDIF ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")

elseif(ALIZA_QT_VERSION STREQUAL "5")

write_basic_package_version_file(${version_file} VERSION ${GOOGLETEST_VERSION} COMPATIBILITY AnyNewerVersion)

math(EXPR KOKKOS_VERSION "${Kokkos_VERSION_MAJOR} * 10000 + ${Kokkos_VERSION_MINOR} * 100 + ${Kokkos_VERSION_PATCH}")

find_program(GCOV_BIN NAMES gcov-${GCC_VERSION} gcov
				HINTS ${COMPILER_PATH})

target_compile_definitions(${PROJECT_NAME} PRIVATE 
  ECAL_VERSION="${eCAL_COMPLETE_VERSION}"
  ECAL_DATE="${eCAL_DATE}"
)

add_compile_definitions(
    _ATL_STATIC_REGISTRY
    DEBUGGER_EXTENSION;
    JET_VERSION=0xFFFF;
    WSZVERSIONNAME=L"ESE";

    # These are expected to be set in, e.g., the Exchange-specific `bldver.h` or the Windows-specific `ntverp.h`.
    # The values of `BUILD_MAJOR` and `BUILD_MINOR` would eventually be based on Azure pipelines' build numbers
    # and read from the environment, e.g., from `$ENV{BUILD_MINOR}`
    PRODUCT_MAJOR="10"
    PRODUCT_MINOR="0"
    BUILD_MAJOR="0"
    BUILD_MINOR="0"
)

find_package(Qt${QT_MAJOR_VERSION} COMPONENTS Core)

STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" MAJA_ALGORITHMS_VERSION_MINOR "${MAJA_ALGORITHMS_VERSION}")

find_package(ECM ${KF6_MIN_VERSION} REQUIRED NO_MODULE)

find_package(Qt${QT_MAJOR_VERSION}Core QUIET)

execute_process(COMMAND cmd /c "git rev-list ${MAJOR_VERSION}.${MINOR_VERSION}..HEAD | find /v " " /c" OUTPUT_VARIABLE GIT_RELEASE_COMMITS WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

find_package_handle_standard_args(ATK
    REQUIRED_VARS
      ATK_LIBRARY
      ATK_INCLUDE_DIRS
      ${ATK_DEPS_FOUND_VARS}
    VERSION_VAR
      ATK_VERSION)

find_package(ECM ${KF5_MIN_VERSION} REQUIRED NO_MODULE)

find_package(${extProjName} ${${extProjName}_REQUIRED_VERSION} REQUIRED)

add_compile_definitions (OSL_LLVM_VERSION=${OSL_LLVM_VERSION})

string(COMPARE GREATER "${PC_LIBSNDFILE_VERSION}" "${LIBSNDFILE_VERSION_FLAC_OGG}" H2CORE_HAVE_FLAC_SUPPORT)

list(APPEND cdefs CPU_X86_64 HAVE_LIBPTHREAD
	"BACKTRACE_METHOD_X86_LINUX"
	"BACKTRACE_METHOD_TEXT=\"x86 custom backtrace\""
	"BACKTRACE_LOOKUP_METHOD_TEXT=\"backtrace_symbols\""
	"BACKTRACE_LOOKUP_METHOD_DLADDR"
	PACKAGE_NAME="Etterna"
	PACKAGE_VERSION="EtternaVersion")

find_package(ECM ${KF6_MIN_VERSION} CONFIG REQUIRED)

check_cxx_symbol_exists(_LIBCPP_VERSION version LIBCPP)

add_compile_definitions(BOOST_USE_WINAPI_VERSION=BOOST_WINAPI_VERSION_WIN7)

cmake_minimum_required(VERSION ${CMAKE_MIN_VERSION})

EXEC_PROGRAM(${GSL_CONFIG}
        ARGS --version
        OUTPUT_VARIABLE GSL_FULL_VERSION )

elseif(${ICU_PRIVATE_VAR_NS}_VERSION_HEADER_CONTENTS MATCHES ".*# *define *U_ICU_VERSION *\"(([0-9]+)(\\.[0-9]+)*)\".*")

elseif (${ROS_VERSION} EQUAL 2)

find_program(GCOV_BIN NAMES gcov-${GCC_VERSION} gcov
				HINTS ${COMPILER_PATH})

write_basic_package_version_file("${PROJECT_BINARY_DIR}/cmake/cpd-config-version.cmake" VERSION ${CPD_VERSION} COMPATIBILITY AnyNewerVersion)

find_package(Boost ${KWIVER_BOOST_VERSION} REQUIRED
  COMPONENTS
  chrono
  date_time
  iostreams
  filesystem
  program_options
  regex
  system
  thread)

find_package(Eigen3 ${EIGEN_VERSION} QUIET)

EXEC_PROGRAM(${GSL_CONFIG}
        ARGS --version
        OUTPUT_VARIABLE GSL_FULL_VERSION )

find_package(Boost ${OPENTISSUE_BOOST_VERSION} COMPONENTS "${OPENTISSUE_BOOST_COMPONENTS}" REQUIRED)

string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}")

write_basic_package_version_file(
        "${CMAKE_CURRENT_BINARY_DIR}/${EDSP_LIBRARY}-config-version.cmake"
        VERSION ${LIB_VERSION}
        COMPATIBILITY ExactVersion
)

file(STRINGS "${CGAL_MAINTENANCE_PACKAGE_DIR}/release_building/MINOR_NUMBER" CGAL_MINOR_VERSION REGEX "[0-9]*")

FetchContent_Declare(
    googletest EXCLUDE_FROM_ALL SYSTEM
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG        ${KAHYPAR_GOOGLETEST_VERSION}
  )

write_basic_package_version_file(src/glfw3ConfigVersion.cmake
                                 VERSION ${GLFW_VERSION}
                                 COMPATIBILITY SameMajorVersion)

write_basic_package_version_file(
  "${D3D12MA_VERSION_CONFIG}" VERSION ${D3D12MA_VERSION} COMPATIBILITY SameMajorVersion
)

find_package_handle_standard_args(Adb
    VERSION_VAR ADB_VERSION
    REQUIRED_VARS ADB_EXECUTABLE)

find_package(${pkg_name} ${${pkg_name}_REQUIRED_VERSION}
                   REQUIRED PATHS ${${pkg_name}_PREFIX} NO_DEFAULT_PATH)

add_compile_definitions(MAA_VERSION="${MAA_HASH_VERSION}")

find_package(${CPM_ARGS_NAME} ${CPM_ARGS_VERSION})

add_custom_target(${${Type}Name}
                    COMMAND ${CMAKE_COMMAND}
                        -DSUPER_PROJECT_BINARY_DIR="${CMAKE_BINARY_DIR}"
                        -DSUPER_PROJECT_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
                        -DCMAKE_CL_64="${CMAKE_CL_64}"
                        -DVersion="${ApplicationVersionMajor}.${ApplicationVersionMinor}.${ApplicationVersionPatch}"
                        -DTargetName="${${Type}Name}"
                        -DTargetType=${Type}
                        $<$<OR:$<STREQUAL:${Type},Dev>,$<STREQUAL:${Type},DevDebug>>:-DTargetLibs=$<TARGET_FILE:maidsafe>>
                        -DMonolithicIncludes="${MonolithicIncludes}"
                        -DTargetExes="${${Type}Exes}"
                        -DBoostSourceDir="${BoostSourceDir}"
                        -DConfig=$<CONFIGURATION>
                        -DCMAKE_SYSTEM_VERSION="${CMAKE_SYSTEM_VERSION}"
                        -P "${CMAKE_SOURCE_DIR}/cmake_modules/${InstallerScriptName}"
                        -V)

find_package(Qt${QT_MAJOR_VERSION}Core QUIET)

find_package(Qt${QT_MAJOR_VERSION}Core QUIET)

find_program(GCOV_BIN NAMES gcov-${GCC_VERSION} gcov
				HINTS ${COMPILER_PATH})

write_basic_package_version_file (
    "${VERSION_CONFIG}"
    VERSION ${PACKAGE_VERSION}
    COMPATIBILITY SameMajorVersion
)

ExternalProject_Add(nvshmem_device_project
                    SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/device
                    BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/device
                    CMAKE_ARGS  -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
                                -DNVSHMEM_PREFIX=${NVSHMEM_PREFIX}
                                -DNVSHMEM_DEBUG=${NVSHMEM_DEBUG}
                                -DNVSHMEM_DEVICELIB_CUDA_HOME=${NVSHMEM_DEVICELIB_CUDA_HOME}
                                -DNVSHMEM_ENABLE_ALL_DEVICE_INLINING=${NVSHMEM_ENABLE_ALL_DEVICE_INLINING}
                                -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
                                -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
                                -DCMAKE_CUDA_HOST_COMPILER=${CMAKE_CUDA_HOST_COMPILER}
                                -DPROJECT_VERSION=${PROJECT_VERSION}
				$ENV{CMAKE_CCACHE_FLAGS}
                    CMAKE_CACHE_ARGS ${my_cmake_cache_args}
                    STEP_TARGETS build install
                    BUILD_ALWAYS TRUE
                    BUILD_BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/lib/libnvshmem_device.a
                    )

execute_process(
    COMMAND
      zsh "-c"
      "echo \"__METAL_VERSION__\" | xcrun -sdk macosx metal ${XCRUN_FLAGS} -E -x metal -P - | tail -1 | tr -d '\n'"
    OUTPUT_VARIABLE MLX_METAL_VERSION COMMAND_ERROR_IS_FATAL ANY)

math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")

add_definitions(-DNAPI_VERSION=8)

IF(SUBPATCH_VERSION EQUAL "0")

find_package(Qt6 ${EZ_REQUIRED_QT_VERSION} COMPONENTS ${EZ_QT_COMPONENTS} REQUIRED PATHS ${EZ_QT_DIR})

string(REGEX MATCH "^[0-9]+" GCC_VERSION
				"${CMAKE_${LANG}_COMPILER_VERSION}")

math(EXPR MAPNIK_PROJ_VERSION "${PROJ_VERSION_MAJOR}*10000 + ${PROJ_VERSION_MINOR}*100 + ${PROJ_VERSION_PATCH}" OUTPUT_FORMAT DECIMAL)

set_package_properties(Git PROPERTIES
        URL "https://git-scm.com"
        DESCRIPTION "A free and open source distributed version control system (found: v${GIT_VERSION_STRING})"
        PURPOSE "Manage version control, get MINOR_VERSION name for version number."
        TYPE REQUIRED
    )

find_package (Python ${BUILD_PYTHON_VERSION} COMPONENTS Interpreter Development QUIET)

string(STRIP ${OT_DEFAULT_VERSION} OT_DEFAULT_VERSION)

pkg_check_modules(libcurl REQUIRED IMPORTED_TARGET libcurl>=${CURL_MIN_VERSION})

find_package(${lib} ${${lib}_REQUIRED_VERSION} REQUIRED)

cmake_policy(VERSION ${US_CMAKE_MINIMUM_REQUIRED_VERSION})

find_package_handle_standard_args(CUDA
  REQUIRED_VARS
    CUDA_TOOLKIT_ROOT_DIR
    CUDA_NVCC_EXECUTABLE
    CUDA_INCLUDE_DIRS
    CUDA_CUDART_LIBRARY
  VERSION_VAR
    CUDA_VERSION
  )