cmake_minimum_required (VERSION 2.8.11)
project (upm)

# Before going any further, define build options
option (BUILDDOC "Build all doc" OFF)
option (BUILDCPP "Build CPP sensor libraries" ON)
option (BUILDFTI "Build Funtion Table Interface (FTI) in C sensor libraries" OFF)
option (BUILDSWIGPYTHON "Build swig python modules" ON)
option (BUILDSWIGNODE "Build swig node modules" ON)
option (BUILDSWIGJAVA "Build swig java modules" OFF)
option (BUILDCORDOVA "Build cordova bindings" OFF)
option (BUILDEXAMPLES "Build C/C++/JAVA examples" OFF)
option (IPK "Generate IPK using CPack" OFF)
option (RPM "Generate RPM using CPack" OFF)
option (NPM "Generate NPM/GYP tarballs" OFF)
option (BUILDTESTS "Generate check-ups for upm" OFF)
option (WERROR "Make all warnings into errors." ON)
option (WNO-UNUSED "Remove warnings if return value unused, default is OFF [warnings are printed]" OFF)

# Warn if building in source root
if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
  message (WARNING "Building into sources dir can be risky, prefer other directory")
endif ()

# Appends the cmake/modules path to MAKE_MODULE_PATH variable.
set (CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})

# Check if provided compiler supports target flag
# usage:
#       compiler_flag_supported(C/CXX is_supported flag)
#
# The result of output_variable is set to the sanitized flag name if supported
# or cleared if the flag is not supported.
function (compiler_flag_supported compiler output_variable flag)
  # Currently only C and CXX compile flags, clear and return if not supported
  if (NOT ${compiler} MATCHES "C|CXX")
    message (WARNING "Unknown compiler: ${compiler}")
    set ("${output_variable}" "" PARENT_SCOPE)
    return ()
  endif (NOT ${compiler} MATCHES "C|CXX")

  string (REPLACE "-" "_" SANITIZED_FLAG_NAME "${flag}")
  string (REPLACE "/" "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
  string (REPLACE "=" "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")
  string (REPLACE " " "_" SANITIZED_FLAG_NAME "${SANITIZED_FLAG_NAME}")

  # Disable messages from CHECK_C/XX_COMPILER_FLAGS macros
  set (CMAKE_REQUIRED_QUIET_SAVED ${CMAKE_REQUIRED_QUIET})
  set (CMAKE_REQUIRED_QUIET ON)

  # C or CXX?
  if (${compiler} STREQUAL C)
    CHECK_C_COMPILER_FLAG("${flag}" HAS_${SANITIZED_FLAG_NAME})
  elseif (${compiler} STREQUAL CXX)
    CHECK_CXX_COMPILER_FLAG("${flag}" HAS_${SANITIZED_FLAG_NAME})
  endif ()

  # Restore previous CMAKE_REQUIRED_QUIET state
  set (CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVED})

  # Does the compiler support this flag?
  if (HAS_${SANITIZED_FLAG_NAME})
    set ("${output_variable}" "${SANITIZED_FLAG_NAME}" PARENT_SCOPE)
  else ()
    set ("${output_variable}" "" PARENT_SCOPE)
  endif()
endfunction ()

include (CheckCCompilerFlag)
include (CheckCXXCompilerFlag)
# Add scoped compile flag/s using add_compile_options.
# This function checks to see if each flag is supported
# by the compiler before setting the compile option.
function (upm_add_compile_flags compiler)
  set (_TMP_COMPILER_FLAGS "")
  # Iterate the flags, check if supported
  foreach (flag ${ARGN})
    # Check if this compile flag is supported
    compiler_flag_supported(${compiler} is_supported ${flag})

    # Add if supported, warn and skip if not supported
    if (is_supported)
      set (_TMP_COMPILER_FLAGS "${_TMP_COMPILER_FLAGS} ${flag}")
    else ()
      message (WARNING "${compiler} compiler does not support flag \"${flag}\"")
    endif ()
  endforeach (flag ${ARGN})

  # Set the variable in the parent scope
  set (CMAKE_${compiler}_FLAGS "${CMAKE_${compiler}_FLAGS} ${_TMP_COMPILER_FLAGS}" PARENT_SCOPE)
endfunction ()

