cmake_minimum_required(VERSION 2.9)

IF(NOT CMAKECHAOS)
SET(CMAKECHAOS TRUE)
include(${CMAKE_CURRENT_LIST_DIR}/CMakeMacroUtils.txt)
include(ExternalProject)

### options and configuration variables ####

SET(GITSOURCE https://github.com/amichelotti)

SET (CHAOS_FRAMEWORK ${CMAKE_CURRENT_LIST_DIR}/..)
set (CHAOS_C_FLAGS "-Wno-deprecated")
set (CHAOS_CXX_FLAGS "-Wno-deprecated")
set (CHAOS_LINKER_FLAGS "")

SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}")

IF(CHAOS_CC_COMPILER)
  MESG("Setting CC compiler ${CHAOS_CC_COMPILER}")
  SET(CMAKE_CXX_COMPILER ${CHAOS_CC_COMPILER})
  CheckCompiler("CXX" ${CHAOS_CC_COMPILER})
  CheckCompiler("C" ${CHAOS_C_COMPILER})
  SET(CHAOS_BOOST_FLAGS toolset=${CHAOS_C_COMPILER})
ENDIF()

IF(CERN_ROOT)
ADD_DEFINITIONS(-DCERN_ROOT)
ENDIF()
IF(NOT DEFINED PROCESSOR_COUNT)
  SET(PROCESSOR_COUNT 4)

  execute_process(COMMAND getconf _NPROCESSORS_ONLN
    OUTPUT_VARIABLE PROCESSOR_COUNT
    )
  STRING(REPLACE "\n" "" PROCESSOR_COUNT ${PROCESSOR_COUNT})

ENDIF()

option(CHAOS_FORCE32 "Set to ON to enable 32 bit compilation" OFF)
option(CHAOS_STATIC "Set static compilation" OFF)
option(ENABLE_MEMCACHE "Enable Memcacahe" OFF)
option(CHAOS_DEBUG "Enable Debug" OFF)
option(CHAOS_ENABLE_C11 "Enable C11" ON)
option(CHAOS_DISABLE_EVENTFD "Disable EventFD" OFF)
option(CHAOS_BUILD_CACHE "Keep third part sources" ON)
option(CHAOS_BOOST_VERSION "Use a predefined boost version" 66)
option(CHAOS_BOOST_MINOR_VERSION "Use a predefined boost minor version" 0)
option(CHAOS_BOOST_DYNAMIC "compile and use dynamic boost" OFF)
option(CHAOS_BUILD_UNITSERVER "Automatically build an Unit Server that includes all CUs found in distribution" ON)
option(CHAOS_SANITIZER "sanitize the specified project" "")
option(CHAOS_ADDRESS_SANITIZER "sanitize address" OFF)
option(CHAOS_THREAD_SANITIZER "sanitize threads" OFF)
option(CDSLIB "Chaos CDS LIBRARY" ON)
option(CHAOS_DRIVER_MISC "Driver Misc" ON)
option(CHAOS_DRIVER_CCALT "Driver CCALT" ON)
option(CHAOS_DRIVER_LUMINOMETER "Driver Luminometer" OFF)
option(CHAOS_ENABLE_ZMQ_MONITOR "Enable ZMQ Monitor" OFF)
option(CHAOS_EPICS_SUPPORT "Enable EPICS SUPPORT/DRIVERS" OFF)
option(KAFKA_RDK_ENABLE "Enable KAFKA" ON)
option(CHAOS_TEST "Enable Test" OFF)

option(GPUFIT "Fast Fitting libraries (needs CUDA toolkit)" OFF)

IF(CHAOS_EPICS_SUPPORT)
  add_definitions(-DEPICS)
  INCLUDE_DIRECTORIES(${CMAKE_INSTALL_PREFIX}/include/compiler/gcc ${CMAKE_INSTALL_PREFIX}/include/os/Linux )
  LINK_DIRECTORIES(${CMAKE_INSTALL_PREFIX}/lib/linux-x86_64)
ENDIF()
IF(NOT CHAOS_VERSION_MAJOR)
	 SET(CHAOS_VERSION_MAJOR "1")
ENDIF()
IF(NOT CHAOS_VERSION_MINOR)
	 SET(CHAOS_VERSION_MINOR "1")
ENDIF()
IF(NOT CHAOS_BUILD_ID)
	 SET(CHAOS_BUILD_ID 666)
