# Notes:
#
# Author: Paul Harris, June 2012
# Additions: Joakim Soderberg, Febuary 2013
#
# Supports: building static/shared, release/debug/etc, can also build html docs
# and some of the tests.
# Note that its designed for out-of-tree builds, so it will not pollute your
# source tree.
#
# TODO 1: Finish implementing tests. api tests are working, but the valgrind
# variants are not flagging problems.
#
# TODO 2: There is a check_exports script that would try and incorporate.
#
# TODO 3: Consolidate version numbers, currently the version number is written
# into: * cmake (here) * autotools (the configure) * source code header files.
# Should not be written directly into header files, autotools/cmake can do
# that job.
#
# Brief intro on how to use cmake:
# > mkdir build (somewhere - we do out-of-tree builds)
# > use cmake, ccmake, or cmake-gui to configure the project. for linux, you
# can only choose one variant: release,debug,etc... and static or shared.
# >> example:
# >> cd build
# >> ccmake -i ../path_to_jansson_dir
# >>  inside, configure your options. press C until there are no lines
#     with * next to them.
# >>  note, I like to configure the 'install' path to ../install, so I get
#     self-contained clean installs I can point other projects to.
# >>  press G to 'generate' the project files.
# >> make (to build the project)
# >> make install
# >> make test (to run the tests, if you enabled them)
#
# Brief description on how it works:
# There is a small heirachy of CMakeLists.txt files which define how the
# project is built.
# Header file detection etc is done, and the results are written into config.h
# and jansson_config.h, which are generated from the corresponding
# config.h.cmake and jansson_config.h.cmake template files.
# The generated header files end up in the build directory - not in
# the source directory.
# The rest is down to the usual make process.

cmake_minimum_required(VERSION 2.8)
# required for exports? cmake_minimum_required (VERSION 2.8.6)
project(jansson C)

# Options
option(JANSSON_BUILD_SHARED_LIBS "Build shared libraries." OFF)
option(USE_URANDOM "Use /dev/urandom to seed the hash function." ON)
option(USE_WINDOWS_CRYPTOAPI "Use CryptGenRandom to seed the hash function." ON)

if(MSVC)
    # This option must match the settings used in your program, in particular if you
    # are linking statically
    option(JANSSON_STATIC_CRT "Link the static CRT libraries" OFF)
endif()

# Set some nicer output dirs.
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)

# Give the debug version a different postfix for windows,
# so both the debug and release version can be built in the
# same build-tree on Windows (MSVC).
if(WIN32)
    set(CMAKE_DEBUG_POSTFIX "_d")
else(WIN32)

endif(WIN32)

# This is how I thought it should go
# set (JANSSON_VERSION "2.3.1")
# set (JANSSON_SOVERSION 2)

set(JANSSON_DISPLAY_VERSION "2.7")

# This is what is required to match the same numbers as automake's
set(JANSSON_VERSION "4.7.0")
set(JANSSON_SOVERSION 4)

# for CheckFunctionKeywords
set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")

include(CheckCSourceCompiles)
include(CheckFunctionExists)
include(CheckFunctionKeywords)
include(CheckIncludeFiles)
include(CheckTypeSize)

if(MSVC)
    # Turn off Microsofts "security" warnings.
    add_definitions("/W3 /D_CRT_SECURE_NO_WARNINGS /wd4005 /wd4996 /nologo")

    if(STATIC_CRT)
        set(CMAKE_C_FLAGS_RELEASE "/MT")
        set(CMAKE_C_FLAGS_DEBUG "/MTd")
    endif()

endif()

if(NOT WIN32 AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX))
    add_definitions("-fPIC")
endif()

check_include_files(endian.h HAVE_ENDIAN_H)
check_include_files(fcntl.h HAVE_FCNTL_H)
check_include_files(sched.h HAVE_SCHED_H)
check_include_files(unistd.h HAVE_UNISTD_H)
check_include_files(sys/param.h HAVE_SYS_PARAM_H)
check_include_files(sys/stat.h HAVE_SYS_STAT_H)
check_include_files(sys/time.h HAVE_SYS_TIME_H)
check_include_files(sys/time.h HAVE_SYS_TYPES_H)

check_function_exists(close HAVE_CLOSE)
check_function_exists(getpid HAVE_GETPID)
check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
check_function_exists(open HAVE_OPEN)
check_function_exists(read HAVE_READ)
check_function_exists(sched_yield HAVE_SCHED_YIELD)

