CMAKE_MINIMUM_REQUIRED(VERSION 3.6 FATAL_ERROR)
# set path to additional CMake modules
SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
SET(CMAKE_BUILD_TYPE Debug CACHE STRING "Build type" FORCE)

#############################################################
# Project and version
SET(CPACK_PACKAGE_VERSION_MAJOR "3")
SET(CPACK_PACKAGE_VERSION_MINOR "0")
SET(CPACK_PACKAGE_VERSION_PATCH "0")
SET(COMPLETE_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
SET(RELEASE_NAME "Master")
PROJECT(DMap VERSION ${COMPLETE_VERSION})

# we default to Release build type
if(NOT CMAKE_BUILD_TYPE)
  SET(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
endif()

MESSAGE(STATUS "Build type: ${CMAKE_BUILD_TYPE}")

# Note the version no is Mmmpp for Major/minor/patch, 0-padded, thus '10100' for 1.1.0
MATH(EXPR DMAP_VERSION_INT "${CPACK_PACKAGE_VERSION_MAJOR}*10000+${CPACK_PACKAGE_VERSION_MINOR}*100+${CPACK_PACKAGE_VERSION_PATCH}")
MESSAGE(STATUS "DMAP version: ${COMPLETE_VERSION} ${RELEASE_NAME} (${DMAP_VERSION_INT})")

SET (WITH_CORE TRUE CACHE BOOL "Determines whether DMap core should be built.")
MARK_AS_ADVANCED(WITH_CORE)

IF(WITH_CORE)

  SET (WITH_BINDINGS FALSE CACHE BOOL "Determines whether python bindings should be built")
  IF (WITH_BINDINGS)
    # By default bindings will be installed only to DMap directory
    # Someone might want to install it to python site-packages directory
    # as otherwise user has to use PYTHONPATH environment variable to add
    # DMap bindings to package search path
    SET (BINDINGS_GLOBAL_INSTALL TRUE CACHE BOOL "Install bindings to global python directory? (might need root)")
    SET (WITH_STAGED_PLUGINS FALSE CACHE BOOL "Stage-install core Python plugins to run from build directory? (utilities and console are always staged)")
    SET (WITH_PY_COMPILE FALSE CACHE BOOL "Determines whether Python modules in staged or installed locations are byte-compiled")
    ADD_DEFINITIONS(-DWITH_BINDINGS)
  ENDIF (WITH_BINDINGS)

  SET (WITH_SERVER TRUE CACHE BOOL "Determines whether DMap server should be built")
  IF(WITH_SERVER)
    SET (WITH_SERVER_PLUGINS ${WITH_BINDINGS} CACHE BOOL "Determines whether DMap server support for python plugins should be built")
    IF(WITH_SERVER_PLUGINS AND NOT WITH_BINDINGS)
      MESSAGE(FATAL_ERROR "Server plugins are not supported without python bindings. Enable WITH_BINDINGS or disable WITH_SERVER_PLUGINS")
    ENDIF(WITH_SERVER_PLUGINS AND NOT WITH_BINDINGS)
    IF(WITH_SERVER_PLUGINS)
      SET(HAVE_SERVER_PYTHON_PLUGINS TRUE)
    ENDIF(WITH_SERVER_PLUGINS)
  ENDIF(WITH_SERVER)

  # try to configure and build POSTGRESQL support
  SET (WITH_POSTGRESQL TRUE CACHE BOOL "Determines whether POSTGRESQL support should be built")
  IF (WITH_POSTGRESQL)
    SET (POSTGRESQL_PREFIX "" CACHE PATH "Path to POSTGRESQL base directory")
  ENDIF (WITH_POSTGRESQL)

  #############################################################
  # search for dependencies

  # required
  FIND_PACKAGE(Boost 1.57 REQUIRED COMPONENTS filesystem REQUIRED)
  FIND_PACKAGE(Boost 1.57 COMPONENTS regex REQUIRED)
  FIND_PACKAGE(Boost 1.57 COMPONENTS system REQUIRED)  
  #FIND_PACKAGE(Proj)
  #FIND_PACKAGE(GEOS)
  #FIND_PACKAGE(GDAL)
  #FIND_PACKAGE(Spatialindex REQUIRED)

  # optional
  IF (WITH_POSTGRESQL)
    FIND_PACKAGE(Postgres) # PostgreSQL provider
  ENDIF (WITH_POSTGRESQL)

  #[[
  IF (NOT PROJ_FOUND OR NOT GEOS_FOUND OR NOT GDAL_FOUND)
    MESSAGE (SEND_ERROR "Some dependencies were not found! Proj: ${PROJ_FOUND}, Geos: ${GEOS_FOUND}, GDAL: ${GDAL_FOUND}")
  ENDIF (NOT PROJ_FOUND OR NOT GEOS_FOUND OR NOT GDAL_FOUND)
  ]]
  IF (POSTGRES_FOUND)
    SET (HAVE_POSTGRESQL TRUE)
  ENDIF (POSTGRES_FOUND)