ENDIF()
IF(CHAOS_ENABLE_ZMQ_MONITOR)
ADD_DEFINITIONS(-DENABLE_ZMQ_MONITOR)
ENDIF()
ADD_DEFINITIONS(-DCSLIB_VERSION_MAJOR="${CHAOS_VERSION_MAJOR}")
ADD_DEFINITIONS(-DCSLIB_VERSION_MINOR="${CHAOS_VERSION_MINOR}")
ADD_DEFINITIONS(-DCSLIB_BUILD_ID=${CHAOS_BUILD_ID})


if(CMAKE_BUILD_TYPE MATCHES PROFILE)
   MESG("ENABLING PROFILE on ${PROJECT_NAME}")
   SET(GCC_COVERAGE_COMPILE_FLAGS "-O0 -g -fprofile-arcs -ftest-coverage")
#   SET(GCC_COVERAGE_LINK_FLAGS    "-lgcov")
   SET(GCC_COVERAGE_LINK_LIB    "gcov")

   SET(GCC_COVERAGE_LINK_FLAGS    "-fprofile-arcs -ftest-coverage -coverage")
#   ADD_DEFINITIONS(${GCC_COVERAGE_COMPILE_FLAGS})
   SET(CHAOS_LINKER_FLAGS  "${CHAOS_LINKER_FLAGS} ${GCC_COVERAGE_LINK_FLAGS}")

ENDIF()
   

if((CMAKE_BUILD_TYPE MATCHES DEBUG) OR (CMAKE_BUILD_TYPE MATCHES Debug))
  set(CHAOS_DEBUG ON)
  MESG("ENABLING DEBUG on ${PROJECT_NAME}")
ENDIF()

if((CMAKE_BUILD_TYPE MATCHES Release) OR (CMAKE_BUILD_TYPE MATCHES RELEASE))
  MESG("ENABLING RELEASE on ${PROJECT_NAME}")
  set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -O3")
  set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -O3")
ENDIF()

if((CMAKE_BUILD_TYPE MATCHES RelWithDebInfo) OR (CMAKE_BUILD_TYPE MATCHES RELWITHDEBINFO))
  MESG("ENABLING RELWITHDEBINFO on ${PROJECT_NAME}")
  set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -g -O3")
  set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -g -O3")
ENDIF()


if((CMAKE_BUILD_TYPE MATCHES MinSizeRel) OR (CMAKE_BUILD_TYPE MATCHES MINSIZEREL))
  MESG("ENABLING MINSIZEREL on ${PROJECT_NAME}")
  set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -Os")
  set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -Os")
ENDIF()

if (CHAOS_DEBUG)
  MESG("Enable debug mode")
  set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -DDEBUG -g")
  set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -DDEBUG -g")
ENDIF()

if (CHAOS_ADDRESS_SANITIZER)
  MESG("Enable ADDRESS SANITIZER")
  set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -fsanitize=address")
  set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -fsanitize=address")
ENDIF()
if (CHAOS_THREAD_SANITIZER)
  MESG("Enable THREAD SANITIZER")
  set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -fsanitize=thread")
  set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -fsanitize=thread")
ENDIF()

set (BOOST_CXX_ADDITIONAL_FLAGS "")
IF(CHAOS_ENABLE_C11 AND NOT CHAOS_TARGET)
#    set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -std=c++14")
#    set (BOOST_CXX_ADDITIONAL_FLAGS "-fvisibility=default")
  ELSE()
#   set (BOOST_CXX_ADDITIONAL_FLAGS "-fvisibility=default")
  set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -std=c++98 -DFORCE_BOOST_SHPOINTER")
ENDIF()
IF( ( DEFINED ENV{CHAOS32}) OR CHAOS_FORCE_32 )
  MESG("Enabling 32 bit Compilation")
  set (BUILD_FORCE_32 1)
  set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -m32")
  set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -m32")
  SET( CHAOS_BOOST_FLAGS "${CHAOS_BOOST_FLAGS} cflags=-m32 cxxflags=-m32 address-model=32")
  set (CMAKE_LINK_FLAGS "-m32")
ENDIF()

IF(CHAOS_BUILD_CACHE)
  MESG("activated chaos build cache ${CACHE_DIR}")
  if(NOT EXISTS "${CACHE_DIR}")
    FILE(MAKE_DIRECTORY ${CACHE_DIR})
  ENDIF()