# Check for the int-type includes
check_include_files(stdint.h HAVE_STDINT_H)

# Check our 64 bit integer sizes
check_type_size(__int64 __INT64)
check_type_size(int64_t INT64_T)
check_type_size("long long" LONG_LONG_INT)

# Check our 32 bit integer sizes
check_type_size(int32_t INT32_T)
check_type_size(__int32 __INT32)
check_type_size("long" LONG_INT)
check_type_size("int" INT)
if(HAVE_INT32_T)
    set(JSON_INT32 int32_t)
elseif(HAVE___INT32)
    set(JSON_INT32 __int32)
elseif(HAVE_LONG_INT AND (${LONG_INT} EQUAL 4))
    set(JSON_INT32 long)
elseif(HAVE_INT AND (${INT} EQUAL 4))
    set(JSON_INT32 int)
else()
    message(FATAL_ERROR "Could not detect a valid 32-bit integer type")
endif()

check_type_size("unsigned long" UNSIGNED_LONG_INT)
check_type_size("unsigned int" UNSIGNED_INT)
check_type_size("unsigned short" UNSIGNED_SHORT)

check_type_size(uint32_t UINT32_T)
check_type_size(__uint32 __UINT32)
if(HAVE_UINT32_T)
    set(JSON_UINT32 uint32_t)
elseif(HAVE___UINT32)
    set(JSON_UINT32 __uint32)
elseif(HAVE_UNSIGNED_LONG_INT AND (${UNSIGNED_LONG_INT} EQUAL 4))
    set(JSON_UINT32 "unsigned long")
elseif(HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 4))
    set(JSON_UINT32 "unsigned int")
else()
    message(FATAL_ERROR "Could not detect a valid unsigned 32-bit integer type")
endif()

check_type_size(uint16_t UINT16_T)
check_type_size(__uint16 __UINT16)
if(HAVE_UINT16_T)
    set(JSON_UINT16 uint16_t)
elseif(HAVE___UINT16)
    set(JSON_UINT16 __uint16)
elseif(HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 2))
    set(JSON_UINT16 "unsigned int")
elseif(HAVE_UNSIGNED_SHORT AND (${UNSIGNED_SHORT} EQUAL 2))
    set(JSON_UINT16 "unsigned short")
else()
    message(FATAL_ERROR "Could not detect a valid unsigned 16-bit integer type")
endif()

check_type_size(uint8_t UINT8_T)
check_type_size(__uint8 __UINT8)
if(HAVE_UINT8_T)
    set(JSON_UINT8 uint8_t)
elseif(HAVE___UINT8)
    set(JSON_UINT8 __uint8)
else()
    set(JSON_UINT8 "unsigned char")
endif()

# Check for ssize_t and SSIZE_T existance.
check_type_size(ssize_t SSIZE_T)
check_type_size(SSIZE_T UPPERCASE_SSIZE_T)
if(NOT HAVE_SSIZE_T)
    if(HAVE_UPPERCASE_SSIZE_T)
        set(JSON_SSIZE SSIZE_T)
    else()
        set(JSON_SSIZE int)
    endif()
endif()
set(CMAKE_EXTRA_INCLUDE_FILES "")

# Check for all the variants of strtoll
check_function_exists(strtoll HAVE_STRTOLL)
check_function_exists(strtoq HAVE_STRTOQ)
check_function_exists(_strtoi64 HAVE__STRTOI64)

# Figure out what variant we should use
if(HAVE_STRTOLL)
    set(JSON_STRTOINT strtoll)
elseif(HAVE_STRTOQ)
    set(JSON_STRTOINT strtoq)
elseif(HAVE__STRTOI64)
    set(JSON_STRTOINT _strtoi64)
else()
    # fallback to strtol (32 bit)
    # this will set all the required variables
    set(JSON_STRTOINT strtol)
    set(JSON_INT_T long)
    set(JSON_INTEGER_FORMAT "\"ld\"")
    set(JSON_NUMBER_FORMAT "\"lu\"")
endif()

