cmake_minimum_required(VERSION 3.21)

project(revera
    VERSION 0.1.0
    DESCRIPTION "POSIX ERE regular expressions with a leftmost-longest engine and CLDR locales"
    LANGUAGES C CXX)

include(CMakePackageConfigHelpers)
include(CTest)
include(GNUInstallDirs)

option(REVERA_USE_EMBED "Load data.bin with #embed instead of a generated byte list; needs clang 19 or gcc 15" OFF)

set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# The engines count on wrapping signed arithmetic, so -fwrapv is not optional.
# The warning flags are the ones of the plain Makefiles.
set(revera_compile_options -fwrapv -Wall -Wextra -Wno-parentheses-equality)
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
    list(APPEND revera_compile_options -Wno-c23-extensions)
endif()
if(NOT CMAKE_C_COMPILER_ID MATCHES "Clang|GNU" OR NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
    message(FATAL_ERROR "Revera needs clang or gcc: the engines rely on -fwrapv semantics")
endif()

# Consumers include <revera/revera.h> and <revera/revera.hpp>.
# The sources keep including "revera.h" from their own directory, so the build tree gets a copy of the two public headers under the installed layout.
set(revera_include_dir "${PROJECT_BINARY_DIR}/include")
configure_file(c/revera.h "${revera_include_dir}/revera/revera.h" COPYONLY)
configure_file(cpp/revera.hpp "${revera_include_dir}/revera/revera.hpp" COPYONLY)

# The locale data.
# The plain Makefiles rely on #embed, which needs a recent compiler.
# The default here is a byte list that CMake writes at configure time, so any C11 and C++20 compiler works.
# Both copies of data.bin must stay identical; the check is cheap and catches a stale copy early.
file(SHA256 "${PROJECT_SOURCE_DIR}/c/data.bin" revera_c_data_hash)
file(SHA256 "${PROJECT_SOURCE_DIR}/cpp/data.bin" revera_cpp_data_hash)
if(NOT revera_c_data_hash STREQUAL revera_cpp_data_hash)
    message(FATAL_ERROR "c/data.bin and cpp/data.bin differ; copy the fresh one over the stale one")
endif()
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS c/data.bin cpp/data.bin)

if(NOT REVERA_USE_EMBED)
    set(revera_locale_inc "${PROJECT_BINARY_DIR}/revera_locale_data.inc")
    file(READ "${PROJECT_SOURCE_DIR}/c/data.bin" revera_locale_hex HEX)
    string(REGEX REPLACE "(..)" "0x\\1," revera_locale_bytes "${revera_locale_hex}")
    string(REPEAT "0x..," 16 revera_locale_row)
    string(REGEX REPLACE "(${revera_locale_row})" "\\1\n" revera_locale_bytes "${revera_locale_bytes}")
    file(WRITE "${revera_locale_inc}.tmp" "${revera_locale_bytes}\n")
    configure_file("${revera_locale_inc}.tmp" "${revera_locale_inc}" COPYONLY)
    file(REMOVE "${revera_locale_inc}.tmp")
    unset(revera_locale_hex)
    unset(revera_locale_bytes)
    set(revera_locale_definitions "REVERA_LOCALE_DATA_INC=\"${revera_locale_inc}\"")
    set(revera_locale_sources "${revera_locale_inc}")
else()
    set(revera_locale_definitions)
    set(revera_locale_sources)
endif()