ENDIF()
EXECUTE_PROCESS(COMMAND uname -s OUTPUT_VARIABLE CHAOS_SYSTEM_NAME)
EXECUTE_PROCESS(COMMAND uname -m OUTPUT_VARIABLE CHAOS_SYSTEM_MACHINE)
STRING(REPLACE "\n" "" CHAOS_SYSTEM_NAME ${CHAOS_SYSTEM_NAME})
STRING(REPLACE "\n" "" CHAOS_SYSTEM_MACHINE ${CHAOS_SYSTEM_MACHINE})

SET(SYSTEM_NAME ${CHAOS_SYSTEM_NAME})
SET(CMAKE_SYSTEM_NAME ${CHAOS_SYSTEM_NAME})

IF (DEFINED ENV{CHAOS_TARGET} AND NOT CHAOS_TARGET)
  SET(CHAOS_TARGET $ENV{CHAOS_TARGET})
ENDIF()

IF(CHAOS_TARGET)
  SET(CHAOS_POSTFIX ${CHAOS_TARGET})
  ADD_DEFINITIONS(-DCHAOS_TARGET)

ELSE()
  SET(CHAOS_POSTFIX "${CHAOS_SYSTEM_MACHINE}-${CHAOS_SYSTEM_NAME}")
ENDIF()
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_STATIC_RUNTIME ON)

IF(${SYSTEM_NAME} MATCHES "Darwin")
  # Mac OS X specific code
  MESG("enabling MAC compilation")
  SET(FrameworkLib boost_program_options boost_date_time boost_system  boost_chrono boost_regex boost_log_setup boost_log boost_filesystem boost_thread boost_atomic boost_random jsoncpp pthread dl ${GCC_COVERAGE_LINK_LIB})
  SET(CHAOS_BOOST_FLAGS toolset=clang)
  CheckCompiler("CXX" clang++)
  CheckCompiler("C" clang)
  SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -stdlib=libc++")
  SET(CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -stdlib=libc++")
  set(CHAOS_LINKER_FLAGS "${CHAOS_LINKER_FLAGS} -stdlib=libc++")

ELSE()

  SET(FrameworkLib boost_program_options boost_date_time boost_system  boost_chrono boost_regex boost_log_setup boost_log boost_filesystem boost_thread boost_atomic boost_random jsoncpp pthread rt dl ${GCC_COVERAGE_LINK_LIB})

ENDIF()

IF ( NOT CMAKE_INSTALL_PREFIX AND DEFINED ENV{CHAOS_PREFIX} )
  set(CMAKE_INSTALL_PREFIX $ENV{CHAOS_PREFIX} CACHE FILEPATH "path")
  set(CMAKE_INSTALL_PREFIX $ENV{CHAOS_PREFIX})
  MESG("Setting Install Dir to CHAOS_PREFIX ${CMAKE_INSTALL_PREFIX}")
ELSE()
  IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
    set(CMAKE_INSTALL_PREFIX ${CHAOS_FRAMEWORK}/chaos-distrib-${CHAOS_POSTFIX} CACHE FILEPATH "path")
    set(CMAKE_INSTALL_PREFIX ${CHAOS_FRAMEWORK}/chaos-distrib-${CHAOS_POSTFIX})
    MESG("Overriding default CHAOS_PREFIX to ${CMAKE_INSTALL_PREFIX}")
  ELSE()
    MESG("Default prefix ${CMAKE_INSTALL_PREFIX}")

  ENDIF()
ENDIF()


IF (CHAOS_TARGET)

  IF(${CHAOS_TARGET} MATCHES "armhf")
    MESG("checking armhf cross compilation chain....")

    CheckCompiler("CXX" arm-linux-gnueabihf-g++-4.8)
    CheckCompiler("C" arm-linux-gnueabihf-gcc-4.8)
    SET(CMAKE_SYSTEM_NAME "Linux")
    SET(CMAKE_SYSTEM_PROCESSOR "arm")
    #    SET(CMAKE_FIND_ROOT_PATH  /usr/arm-linux-gnueabihf/)
#      SET(CMAKE_CXX_COMPILER_WORKS OFF)
#     unset(CMAKE_CXX_COMPILER_WORKS CACHE)
#      unset(CMAKE_CXX_COMPILER_WORKS)
    SET(COMP_FLAGS "-D__BSON_USEMEMCPY__ -mcpu=xscale -D__BSON_USEM")
    SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -DBOOST_ASIO_DISABLE_EVENTFD -D__BSON_USEMEMCPY__ -D__BSON_USEMEMCPY__ -DBOOST_ASIO_DISABLE_EVENTFD -mno-unaligned-access -DDISABLE_COMPARE_AND_SWAP")
    SET(CHAOS_CROSS_HOST arm-linux-gnueabihf)
  ELSE()
    IF(${CHAOS_TARGET} MATCHES "arm-linux-2.6")
    MESG("Cross compiling for ARM(soft float) platforms on linux 2.6")
CheckCompiler("CXX" arm-infn-linux-gnueabi-g++)
CheckCompiler("C" arm-infn-linux-gnueabi-gcc)
SET(CHAOS_CROSS_HOST arm-infn-linux-gnueabi)
SET(CHAOS_ENABLE_C11 "Enable C11" OFF)
SET (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -fno-builtin -DCHAOS_NO_BACKTRACE -DBOOST_ASIO_DISABLE_EVENTFD -D__BSON_USEMEMCPY__ -mcpu=xscale -D__BSON_USEMEMCPY__ -DBOOST_ASIO_DISABLE_EVENTFD -mno-unaligned-access -DDISABLE_COMPARE_AND_SWAP -mfloat-abi=soft")
SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} ${CHAOS_C_FLAGS}")
SET(CHAOS_BOOST_FLAGS toolset=gcc-arm target-os=linux)
SET(CHAOS_DISABLE_EVENTFD ON)
 set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS)       # remove -Wl,-Bdynamic
  set(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS)

    ELSE()