# if we haven't defined JSON_INT_T, then we have a 64 bit conversion function.
# detect what to use for the 64 bit type.
# Note: I will prefer long long if I can get it, as that is what the automake system aimed for.
if(NOT DEFINED JSON_INT_T)
    if(HAVE_LONG_LONG_INT AND (${LONG_LONG_INT} EQUAL 8))
        set(JSON_INT_T "long long")
    elseif(HAVE_INT64_T)
        set(JSON_INT_T int64_t)
    elseif(HAVE___INT64)
        set(JSON_INT_T __int64)
    else()
        message(
            FATAL_ERROR "Could not detect 64 bit type, although I detected the strtoll equivalent"
        )
    endif()

    # Apparently, Borland BCC and MSVC wants I64d,
    # Borland BCC could also accept LD
    # and gcc wants ldd,
    # I am not sure what cygwin will want, so I will assume I64d

    if(WIN32) # matches both msvc and cygwin
        set(JSON_INTEGER_FORMAT "\"I64d\"")
        set(JSON_NUMBER_FORMAT "\"I64u\"")
    else()
        set(JSON_INTEGER_FORMAT "\"lld\"")
        set(JSON_NUMBER_FORMAT "\"llu\"")
    endif()
endif()

# If locale.h and localeconv() are available, define to 1, otherwise to 0.
check_include_files(locale.h HAVE_LOCALE_H)
check_function_exists(localeconv HAVE_LOCALECONV)

if(HAVE_LOCALECONV AND HAVE_LOCALE_H)
    set(JSON_HAVE_LOCALECONV 1)
else()
    set(JSON_HAVE_LOCALECONV 0)
endif()

# check if we have setlocale
check_function_exists(setlocale HAVE_SETLOCALE)

# Check what the inline keyword is.
# Note that the original JSON_INLINE was always set to just 'inline', so this goes further.
check_function_keywords("inline")
check_function_keywords("__inline")
check_function_keywords("__inline__")

if(HAVE_INLINE)
    set(JSON_INLINE inline)
elseif(HAVE___INLINE)
    set(JSON_INLINE __inline)
elseif(HAVE___INLINE__)
    set(JSON_INLINE __inline__)
else()
    # no inline on this platform
    set(JSON_INLINE)
endif()

# Find our snprintf
check_function_exists(snprintf HAVE_SNPRINTF)
check_function_exists(_snprintf HAVE__SNPRINTF)

if(HAVE_SNPRINTF)
    set(JSON_SNPRINTF snprintf)
elseif(HAVE__SNPRINTF)
    set(JSON_SNPRINTF _snprintf)
endif()

check_c_source_compiles(
    "int main() { unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1); return 0; } "
    HAVE_SYNC_BUILTINS
)
check_c_source_compiles(
    "int main() { char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_RELEASE); __atomic_load_n(&v, __ATOMIC_ACQUIRE); return 0; }"
    HAVE_ATOMIC_BUILTINS
)

# Create pkg-conf file.
# (We use the same files as ./configure does, so we
#  have to defined the same variables used there).
if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
    set(CMAKE_INSTALL_LIBDIR lib)
endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${CMAKE_INSTALL_PREFIX})
set(libdir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
set(VERSION ${JANSSON_DISPLAY_VERSION})
configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/jansson.pc.in ${CMAKE_CURRENT_BINARY_DIR}/jansson.pc @ONLY
)

# configure the public config file
configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/jansson_config.h.cmake
    ${CMAKE_CURRENT_BINARY_DIR}/include/jansson_config.h
)

# Copy the jansson.h file to the public include folder
file(
    COPY
    ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson.h
    DESTINATION
    ${CMAKE_CURRENT_BINARY_DIR}/include/
)

add_definitions(-DJANSSON_USING_CMAKE)

# configure the private config file
configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/jansson_private_config.h.cmake
    ${CMAKE_CURRENT_BINARY_DIR}/private_include/jansson_private_config.h
)

# and tell the source code to include it
add_definitions(-DHAVE_CONFIG_H)

include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/private_include)

# Add the lib sources.
file(GLOB JANSSON_SRC src/*.c)

set(
    JANSSON_HDR_PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/src/hashtable.h
    ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson_private.h
    ${CMAKE_CURRENT_SOURCE_DIR}/src/strbuffer.h
    ${CMAKE_CURRENT_SOURCE_DIR}/src/utf.h
    ${CMAKE_CURRENT_BINARY_DIR}/private_include/jansson_private_config.h
)

set(
    JANSSON_HDR_PUBLIC ${CMAKE_CURRENT_BINARY_DIR}/include/jansson_config.h
    ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson.h
)

source_group("Library Sources" FILES ${JANSSON_SRC})
source_group("Library Private Headers" FILES ${JANSSON_HDR_PRIVATE})
source_group("Library Public Headers" FILES ${JANSSON_HDR_PUBLIC})

if(JANSSON_BUILD_SHARED_LIBS)
    add_library(
        jansson
        SHARED
        ${JANSSON_SRC}
        ${JANSSON_HDR_PRIVATE}
        ${JANSSON_HDR_PUBLIC}
        src/jansson.def
    )

    set_target_properties(
        jansson
        PROPERTIES
            VERSION
            ${JANSSON_VERSION}
            SOVERSION
            ${JANSSON_SOVERSION}
    )
else()
    add_library(jansson ${JANSSON_SRC} ${JANSSON_HDR_PRIVATE} ${JANSSON_HDR_PUBLIC})
endif()

# For building Documentation (uses Sphinx)
option(JANSSON_BUILD_DOCS "Build documentation (uses python-sphinx)." ON)
if(JANSSON_BUILD_DOCS)
    find_package(Sphinx)

    if(NOT SPHINX_FOUND)
        message(WARNING "Sphinx not found. Cannot generate documentation!
      Set -DJANSSON_BUILD_DOCS=OFF to get rid of this message.")
    else()
        if(Sphinx_VERSION_STRING VERSION_LESS 1.0)
            message(WARNING "Your Sphinx version is too old!
               This project requires Sphinx v1.0 or above to produce
               proper documentation (you have v${Sphinx_VERSION_STRING}).
               You will get output but it will have errors.")
        endif()

        # configured documentation tools and intermediate build results
        set(BINARY_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/_build")

        # Sphinx cache with pickled ReST documents
        set(SPHINX_CACHE_DIR "${CMAKE_CURRENT_BINARY_DIR}/_doctrees")

        # CMake could be used to build the conf.py file too,
        # eg it could automatically write the version of the program or change the theme.
        # if(NOT DEFINED SPHINX_THEME)
        #    set(SPHINX_THEME default)
        # endif()
        #
        # if(NOT DEFINED SPHINX_THEME_DIR)
        #    set(SPHINX_THEME_DIR)
        # endif()
        #
        # configure_file(
        #    "${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in"
        #    "${BINARY_BUILD_DIR}/conf.py"
        #    @ONLY)

        # TODO: Add support for all sphinx builders: http://sphinx-doc.org/builders.html

        # Add documentation targets.
        set(DOC_TARGETS html)

        option(JANSSON_BUILD_MAN "Create a target for building man pages." ON)

        if(JANSSON_BUILD_MAN)
            if(Sphinx_VERSION_STRING VERSION_LESS 1.0)
                message(
                    WARNING
                        "Sphinx version 1.0 > is required to build man pages. You have v${Sphinx_VERSION_STRING}."
                )
            else()
                list(APPEND DOC_TARGETS man)
            endif()
        endif()

        option(JANSSON_BUILD_LATEX "Create a target for building latex docs (to create PDF)." OFF)

        if(JANSSON_BUILD_LATEX)
            find_package(LATEX)

            if(NOT LATEX_COMPILER)
                message("Couldn't find Latex, can't build latex docs using Sphinx")
            else()
                message(
                    "Latex found! If you have problems building, see Sphinx documentation for required Latex packages."
                )
                list(APPEND DOC_TARGETS latex)
            endif()
        endif()

        # The doc target will build all documentation targets.
        add_custom_target(doc)

        foreach(DOC_TARGET ${DOC_TARGETS})
            add_custom_target(
                ${DOC_TARGET} ${SPHINX_EXECUTABLE}
                # -q   # Enable for quiet mode
                -b
                ${DOC_TARGET}
                -d
                "${SPHINX_CACHE_DIR}"
                # -c "${BINARY_BUILD_DIR}" # enable if using cmake-generated conf.py
                "${CMAKE_CURRENT_SOURCE_DIR}/doc" "${CMAKE_CURRENT_BINARY_DIR}/doc/${DOC_TARGET}"
                COMMENT "Building ${DOC_TARGET} documentation with Sphinx"
            )

            add_dependencies(doc ${DOC_TARGET})
        endforeach()

        message("Building documentation enabled for: ${DOC_TARGETS}")
    endif()
endif()

option(JANSSON_WITHOUT_TESTS "Don't build tests ('make test' to execute tests)" OFF)

if(NOT JANSSON_WITHOUT_TESTS)
    option(JANSSON_TEST_WITH_VALGRIND "Enable valgrind tests." OFF)

    ENABLE_TESTING()

    if(JANSSON_TEST_WITH_VALGRIND)
        # TODO: Add FindValgrind.cmake instead of having a hardcoded path.

        add_definitions(-DVALGRIND)

        # enable valgrind
        set(CMAKE_MEMORYCHECK_COMMAND valgrind)
        set(
            CMAKE_MEMORYCHECK_COMMAND_OPTIONS
            "--error-exitcode=1 --leak-check=full --show-reachable=yes --track-origins=yes -q"
        )

        set(MEMCHECK_COMMAND "${CMAKE_MEMORYCHECK_COMMAND} ${CMAKE_MEMORYCHECK_COMMAND_OPTIONS}")
        separate_arguments(MEMCHECK_COMMAND)
    endif()

    #
    # Test suites.
    #
    if(CMAKE_COMPILER_IS_GNUCC)
        add_definitions(-Wall -Wextra -Wdeclaration-after-statement)
    endif()

    set(
        api_tests
        test_array
        test_copy
        test_dump
        test_dump_callback
        test_equal
        test_load
        test_loadb
        test_number
        test_object
        test_pack
        test_simple
        test_unpack
    )

    # Doing arithmetic on void pointers is not allowed by Microsofts compiler
    # such as secure_malloc and secure_free is doing, so exclude it for now.
    if(NOT MSVC)
        list(APPEND api_tests test_memory_funcs)
    endif()

    # Helper macro for building and linking a test program.
    macro(build_testprog name dir)
        add_executable(${name} ${dir}/${name}.c)
        add_dependencies(${name} jansson)
        target_link_libraries(${name} jansson)
    endmacro(build_testprog)

    # Create executables and tests/valgrind tests for API tests.
    foreach(test ${api_tests})
        build_testprog(${test} ${PROJECT_SOURCE_DIR}/test/suites/api)

        if(JANSSON_TEST_WITH_VALGRIND)
            add_test(
                memcheck__${test} ${MEMCHECK_COMMAND} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${test}
            )
        else()
            add_test(${test} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${test})
        endif()
    endforeach()

    # Test harness for the suites tests.
    build_testprog(json_process ${PROJECT_SOURCE_DIR}/test/bin)

    set(SUITES encoding-flags valid invalid invalid-unicode)
    foreach(SUITE ${SUITES})
        file(GLOB TESTDIRS ${jansson_SOURCE_DIR}/test/suites/${SUITE}/*)

        foreach(TESTDIR ${TESTDIRS})
            if(IS_DIRECTORY ${TESTDIR})
                get_filename_component(TNAME ${TESTDIR} NAME)

                set(SUITE_TEST_CMD ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/json_process)

                if(JANSSON_TEST_WITH_VALGRIND)
                    add_test(
                        memcheck__${SUITE}__${TNAME}
                        ${MEMCHECK_COMMAND}
                        ${SUITE_TEST_CMD}
                        ${TESTDIR}
                    )
                else()
                    add_test(${SUITE}__${TNAME} ${SUITE_TEST_CMD} ${TESTDIR})
                endif()

                if(
                    (${SUITE} STREQUAL "valid" OR ${SUITE} STREQUAL "invalid")
                    AND NOT EXISTS ${TESTDIR}/nostrip
                )
                    if(JANSSON_TEST_WITH_VALGRIND)
                        add_test(
                            memcheck__${SUITE}__${TNAME}__strip
                            ${MEMCHECK_COMMAND}
                            ${SUITE_TEST_CMD}
                            --strip
                            ${TESTDIR}
                        )
                    else()
                        add_test(${SUITE}__${TNAME}__strip ${SUITE_TEST_CMD} --strip ${TESTDIR})
                    endif()
                endif()
            endif()
        endforeach()
    endforeach()

    add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} DEPENDS json_process ${api_tests})
endif()

#
# Installation preparation.
#

# Allow the user to override installation directories.
set(JANSSON_INSTALL_LIB_DIR lib CACHE PATH "Installation directory for libraries")
set(JANSSON_INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
set(JANSSON_INSTALL_INCLUDE_DIR include CACHE PATH "Installation directory for header files")

if(WIN32 AND NOT CYGWIN)
    set(DEF_INSTALL_CMAKE_DIR cmake)
else()
    set(DEF_INSTALL_CMAKE_DIR lib/cmake/jansson)
endif()

set(
    JANSSON_INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR}
    CACHE PATH "Installation directory for CMake files"
)

# Make sure the paths are absolute.
foreach(p LIB BIN INCLUDE CMAKE)
    set(var JANSSON_INSTALL_${p}_DIR)
    if(NOT IS_ABSOLUTE "${${var}}")
        set(${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
    endif()
endforeach()

# Export targets (This is used for other CMake projects to easily find the libraries and include files).
export(TARGETS jansson FILE "${PROJECT_BINARY_DIR}/JanssonTargets.cmake")
export(PACKAGE jansson)

# Generate the config file for the build-tree.
set(JANSSON__INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/include" "${PROJECT_BINARY_DIR}/include")
set(JANSSON_INCLUDE_DIRS ${JANSSON__INCLUDE_DIRS} CACHE PATH "Jansson include directories")
configure_file(
    ${PROJECT_SOURCE_DIR}/cmake/JanssonConfig.cmake.in ${PROJECT_BINARY_DIR}/JanssonConfig.cmake
    @ONLY
)

# Generate the config file for the installation tree.
file(
    RELATIVE_PATH REL_INCLUDE_DIR "${JANSSON_INSTALL_CMAKE_DIR}" "${JANSSON_INSTALL_INCLUDE_DIR}"
) # Calculate the relative directory from the Cmake dir.

# Note the EVENT_CMAKE_DIR is defined in JanssonConfig.cmake.in,
# we escape it here so it's evaluated when it is included instead
# so that the include dirs are given relative to where the
# config file is located.
set(JANSSON__INCLUDE_DIRS "\${JANSSON_CMAKE_DIR}/${REL_INCLUDE_DIR}")
configure_file(
    ${PROJECT_SOURCE_DIR}/cmake/JanssonConfig.cmake.in
    ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/JanssonConfig.cmake @ONLY
)

# Generate version info for both build-tree and install-tree.
configure_file(
    ${PROJECT_SOURCE_DIR}/cmake/JanssonConfigVersion.cmake.in
    ${PROJECT_BINARY_DIR}/JanssonConfigVersion.cmake @ONLY
)

# Define the public headers.
set_target_properties(jansson PROPERTIES PUBLIC_HEADER "${JANSSON_HDR_PUBLIC}")
#TODO: fix this.

# Create pkg-conf file.
# (We use the same files as ./configure does, so we
#  have to defined the same variables used there).
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${CMAKE_INSTALL_PREFIX})
set(libdir ${CMAKE_INSTALL_PREFIX}/${JANSSON_INSTALL_LIB_DIR})
set(VERSION ${JANSSON_DISPLAY_VERSION})
configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/jansson.pc.in ${CMAKE_CURRENT_BINARY_DIR}/jansson.pc @ONLY
)

#
# Install targets.
#
install(
    TARGETS jansson
    EXPORT JanssonTargets
    LIBRARY DESTINATION "${JANSSON_INSTALL_LIB_DIR}" COMPONENT lib
    ARCHIVE DESTINATION "${JANSSON_INSTALL_LIB_DIR}" COMPONENT lib
    RUNTIME
        DESTINATION "${JANSSON_INSTALL_BIN_DIR}"
        COMPONENT
            lib # Windows DLLs
    PUBLIC_HEADER DESTINATION "${JANSSON_INSTALL_INCLUDE_DIR}" COMPONENT dev
)

# Install the pkg-config.
install(
    FILES ${CMAKE_CURRENT_BINARY_DIR}/jansson.pc
    DESTINATION ${JANSSON_INSTALL_LIB_DIR}/pkgconfig
    COMPONENT dev
)

# Install the configs.
install(
    FILES
        ${PROJECT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/JanssonConfig.cmake
        ${PROJECT_BINARY_DIR}/JanssonConfigVersion.cmake
    DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}"
    COMPONENT dev
)

# Install exports for the install-tree.
install(EXPORT JanssonTargets DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}" COMPONENT dev)

# For use when simply using add_library from a parent project to build jansson.
set(JANSSON_LIBRARIES jansson CACHE STRING "Jansson libraries")