function(revera_add_library target)
    add_library(${target} ${ARGN})
    target_compile_options(${target} PRIVATE ${revera_compile_options})
    target_compile_definitions(${target} PRIVATE ${revera_locale_definitions})
    target_include_directories(${target} PUBLIC
        $<BUILD_INTERFACE:${revera_include_dir}>
        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
    set_target_properties(${target} PROPERTIES
        VERSION ${PROJECT_VERSION}
        SOVERSION ${PROJECT_VERSION_MAJOR})
    if(revera_locale_sources)
        set_source_files_properties(${ARGN} PROPERTIES OBJECT_DEPENDS "${revera_locale_sources}")
    endif()
endfunction()

revera_add_library(revera_c c/revera.c c/engine.c)
set_target_properties(revera_c PROPERTIES EXPORT_NAME C)
target_compile_features(revera_c PUBLIC c_std_11)
add_library(Revera::C ALIAS revera_c)

revera_add_library(revera_cxx cpp/revera.cpp cpp/engine.cpp)
set_target_properties(revera_cxx PROPERTIES EXPORT_NAME CXX)
target_compile_features(revera_cxx PUBLIC cxx_std_20)
add_library(Revera::CXX ALIAS revera_cxx)

install(TARGETS revera_c revera_cxx
    EXPORT ReveraTargets
    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
install(FILES c/revera.h cpp/revera.hpp DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/revera")

set(revera_cmake_dir "${CMAKE_INSTALL_LIBDIR}/cmake/Revera")
install(EXPORT ReveraTargets NAMESPACE Revera:: DESTINATION "${revera_cmake_dir}")
configure_package_config_file(cmake/ReveraConfig.cmake.in
    "${PROJECT_BINARY_DIR}/ReveraConfig.cmake"
    INSTALL_DESTINATION "${revera_cmake_dir}")
write_basic_package_version_file("${PROJECT_BINARY_DIR}/ReveraConfigVersion.cmake"
    COMPATIBILITY SameMajorVersion)
install(FILES
    "${PROJECT_BINARY_DIR}/ReveraConfig.cmake"
    "${PROJECT_BINARY_DIR}/ReveraConfigVersion.cmake"
    DESTINATION "${revera_cmake_dir}")

# The .pc files locate the prefix from their own position, so an install with a different --prefix still works.
# An absolute CMAKE_INSTALL_LIBDIR outside the prefix falls back to the configured prefix.
set(revera_pc_dir "${CMAKE_INSTALL_FULL_LIBDIR}/pkgconfig")
file(RELATIVE_PATH revera_pc_prefix "${revera_pc_dir}" "${CMAKE_INSTALL_PREFIX}")
string(REGEX REPLACE "/$" "" revera_pc_prefix "${revera_pc_prefix}")
if(revera_pc_prefix MATCHES "^\\.\\.(/\\.\\.)*$")
    set(revera_pc_prefix "\${pcfiledir}/${revera_pc_prefix}")
else()
    set(revera_pc_prefix "${CMAKE_INSTALL_PREFIX}")
endif()
file(RELATIVE_PATH revera_pc_libdir "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_FULL_LIBDIR}")
file(RELATIVE_PATH revera_pc_includedir "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
configure_file(cmake/revera-c.pc.in "${PROJECT_BINARY_DIR}/revera-c.pc" @ONLY)
configure_file(cmake/revera-cxx.pc.in "${PROJECT_BINARY_DIR}/revera-cxx.pc" @ONLY)
install(FILES
    "${PROJECT_BINARY_DIR}/revera-c.pc"
    "${PROJECT_BINARY_DIR}/revera-cxx.pc"
    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")

install(FILES README.md DESTINATION "${CMAKE_INSTALL_DOCDIR}")
# LICENSE and LICENSES/ are copies of the repository root files, kept in step by `make licenses`.
# The release archive is built from this directory, so the copies are what ships.
if(EXISTS "${PROJECT_SOURCE_DIR}/LICENSE")
    install(FILES "${PROJECT_SOURCE_DIR}/LICENSE" DESTINATION "${CMAKE_INSTALL_DOCDIR}")
else()
    message(STATUS "revera: no LICENSE file next to CMakeLists.txt; none is installed")
endif()
if(EXISTS "${PROJECT_SOURCE_DIR}/LICENSES/Unicode-3.0.txt")
    install(FILES "${PROJECT_SOURCE_DIR}/LICENSES/Unicode-3.0.txt" DESTINATION "${CMAKE_INSTALL_DOCDIR}/LICENSES")
else()
    message(FATAL_ERROR "revera: LICENSES/Unicode-3.0.txt is missing; run `make licenses` at the repository root")
endif()

if(BUILD_TESTING)
    add_executable(revera_c_api_test c/api_test.c)
    target_link_libraries(revera_c_api_test PRIVATE Revera::C)
    target_compile_options(revera_c_api_test PRIVATE ${revera_compile_options})
    add_test(NAME revera_c_api COMMAND revera_c_api_test)

    add_executable(revera_cxx_api_test cpp/api_test.cpp)
    target_link_libraries(revera_cxx_api_test PRIVATE Revera::CXX)
    target_compile_options(revera_cxx_api_test PRIVATE ${revera_compile_options})
    add_test(NAME revera_cxx_api COMMAND revera_cxx_api_test)

    # The consumer test installs the package into a staging prefix, then builds tests/consumer against it with find_package.
    add_test(NAME revera_consumer
        COMMAND "${CMAKE_COMMAND}"
            -DREVERA_BUILD_DIR=${PROJECT_BINARY_DIR}
            -DREVERA_CONSUMER_SOURCE_DIR=${PROJECT_SOURCE_DIR}/tests/consumer
            -DREVERA_STAGE_DIR=${PROJECT_BINARY_DIR}/consumer-stage
            -DREVERA_CONFIG=$<CONFIG>
            -DREVERA_GENERATOR=${CMAKE_GENERATOR}
            -DREVERA_C_COMPILER=${CMAKE_C_COMPILER}
            -DREVERA_CXX_COMPILER=${CMAKE_CXX_COMPILER}
            -P "${PROJECT_SOURCE_DIR}/cmake/ConsumerTest.cmake")
endif()
