if(COLMAP_FIND_QUIETLY)
    set(COLMAP_FIND_TYPE QUIET)
else()
    set(COLMAP_FIND_TYPE REQUIRED)
endif()

# Track all the compile definitions
set(COLMAP_COMPILE_DEFINITIONS)
if(LSD_ENABLED)
    list(APPEND COLMAP_COMPILE_DEFINITIONS COLMAP_LSD_ENABLED)
    message(STATUS "Enabling LSD support")
else()
    message(STATUS "Disabling LSD support")
endif()

find_package(OpenMP REQUIRED COMPONENTS C CXX)

find_package(Boost ${COLMAP_FIND_TYPE} COMPONENTS
             graph
             program_options
             OPTIONAL_COMPONENTS
             system)

find_package(Eigen3 ${COLMAP_FIND_TYPE})

find_package(OpenImageIO ${COLMAP_FIND_TYPE})

find_package(Metis ${COLMAP_FIND_TYPE})

find_package(Glog ${COLMAP_FIND_TYPE})
if(DEFINED glog_VERSION_MAJOR)
  # Older versions of glog don't export version variables.
  list(APPEND COLMAP_COMPILE_DEFINITIONS GLOG_VERSION_MAJOR=${glog_VERSION_MAJOR})
  list(APPEND COLMAP_COMPILE_DEFINITIONS GLOG_VERSION_MINOR=${glog_VERSION_MINOR})
endif()

find_package(SQLite3 ${COLMAP_FIND_TYPE})

set(OpenGL_GL_PREFERENCE GLVND)
find_package(OpenGL ${COLMAP_FIND_TYPE})

find_package(Glew ${COLMAP_FIND_TYPE})

find_package(Git)

find_package(CHOLMOD REQUIRED)

find_package(Ceres ${COLMAP_FIND_TYPE})
if(NOT TARGET Ceres::ceres)
    # Older Ceres versions don't come with an imported interface target.
    add_library(Ceres::ceres INTERFACE IMPORTED)
    target_include_directories(
        Ceres::ceres INTERFACE ${CERES_INCLUDE_DIRS})
    target_link_libraries(
        Ceres::ceres INTERFACE ${CERES_LIBRARIES})
endif()

if(TESTS_ENABLED)
    find_package(GTest ${COLMAP_FIND_TYPE})
endif()

if(CGAL_ENABLED)
    set(CGAL_DO_NOT_WARN_ABOUT_CMAKE_BUILD_TYPE TRUE)
    # We do not use CGAL data. This prevents an unnecessary warning by CMake.
    set(CGAL_DATA_DIR "unused")
    find_package(CGAL ${COLMAP_FIND_TYPE})
endif()

if(CGAL_FOUND)
    list(APPEND COLMAP_COMPILE_DEFINITIONS COLMAP_CGAL_ENABLED)
    list(APPEND CGAL_LIBRARY ${CGAL_LIBRARIES})
    message(STATUS "Found CGAL")
    message(STATUS "  Includes : ${CGAL_INCLUDE_DIRS}")
    message(STATUS "  Libraries : ${CGAL_LIBRARY}")
    if(NOT TARGET CGAL)
        # Older CGAL versions don't come with an imported interface target.
        add_library(CGAL INTERFACE IMPORTED)
        target_include_directories(
            CGAL INTERFACE ${CGAL_INCLUDE_DIRS} ${GMP_INCLUDE_DIR})
        target_link_libraries(
            CGAL INTERFACE ${CGAL_LIBRARY} ${GMP_LIBRARIES})
    endif()
    list(APPEND COLMAP_LINK_DIRS ${CGAL_LIBRARIES_DIR})
else()
    if(CGAL_ENABLED)
        set(CGAL_ENABLED OFF)
        message(STATUS "Disabling CGAL support (not found)")
    else()
        message(STATUS "Disabling CGAL support")
    endif()
endif()

