cmake_minimum_required(VERSION 3.16)
cmake_policy(SET CMP0074 NEW) # find_package() uses <PackageName>_ROOT implicit hints

project(jana2 VERSION 2026.03.00)

set(CMAKE_POSITION_INDEPENDENT_CODE ON)   # Enable -fPIC for all targets

# Default the C++ standard to C++17, and validate that they provided one we can use
set(CMAKE_CXX_STANDARD 17 CACHE STRING "Set the C++ standard to be used")
if(NOT CMAKE_CXX_STANDARD MATCHES "14|17|20|23")
    message(FATAL_ERROR "Unsupported C++ standard: ${CMAKE_CXX_STANDARD}")
endif()

string(APPEND CMAKE_CXX_FLAGS_DEBUG " -O0 -g -Wall -Wextra")

# Expose custom cmake modules
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")

# Require the user to specify CMAKE_INSTALL_PREFIX directly. DO NOT AUTOMATICALLY INSTALL to /usr/local!
# Remember that we ultimately want CMAKE_INSTALL_PREFIX=$ENV{JANA_HOME}
if(NOT CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
    message(STATUS "Installing to ${CMAKE_INSTALL_PREFIX} .")
elseif(DEFINED ENV{JANA_HOME})
    message(STATUS "Installing to $ENV{JANA_HOME} ..")
    set(CMAKE_INSTALL_PREFIX $ENV{JANA_HOME} CACHE PATH "Comment explaining this nonsense" FORCE)
else()
    message(STATUS "Missing CMAKE_INSTALL_PREFIX=$JANA_HOME => Defaulting to ${CMAKE_BINARY_DIR}/install")
    set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/install CACHE PATH "Comment explaining this nonsense" FORCE)
endif()