# Compiler flags common to both C and CXX
# Enable -Wall
# GCC-6 added -Wmisleading-indentation to -Wall, skip these for now
set (C_CXX_WARNING_FLAGS -Wall
    -Wno-misleading-indentation
    -Wno-strict-aliasing
    -Wno-deprecated-declarations # Temp fix for MRAA deprecated methods
    )

# Warnings as errors?
if (WERROR)
  list (APPEND C_CXX_WARNING_FLAGS -Werror)
  message (STATUS "Warnings as errors enabled (-Werror), disable with -DWERROR=off")
endif (WERROR)

# Remove Warnings for "unused return"  ?
if (WNO-UNUSED)
  list (APPEND C_CXX_WARNING_FLAGS -Wno-unused-result)
   message (STATUS "Remove compiler warnings regarding unused return values.  To remove warnings put the filter on with -DWNO-UNUSED=on")
endif (WNO-UNUSED)


# Set C compiler warning flags at top-level scope and emit a warning about
# unsupported flags
upm_add_compile_flags(C ${C_CXX_WARNING_FLAGS}
  -Winit-self
  -Wimplicit
  -Wsign-compare
  -Wmissing-parameter-type)

# Set CXX compiler warning flags at top-level scope and emit a warning about
# unsupported flags
upm_add_compile_flags(CXX ${C_CXX_WARNING_FLAGS}
  -Wnon-virtual-dtor
  -Woverloaded-virtual
  -Wsign-compare
  -Wreorder)

# Allow exception error handling for Android C++
if (ANDROID)
  upm_add_compile_flags(CXX -fexceptions)
endif (ANDROID)

find_package (Threads REQUIRED)
find_package (PkgConfig REQUIRED)

# Force a libmraa search and minimum required version every time a config is generated
unset(MRAA_FOUND CACHE)
set(MRAA_MINIMUM 1.9.0)
pkg_check_modules (MRAA REQUIRED mraa>=${MRAA_MINIMUM})
# Also, get full path to the mraa library
find_library(MRAA_LIBRARY NAMES mraa HINTS ${MRAA_LIBDIR})

# Test MRAA for various compile options
include (CheckLibraryExists)
check_library_exists (${MRAA_LIBRARIES} mraa_iio_init "${MRAA_LIBDIR}" MRAA_IIO_FOUND)
check_library_exists (${MRAA_LIBRARIES} mraa_firmata_init "${MRAA_LIBDIR}" MRAA_FIRMATA_FOUND)
check_library_exists (${MRAA_LIBRARIES} mraa_uart_ow_init "${MRAA_LIBDIR}" MRAA_OW_FOUND)

# Check for BACNET
pkg_check_modules (BACNET libbacnet)

# Check for MODBUS
pkg_check_modules (MODBUS libmodbus>=3.1.2)

# Check for OPENZWAVE
pkg_check_modules (OPENZWAVE libopenzwave)

# Find JPEG
find_package (JPEG)

# Find nodejs
if (BUILDSWIGNODE)
  find_package (Node REQUIRED)
  if (BUILDTESTS)
    find_package (Npm REQUIRED)
  endif (BUILDTESTS)
endif (BUILDSWIGNODE)

# Find JAVA/JNI
if (BUILDSWIGJAVA)
  find_package (Java REQUIRED)
  find_package (JNI REQUIRED)
  pkg_check_modules (MRAAJAVA REQUIRED mraajava>=${MRAA_MINIMUM})
  # Also, get full path to the mraajava library
  find_library(MRAAJAVA_LIBRARY NAMES mraajava HINTS ${MRAA_LIBDIR})
endif (BUILDSWIGJAVA)

# Cordova binding
if (BUILDCORDOVA)
  if (NOT BUILDSWIGJAVA)
    message(FATAL_ERROR "Cordova bindings require JAVA packages, please enable BUILDSWIGJAVA (-DBUILDSWIGJAVA=on).")
  endif()

  find_package (Node REQUIRED)
  find_package (Npm REQUIRED)
  find_package (UpmCordovaGenerator 0.2.1 REQUIRED)
endif (BUILDCORDOVA)

# Find swig if any wrapper is enabled
if (BUILDSWIGPYTHON OR BUILDSWIGNODE OR BUILDSWIGJAVA)
  find_package (SWIG 3.0.5 REQUIRED)
  include (${SWIG_USE_FILE})
endif ()

