CMakeLists.txt

cmake_minimum_required(VERSION 3.12)
project(logme VERSION 2.4.20)

# Select which logme library target examples/tools/tests should link against.
# Priority:
#   1) Explicit USE_LOGME_SHARED
#   2) When only dynamic is enabled (LOGME_BUILD_DYNAMIC=ON, LOGME_BUILD_STATIC=OFF)
set(LOGME_LINK_TARGET logme)
if(DEFINED USE_LOGME_SHARED AND USE_LOGME_SHARED)
  set(LOGME_LINK_TARGET logmed)
elseif(LOGME_BUILD_DYNAMIC AND NOT LOGME_BUILD_STATIC)
  set(LOGME_LINK_TARGET logmed)
endif()

# Copy shared logme runtime next to an executable on Windows.
function(LogmeCopyRuntime target)
  if(WIN32 AND TARGET logmed)
    add_custom_command(TARGET ${target} POST_BUILD
      COMMAND ${CMAKE_COMMAND} -E copy_if_different
        $<TARGET_FILE:logmed>
        $<TARGET_FILE_DIR:${target}>
    )
  endif()
endfunction()
cmake_policy(SET CMP0067 NEW)

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF) 

if(MSVC)
  add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/EHsc>)
  add_compile_options(/Zc:preprocessor)
endif()

option(LOGME_BUILD_EXAMPLES "Build logme examples" ON)
option(LOGME_BUILD_TESTS "Build logme tests" ON)
option(LOGME_BUILD_STATIC "Build logme as static library" ON)
option(LOGME_BUILD_DYNAMIC "Build logme as dynamic library" ON)
option(LOGME_BUILD_TOOLS "Build logme tools" ON)

set(USE_JSONCPP "AUTO" CACHE STRING "JsonCpp support: AUTO, ON, or OFF")
set_property(CACHE USE_JSONCPP PROPERTY STRINGS AUTO ON OFF)

set(USE_ZLIB "AUTO" CACHE STRING "zlib gzip compression support: AUTO, ON, or OFF")
set_property(CACHE USE_ZLIB PROPERTY STRINGS AUTO ON OFF)

set(LOGME_FMT_FORMAT "AUTO" CACHE STRING "fmt formatting logging API: AUTO, ON, or OFF")
set_property(CACHE LOGME_FMT_FORMAT PROPERTY STRINGS AUTO ON OFF)
set(LOGME_STD_FORMAT "AUTO" CACHE STRING "std::format logging API: AUTO, ON, or OFF")
set_property(CACHE LOGME_STD_FORMAT PROPERTY STRINGS AUTO ON OFF)

get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if (NOT _isMultiConfig)
  if (CMAKE_BUILD_TYPE STREQUAL "")
    set(CMAKE_BUILD_TYPE Release CACHE STRING "" FORCE)
  endif()
endif()

include(CheckCXXSourceCompiles)

set(_LOGME_FWRITE_NOLOCK_TEST [=[
#include <cstdio>

int main()
{
  FILE* fp = nullptr;
  size_t rc = _fwrite_nolock("", 1, 0, fp);
  (void)rc;
  return 0;
}
]=])

set(_LOGME_FWRITE_UNLOCKED_TEST [=[
#include <cstdio>

int main()
{
  FILE* fp = nullptr;
  size_t rc = fwrite_unlocked("", 1, 0, fp);
  (void)rc;
  return 0;
}
]=])

check_cxx_source_compiles("${_LOGME_FWRITE_NOLOCK_TEST}" LOGME_HAS_FWRITE_NOLOCK)
check_cxx_source_compiles("${_LOGME_FWRITE_UNLOCKED_TEST}" LOGME_HAS_FWRITE_UNLOCKED)

set(_LOGME_STD_FORMAT_TEST [=[
#include <format>
#include <string>
#include <utility>

int main()
{
  auto s = std::format("{}", 1);
  (void)s;
  return 0;
}
]=])

string(TOUPPER "${LOGME_FMT_FORMAT}" _LOGME_FMT_FORMAT_MODE)
string(TOUPPER "${LOGME_STD_FORMAT}" _LOGME_STD_FORMAT_MODE)
string(TOUPPER "${USE_JSONCPP}" _LOGME_JSONCPP_MODE)
string(TOUPPER "${USE_ZLIB}" _LOGME_ZLIB_MODE)

foreach(_LOGME_FORMAT_MODE_NAME _LOGME_FMT_FORMAT_MODE _LOGME_STD_FORMAT_MODE)
  if(NOT "${${_LOGME_FORMAT_MODE_NAME}}" STREQUAL "AUTO"
    AND NOT "${${_LOGME_FORMAT_MODE_NAME}}" STREQUAL "ON"
    AND NOT "${${_LOGME_FORMAT_MODE_NAME}}" STREQUAL "OFF")
    message(FATAL_ERROR "${_LOGME_FORMAT_MODE_NAME} must be AUTO, ON, or OFF")
  endif()
endforeach()