# Add library directories to RPATH for all targets
set( CMAKE_SKIP_BUILD_RPATH FALSE )
set( CMAKE_BUILD_WITH_INSTALL_RPATH FALSE )
set( CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib;${CMAKE_INSTALL_PREFIX}/lib/JANA/plugins" )
set( CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE )

# Generate a compilation database, e.g. for IDE autocompletion
set( CMAKE_EXPORT_COMPILE_COMMANDS TRUE )

# Useful for debugging. Copied from:
# https://stackoverflow.com/questions/9298278/cmake-print-out-all-accessible-variables-in-a-script
function(dump_cmake_variables)
    get_cmake_property(_variableNames VARIABLES)
    list (SORT _variableNames)
    foreach (_variableName ${_variableNames})
        if (ARGV0)
            unset(MATCHED)
            string(REGEX MATCH ${ARGV0} MATCHED ${_variableName})
            if (NOT MATCHED)
                continue()
            endif()
        endif()
        message(STATUS "${_variableName}=${${_variableName}}")
    endforeach()
endfunction()


#----------------------
# Library dependencies
#----------------------

option(USE_ROOT "Include ROOT dependency." OFF)
option(USE_ZEROMQ "Include ZeroMQ dependency. (Needed for plugins/janacontrol, examples/misc/InteractiveStreamingExample), " OFF)
option(USE_XERCES "Include XercesC 3 dependency. (Needed for JGeometryXML)" OFF)
option(USE_PYTHON "Include Python dependency. This requires python-devel and python-distutils." OFF)
option(USE_ASAN "Compile with address sanitizer" OFF)
option(USE_TSAN "Compile with thread sanitizer" OFF)
option(USE_CUDA "Compile CUDA-involved examples (Needed for examples/SubeventCUDAExample)." OFF)
option(USE_PODIO "Compile with PODIO support" OFF)
option(USE_PERFETTO "Include Perfetto tracing SDK for performance profiling." OFF)
option(BUILD_SHARED_LIBS "Build into both shared and static libs." ON)
option(BUILD_EXAMPLES "Build and install examples" ON)
option(BUILD_TESTS "Build and install tests" ON)

if (${BUILD_TESTS} AND ${USE_PODIO} AND NOT ${BUILD_EXAMPLES})
    message(FATAL_ERROR "BUILD_TESTS=ON requires BUILD_EXAMPLES=ON when USE_PODIO=ON (unit tests depend on the PODIO example datamodel)")
endif()

if (${USE_PODIO})
    find_package(podio REQUIRED)
    set(JANA2_HAVE_PODIO 1)
    set(USE_ROOT ON)
    include_directories(SYSTEM ${podio_INCLUDE_DIR})
else()
    set(JANA2_HAVE_PODIO 0)
endif()


if (${USE_ROOT})
    if((NOT DEFINED ROOT_DIR) AND (DEFINED ENV{ROOTSYS}))
        set(ROOT_DIR $ENV{ROOTSYS}/cmake)
    endif()
    find_package(ROOT REQUIRED)
    set(JANA2_HAVE_ROOT 1)
    include_directories(${ROOT_INCLUDE_DIRS})
    link_libraries(ROOT::Core)
    execute_process(
        COMMAND ${ROOT_BINDIR}/root-config --features
        OUTPUT_VARIABLE ROOT_FEATURES
    )
    if(NOT ${ROOT_FEATURES} MATCHES .*cxx${CMAKE_CXX_STANDARD}.*)
        message(STATUS "root-config --features: ${ROOT_FEATURES}.")
        message(FATAL_ERROR "ROOT was not compiled against C++${CMAKE_CXX_STANDARD}. "
            "Specify the C++ standard used to compile ROOT with e.g. -DCMAKE_CXX_STANDARD=17. "
            "Check the root-config output above for cxx flags.")
    endif()
else()
    set(JANA2_HAVE_ROOT 0)
endif()

if (${USE_ZEROMQ})
    find_package(cppzmq REQUIRED)
endif()

if (${USE_XERCES})
    if((NOT DEFINED XercesC_DIR) AND (DEFINED ENV{XERCESCROOT}))
        set(XercesC_DIR $ENV{XERCESCROOT})
    endif()
    find_package(XercesC REQUIRED)
    set(JANA2_HAVE_XERCES 1)
    include_directories(${XercesC_INCLUDE_DIRS})
    link_libraries(${XercesC_LIBRARIES})
else()
    set(JANA2_HAVE_XERCES 0)
endif()

if (${USE_ASAN})
    add_compile_options(-fsanitize=address)
    add_link_options(-fsanitize=address)
endif()

if (${USE_TSAN})
    add_compile_options(-fsanitize=thread)
    add_link_options(-fsanitize=thread)
endif()

if (${USE_CUDA})
    find_package(CUDA REQUIRED)
endif()

if (USE_PERFETTO)
    set(PERFETTO_VERSION "55.3" CACHE STRING "Perfetto SDK version to download")
    set(PERFETTO_HASH "443b148764c4259c9bf3e724bb508b66f3ff77d30e2ccfafbc0f1791cc08141c" CACHE STRING "Perfetto zip sha256 hash")
    set(PERFETTO_SDK_URL "https://github.com/google/perfetto/releases/download/v${PERFETTO_VERSION}/perfetto-cpp-sdk-src.zip")
    set(PERFETTO_SDK_ZIP "${CMAKE_BINARY_DIR}/perfetto-cpp-sdk-src-${PERFETTO_VERSION}.zip")
    set(PERFETTO_SDK_DIR "${CMAKE_BINARY_DIR}/perfetto_sdk_${PERFETTO_VERSION}")

    if(NOT EXISTS "${PERFETTO_SDK_DIR}/perfetto.cc")
        message(STATUS "Downloading Perfetto SDK v${PERFETTO_VERSION}...")
        file(DOWNLOAD "${PERFETTO_SDK_URL}" "${PERFETTO_SDK_ZIP}"
            STATUS DOWNLOAD_STATUS
            TLS_VERIFY ON
            EXPECTED_HASH SHA256=${PERFETTO_HASH}
        )
        list(GET DOWNLOAD_STATUS 0 DOWNLOAD_ERROR_CODE)
        if(DOWNLOAD_ERROR_CODE)
            list(GET DOWNLOAD_STATUS 1 DOWNLOAD_ERROR_MSG)
            message(FATAL_ERROR "Failed to download Perfetto SDK from ${PERFETTO_SDK_URL}: ${DOWNLOAD_ERROR_MSG}")
        endif()
        file(ARCHIVE_EXTRACT INPUT "${PERFETTO_SDK_ZIP}" DESTINATION "${PERFETTO_SDK_DIR}")
    endif()

    add_library(perfetto_sdk STATIC ${PERFETTO_SDK_DIR}/perfetto.cc)
    target_include_directories(perfetto_sdk PUBLIC
        $<BUILD_INTERFACE:${PERFETTO_SDK_DIR}>
        $<INSTALL_INTERFACE:include/perfetto>
    )
    target_compile_options(perfetto_sdk PRIVATE
        $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
            -Wno-sign-compare -Wno-unused-parameter -Wno-missing-field-initializers>
    )
    install(TARGETS perfetto_sdk EXPORT jana2_targets DESTINATION lib)
    install(FILES ${PERFETTO_SDK_DIR}/perfetto.h DESTINATION include/perfetto)
    set(JANA2_HAVE_PERFETTO 1)
else()
    set(JANA2_HAVE_PERFETTO 0)
endif()


#---------
# Report back to the user what we've discovered
#---------

message(STATUS "-----------------------")
message(STATUS "Build type is ${CMAKE_BUILD_TYPE}")
message(STATUS "C++ standard is ${CMAKE_CXX_STANDARD}")
message(STATUS "Installation directory is ${CMAKE_INSTALL_PREFIX}")
if (${USE_ROOT})
    message(STATUS "USE_ROOT    On  --> " ${ROOT_DIR})
else()
    message(STATUS "USE_ROOT    Off")
endif()
if (${USE_ZEROMQ})
    message(STATUS "USE_ZEROMQ  On  --> " ${cppzmq_DIR})
else()
    message(STATUS "USE_ZEROMQ  Off")
endif()
if (${USE_XERCES})
    message(STATUS "USE_XERCES  On  --> " ${XercesC_DIR})
else()
    message(STATUS "USE_XERCES  Off")
endif()
if (${USE_PYTHON})
    message(STATUS "USE_PYTHON  On")
else()
    message(STATUS "USE_PYTHON  Off")
endif()
if (${USE_ASAN})
    message(STATUS "USE_ASAN    On")
else()
    message(STATUS "USE_ASAN    Off")
endif()
if (${USE_TSAN})
    message(STATUS "USE_TSAN    On")
else()
    message(STATUS "USE_TSAN    Off")
endif()
if (${USE_CUDA})
    message(STATUS "USE_CUDA    On")
else()
    message(STATUS "USE_CUDA    Off")
endif()
if (USE_PERFETTO)
    message(STATUS "USE_PERFETTO On")
else()
    message(STATUS "USE_PERFETTO Off")
endif()
if (${USE_PODIO})
    message(STATUS "USE_PODIO   On  --> " ${podio_DIR})
else()
    message(STATUS "USE_PODIO   Off")
endif()
if (${BUILD_SHARED_LIBS})
    message(STATUS "BUILD_SHARED_LIBS    On")
else()
    message(STATUS "BUILD_SHARED_LIBS    Off")
endif()
if (${BUILD_EXAMPLES})
    message(STATUS "BUILD_EXAMPLES       On")
else()
    message(STATUS "BUILD_EXAMPLES       Off")
endif()
if (${BUILD_TESTS})
    message(STATUS "BUILD_TESTS          On")
else()
    message(STATUS "BUILD_TESTS          Off")
endif()
message(STATUS "-----------------------")

#---------
# Targets
#---------

include_directories(src/libraries)   # So that everyone can find the JANA header files
include_directories(${CMAKE_CURRENT_BINARY_DIR}/src/libraries)   # So that everyone can find JVersion.h

# This is needed on macos to allow plugins to link without resolving all JANA symbols until runtime
if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
    add_link_options(-undefined dynamic_lookup)
endif()

include(CTest)
include(cmake/AddJanaPlugin.cmake)
include(cmake/AddJanaLibrary.cmake)
include(cmake/AddJanaTest.cmake)

add_subdirectory(src/external)
add_subdirectory(src/libraries/JANA)
add_subdirectory(src/plugins)
add_subdirectory(src/programs)
add_subdirectory(src/python)

if (${BUILD_EXAMPLES})
    add_subdirectory(src/examples)
endif()


#---------------------------------------------------------------------------------------

install(DIRECTORY scripts/ DESTINATION bin FILES_MATCHING PATTERN "jana-*.py"
        PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE)

    install(FILES "scripts/jana-status.sh" RENAME "jana-status" DESTINATION "bin"
        PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE)

include(${CMAKE_SOURCE_DIR}/cmake/MakeConfig.cmake)
include(${CMAKE_SOURCE_DIR}/cmake/MakeJanaThis.cmake)
include(${CMAKE_SOURCE_DIR}/cmake/MakeJVersionH.cmake)