IF(${CHAOS_TARGET} MATCHES "i686-linux26")
  SET(CHAOS_ENABLE_C11 "Enable C11" OFF)
  MESG("Cross compiling for i686 platforms on linux 2.6")
  CheckCompiler("CXX" i686-nptl-linux-gnu-g++)
  CheckCompiler("C" i686-nptl-linux-gnu-gcc)
  SET(CHAOS_CROSS_HOST i686-nptl-linux-gnu)
  SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -DCHAOS_NO_BACKTRACE -DBOOST_ASIO_DISABLE_EVENTFD")
  SET(CHAOS_BOOST_FLAGS target-os=linux)
  SET(CHAOS_DISABLE_EVENTFD ON)
 set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS)       # remove -Wl,-Bdynamic
  set(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS)

ELSE()
  IF(${CHAOS_TARGET} MATCHES "crio90xx")
    MESG("Cross compiling for crio90xx")
    CheckCompiler("CXX" arm-nilrt-linux-gnueabi-g++)
    CheckCompiler("C" arm-nilrt-linux-gnueabi-gcc)

    SET(CHAOS_DISABLE_EVENTFD ON)
    SET(CHAOS_LINKER_FLAGS "${CHAOS_LINKER_FLAGS} -L/usr/local/chaos/oecore-x86_64/sysroots/armv7a-vfp-neon-nilrt-linux-gnueabi/lib")
    SET(CHAOS_CROSS_HOST arm-nilrt-linux-gnueabi)
    SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -march=armv7-a -mthumb-interwork -mfloat-abi=softfp -mfpu=neon -mno-unaligned-access --sysroot=/usr/local/chaos/oecore-x86_64/sysroots/armv7a-vfp-neon-nilrt-linux-gnueabi -L/usr/local/chaos/oecore-x86_64/sysroots/armv7a-vfp-neon-nilrt-linux-gnueabi/lib -DBOOST_ASIO_DISABLE_EVENTFD")
    SET(CHAOS_BOOST_FLAGS target-os=linux)
  ELSE()
    ERROR("UNSUPPORTED CHAOS_TARGET ${CHAOS_TARGET}")
  ENDIF()
ENDIF()
    ENDIF()
  ENDIF()
  IF(NOT CMAKE_CXX_COMPILER)
    ERROR("CANNOT FOUND COMPILER FOR ${CHAOS_TARGET}, \"${CHAOS_CROSS_HOST}-g++\" should be found in path")
  ENDIF()
ENDIF()

  IF(NOT CMAKE_CXX_COMPILER)
    project(config)
  ENDIF()

  if(CHAOS_BOOST_DYNAMIC)
    SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -DBOOST_LOG_DYN_LINK")
    SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} link=shared runtime-link=shared)
  ELSE()
    SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} link=static runtime-link=static)
  ENDIF()
  IF(CHAOS_LINKER_FLAGS)
    SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} linkflags=\""${CHAOS_LINKER_FLAGS}"\")
  ENDIF()