set(LOGME_FMT_FORMAT "${_LOGME_FMT_FORMAT_MODE}" CACHE STRING "fmt formatting logging API: AUTO, ON, or OFF" FORCE)
set(LOGME_STD_FORMAT "${_LOGME_STD_FORMAT_MODE}" CACHE STRING "std::format logging API: AUTO, ON, or OFF" FORCE)

if(NOT "${_LOGME_JSONCPP_MODE}" STREQUAL "AUTO"
  AND NOT "${_LOGME_JSONCPP_MODE}" STREQUAL "ON"
  AND NOT "${_LOGME_JSONCPP_MODE}" STREQUAL "OFF")
  message(FATAL_ERROR "USE_JSONCPP must be AUTO, ON, or OFF")
endif()

set(USE_JSONCPP "${_LOGME_JSONCPP_MODE}" CACHE STRING "JsonCpp support: AUTO, ON, or OFF" FORCE)

if(NOT "${_LOGME_ZLIB_MODE}" STREQUAL "AUTO"
  AND NOT "${_LOGME_ZLIB_MODE}" STREQUAL "ON"
  AND NOT "${_LOGME_ZLIB_MODE}" STREQUAL "OFF")
  message(FATAL_ERROR "USE_ZLIB must be AUTO, ON, or OFF")
endif()

set(USE_ZLIB "${_LOGME_ZLIB_MODE}" CACHE STRING "zlib gzip compression support: AUTO, ON, or OFF" FORCE)

if(_LOGME_FMT_FORMAT_MODE STREQUAL "ON" AND _LOGME_STD_FORMAT_MODE STREQUAL "ON")
  message(FATAL_ERROR "LOGME_FMT_FORMAT=ON and LOGME_STD_FORMAT=ON are mutually exclusive")
endif()

set(LOGME_DISABLE_STD_FORMAT 1)
set(LOGME_USE_FMT_FORMAT 0)
set(LOGME_FORMAT_LIBRARIES "")

if(NOT _LOGME_FMT_FORMAT_MODE STREQUAL "OFF")
  if(_LOGME_FMT_FORMAT_MODE STREQUAL "ON")
    find_package(fmt CONFIG REQUIRED)
  else()
    find_package(fmt CONFIG QUIET)
  endif()

  if(TARGET fmt::fmt)
    set(LOGME_DISABLE_STD_FORMAT 0)
    set(LOGME_USE_FMT_FORMAT 1)
    set(LOGME_FORMAT_LIBRARIES fmt::fmt)
  elseif(_LOGME_FMT_FORMAT_MODE STREQUAL "ON")
    message(FATAL_ERROR "LOGME_FMT_FORMAT=ON but fmt::fmt is not available")
  endif()
endif()

if(LOGME_DISABLE_STD_FORMAT AND NOT _LOGME_STD_FORMAT_MODE STREQUAL "OFF")
  check_cxx_source_compiles("${_LOGME_STD_FORMAT_TEST}" LOGME_HAS_STD_FORMAT)
  if (LOGME_HAS_STD_FORMAT)
    set(LOGME_DISABLE_STD_FORMAT 0)
  else()
    if (_LOGME_STD_FORMAT_MODE STREQUAL "ON")
      message(FATAL_ERROR "LOGME_STD_FORMAT=ON but <format>/std::format is not available in this toolchain. Use GCC 13+ or Clang with libc++.")
    endif()
    set(LOGME_DISABLE_STD_FORMAT 1)
  endif()
endif()

if(LOGME_USE_FMT_FORMAT)
  set(LOGME_FORMAT_BACKEND "fmt::vformat")
elseif(NOT LOGME_DISABLE_STD_FORMAT)
  set(LOGME_FORMAT_BACKEND "std::vformat")
else()
  set(LOGME_FORMAT_BACKEND "disabled")
endif()

message(STATUS "LOGME_FMT_FORMAT = ${LOGME_FMT_FORMAT}")
message(STATUS "LOGME_STD_FORMAT = ${LOGME_STD_FORMAT}")
message(STATUS "Logme format backend: ${LOGME_FORMAT_BACKEND}")

set(LOGME_DISABLE_STD_FORMAT ${LOGME_DISABLE_STD_FORMAT} CACHE INTERNAL "Resolved format API availability" FORCE)
set(LOGME_USE_FMT_FORMAT ${LOGME_USE_FMT_FORMAT} CACHE INTERNAL "Resolved fmt format API usage" FORCE)
if (LOGME_DISABLE_STD_FORMAT)
  add_compile_definitions(LOGME_DISABLE_STD_FORMAT)
endif()
if (LOGME_USE_FMT_FORMAT)
  add_compile_definitions(LOGME_USE_FMT_FORMAT)
endif()


set(LOGME_USE_JSONCPP 0)
set(JSONCPP_LIBRARIES "")
set(LOGME_USE_ZLIB 0)
set(ZLIB_LIBRARIES "")