# Python is required for swig generated python and for UPM tests.
# The UPM build can generated modules for both python2 AND python3
# with the corresponding PYTHONLIBS.  Currently, BUILDTESTS has a
# hard dependency on the PYTHON2INTERP.
# OpenCV python detect will attempt to find python2/3
if (BUILDSWIGPYTHON OR BUILDTESTS)
  include (cmake/modules/OpenCVDetectPython.cmake)

  # Fail if building tests but no python interpreter was found
  if (BUILDTESTS AND NOT PYTHON2INTERP_FOUND)
      message(FATAL_ERROR "BUILDTESTS=ON requires the python2 interpreter")
  endif (BUILDTESTS AND NOT PYTHON2INTERP_FOUND)

  # Fail if no LIBS were found
  if (NOT PYTHON2LIBS_FOUND AND NOT PYTHON3LIBS_FOUND)
      message(FATAL_ERROR "At least one python lib is required")
  endif (NOT PYTHON2LIBS_FOUND AND NOT PYTHON3LIBS_FOUND)
endif (BUILDSWIGPYTHON OR BUILDTESTS)

# Which versions of python were found?
if (PYTHON2LIBS_FOUND AND BUILDSWIGPYTHON)
  message(STATUS "Building python2 modules with python-${PYTHON2LIBS_VERSION_STRING}")
endif (PYTHON2LIBS_FOUND AND BUILDSWIGPYTHON)
if (PYTHON3LIBS_FOUND AND BUILDSWIGPYTHON)
  message(STATUS "Building python3 modules with python-${PYTHON3LIBS_VERSION_STRING}")
endif (PYTHON3LIBS_FOUND AND BUILDSWIGPYTHON)

# Python2 is currently required for python documentation
if (BUILDSWIGPYTHON AND BUILDDOC AND NOT PYTHON2INTERP_FOUND)
  message(FATAL_ERROR "Failed to find python2 interpreter which is required "
      "to build python documentation.")
endif (BUILDSWIGPYTHON AND BUILDDOC AND NOT PYTHON2INTERP_FOUND)

# Set CMAKE_INSTALL_LIBDIR if not defined
include(GNUInstallDirs)
set (LIB_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}" CACHE PATH "Installation path for libraries")

# Make a version file containing the current version from git.
include (GetGitRevisionDescription)
git_describe (VERSION "--tags")
# If git_describe fails, use a dirty version
if (${VERSION} MATCHES -NOTFOUND)
  set (VERSION "v1.6.0")
  message (WARNING "Failed to retrieve UPM version with 'git describe' (using "
      "${VERSION}). Check that git is installed and this is a valid git repo.")
endif ()

message (STATUS "UPM Version ${VERSION}")