#  SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} cxxflags=\""${CHAOS_CXX_FLAGS} -fPIC ${BOOST_CXX_ADDITIONAL_FLAGS}"\" --prefix=${CMAKE_INSTALL_PREFIX} --with-program_options --with-exception --with-chrono --with-filesystem --with-log --with-regex --with-random --with-system --with-thread --with-atomic --with-timer install "-j ${PROCESSOR_COUNT}" )
SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} cxxflags=\""-fPIC"\" --variant=release --prefix=${CMAKE_INSTALL_PREFIX} --with-program_options --with-iostreams --with-exception --with-chrono --with-filesystem --with-log --with-regex --with-random --with-system --with-thread --with-atomic --with-timer install "-j ${PROCESSOR_COUNT}" )



IF(CHAOS_STATIC)
  MESG("Enabling Static compilation")
  SET(BUILD_FORCE_STATIC 1)
  SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
  ADD_DEFINITIONS(-DCHAOS_STATIC)
  SET(CHAOS_LINKER_FLAGS "-static")
  SET(CMAKE_EXE_LINKER_FLAGS "-static")
  SET(BUILD_SHARED_LIBRARIES OFF)
  SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS)
  SET(CMAKE_SHARED_LIBRARY_LINK_CC_FLAGS)
  set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS)       # remove -Wl,-Bdynamic
  set(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS)
#    SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES LINK_SEARCH_END_STATIC 1)
ELSE()
  SET(BUILD_SHARED_LIBRARIES ON)
ENDIF()

set (CMAKE_C_FLAGS ${CHAOS_C_FLAGS} CACHE STRING "C flags")
set (CMAKE_CXX_FLAGS ${CHAOS_CXX_FLAGS} CACHE STRING "C++ flags")
set (CMAKE_EXE_LINKER_FLAGS ${CHAOS_LINKER_FLAGS} CACHE STRING "Linker flags")

set (CMAKE_C_FLAGS ${CHAOS_C_FLAGS})
set (CMAKE_CXX_FLAGS ${CHAOS_CXX_FLAGS})
set (CMAKE_EXE_LINKER_FLAGS ${CHAOS_LINKER_FLAGS})
#  ADD_DEFINITIONS(${CHAOS_C_FLAGS} ${CHAOS_CXX_FLAGS})

IF(CHAOS_CROSS_HOST)
  SET( CROSS_HOST "--host=${CHAOS_CROSS_HOST}")
ENDIF()

SET(EXTERNAL_BUILD_DIR ${CMAKE_CURRENT_LIST_DIR}/../external-${CHAOS_POSTFIX})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build-${CHAOS_POSTFIX})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build-${CHAOS_POSTFIX})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build-${CHAOS_POSTFIX})

get_filename_component(CHAOS_CXX_COMPILER_REL ${CMAKE_CXX_COMPILER} NAME)
get_filename_component(CHAOS_C_COMPILER_REL ${CMAKE_C_COMPILER} NAME)
######

#### TOOL VERSIONS
if (CHAOS_BOOST_MINOR_VERSION)
  SET(BOOST_MINOR_VERSION ${CHAOS_BOOST_MINOR_VERSION})
ELSE()
  SET(BOOST_MINOR_VERSION 0)
ENDIF()
if( CHAOS_BOOST_VERSION)
  SET(BOOST_VERSION ${CHAOS_BOOST_VERSION})
  
ELSE()
  SET(BOOST_VERSION 66)
ENDIF()

#####

INCLUDE_DIRECTORIES(${CHAOS_FRAMEWORK})
# if( DEFINED ENV{CHAOS_BUNDLE} )
#     MESSAGE(STATUS "Using Chaos Bundle Dir $ENV{CHAOS_BUNDLE}")
#     set (PROJECT_SOURCE_DIR $ENV{CHAOS_BUNDLE})
#     INCLUDE_DIRECTORIES($ENV{CHAOS_BUNDLE}/chaosframework)
# ENDIF()

#If(CHAOS_C_COMPILER)
#  MESG("Setting C compiler ${CHAOS_C_COMPILER}")
#  SET(CMAKE_C_COMPILER ${CHAOS_C_COMPILER})
#ENDIF()

SET( CMAKE_CHAOS  $ENV{CHAOS_CMAKE_FLAGS})

#ADD_DEFINITIONS(-O2)

  
#set(FrameworkLib $ENV{CHAOS_LINK_LIBRARY})
#separate_arguments(FrameworkLib)


INCLUDE_DIRECTORIES(. ${PROJECT_SOURCE_DIR} ${CMAKE_INSTALL_PREFIX}/include)
LINK_DIRECTORIES(${CMAKE_LIBRARY_OUTPUT_DIRECTORY} ${CMAKE_INSTALL_PREFIX}/lib ${CMAKE_INSTALL_PREFIX}/lib64)

# foreach(cu ${CHAOS_CUS})
#   string (REPLACE ".cpp" ".h" cuh ${cu})

#   MESG("CU defined ${cu}")
#   IF (DEFINED CU_H)
#     SET(CU_H ${CU_H} ${cuh})
#   ELSE()
#     SET(CU_H ${cuh})
#   ENDIF()
#   IF (DEFINED CU_H)
#     INSTALL(FILES ${CU_H} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${PROJECT_OUT_H})
#   ENDIF()
# ENDFOREACH()

IF (DEFINED PROJECT_NAME)
  FILE(GLOB conf_src conf/*)
  FILE(GLOB perf_src perf/*)
  INSTALL(FILES ${conf_src} ${perf_src} DESTINATION etc/${PROJECT_NAME})
ENDIF()

#  SET(CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX} CACHE FILEPATH "prefix")
#  SET(CMAKE_LIBRARY_PATH ${CMAKE_INSTALL_PREFIX}/lib CACHE FILEPATH "prefix")
#  SET(CMAKE_FRAMEWORK_PATH ${CMAKE_LIBRARY_PATH} CACHE FILEPATH "prefix")

SET(CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX} )
SET(CMAKE_LIBRARY_PATH ${CMAKE_INSTALL_PREFIX}/lib)
SET(CMAKE_FRAMEWORK_PATH ${CMAKE_LIBRARY_PATH})

MESG("Chaos Generic settings dir ${CMAKE_CURRENT_SOURCE_DIR} CHAOS_FRAMEWORK: ${CHAOS_FRAMEWORK} on ${PROJECT_NAME}")
MESG("CMAKE Version    : ${CMAKE_VERSION}")
MESG("Host System      : ${CHAOS_SYSTEM_NAME}-${CHAOS_SYSTEM_MACHINE}")
MESG("Installation Dir : ${CMAKE_INSTALL_PREFIX}")
MESG("CXX compiler     : ${CMAKE_CXX_COMPILER}")
MESG("CXX Flags        : ${CHAOS_CXX_FLAGS}")
MESG("C compiler       : ${CMAKE_C_COMPILER}")
MESG("C Flags          : ${CHAOS_C_FLAGS}")
MESG("Linker Flags     : ${CHAOS_LINKER_FLAGS}")
MESG("Parallel build   : ${PROCESSOR_COUNT}")
MESG("Framework libs   : ${FrameworkLib}")
MESG("BUILD TYPE:${CMAKE_BUILD_TYPE}")

if(NOT EXISTS "${CMAKE_INSTALL_PREFIX}")
  FILE(MAKE_DIRECTORY ${CMAKE_INSTALL_PREFIX})
ENDIF()
FILE(COPY ${CMAKE_CURRENT_LIST_DIR}/Findchaos.cmake DESTINATION ${CMAKE_INSTALL_PREFIX}/)
FILE(COPY ${CMAKE_CURRENT_LIST_DIR}/CMakeMacroUtils.txt DESTINATION ${CMAKE_INSTALL_PREFIX}/)
unset(Boost_FOUND CACHE)
#find_package( Boost COMPONENTS program_options regex date_time system chrono regex log_setup log filesystem thread atomic)
unset(LIB_NEED CACHE)
find_library(LIB_NEED NAMES boost_program_options boost_regex boost_date_time boost_system boost_chrono boost_log_setup boost_log boost_filesystem boost_thread boost_atomic boost_random PATHS ${CMAKE_INSTALL_PREFIX}/lib NO_DEFAULT_PATH)
if(LIB_NEED)
  MESG("BOOST found !!")
  #  include_directories(${Boost_INCLUDE_DIRS})
else()
  MESG("boost not found in ${CMAKE_INSTALL_PREFIX}/lib downloading...")
  set(Boost_USE_STATIC_LIBS ON)
  set(Boost_USE_STATIC_RUNTIME ON)

#  boostInstall(${BOOST_VERSION} ${BOOST_MINOR_VERSION}  https://dl.bintray.com/boostorg/release/1.${BOOST_VERSION}.${BOOST_MINOR_VERSION}/source "${CHAOS_BOOST_FLAGS}")
  boostInstall(${BOOST_VERSION} ${BOOST_MINOR_VERSION}  https://sourceforge.net/projects/boost/files/boost/1.${BOOST_VERSION}.${BOOST_MINOR_VERSION} "${CHAOS_BOOST_FLAGS}")
endif()

ENDIF()