if(DOWNLOAD_ENABLED)
    # The OpenSSL package in vcpkg seems broken under Windows and leads to
    # missing certificate verification when connecting to SSL servers. We
    # therefore use curl[sspi] (i.e., native Windows SSL/TLS) under Windows
    # and curl[openssl] otherwise.
    find_package(CURL QUIET)
    set(CRYPTO_FOUND FALSE)
    if(IS_MSVC AND IS_ARM64)
        # OpenSSL crashes for ARM64 under Windows. We therefore fall back to
        # CryptoPP as an alternative to OpenSSL for SHA256 computation.
        find_package(CryptoPP QUIET)
        if(CryptoPP_FOUND)
            set(CRYPTO_FOUND TRUE)
        else()
            message(STATUS "CryptoPP not found")
        endif()
    else()
        find_package(OpenSSL QUIET COMPONENTS Crypto)
        if(OpenSSL_FOUND)
            set(CRYPTO_FOUND TRUE)
        else()
            message(STATUS "OpenSSL::Crypto not found")
        endif()
    endif()
    if(CURL_FOUND AND CRYPTO_FOUND)
        message(STATUS "Enabling download support")
        list(APPEND COLMAP_COMPILE_DEFINITIONS COLMAP_DOWNLOAD_ENABLED)
    else()
        set(DOWNLOAD_ENABLED OFF)
        message(STATUS "Disabling download support (Curl/Crypto not found)")
    endif()
else()
    message(STATUS "Disabling download support")
endif()

if(NOT FETCH_POSELIB)
    find_package(PoseLib ${COLMAP_FIND_TYPE})
endif()

if(NOT FETCH_FAISS)
    find_package(faiss ${COLMAP_FIND_TYPE})
endif()

set(COLMAP_LINK_DIRS ${Boost_LIBRARY_DIRS})

set(CUDA_MIN_VERSION "7.0")
if(CUDA_ENABLED)
    if(CMAKE_VERSION VERSION_LESS 3.17)
        find_package(CUDA QUIET)
        if(CUDA_FOUND)
            message(STATUS "Found CUDA version ${CUDA_VERSION} installed in "
                    "${CUDA_TOOLKIT_ROOT_DIR} via legacy CMake (<3.17) module. "
                    "Using the legacy CMake module means that any installation of "
                    "COLMAP will require that the CUDA libraries are "
                    "available under LD_LIBRARY_PATH.")
            message(STATUS "Found CUDA ")
            message(STATUS "  Includes : ${CUDA_INCLUDE_DIRS}")
            message(STATUS "  Libraries : ${CUDA_LIBRARIES}")

            enable_language(CUDA)

            macro(declare_imported_cuda_target module)
                add_library(CUDA::${module} INTERFACE IMPORTED)
                target_include_directories(
                    CUDA::${module} INTERFACE ${CUDA_INCLUDE_DIRS})
                target_link_libraries(
                    CUDA::${module} INTERFACE ${CUDA_${module}_LIBRARY} ${ARGN})
            endmacro()

            declare_imported_cuda_target(cudart ${CUDA_LIBRARIES})
            declare_imported_cuda_target(curand ${CUDA_LIBRARIES})

            set(CUDAToolkit_VERSION "${CUDA_VERSION_STRING}")
            set(CUDAToolkit_BIN_DIR "${CUDA_TOOLKIT_ROOT_DIR}/bin")
        else()
            message(STATUS "Disabling CUDA support (not found)")
        endif()
    else()
        find_package(CUDAToolkit QUIET)
        if(CUDAToolkit_FOUND)
            set(CUDA_FOUND ON)
            enable_language(CUDA)
        else()
            message(STATUS "Disabling CUDA support (not found)")
        endif()
    endif()
else()
    message(STATUS "Disabling CUDA support")
endif()