# Parse the version information into pieces.
string (REGEX REPLACE "^v([0-9]+)\\..*" "\\1" VERSION_MAJOR "${VERSION}")
string (REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" VERSION_MINOR "${VERSION}")
string (REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" VERSION_PATCH "${VERSION}")
string (REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+\\-([0-9]+).*" "\\1" VERSION_COMMIT "${VERSION}")
string (REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+-[0-9]+\\-(.*)" "\\1" VERSION_SHA1 "${VERSION}")

if ("${VERSION_COMMIT}" MATCHES "^v.*")
  set (VERSION_COMMIT "")
endif()

set (upm_VERSION_MAJOR ${VERSION_MAJOR})
set (upm_VERSION_MINOR ${VERSION_MINOR})
set (upm_VERSION_PATCH ${VERSION_PATCH})
set (upm_VERSION_STRING ${upm_VERSION_MAJOR}.${upm_VERSION_MINOR}.${upm_VERSION_PATCH})

# Detect arch
include (TargetArch)
target_architecture (DETECTED_ARCH)
message (STATUS "Target arch is ${DETECTED_ARCH}")

# enable c++11 standards support unconditionally
include(CheckCXXCompilerFlag)
if (CMAKE_VERSION VERSION_LESS "3.1")
  CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
  CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
  if (COMPILER_SUPPORTS_CXX11)
    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
  elseif (COMPILER_SUPPORTS_CXX0X)
    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
  else()
    message(FATAL_ERROR "A C++11 compliant compiler is required to build UPM.")
  endif()
else()
  # 3.1+ uses this generic method to enable c++11
  set (CMAKE_CXX_STANDARD 11)
  set (CXX_STANDARD_REQUIRED ON)
  set (CXX_EXTENSIONS OFF)
endif()

include(CheckCCompilerFlag)
if (CMAKE_VERSION VERSION_LESS "3.1")
  CHECK_C_COMPILER_FLAG("-std=c11" COMPILER_SUPPORTS_C11)
  if (COMPILER_SUPPORTS_C11)
    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11")
  else()
    message(FATAL_ERROR "A C11 compliant C compiler is required to build UPM.")
  endif()
else()
  # 3.1+ uses this generic method to enable c11
  set (CMAKE_C_STANDARD 11)
  set (C_STANDARD_REQUIRED ON)
  set (C_EXTENSIONS OFF)
endif()

# The doc target depends on the C/C++ source and all libraries
#
# doc
#   ├──> src
#   ├──> include
#   ├──> libupm_sensor0
#   ├──> libupm_sensor1
#   ├──> ...
#   └──> libupm_sensor_n
#
# The pydoc target builds documentation with sphinx via inspection by loading
# each python2 module.  Those modules must include the CXX documentation via
# a monolithic swig file generated by doxy2swig
#
# pydoc
#  └──> _pyupm_sensor0_python2
#        ├──> libupm_sensor0
#        └──> doxy2swig
#
# The doxy2swig target is dependent upon the doc target IF BUILDDOC=ON,
#
# doxy2swig
#  └──> BUILDDOC=ON───> doc
#
# The jsdoc target builds js documentation via yuidoc and only requires
# the doc target
#
# jsdoc ─> doc
#
function (CreateDocumentationTargets)
  # Add a target to generate API documentation with Doxygen
  find_package (Doxygen 1.8 REQUIRED)
  if (DOXYGEN_FOUND AND DOXYGEN_VERSION VERSION_GREATER "1.8")
    configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
    if (BUILDSWIGJAVA)
        configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/Doxyfile.java.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile-java @ONLY)
    endif()
    file(GLOB PNG_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/docs docs/icons/*.png)
    foreach(PNG_FILE ${PNG_FILES})
      configure_file(${CMAKE_CURRENT_SOURCE_DIR}/docs/${PNG_FILE} ${CMAKE_CURRENT_BINARY_DIR}/html/docs/${PNG_FILE} COPYONLY)
    endforeach()

    # Custom command to run doxygen (note depends on ALL UPM C++ targets)
    add_custom_command (
      OUTPUT ${CMAKE_BINARY_DIR}/xml/index.xml
      DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile ${UPM_TARGETS_CXX}
      COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
      COMMAND tar -czf html/xml.tar.gz -C xml .
      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
      COMMENT "Generating C/C++ API documentation with Doxygen"
      VERBATIM)
    add_custom_target(doc DEPENDS ${CMAKE_BINARY_DIR}/xml/index.xml)
  else ()
    message (SEND_ERROR "ERROR - Failed to find a compatible version of Doxygen. API doc will not be generated")
  endif (DOXYGEN_FOUND AND DOXYGEN_VERSION VERSION_GREATER "1.8")

  # Check if Sphinx is installed and add target to generate API documentation
  # Currently, the per-module documentation for python is generated from the
  # python2 modules.
  # Since python2 is required for documentation, only copy from python2 paths, this
  # ensures that sphinx doesn't run across python2 and python3 binaries.  When running
  # the sphinx tools, explicitly run from the python2 interpreter (tested with the sphinx
  # 1.3.6 python2 and python3 modules).
  if(BUILDSWIGPYTHON)
    # Generate python module documentation from doxygen collateral
    #
    # doxygen index.xml -> doxy2swig.py -> pyupm_doxy2swig.i
    add_custom_command (
      OUTPUT ${CMAKE_BINARY_DIR}/src/pyupm_doxy2swig.i
      COMMAND ${PYTHON2_EXECUTABLE} ${CMAKE_SOURCE_DIR}/src/doxy2swig.py
              ${CMAKE_BINARY_DIR}/xml/index.xml --quiet
              ${CMAKE_BINARY_DIR}/src/pyupm_doxy2swig.i
      COMMENT "Generating pyupm_doxy2swig.i from Doxygen output for use by SWIG"
      DEPENDS doc
      VERBATIM)
    add_custom_target(pyupm_doxy2swig DEPENDS ${CMAKE_BINARY_DIR}/src/pyupm_doxy2swig.i)
    foreach (_python2_target ${UPM_TARGETS_PYTHON2})
      add_dependencies(${_python2_target} pyupm_doxy2swig)
    endforeach()

    find_package (Sphinx 1.3 REQUIRED)
    if (SPHINX_FOUND AND SPHINX_VERSION VERSION_GREATER "1.3")
      configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/conf.py.in ${CMAKE_CURRENT_BINARY_DIR}/pydoc/conf.py @ONLY)
      configure_file (${CMAKE_CURRENT_SOURCE_DIR}/doxy/index.rst ${CMAKE_CURRENT_BINARY_DIR}/pydoc/index.rst COPYONLY)
      add_custom_command (
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/pydoc.stamp
        COMMAND rm -r -f ${CMAKE_BINARY_DIR}/pyupm && mkdir -p ${CMAKE_BINARY_DIR}/pyupm
        COMMAND find ${CMAKE_BINARY_DIR}/src -path "*python${MIN_VER_PYTHON2}/_pyupm_*.so" -exec cp {} ${CMAKE_BINARY_DIR}/pyupm \;
        COMMAND find ${CMAKE_BINARY_DIR}/src -path "*python${MIN_VER_PYTHON2}/pyupm_*.py" -exec cp {} ${CMAKE_BINARY_DIR}/pyupm \;
        COMMAND ${PYTHON2_EXECUTABLE} ${SPHINX_API_EXECUTABLE} -f -o pydoc  ${CMAKE_BINARY_DIR}/pyupm
        # TODO: use a separate cmake FILE module for string replacement instead
        COMMAND ${PYTHON2_EXECUTABLE} ${SPHINX_EXECUTABLE} -b html pydoc html/python
        COMMAND sed -i.bak s|\">pyupm_|\">|g html/python/index.html html/python/modules.html
        COMMAND sed -i.bak s|[[:space:]][mM]odule</a>|</a>|g html/python/index.html html/python/modules.html
        COMMAND cmake -E touch ${CMAKE_CURRENT_BINARY_DIR}/pydoc.stamp
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
        COMMENT "Generating Python API documentation with Sphinx"
        DEPENDS doc ${UPM_TARGETS_PYTHON2}
        VERBATIM)
      add_custom_target(pydoc DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/pydoc.stamp)
    else ()
      message (SEND_ERROR "ERROR - Failed to find a compatible version of Sphinx. Python API doc will not be generated")
    endif ()
  endif(BUILDSWIGPYTHON)

  # Check if Yuidoc is installed and add target for API documentation
  if(BUILDSWIGNODE)
    find_package (Yuidoc 0.10 REQUIRED)
    if (YUIDOC_FOUND AND YUIDOC_VERSION VERSION_GREATER "0.10")
      add_custom_command (
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/jsdoc/jsdoc.stamp
        COMMAND ${CMAKE_SOURCE_DIR}/doxy/doxygen2jsdoc/docgen.js -m upm -i xml -o jsdoc -t ${CMAKE_CURRENT_SOURCE_DIR}/src -g ../../
        COMMAND ${YUIDOC_EXECUTABLE} -C --no-sort --helpers ${CMAKE_SOURCE_DIR}/doxy/node/generators/yuidoc/helper.js --themedir ${CMAKE_SOURCE_DIR}/doxy/node/generators/yuidoc/tmpl -o html/node jsdoc/yuidoc/upm
        COMMAND ${CMAKE_SOURCE_DIR}/doxy/doxygen2jsdoc/tolower.js -i html/node
        COMMAND cmake -E touch ${CMAKE_CURRENT_BINARY_DIR}/jsdoc/jsdoc.stamp
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
        COMMENT "Generating Javascript API documentation with Yuidoc"
        DEPENDS doc
        VERBATIM)
      add_custom_target(jsdoc DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/jsdoc/jsdoc.stamp)
    else ()
      message (SEND_ERROR "ERROR - Failed to find a compatible version of Yuidoc. Node.js API doc will not be generated")
    endif ()
  endif(BUILDSWIGNODE)
endfunction()

if (IPK)
 # Get target package arch from Yocto ADT sysroot if set or host OS, mapping to Ubuntu name if necessary
  if (DEFINED ENV{OECORE_TARGET_SYSROOT})
    GET_FILENAME_COMPONENT (DETECTED_SYSROOT $ENV{OECORE_TARGET_SYSROOT} NAME)
    string (REGEX REPLACE "-poky-linux" "" TARGET_ARCH "${DETECTED_SYSROOT}")
  else ()
    # Debian uses amd64 to denote x86_64
    if (DETECTED_ARCH STREQUAL "x86_64")
      set (TARGET_ARCH "amd64")
    else ()
      set (TARGET_ARCH ${DETECTED_ARCH})
    endif ()
  endif ()
  message (STATUS "Package arch is ${TARGET_ARCH}")

  set(CPACK_GENERATOR "DEB")
  set(OPKG_ARCH ${TARGET_ARCH})
  set(CPACK_BINARY_DIR ${CMAKE_BINARY_DIR})
  set(CPACK_DEBIAN_PACKAGE_MAINTAINER "Intel IoT-Devkit") #required
  set(upm_PACKAGE_ON_TAG ".")
  if ("${VERSION_COMMIT}" STREQUAL "")
    set(upm_PACKAGE_ON_TAG "")
  endif()
  set(CPACK_PACKAGE_VERSION
      "${upm_VERSION_MAJOR}.${upm_VERSION_MINOR}.${upm_VERSION_PATCH}${upm_PACKAGE_ON_TAG}${VERSION_COMMIT}")
  set(CPACK_PACKAGE_NAME "upm")
  set(CPACK_DEBIAN_PACKAGE_SECTION "libs")
  set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE ${TARGET_ARCH})
  set(CPACK_SYSTEM_NAME ${TARGET_ARCH})
  set(CPACK_DEBIAN_PACKAGE_DEPENDS "mraa (>= ${MRAA_VERSION})")
  set(CPACK_DEBIAN_PACKAGE_PROVIDES "upm-dev, upm-dbg, upm-doc")
  set(CPACK_DEBIAN_PACKAGE_REPLACES ${CPACK_DEBIAN_PACKAGE_PROVIDES})
  set(CPACK_DEBIAN_PACKAGE_CONFLICTS ${CPACK_DEBIAN_PACKAGE_PROVIDES})
  set(WDIR "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}")
  include (CPack)
endif()

if (RPM)
  message (STATUS "RPM packaging enabled for ${DETECTED_ARCH}")
  set(CPACK_GENERATOR "RPM")
  set(CPACK_PACKAGE_NAME "upm")
  set(upm_PACKAGE_ON_TAG ".")
  if ("${VERSION_COMMIT}" STREQUAL "")
    set(upm_PACKAGE_ON_TAG "")
  endif()
  set(CPACK_PACKAGE_VERSION
      "${upm_VERSION_MAJOR}.${upm_VERSION_MINOR}.${upm_VERSION_PATCH}${upm_PACKAGE_ON_TAG}${VERSION_COMMIT}")
  set(CPACK_PACKAGE_CONTACT "Intel IoT-Devkit")
  set(CPACK_PACKAGE_VENDOR "Intel IoT-Devkit")
  set(CPACK_RPM_PACKAGE_REQUIRES "mraa >= ${MRAA_VERSION}")
  set(CPACK_RPM_PACKAGE_PROVIDES "${CPACK_PACKAGE_NAME}-devel")
  set(CPACK_RPM_PACKAGE_LICENSE "MIT")
  EXECUTE_PROCESS(COMMAND rpm --showrc
    COMMAND grep -E "dist[[:space:]]*\\."
    COMMAND sed -e "s/^.*dist\\s*\\.//"
    COMMAND tr \\n \\t
    COMMAND sed  -e s/\\t//
    OUTPUT_VARIABLE DIST_TAG)
  set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.${DIST_TAG}.${DETECTED_ARCH}")
  include(CPack)
endif()

# UPM common headers
set (UPM_COMMON_HEADER_DIRS ${CMAKE_HOME_DIRECTORY}/include)

# Generate a build-only C++ header to add functionality to SWIG'ed modules
configure_file (${PROJECT_SOURCE_DIR}/cmake/modules/version.hpp.in ${PROJECT_BINARY_DIR}/src/version.hpp @ONLY)

# UPM source
add_subdirectory (src)

# UPM examples
add_subdirectory (examples)

# Python interp is previously found if BUILDTESTS=ON
if (BUILDTESTS)
  enable_testing ()
  add_subdirectory (tests)
endif()

# Setup documentation AFTER all source targets have been added
if (BUILDDOC)
  CreateDocumentationTargets()
endif()

# Install C headers
install(DIRECTORY include/ DESTINATION include/upm
    COMPONENT ${CMAKE_PROJECT_NAME}-dev
    FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp")