project(FDO)

# CMake base requires and policy tweaks
if (WIN32)
    # Our Windows-specific code paths use:
    #  1. TARGET_PDB_FILE generator expressions (CMake >= 3.1.3)
    #  2. Multi-file copy mode for ${CMAKE_COMMAND} (CMake >= 3.5)
    cmake_minimum_required( VERSION 3.5 FATAL_ERROR )
    message(STATUS "Your CMake version (${CMAKE_VERSION}) meets the min required version (3.5)")
else (WIN32)
    cmake_minimum_required( VERSION 2.8.12 FATAL_ERROR )
    message(STATUS "Your CMake version (${CMAKE_VERSION}) meets the min required version (2.8.12)")
endif (WIN32)

function(set_policy POL VAL)
    if(POLICY ${POL})
        cmake_policy(SET ${POL} ${VAL})
    endif()
endfunction(set_policy)

set_policy(CMP0012 NEW)
set_policy(CMP0022 NEW)

# Look first in internal modules
set(CMAKE_MODULE_PATH 
    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules
)

if (WIN32)
    set(VCPKG_APPLOCAL "${_VCPKG_ROOT_DIR}/scripts/buildsystems/msbuild/applocal.ps1")
    set(VCPKG_INSTALL_ROOT "${_VCPKG_ROOT_DIR}/installed/${VCPKG_TARGET_TRIPLET}")
endif (WIN32)
if (MSVC)
    # Set compiler flags that should be applied globally
    set(CMAKE_C_FLAGS_DEBUG     "${CMAKE_C_FLAGS_DEBUG} /GS")
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /GS")
    #set(CMAKE_C_FLAGS_RELEASE     "${CMAKE_C_FLAGS_RELEASE} /GS /GL")
    #set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GS /GL")

    # We want pdbs also in release
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
    set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
    set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")

    # Enable WholeProgramOptimization and LTCG for Release
    #set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG")
    #set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} /LTCG")
    #set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG")
endif (MSVC)

message (STATUS "CMake module path is: ${CMAKE_MODULE_PATH}")
message (STATUS "Generator is: ${CMAKE_GENERATOR}")
message (STATUS "Make program is: ${CMAKE_MAKE_PROGRAM}")
message (STATUS "Link executable is: ${CMAKE_LINKER}")

if (WIN32)
    message (STATUS "vcpkg applocal.ps1 path: ${VCPKG_APPLOCAL}")
    message (STATUS "vcpkg install root: ${VCPKG_INSTALL_ROOT}")
endif (WIN32)

if (NOT MSVC)
    # Set configuration if not defined. Only applicable for single config generators (ie. Not MSVC)
    if (NOT CMAKE_BUILD_TYPE)
        set(CMAKE_BUILD_TYPE "Release")
    endif (NOT CMAKE_BUILD_TYPE)

    message(STATUS "CMake Build Type is: ${CMAKE_BUILD_TYPE}")
endif (NOT MSVC)

# Use ccache if available
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
    message(STATUS "ccache was found and will be used to cache compilations")
endif()

# Determine bitness
if ((NOT FDO_CPU EQUAL 32) AND (NOT FDO_CPU EQUAL 64))
    message(STATUS "FDO_CPU not defined, determining what we're building for based on system bitness")
    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
        set(FDO_CPU 64)
    else(CMAKE_SIZEOF_VOID_P EQUAL 8)
        set(FDO_CPU 32)
    endif(CMAKE_SIZEOF_VOID_P EQUAL 8)
    message (STATUS "FDO_CPU is ${FDO_CPU}")
endif ((NOT FDO_CPU EQUAL 32) AND (NOT FDO_CPU EQUAL 64))

if (FDO_CPU EQUAL 64)
    set (FDO_CPU_PLAT "x64")
else (FDO_CPU EQUAL 64)
    set (FDO_CPU_PLAT "x86")
endif (FDO_CPU EQUAL 64)
message (STATUS "FDO_CPU_PLAT is ${FDO_CPU_PLAT}")

# Set FDO version macros
if (NOT FDO_VERSION_MAJOR)
    set(FDO_VERSION_MAJOR 4)
endif (NOT FDO_VERSION_MAJOR)
if (NOT FDO_VERSION_MINOR)
    set(FDO_VERSION_MINOR 2)
endif (NOT FDO_VERSION_MINOR)
if (NOT FDO_VERSION_RELEASE)
    set(FDO_VERSION_RELEASE 0)
endif (NOT FDO_VERSION_RELEASE)
if (NOT FDO_REV)
    set (FDO_REV 0)
endif (NOT FDO_REV)
set(FDO_VERSION "${FDO_VERSION_MAJOR}.${FDO_VERSION_MINOR}.${FDO_VERSION_RELEASE}")
set(FDO_DISTRIBUTION_TEXT "Self compiled sources" CACHE STRING "Indicate compilation origin")

# The version suffix is only meant to be applied for Linux binaries
if (NOT WIN32)
    set(FDO_VERSION_SUFFIX "-${FDO_VERSION}")
endif (NOT WIN32)

# Set CPack vars
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Feature Data Objects SDK")
set(CPACK_PACKAGE_VENDOR "Open Source Geospatial Foundation")
set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/CMake__README.txt")
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/License_README.txt")
set(CPACK_PACKAGE_VERSION_MAJOR "${FDO_VERSION_MAJOR}")
set(CPACK_PACKAGE_VERSION_MINOR "${FDO_VERSION_MINOR}")
set(CPACK_PACKAGE_VERSION_PATCH "${FDO_VERSION_RELEASE}")
set(CPACK_PACKAGE_VERSION "${FDO_VERSION_MAJOR}.${FDO_VERSION_MINOR}.${FDO_VERSION_RELEASE}.${FDO_REV}")
set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0)

# Base values applicable for all Windows dll resources
set(DLL_PRODUCT "Feature Data Objects")
set(DLL_VENDOR "Open Source Geospatial Foundation")
set(DLL_COPYRIGHT "Copyright (C) 2007-2019")

if (NOT WIN32)
    # Collect distro name for so we know how to name these packages
    # NOTE: This uses lsb_release to detect the name, so this tool must already be installed first
    execute_process(COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/cmake/tools/getdistro.sh OUTPUT_VARIABLE DISTRO)
    message(STATUS "Detected Distro: ${DISTRO}")
else (NOT WIN32)
    set(DISTRO "windows")
endif (NOT WIN32)

if(FDO_CPU EQUAL 64)
    set(CPACK_SYSTEM_NAME "${DISTRO}-amd64")
else(FDO_CPU EQUAL 64)
    set(CPACK_SYSTEM_NAME "${DISTRO}-i386")
endif(FDO_CPU EQUAL 64)
message(STATUS "CPack system name: ${CPACK_SYSTEM_NAME}")

# Default to:
#   Plain tarballs for packaging (Linux)
#   Zip files for packaging (Windows)
if (NOT CPACK_GENERATOR)
    if (NOT WIN32)
        set(CPACK_GENERATOR "TGZ")
    else (NOT WIN32)
        set(CPACK_GENERATOR "ZIP")
    endif (NOT WIN32)
endif (NOT CPACK_GENERATOR)
message(STATUS "Using CPack generator: ${CPACK_GENERATOR}")

# If making tarballs, force monolithic packaging
if (CPACK_GENERATOR MATCHES "TGZ")
    set(CPACK_MONOLITHIC_INSTALL 1)
else (CPACK_GENERATOR MATCHES "TGZ")
    set(CPACK_MONOLITHIC_INSTALL 0)
endif (CPACK_GENERATOR MATCHES "TGZ")
message(STATUS "CPack monolithic install: ${CPACK_MONOLITHIC_INSTALL}")

# For monolithic packages, 
if (CPACK_MONOLITHIC_INSTALL)
    set (CPACK_PACKAGE_FILE_NAME "fdosdk-${FDO_VERSION}.${FDO_REV}-${CPACK_SYSTEM_NAME}")
endif (CPACK_MONOLITHIC_INSTALL)

if (UNIX)
    if (CMAKE_BUILD_TYPE MATCHES Release)
        message(STATUS "Binaries will be stripped as part of packaging")
        set(CPACK_STRIP_FILES TRUE)
    endif (CMAKE_BUILD_TYPE MATCHES Release)