if(CUDA_ENABLED AND CUDA_FOUND)
    if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
        set(CMAKE_CUDA_ARCHITECTURES "native")
    endif()

    list(APPEND COLMAP_COMPILE_DEFINITIONS COLMAP_CUDA_ENABLED)

    # Do not show warnings if the architectures are deprecated.
    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
    # Suppress warnings related to Eigen:
    # Calling a constexpr __host__ function from a __host__ __device__ function is not allowed.
    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr")
    # Explicitly set PIC flags for CUDA targets.
    if(NOT IS_MSVC)
        set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --compiler-options -fPIC")
    endif()

    # Handle MSVC runtime library for CUDA to support static CRT linking.
    # CMake's default CUDA flags use /MD (dynamic), but if the user is building
    # with static CRT (/MT), we need to override the CUDA flags to match.
    if(IS_MSVC)
        # Detect the runtime library from CMAKE_MSVC_RUNTIME_LIBRARY or CXX flags
        set(_COLMAP_USE_STATIC_RUNTIME OFF)

        if(DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
            if(CMAKE_MSVC_RUNTIME_LIBRARY MATCHES "MultiThreaded" AND
               NOT CMAKE_MSVC_RUNTIME_LIBRARY MATCHES "DLL")
                set(_COLMAP_USE_STATIC_RUNTIME ON)
            endif()
        elseif(CMAKE_CXX_FLAGS_DEBUG MATCHES "/MTd" OR
               CMAKE_CXX_FLAGS_RELEASE MATCHES "/MT[^d]" OR
               CMAKE_CXX_FLAGS MATCHES "/MT")
            set(_COLMAP_USE_STATIC_RUNTIME ON)
        endif()

        if(_COLMAP_USE_STATIC_RUNTIME)
            message(STATUS "CUDA: Using static MSVC runtime library (/MT)")
            # Replace /MD with /MT in CUDA flags for each build type
            foreach(_BUILD_TYPE DEBUG RELEASE RELWITHDEBINFO MINSIZEREL)
                if(DEFINED CMAKE_CUDA_FLAGS_${_BUILD_TYPE})
                    string(REPLACE "-MDd" "-MTd" CMAKE_CUDA_FLAGS_${_BUILD_TYPE}
                           "${CMAKE_CUDA_FLAGS_${_BUILD_TYPE}}")
                    string(REPLACE "-MD" "-MT" CMAKE_CUDA_FLAGS_${_BUILD_TYPE}
                           "${CMAKE_CUDA_FLAGS_${_BUILD_TYPE}}")
                    string(REPLACE "/MDd" "/MTd" CMAKE_CUDA_FLAGS_${_BUILD_TYPE}
                           "${CMAKE_CUDA_FLAGS_${_BUILD_TYPE}}")
                    string(REPLACE "/MD" "/MT" CMAKE_CUDA_FLAGS_${_BUILD_TYPE}
                           "${CMAKE_CUDA_FLAGS_${_BUILD_TYPE}}")
                endif()
            endforeach()
        endif()

        unset(_COLMAP_USE_STATIC_RUNTIME)
    endif()

    message(STATUS "Enabling CUDA support (version: ${CUDAToolkit_VERSION}, "
                    "archs: ${CMAKE_CUDA_ARCHITECTURES})")
else()
    set(CUDA_ENABLED OFF)
endif()

if(ONNX_ENABLED)
    if(FETCH_ONNX)
        include(FetchContent)

        message(STATUS "Configuring onnxruntime...")

        set(ONNX_VERSION "1.24.1")
        # ONNX Runtime >= 1.22 GPU binaries are built with CUDA >= 12
        if(ONNX_VERSION VERSION_GREATER_EQUAL "1.22"
           AND CUDA_ENABLED AND CUDA_FOUND AND CUDAToolkit_VERSION VERSION_LESS "12.0")
            message(WARNING
                "ONNX Runtime ${ONNX_VERSION} GPU binary is built with CUDA >= 12, "
                "but CUDA ${CUDAToolkit_VERSION} was detected. The ONNX Runtime CUDA "
                "execution provider may fail at runtime, CPU execution will continue to work. "
                "Consider upgrading CUDA to >= 12 or using a source-built onnxruntime.")
        endif()

        if(IS_MACOS)
            if(CMAKE_OSX_ARCHITECTURES)
                set(_COLMAP_MACOS_ARCH ${CMAKE_OSX_ARCHITECTURES})
            else()
                set(_COLMAP_MACOS_ARCH ${CMAKE_SYSTEM_PROCESSOR})
            endif()
            if(_COLMAP_MACOS_ARCH STREQUAL "x86_64")
                message(FATAL_ERROR "x86_64 is not supported for onnxruntime")
            else()
                FetchContent_Declare(onnxruntime
                    URL https://github.com/microsoft/onnxruntime/releases/download/v${ONNX_VERSION}/onnxruntime-osx-arm64-${ONNX_VERSION}.tgz
                    URL_HASH SHA256=c2969315cd9ce0f5fa04f6b53ff72cb92f87f7dcf38e88cacfa40c8f983fbba9
                    ${_fetch_content_declare_args}
                )
            endif()
        elseif(IS_LINUX)
            if(IS_ARM64)
                FetchContent_Declare(onnxruntime
                    URL https://github.com/microsoft/onnxruntime/releases/download/v${ONNX_VERSION}/onnxruntime-linux-aarch64-${ONNX_VERSION}.tgz
                    URL_HASH SHA256=0f56edd68f7602df790b68b874a46b115add037e88385c6c842bb763b39b9f89
                    ${_fetch_content_declare_args}
                )
            else()
                if(CUDA_ENABLED)
                    FetchContent_Declare(onnxruntime
                        URL https://github.com/microsoft/onnxruntime/releases/download/v${ONNX_VERSION}/onnxruntime-linux-x64-gpu-${ONNX_VERSION}.tgz
                        URL_HASH SHA256=1c468821456b7863640555e31ee5b71e56bb959874b9db0dbf79503997993673
                        ${_fetch_content_declare_args}
                    )
                else()
                    FetchContent_Declare(onnxruntime
                        URL https://github.com/microsoft/onnxruntime/releases/download/v${ONNX_VERSION}/onnxruntime-linux-x64-${ONNX_VERSION}.tgz
                        URL_HASH SHA256=9142552248b735920f9390027e4512a2cacf8946a1ffcbe9071a5c210531026f
                        ${_fetch_content_declare_args}
                    )
                endif()
            endif()
        elseif(IS_WINDOWS)
            FetchContent_Declare(onnxruntime
                URL https://github.com/microsoft/onnxruntime/releases/download/v${ONNX_VERSION}/onnxruntime-win-x64-gpu-${ONNX_VERSION}.zip
                URL_HASH SHA256=176af2aade9eb9e429cd2a738aa5d71a1f20ec7123e4b99a382ad62b9db970fb
                ${_fetch_content_declare_args}
            )
        endif()

        FetchContent_MakeAvailable(onnxruntime)

        set(ONNX_INCLUDE_DIR ${onnxruntime_BINARY_DIR}/include/onnxruntime)
        if(NOT EXISTS ${ONNX_INCLUDE_DIR})
            file(MAKE_DIRECTORY ${ONNX_INCLUDE_DIR})
            file(COPY ${onnxruntime_SOURCE_DIR}/include/ DESTINATION ${ONNX_INCLUDE_DIR}/)
        endif()
        set(onnxruntime_LIB_DIR ${onnxruntime_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
        if(NOT EXISTS ${onnxruntime_LIB_DIR})
            file(MAKE_DIRECTORY ${onnxruntime_LIB_DIR})
            file(COPY ${onnxruntime_SOURCE_DIR}/lib/ DESTINATION ${onnxruntime_LIB_DIR})
            file(REMOVE_RECURSE ${onnxruntime_LIB_DIR}/cmake)
            file(REMOVE_RECURSE ${onnxruntime_LIB_DIR}/pkgconfig)
        endif()
        if(NOT IS_WINDOWS)
            set(ONNX_DATA_DIR ${onnxruntime_BINARY_DIR}/share/onnxruntime)
            if(NOT EXISTS ${ONNX_DATA_DIR})
                file(MAKE_DIRECTORY ${ONNX_DATA_DIR})
                file(COPY ${onnxruntime_SOURCE_DIR}/lib/cmake/onnxruntime/ DESTINATION ${ONNX_DATA_DIR}/cmake/)
                file(REMOVE_RECURSE ${onnxruntime_SOURCE_DIR}/lib/cmake)
                # The downloaded cmake configs may reference lib64/ (e.g. on Linux x64),
                # but the actual install directory depends on CMAKE_INSTALL_LIBDIR
                # (lib/ or lib64/ depending on the distro). Patch the configs to match.
                if(IS_LINUX AND NOT IS_ARM64)
                    file(GLOB _onnx_cmake_configs "${ONNX_DATA_DIR}/cmake/*.cmake")
                    foreach(_config_file ${_onnx_cmake_configs})
                        file(READ "${_config_file}" _config_content)
                        string(REPLACE "/lib64/" "/${CMAKE_INSTALL_LIBDIR}/" _config_content "${_config_content}")
                        file(WRITE "${_config_file}" "${_config_content}")
                    endforeach()
                endif()
            endif()
            set(onnxruntime_CONFIG_DIR_HINTS ${ONNX_DATA_DIR}/cmake CACHE PATH "ONNX Runtime config directory hints")
        endif()

        set(onnxruntime_INCLUDE_DIR_HINTS ${onnxruntime_BINARY_DIR}/include CACHE PATH "ONNX Runtime include directory hints")
        set(onnxruntime_LIBRARY_DIR_HINTS ${onnxruntime_BINARY_DIR}/lib CACHE PATH "ONNX Runtime library directory hints")
        find_package(onnxruntime ${COLMAP_FIND_TYPE})

        install(DIRECTORY "${onnxruntime_BINARY_DIR}/include/" TYPE INCLUDE)
        if(IS_WINDOWS)
            # On Windows, selectively install Libs to lib/. Always install core Libs.
            # For not supporting TensorRT/ROCM/etc. as a runtime, so not installing it intentionally.
            install(FILES
                "${onnxruntime_LIB_DIR}/onnxruntime.lib"
                "${onnxruntime_LIB_DIR}/onnxruntime_providers_shared.lib"
                TYPE LIB)
            # Only install CUDA provider Lib if CUDA is enabled.
            if(CUDA_ENABLED)
                install(FILES
                    "${onnxruntime_LIB_DIR}/onnxruntime_providers_cuda.lib"
                    TYPE LIB)
            endif()
            # On Windows, selectively install DLLs to bin/. Always install core DLLs.
            # For not supporting TensorRT/ROCM/etc. as a runtime, so not installing it intentionally.
            install(FILES
                "${onnxruntime_LIB_DIR}/onnxruntime.dll"
                "${onnxruntime_LIB_DIR}/onnxruntime_providers_shared.dll"
                TYPE BIN)
            # Only install CUDA provider DLL if CUDA is enabled.
            if(CUDA_ENABLED)
                install(FILES
                    "${onnxruntime_LIB_DIR}/onnxruntime_providers_cuda.dll"
                    TYPE BIN)
            endif()
        else()
            # On Linux/macOS, selectively install library files. Always install core libraries.
            # Not supporting TensorRT/ROCM/etc. as a runtime, so not installing them.
            if(IS_MACOS)
                file(GLOB onnxruntime_CORE_LIBS
                    "${onnxruntime_LIB_DIR}/libonnxruntime.dylib"
                    "${onnxruntime_LIB_DIR}/libonnxruntime.*.dylib"
                    "${onnxruntime_LIB_DIR}/libonnxruntime_providers_shared.dylib")
                install(FILES ${onnxruntime_CORE_LIBS} TYPE LIB)
            else()
                file(GLOB onnxruntime_CORE_LIBS
                    "${onnxruntime_LIB_DIR}/libonnxruntime.so*"
                    "${onnxruntime_LIB_DIR}/libonnxruntime_providers_shared.so*")
                install(FILES ${onnxruntime_CORE_LIBS} TYPE LIB)
                # Only install CUDA provider if CUDA is enabled.
                if(CUDA_ENABLED)
                    file(GLOB onnxruntime_CUDA_LIBS
                        "${onnxruntime_LIB_DIR}/libonnxruntime_providers_cuda.so*")
                    install(FILES ${onnxruntime_CUDA_LIBS} TYPE LIB)
                endif()
            endif()
        endif()
        if(EXISTS "${onnxruntime_BINARY_DIR}/share")
            install(DIRECTORY "${onnxruntime_BINARY_DIR}/share/" TYPE DATA)
        endif()

        message(STATUS "Configuring onnxruntime... done")
    else()
        find_package(onnxruntime ${COLMAP_FIND_TYPE})
        if(NOT onnxruntime_FOUND)
            message(STATUS "Disabling ONNX support (not found)")
            set(ONNX_ENABLED OFF)
        endif()
    endif()
else()
    message(STATUS "Disabling ONNX support")
endif()

if(TARGET onnxruntime::onnxruntime)
    list(APPEND COLMAP_COMPILE_DEFINITIONS COLMAP_ONNX_ENABLED)
    message(STATUS "Enabling ONNX support")
endif()

if(GUI_ENABLED)
    find_package(QT NAMES Qt5 Qt6 REQUIRED)
    set(COLMAP_QT_COMPONENTS Core OpenGL Widgets)
    if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
        list(APPEND COLMAP_QT_COMPONENTS OpenGLWidgets)
    endif()
    find_package(Qt${QT_VERSION_MAJOR} ${COLMAP_FIND_TYPE} ${COLMAP_QT_COMPONENTS})
    message(STATUS "Found Qt")
    message(STATUS "  Module : ${Qt${QT_VERSION_MAJOR}Core_DIR}")
    message(STATUS "  Module : ${Qt${QT_VERSION_MAJOR}OpenGL_DIR}")
    message(STATUS "  Module : ${Qt${QT_VERSION_MAJOR}Widgets_DIR}")
    if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
        message(STATUS "  Module : ${Qt${QT_VERSION_MAJOR}OpenGLWidgets_DIR}")
    endif()
    if(Qt5_FOUND)
        # Qt5 was built with -reduce-relocations.
        if(Qt5_POSITION_INDEPENDENT_CODE)
            set(CMAKE_POSITION_INDEPENDENT_CODE ON)
            # Workaround for Qt5 CMake config bug under Ubuntu 20.04: https://gitlab.kitware.com/cmake/cmake/-/issues/16915
            if(TARGET Qt5::Core)
                get_property(core_options TARGET Qt5::Core PROPERTY INTERFACE_COMPILE_OPTIONS)
                string(REPLACE "-fPIC" "" new_qt5_core_options "${core_options}")
                set_property(TARGET Qt5::Core PROPERTY INTERFACE_COMPILE_OPTIONS ${new_qt5_core_options})
                set_property(TARGET Qt5::Core PROPERTY INTERFACE_POSITION_INDEPENDENT_CODE "ON")
                if(NOT IS_MSVC)
                    set(CMAKE_CXX_COMPILE_OPTIONS_PIE "-fPIC")
                endif()
            endif()
        endif()
    endif()

    if(QT_FOUND)
        # Enable automatic compilation of Qt resource files.
        set(CMAKE_AUTORCC ON)
    endif()
endif()

if(GUI_ENABLED AND Qt${QT_VERSION_MAJOR}_FOUND)
    list(APPEND COLMAP_COMPILE_DEFINITIONS COLMAP_GUI_ENABLED)
    message(STATUS "Enabling GUI support")
else()
    set(GUI_ENABLED OFF)
    message(STATUS "Disabling GUI support")
endif()

if(OPENGL_ENABLED)
    if(NOT GUI_ENABLED)
        message(STATUS "Disabling GUI also disables OpenGL")
        set(OPENGL_ENABLED OFF)
    else()
        message(STATUS "Enabling OpenGL support")
    endif()
else()
    message(STATUS "Disabling OpenGL support")
endif()

set(GPU_ENABLED OFF)
if(OPENGL_ENABLED OR CUDA_ENABLED)
    list(APPEND COLMAP_COMPILE_DEFINITIONS COLMAP_GPU_ENABLED)
    message(STATUS "Enabling GPU support (OpenGL: ${OPENGL_ENABLED}, CUDA: ${CUDA_ENABLED})")
    set(GPU_ENABLED ON)
endif()