ENDIF(WITH_CORE)

#############################################################
SET(CMAKE_CXX_STANDARD 14)
SET(CMAKE_CXX_STANDARD_REQUIRED ON)
# SET(CMAKE_CXX_EXTENSIONS OFF)
#############################################################
# platform specific stuff
IF (WITH_CORE)
  IF (WIN32)
    ADD_DEFINITIONS(-DIS_WIN32)
    SET (DEFAULT_LIB_SUBDIR     lib)
    SET (DEFAULT_LIBEXEC_SUBDIR .)
    SET (DEFAULT_DATA_SUBDIR    .)
    SET (DEFAULT_PLUGIN_SUBDIR  plugins)
    SET (DEFAULT_INCLUDE_SUBDIR include)
    SET (DEFAULT_SERVER_MODULE_SUBDIR server)

    IF (MSVC)
      SET (DEFAULT_BIN_SUBDIR bin)
      SET (DEFAULT_CGIBIN_SUBDIR bin)
      # put all the build products into a single directory
      # under build (doesn't affect install target) to make for
      # easier debugging.

      # Turn on defines for non standard maths stuff
      ADD_DEFINITIONS(-D_USE_MATH_DEFINES)

      # Turn off deprecation warnings
      ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
      ADD_DEFINITIONS(-D_CRT_NONSTDC_NO_WARNINGS)

      IF (INSTALL_DEPS)
        INSTALL(DIRECTORY ${INSTALL_DEPS} DESTINATION .)
      ENDIF (INSTALL_DEPS)
    ELSE(MSVC)
      SET (DEFAULT_BIN_SUBDIR .)
      SET (DEFAULT_CGIBIN_SUBDIR .)
    ENDIF(MSVC)
  ELSE (WIN32)
    # UNIX
    ADD_DEFINITIONS(-DIS_LINUX)
    SET (DEFAULT_BIN_SUBDIR     bin)
    SET (DEFAULT_CGIBIN_SUBDIR  bin)
    SET (DEFAULT_LIB_SUBDIR     lib${LIB_SUFFIX})
    SET (DEFAULT_DATA_SUBDIR    share/dmap)
    SET (DEFAULT_LIBEXEC_SUBDIR lib${LIB_SUFFIX}/dmap)
    SET (DEFAULT_PLUGIN_SUBDIR  lib${LIB_SUFFIX}/dmap/plugins)
    SET (DEFAULT_INCLUDE_SUBDIR include/dmap)
    SET (DEFAULT_SERVER_MODULE_SUBDIR ${DEFAULT_LIBEXEC_SUBDIR}/server)
  ENDIF (WIN32)
  #[[
  if("${CMAKE_SYSTEM_NAME}"  MATCHES "Linux")
    SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
    SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--no-undefined")
    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--no-undefined")
  endif() #"${CMAKE_SYSTEM_NAME}"  MATCHES "Linux")
  ]]
  INCLUDE(GenerateExportHeader)

ENDIF (WITH_CORE)


#############################################################
# user-changeable settings which can be used to customize
# layout of DMAP installation
# (default values are platform-specific)

SET (DMAP_BIN_SUBDIR     ${DEFAULT_BIN_SUBDIR}     CACHE STRING "Subdirectory where executables will be installed")
SET (DMAP_CGIBIN_SUBDIR  ${DEFAULT_CGIBIN_SUBDIR}  CACHE STRING "Subdirectory where CGI executables will be installed")
SET (DMAP_LIB_SUBDIR     ${DEFAULT_LIB_SUBDIR}     CACHE STRING "Subdirectory where libraries will be installed")
SET (DMAP_LIBEXEC_SUBDIR ${DEFAULT_LIBEXEC_SUBDIR} CACHE STRING "Subdirectory where private executables will be installed")
SET (DMAP_DATA_SUBDIR    ${DEFAULT_DATA_SUBDIR}    CACHE STRING "Subdirectory where DMAP data will be installed")
SET (DMAP_PLUGIN_SUBDIR  ${DEFAULT_PLUGIN_SUBDIR}  CACHE STRING "Subdirectory where plugins will be installed")
SET (DMAP_INCLUDE_SUBDIR ${DEFAULT_INCLUDE_SUBDIR} CACHE STRING "Subdirectory where header files will be installed")
SET (DMAP_SERVER_MODULE_SUBDIR  ${DEFAULT_SERVER_MODULE_SUBDIR}  CACHE STRING "Subdirectory where server modules will be installed")

# mark *_SUBDIR variables as advanced as this is not something
# that an average user would use
MARK_AS_ADVANCED (DMAP_BIN_SUBDIR DMAP_CGIBIN_SUBDIR DMAP_LIB_SUBDIR DMAP_LIBEXEC_SUBDIR DMAP_DATA_SUBDIR DMAP_PLUGIN_SUBDIR DMAP_INCLUDE_SUBDIR)

# full paths for the installation
SET (DMAP_BIN_DIR     ${DMAP_BIN_SUBDIR})
SET (DMAP_CGIBIN_DIR  ${DMAP_CGIBIN_SUBDIR})
SET (DMAP_LIB_DIR     ${DMAP_LIB_SUBDIR})
SET (DMAP_LIBEXEC_DIR ${DMAP_LIBEXEC_SUBDIR})
SET (DMAP_DATA_DIR    ${DMAP_DATA_SUBDIR})
SET (DMAP_PLUGIN_DIR  ${DMAP_PLUGIN_SUBDIR})
SET (DMAP_INCLUDE_DIR ${DMAP_INCLUDE_SUBDIR})
SET (DMAP_SERVER_MODULE_DIR ${DMAP_SERVER_MODULE_SUBDIR})

# set the default locations where the targets (executables, libraries) will land when compiled
# this is to allow running dmap from the source tree without having to actually do a "make install"
SET (DMAP_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output)
SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${DMAP_OUTPUT_DIRECTORY}/${DMAP_BIN_SUBDIR})
SET (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${DMAP_OUTPUT_DIRECTORY}/${DMAP_LIB_SUBDIR})
SET (TEST_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests/testdata")

# write a marker with source directory path into the output's bin directory
# if run from the build directory DMAP will detect it and alter the paths
FILE(WRITE ${DMAP_OUTPUT_DIRECTORY}/${DMAP_BIN_SUBDIR}/dmapbuildpath.txt "${CMAKE_SOURCE_DIR}\n${DMAP_OUTPUT_DIRECTORY}")

#############################################################
# Python build dependency

FIND_PACKAGE(PythonInterp 3 REQUIRED)

#############################################################
# Python bindings

# IF (WITH_CORE AND WITH_BINDINGS)

  FIND_PACKAGE(PythonLibrary ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR} EXACT REQUIRED)
  LIST(
    APPEND _components
      python${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}
      python${PYTHON_VERSION_MAJOR}
      python
  )
  SET(DMAP_BOOST_PYTHON_FOUND "")

  foreach(_component IN ITEMS ${_components})
    find_package(Boost COMPONENTS ${_component})
    if(Boost_FOUND)
      SET(DMAP_BOOST_PYTHON_FOUND ${_component})
      break()
    endif()
  endforeach()

  if(DMAP_BOOST_PYTHON_FOUND STREQUAL "")
    message(FATAL_ERROR "No matching Boost.Python component found")
  endif()
  #MESSAGE(STATUS "XXX python: ${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}")

  IF (NOT BINDINGS_GLOBAL_INSTALL)
    SET(PYTHON_SITE_PACKAGES_DIR ${DMAP_DATA_DIR}/python)
  ENDIF (NOT BINDINGS_GLOBAL_INSTALL)

# ENDIF (WITH_CORE AND WITH_BINDINGS)

#############################################################
# create dmpconfig.h
# installed with app target
CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/cmake_templates/dmpconfig.h.in ${CMAKE_BINARY_DIR}/dmpconfig.h)
INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR})

#[[
message(STATUS "Project will be installed to ${CMAKE_INSTALL_PREFIX}")

include(GNUInstallDirs)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})

set(INSTALL_LIBDIR ${CMAKE_INSTALL_LIBDIR} CACHE PATH "Installation directory for libraries")
set(INSTALL_BINDIR ${CMAKE_INSTALL_BINDIR} CACHE PATH "Installation directory for executables")
set(INSTALL_INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH "Installation directory for header files")

# Report to user
foreach(p LIB BIN INCLUDE CMAKE)
  file(TO_NATIVE_PATH ${CMAKE_INSTALL_PREFIX}/${INSTALL_${p}DIR} _path )
  message(STATUS "Installing ${p} components to ${_path}")
  unset(_path)
endforeach()
]]
#############################################################
# process subdirs

ADD_SUBDIRECTORY(apache)
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(python)

include(Dart)
# enable testing and define tests
enable_testing()
add_subdirectory(tests)