endif (UNIX)

# Make CPack available to easy generate binary packages
include(CPack)

# Some helper macros
include(FdoHelpers)

if (WIN32)
    # Can't use generator expressions here :(
    # But CMAKE_INSTALL_CONFIG_NAME is close enough
    set( CMAKE_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/sdk${FDO_CPU}" )
else (WIN32)
    # Override install directory to match what the automake build does (/usr/local, rather than /usr/local/lib)
    set( INSTALL_PREFIX "/usr/local/fdo-${FDO_VERSION}" )
endif (WIN32)

# FDO Build Directories
set( FDO ${CMAKE_CURRENT_SOURCE_DIR}/Fdo )
if (NOT INTERNAL_THIRDPARTY_DIR)
    set( FDOTHIRDPARTY ${CMAKE_CURRENT_SOURCE_DIR}/Thirdparty )
else (NOT INTERNAL_THIRDPARTY_DIR)
    set( FDOTHIRDPARTY ${INTERNAL_THIRDPARTY_DIR}/Thirdparty )
endif (NOT INTERNAL_THIRDPARTY_DIR)
set( FDOUTILITIES ${CMAKE_CURRENT_SOURCE_DIR}/Utilities )

if (UNIX)
    set( FDO_LOCAL_NLS_PATH ${CMAKE_CURRENT_BINARY_DIR}/nls )
    file(MAKE_DIRECTORY ${FDO_LOCAL_NLS_PATH}/linux/en_US)
endif (UNIX)

message(STATUS "FDOTHIRDPARTY is: ${FDOTHIRDPARTY}")

if( UNIX )
    add_definitions( -DFULLPROTO -fPIC -DPIC )
endif( UNIX )

# Only use the "d" debug suffix on Windows
if (WIN32)
    set(CMAKE_DEBUG_POSTFIX "d")
endif (WIN32)

# Establish "Not Set" as the default character set and let specific projects set
# multi-byte or unicode as required through the macros below
if (MSVC)
    remove_definitions(-D_MBCS)
    remove_definitions(-D_UNICODE)
    remove_definitions(-DUNICODE)
    add_definitions(-D_SBCS)
endif (MSVC)

if (CMAKE_SYSTEM_NAME MATCHES Linux)
    add_definitions( -DLINUX -DLINUX_IA32 -pthread )
endif (CMAKE_SYSTEM_NAME MATCHES Linux)

if (MSVC AND NOT ${CMAKE_GENERATOR} STREQUAL "Ninja")
    add_definitions(/MP)
endif (MSVC AND NOT ${CMAKE_GENERATOR} STREQUAL "Ninja")

use_cxx11()
if (CMAKE_COMPILER_IS_GNUCXX)
    add_definitions( -D__USE_GNU )
    set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-write-strings -Wno-deprecated -Wno-narrowing")
    set ( CMAKE_SHARED_LINKER_FLAGS "-Wl,--as-needed -Wl,--no-undefined -lc ${CMAKE_SHARED_LINKER_FLAGS}")
    if(FDO_CPU EQUAL 64)
        set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64" )
        set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m64" )
        message(STATUS "Setting CFLAGS for 64-bit build")
    else(FDO_CPU EQUAL 64)
        set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32" )
        set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32" )
        message(STATUS "Setting CFLAGS for 32-bit build")
    endif(FDO_CPU EQUAL 64)
    if (CMAKE_BUILD_TYPE MATCHES Debug)
        add_definitions(-DDEBUG -D_DEBUG)
        set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g3" )
        set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g3" )
        message(STATUS "Adding standard compiler flags for Debug")
    endif (CMAKE_BUILD_TYPE MATCHES Debug)
endif (CMAKE_COMPILER_IS_GNUCXX)

if (CMAKE_COMPILER_IS_GNUCXX AND USE_LD_GOLD)
    execute_process(COMMAND ${CMAKE_C_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
    if ("${LD_VERSION}" MATCHES "GNU gold")
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fuse-ld=gold")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fuse-ld=gold")
        message(STATUS "Using GNU gold linker instead of ld")
    else (CMAKE_COMPILER_IS_GNUCXX AND USE_LD_GOLD)
        message(WARNING "GNU gold linker isn't available, using the default system linker.")
    endif (CMAKE_COMPILER_IS_GNUCXX AND USE_LD_GOLD)
endif ()

if (NOT WIN32)
    find_package(Sanitizers)
else (NOT WIN32)
    # No-op add_sanitizers on Windows
    macro(add_sanitizers)
    endmacro()
endif (NOT WIN32)

find_package(FDOThirdparty REQUIRED)
find_package(FDOInternal REQUIRED)

if (NOT WIN32)
    # Check Python
    find_package(PythonLibs)
endif (NOT WIN32)

if (WIN32)
    set (FDO_ROOT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")

    # HACK/FIXME: Why is the modern cppunit test (in FindCppUnit.cmake) not passing on Windows?
    add_definitions(-DCPPUNIT_MODERN_API)

    find_program(MC_EXE mc)
    if (MC_EXE EQUAL "MC_EXE-NOTFOUND")
        message (FATAL_ERROR "Missing required mc.exe (Do you have Visual Studio installed?)")
    else (MC_EXE EQUAL "MC_EXE-NOTFOUND")
        message (STATUS "Found mc: ${MC_EXE}")
    endif (MC_EXE EQUAL "MC_EXE-NOTFOUND")

    find_program(RC_EXE rc)
    if (RC_EXE EQUAL "RC_EXE-NOTFOUND")
        message (FATAL_ERROR "Missing required rc.exe (Do you have Visual Studio installed?)")
    else (RC_EXE EQUAL "RC_EXE-NOTFOUND")
        message (STATUS "Found rc: ${RC_EXE}")
    endif (RC_EXE EQUAL "RC_EXE-NOTFOUND")
endif (WIN32)

# The name of the "include" directory when running the install target
if (WIN32)
    set (FDO_INC_DIR_NAME "\${CMAKE_INSTALL_CONFIG_NAME}/Inc")
else (WIN32)
    set (FDO_INC_DIR_NAME "include")
endif (WIN32)

add_subdirectory(Thirdparty)
add_subdirectory(Fdo)
add_subdirectory(Utilities)

# Providers compiled internally are optional and is not added if
# Providers directory not exists
# Correct syntax is: -DWITH_<provider>
# Ex. -DWITH_GDAL
macro_optional_add_subdirectory(Providers)

if (NOT WIN32)
    # Copy providers.cmake.linux.xml to our build staging area as providers.xml so it can be installed from there
    execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/providers.cmake.linux.xml ${CMAKE_CURRENT_BINARY_DIR}/providers.xml)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/providers.xml DESTINATION ${LIB_INSTALL_DIR})
    configure_file(cmake/modules/FindFDO.cmake.tmpl ${CMAKE_CURRENT_BINARY_DIR}/cmake/modules/FindFDO.cmake @ONLY)
    # Install the global template, not the internal one used for whole source build
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/modules/FindFDO.cmake DESTINATION ${CMAKE_ROOT}/Modules)

    # If we're using internal xerces/xalan/gdal we must make sure these libs are also installed. Strip them as well
    # if in release mode as CPack only strips .so files built within CMake and not .so files built from external build
    # systems
    #
    # NOTE: $LIB_INSTALL_DIR doesn't want to be parameterized. Have to use lib/lib64 manually based on FDO_CPU
    if (INTERNAL_XERCESC)
        install(FILES ${FDOTHIRDPARTY}/apache/xerces/lib/libxerces-c.so DESTINATION ${LIB_INSTALL_DIR})
        install(FILES ${FDOTHIRDPARTY}/apache/xerces/lib/libxerces-c-3.1.so DESTINATION ${LIB_INSTALL_DIR})
        if (CMAKE_BUILD_TYPE MATCHES Release)
            if(FDO_CPU EQUAL 64)
                install(CODE "execute_process(COMMAND strip --strip-unneeded \${CMAKE_INSTALL_PREFIX}/lib64/libxerces-c-3.1.so)")
            else (FDO_CPU EQUAL 64)
                install(CODE "execute_process(COMMAND strip --strip-unneeded \${CMAKE_INSTALL_PREFIX}/lib/libxerces-c-3.1.so)")
            endif (FDO_CPU EQUAL 64)
        endif (CMAKE_BUILD_TYPE MATCHES Release)
    endif (INTERNAL_XERCESC)
    if (INTERNAL_XALANC)
        install(FILES ${FDOTHIRDPARTY}/apache/xalan/lib/libxalan-c.so DESTINATION ${LIB_INSTALL_DIR})
        install(FILES ${FDOTHIRDPARTY}/apache/xalan/lib/libxalan-c.so.111 DESTINATION ${LIB_INSTALL_DIR})
        install(FILES ${FDOTHIRDPARTY}/apache/xalan/lib/libxalan-c.so.111.0 DESTINATION ${LIB_INSTALL_DIR})
        if (CMAKE_BUILD_TYPE MATCHES Release)
            install(CODE "execute_process(COMMAND strip --strip-unneeded \${CMAKE_INSTALL_PREFIX}/lib64/libxalan-c.so.111.0)")
        endif (CMAKE_BUILD_TYPE MATCHES Release)
        install(FILES ${FDOTHIRDPARTY}/apache/xalan/lib/libxalanMsg.so DESTINATION ${LIB_INSTALL_DIR})
        install(FILES ${FDOTHIRDPARTY}/apache/xalan/lib/libxalanMsg.so.111 DESTINATION ${LIB_INSTALL_DIR})
        install(FILES ${FDOTHIRDPARTY}/apache/xalan/lib/libxalanMsg.so.111.0 DESTINATION ${LIB_INSTALL_DIR})
        if (CMAKE_BUILD_TYPE MATCHES Release)
            if(FDO_CPU EQUAL 64)
                install(CODE "execute_process(COMMAND strip --strip-unneeded \${CMAKE_INSTALL_PREFIX}/lib64/libxalanMsg.so.111.0)")
            else (FDO_CPU EQUAL 64)
                install(CODE "execute_process(COMMAND strip --strip-unneeded \${CMAKE_INSTALL_PREFIX}/lib/libxalanMsg.so.111.0)")
            endif (FDO_CPU EQUAL 64)
        endif (CMAKE_BUILD_TYPE MATCHES Release)
    endif (INTERNAL_XALANC)
    if (INTERNAL_GDAL)
        # The link target doesn't have to exist at this point in time, the symlink will be valid at install time
        execute_process(COMMAND ln -sf ${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}/libgdal.so.20.3.2 ${CMAKE_CURRENT_BINARY_DIR}/libgdal.so.20)
        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libgdal.so.20 DESTINATION ${LIB_INSTALL_DIR} COMPONENT ${component})
        execute_process(COMMAND ln -sf ${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}/libgdal.so.20.3.2 ${CMAKE_CURRENT_BINARY_DIR}/libgdal.so)
        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libgdal.so DESTINATION ${LIB_INSTALL_DIR} COMPONENT ${component})
        install(FILES ${FDOTHIRDPARTY}/gdal/lib/libgdal.so.20.3.2 DESTINATION ${LIB_INSTALL_DIR})
        if (CMAKE_BUILD_TYPE MATCHES Release)
            if(FDO_CPU EQUAL 64)
                install(CODE "execute_process(COMMAND strip --strip-unneeded \${CMAKE_INSTALL_PREFIX}/lib64/libgdal.so.20.3.2)")
            else (FDO_CPU EQUAL 64)
                install(CODE "execute_process(COMMAND strip --strip-unneeded \${CMAKE_INSTALL_PREFIX}/lib/libgdal.so.20.3.2)")
            endif (FDO_CPU EQUAL 64)
        endif (CMAKE_BUILD_TYPE MATCHES Release)
    endif (INTERNAL_GDAL)
else (NOT WIN32)
    # Copy providers.windows.template.xml to our build staging area as providers.xml so it can be installed from there
    execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/providers.windows.template.xml ${CMAKE_CURRENT_BINARY_DIR}/providers.xml)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/providers.xml DESTINATION "\${CMAKE_INSTALL_CONFIG_NAME}/Bin")
endif (NOT WIN32)