if(NOT _LOGME_JSONCPP_MODE STREQUAL "OFF")
  if(_LOGME_JSONCPP_MODE STREQUAL "ON")
    find_package(jsoncpp CONFIG REQUIRED)
  else()
    find_package(jsoncpp CONFIG QUIET)
  endif()

  if(TARGET JsonCpp::JsonCpp)
    set(LOGME_USE_JSONCPP 1)
    set(JSONCPP_LIBRARIES JsonCpp::JsonCpp)
  elseif(_LOGME_JSONCPP_MODE STREQUAL "ON")
    message(FATAL_ERROR "USE_JSONCPP=ON but JsonCpp::JsonCpp is not available")
  endif()
endif()

message(STATUS "USE_JSONCPP = ${USE_JSONCPP}")
if(LOGME_USE_JSONCPP)
  message(STATUS "Logme JsonCpp support: enabled")
else()
  message(STATUS "Logme JsonCpp support: disabled")
endif()

set(LOGME_USE_JSONCPP ${LOGME_USE_JSONCPP} CACHE INTERNAL "Resolved JsonCpp usage" FORCE)
# Keep legacy subdirectory checks like if(USE_JSONCPP) safe when AUTO resolves to disabled.
set(USE_JSONCPP ${LOGME_USE_JSONCPP})

if(NOT _LOGME_ZLIB_MODE STREQUAL "OFF")
  if(_LOGME_ZLIB_MODE STREQUAL "ON")
    find_package(ZLIB REQUIRED)
  else()
    find_package(ZLIB QUIET)
  endif()

  if(TARGET ZLIB::ZLIB)
    set(LOGME_USE_ZLIB 1)
    set(ZLIB_LIBRARIES ZLIB::ZLIB)
  elseif(_LOGME_ZLIB_MODE STREQUAL "ON")
    message(FATAL_ERROR "USE_ZLIB=ON but ZLIB::ZLIB is not available")
  endif()
endif()

message(STATUS "USE_ZLIB = ${USE_ZLIB}")
if(LOGME_USE_ZLIB)
  message(STATUS "Logme zlib gzip compression support: enabled")
else()
  message(STATUS "Logme zlib gzip compression support: disabled")
endif()

set(LOGME_USE_ZLIB ${LOGME_USE_ZLIB} CACHE INTERNAL "Resolved zlib usage" FORCE)
# Keep legacy subdirectory checks like if(USE_ZLIB) safe when AUTO resolves to disabled.
set(USE_ZLIB ${LOGME_USE_ZLIB})

if(LOGME_BUILD_STATIC)
 add_subdirectory(logme out/Static)
endif()

if(LOGME_BUILD_DYNAMIC)
  add_subdirectory(dynamic out/Dynamic)
endif()

include(GNUInstallDirs)
include(CMakePackageConfigHelpers)

# Install/package rules (disabled automatically for internal dual-build)
option(LOGME_ENABLE_INSTALL "Enable install/package rules" ON)

set(_logme_has_static 0)
set(_logme_has_shared 0)
if(TARGET logme)
  set(_logme_has_static 1)
endif()
if(TARGET logmed)
  set(_logme_has_shared 1)
endif()

set(_logme_both_built 0)
if(_logme_has_static AND _logme_has_shared)
  set(_logme_both_built 1)
endif()

if(LOGME_ENABLE_INSTALL AND NOT _logme_both_built)
  # Install headers
  install(
    DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/logme/include/"
    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
  )

  # Install exactly one library target (static OR shared)
  set(_logme_install_targets "")
  if(_logme_has_static)
    list(APPEND _logme_install_targets logme)
  elseif(_logme_has_shared)
    list(APPEND _logme_install_targets logmed)
  endif()

  if(_logme_install_targets)
    install(
      TARGETS ${_logme_install_targets}
      EXPORT logmeTargets
      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
    )

    install(
      EXPORT logmeTargets
      NAMESPACE logme::
      DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/logme"
    )

    configure_package_config_file(
      "${CMAKE_CURRENT_SOURCE_DIR}/cmake/logmeConfig.cmake.in"
      "${CMAKE_CURRENT_BINARY_DIR}/logmeConfig.cmake"
      INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/logme"
    )

    write_basic_package_version_file(
      "${CMAKE_CURRENT_BINARY_DIR}/logmeConfigVersion.cmake"
      VERSION "${PROJECT_VERSION}"
      COMPATIBILITY SameMajorVersion
    )

    install(
      FILES
        "${CMAKE_CURRENT_BINARY_DIR}/logmeConfig.cmake"
        "${CMAKE_CURRENT_BINARY_DIR}/logmeConfigVersion.cmake"
      DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/logme"
    )
  endif()
endif()

if(LOGME_BUILD_EXAMPLES)
  add_subdirectory(examples out/Examples)
endif()

if(LOGME_BUILD_TOOLS)
  add_subdirectory(tools out/Tools)
endif()

if(LOGME_BUILD_TESTS)
  enable_testing()
  add_subdirectory(tests out/Tests)
endif()