#
# This is a CMake makefile.  CMake is a tool that helps you build C++ programs.
# You can download CMake from http://www.cmake.org.  This CMakeLists.txt file
# you are reading builds dlib's example programs. 
#
# To compile this program all you need to do is ask cmake.  You would type
# these commands from within the directory containing this CMakeLists.txt
# file:
#   mkdir build
#   cd build
#   cmake ..
#   cmake --build . --config Release
#
# The cmake .. command looks in the parent folder for a file named
# CMakeLists.txt, reads it, and sets up everything needed to build program.
# Also, note that CMake can generate Visual Studio or XCode project files.  So
# if instead you had written:
#   cd build
#   cmake .. -G Xcode
#
# You would be able to open the resulting Xcode project and compile and edit
# the example programs within the Xcode IDE.  CMake can generate a lot of
# different types of IDE projects.  Run the cmake -h command to see a list of
# arguments to -G to see what kinds of projects cmake can generate for you.  It
# probably includes your favorite IDE in the list.
cmake_minimum_required (VERSION 3.8)

project(RvcFramework)

set(CMAKE_CXX_STANDARD 11)

option(BUILD_TESTING "Build the project test case." OFF)
option(INSTALL_INCLUDE_FILES "Enable installation of include header file or third_party" ON)

# 
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/addin/cmake/ )
include(CheckStructHasMember)
include(CheckIncludeFiles)
include(CheckSymbolExists)

# Turn on solution folders (2.8.4+)
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

set(BUILD_NUMBER 0)
if ($ENV{BUILD_NUMBER})
	set(BUILD_NUMBER $ENV{BUILD_NUMBER})
endif()

set(RVC_COMPANY "CMB" CACHE STRING "China Merchants Bank")
set(RVC_PRODUCT "VTM")
set(RVC_AUTHOR "CCDG")
set(RVC_COPYRIGHT "Copyright (C) 2020")
set(RVC_DESCRIPTION "2020.01")

set(RAW_VERSION_STRING "0.0.1-dev1")

string(STRIP ${RAW_VERSION_STRING} RAW_VERSION_STRING)

set(VERSION_REGEX "^.?([0-9]+)\\.([0-9]+)\\.([0-9]+)-?(.*)")
string(REGEX REPLACE "${VERSION_REGEX}" "\\1" RVC_VERSION_MAJOR "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\2" RVC_VERSION_MINOR "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\3" RVC_VERSION_REVISION "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\4" RVC_VERSION_SUFFIX "${RAW_VERSION_STRING}")

set(RVC_VERSION_BUILD "${BUILD_NUMBER}")
set(RVC_API_VERSION "${RVC_VERSION_MAJOR}")
set(RVC_VERSION "${RVC_VERSION_MAJOR}.${RVC_VERSION_MINOR}.${RVC_VERSION_REVISION}.${RVC_VERSION_BUILD}")
set(RVC_FRAMEWORK_VERSION "${RVC_VERSION_MAJOR}.${RVC_VERSION_MINOR}.${RVC_VERSION_REVISION}")
if (RVC_VERSION_SUFFIX)
	set(RVC_VERSION_FULL "${RVC_VERSION}-${RVC_VERSION_SUFFIX}")
else()
	set(RVC_VERSION_FULL "${RVC_VERSION}")
endif()
message("RVC_VERSION=${RVC_VERSION_FULL}")

message("CMAKE_SYSTEM_NAME: ${CMAKE_SYSTEM_NAME}, CMAKE_GENERATOR: ${CMAKE_GENERATOR}")

configure_file("${PROJECT_SOURCE_DIR}/version.h.in" "${PROJECT_BINARY_DIR}/version.h")
include_directories(${PROJECT_BINARY_DIR})

set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

if(BUILD_TESTING)
	include(CTest)
	message(STATUS "build the tests.")
	enable_testing()
	set(GTEST_ROOT "${CMAKE_SOURCE_DIR}/third_party/gtest/googletest/include")
	set(GMOCK_ROOT "${CMAKE_SOURCE_DIR}/third_party/gtest/googlemock/include")
	if(MSVC)
		set(TESTING_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
	else()
		set(TESTING_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/Testing")
	endif()
endif()

# specifies what build type (configuration) will be built in this build tree
if(NOT CMAKE_BUILD_TYPE)
	set(CMAKE_BUILD_TYPE "Debug")
endif()

if (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_CONFIGURATION_TYPES STREQUAL Debug)
	message(STATUS "debug type")
	set(BUILD_TYPE_NAME "Debug")
else()
	set(BUILD_TYPE_NAME "Release")
endif()
string(TOLOWER ${BUILD_TYPE_NAME} BUILD_TYPE_NAME_lower)

if(${CMAKE_GENERATOR} MATCHES "Visual Studio*")
	if(NOT CMAKE_GENERATOR_PLATFORM)
		message(STATUS "set win32 platform default")
		set(CMAKE_GENERATOR_PLATFORM "Win32")
	else()
		message(STATUS ${CMAKE_GENERATOR_PLATFORM})
	endif()
endif()

if(BUILD_SHARED_LIBS)
	message(STATUS "build shared libs")
endif(BUILD_SHARED_LIBS)

# Configure MSVC Runtime
if(MSVC)
	include(MSVCRuntime)
	if(NOT DEFINED MSVC_RUNTIME)
		set(MSVC_RUNTIME "dynamic")
	endif()
	set(MSVC_DYNAMIC_RUNTIME ${MSVC_RUNTIME})
	configure_msvc_runtime()
	set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
endif(MSVC)

if(CMAKE_COMPILER_IS_GNUCC)
	if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "i686")
		CHECK_SYMBOL_EXISTS(__x86_64__ "" IS_X86_64)
		if(IS_X86_64)
			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
			message(STATUS "set -fPIC")
		else()
			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=i686")
			message(STATUS "-march=i686")
		endif()
	else()
		if(CMAKE_POSITION_INDEPENDENT_CODE)
			if(${CMAKE_VERSION} VERSION_LESS 2.8.9)
				message(STATUS "set -fPIC 2")
				set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
			endif()
		endif()
	endif()
endif()

if(MSVC)
	# Window occurs '/' error
	STRING(REGEX REPLACE "^([A-Z]*.)([/\\].*)" "\\1" CURRENT_DISK "${CMAKE_CURRENT_SOURCE_DIR}")
	set(OUTPUT_CUR_DISK_PATH "${CURRENT_DISK}\\")
else(MSVC)
		set(OUTPUT_CUR_DISK_PATH "/opt/")
endif(MSVC)
set(OUTPUT_VERSION_DIR_PATH "${OUTPUT_CUR_DISK_PATH}run\\version")
set(OUTPUT_CUR_VERSION_PATH "${OUTPUT_VERSION_DIR_PATH}\\${RVC_VERSION}")
if(NOT MSVC)
	string(REPLACE "\\" "/" OUTPUT_VERSION_DIR_PATH ${OUTPUT_VERSION_DIR_PATH})
	string(REPLACE "\\" "/" OUTPUT_CUR_VERSION_PATH ${OUTPUT_CUR_VERSION_PATH})
endif(NOT MSVC)



set(PACK_INSTALL_PREFIX_ORIGIN "run")
set(PACK_INSTALL_PREFIX_VERSION "${PACK_INSTALL_PREFIX_ORIGIN}/version")
set(PACK_INSTALL_PREFIX_CUR_VER "run/version/${RVC_VERSION}")

set(RVC_INCLUDE_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/include")
set(RVC_LIBRARY_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/lib")
set(RVC_RUNTIME_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/bin")
set(RVC_MODULE_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/mod")
set(RVC_CONFIG_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/cfg")
set(RVC_VENDOR_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/dep")
# set(RVC_MODULE_LIBRARY_PATH "${CMAKE_BINARY_DIR}/mod")
set(RVC_SHARED_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/share")

set(CMAKE_INSTALL_INCLUDEDIR ${RVC_INCLUDE_PATH})
set(CMAKE_INSTALL_LIBDIR ${RVC_LIBRARY_PATH})
set(CMAKE_INSTALL_BINDIR ${RVC_RUNTIME_PATH})

macro(copy_output_on_build module_name output_subdir)
	set(target_name ${module_name})
	set(output_dir ${OUTPUT_CUR_DISK_PATH}\\${output_subdir})
	if(NOT EXISTS ${output_dir} OR NOT IS_DIRECTORY ${output_dir})
		# nothing to do.
	endif()
	add_custom_command(TARGET ${target_name} PRE_BUILD
		COMMAND ${CMAKE_COMMAND}
		ARGS -E make_directory ${output_dir})
	add_custom_command(TARGET ${target_name} POST_BUILD
		COMMAND ${CMAKE_COMMAND} -E copy
		$<TARGET_FILE:${target_name}>
		${OUTPUT_CUR_DISK_PATH}/${output_subdir}
	)
endmacro(copy_output_on_build)

set(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_GENERATOR_PLATFORM}-${BUILD_TYPE_NAME}")
set(CPACK_TOPLEVEL_TAG "${CMAKE_SYSTEM_NAME}-${CMAKE_GENERATOR_PLATFORM}-${BUILD_TYPE_NAME}")

if(WIN32)
   # dll rc version
	string(TIMESTAMP RC_VERSION_YEAR "%Y")
	set(RC_VERSION_AUTHOR ${RVC_AUTHOR})
	set(RC_VERSION_COMPANY ${RVC_COMPANY})
	set(RC_VERSION_PRODUCT ${RVC_PRODUCT})
	set(RC_VERSION_PATCH ${BUILD_NUMBER})
	set(RC_VERSION_DESCRIPTION "${RVC_VERSION_FULL} ${CPACK_SYSTEM_NAME}")
endif(WIN32)

if(WIN32)
	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
	add_definitions(-DWIN32_LEAN_AND_MEAN)
	add_definitions(-D_WINSOCK_DEPRECATED_NO_WARNINGS)
endif(WIN32)

# Include files
check_include_files(fcntl.h HAVE_FCNTL_H)
check_include_files(unistd.h HAVE_UNISTD_H)
check_include_files(execinfo.h HAVE_EXECINFO_H)
check_include_files(inttypes.h HAVE_INTTYPES_H)
check_include_files(sys/modem.h HAVE_SYS_MODEM_H)
check_include_files(sys/filio.h HAVE_SYS_FILIO_H)
check_include_files(sys/sockio.h HAVE_SYS_SOCKIO_H)
check_include_files(sys/strtio.h HAVE_SYS_STRTIO_H)
check_include_files(sys/select.h HAVE_SYS_SELECT_H)
check_include_files(syslog.h HAVE_SYSLOG_H)

check_struct_has_member("struct tm" tm_gmtoff time.h HAVE_TM_GMTOFF)

find_package(Threads REQUIRED)

if(NOT WIN32)
	CHECK_SYMBOL_EXISTS(pthread_mutex_timedlock pthread.h HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
	if (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
		CHECK_LIBRARY_EXISTS(pthread pthread_mutex_timedlock "" HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)
	endif (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
	if (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)
		CHECK_LIBRARY_EXISTS(pthreads pthread_mutex_timedlock "" HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
	endif (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)

	if (HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
		set(HAVE_PTHREAD_MUTEX_TIMEDLOCK ON)
	endif (HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
endif()

add_definitions("-DWITH_OPENSSL")

# Include directories
include_directories(${CMAKE_CURRENT_BINARY_DIR})

# Configure files
add_definitions("-DHAVE_CONFIG_H")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)

# WinPR
include_directories("${CMAKE_SOURCE_DIR}/winpr/include")
include_directories("${CMAKE_BINARY_DIR}/winpr/include")

include_directories(Common)
add_subdirectory(third_party)
add_subdirectory(winpr)
add_subdirectory(libtoolkit)
add_subdirectory(RVCComm)
add_subdirectory(spbase)
add_subdirectory(spshell)
add_subdirectory(sphost)

if(BUILD_TESTING)
	add_subdirectory(test)
endif()

set(RVC_BUILD_CONFIG_LIST "")
GET_CMAKE_PROPERTY(res VARIABLES)
FOREACH(var ${res})
	IF (var MATCHES "^WITH_*|^BUILD_TESTING|^BUILTIN_CHANNELS|^HAVE_*")
		LIST(APPEND RVC_BUILD_CONFIG_LIST "${var}=${${var}}")
	ENDIF()
ENDFOREACH()
string(REPLACE ";" " " RVC_BUILD_CONFIG "${RVC_BUILD_CONFIG_LIST}")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/buildflags.h.in ${CMAKE_CURRENT_BINARY_DIR}/buildflags.h)

# 
if(MSVC)
	string(REPLACE "\\" "/" OUTPUT_VERSION_DIR_PATH ${OUTPUT_VERSION_DIR_PATH})
	string(REPLACE "\\" "/" OUTPUT_CUR_DISK_PATH ${OUTPUT_CUR_DISK_PATH})
endif(MSVC)
set(CMAKE_INSTALL_PREFIX "${OUTPUT_CUR_DISK_PATH}")
#set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install") # /${RVC_VERSION}
set(CMAKE_INSTALL_LOCAL_ONLY ON)

# 
set(CPACK_SOURCE_IGNORE_FILES "/\\\\.git/;/\\\\.gitignore;/CMakeCache.txt;/\\\\build;/\\\\out")
string(TOLOWER ${CMAKE_PROJECT_NAME} CMAKE_PROJECT_NAME_lower)
set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME_lower}-${RVC_VERSION_FULL}-${CPACK_SYSTEM_NAME}")
set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME_lower}-${RVC_VERSION_FULL}-${CPACK_SYSTEM_NAME}")

# 
set(CPACK_PACKAGE_NAME "RvcFramework")
set(CPACK_PACKAGE_VENDOR "RVC-CCDG")
# 
set(CPACK_PACKAGE_VERSION ${RVC_VERSION_FULL})
set(CPACK_PACKAGE_VERSION_MAJOR ${RVC_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${RVC_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${RVC_VERSION_REVISION})

set(CPACK_COMPONENTS_ALL headers libraries symbols scripts)

if(MSVC)
	if( NOT CPACK_GENERATOR)
		set(CPACK_GENERATOR "ZIP")
		message(STATUS "set zip package file type")
	endif()
	if(CPACK_GENERATOR MATCHES "NSIS")
		set(CPACK_PACKAGE_INSTALL_DIRECTORY "C:\\\\Run")
	endif()
else(MSVC)
	if( NOT CPACK_GENERATOR)
		set(CPACK_GENERATOR "TGZ")
	message(STATUS "set tgz package file type")
	endif()
endif(MSVC)

if(MSVC)
	if(MSVC_RUNTIME STREQUAL "dynamic")
	message(STATUS "dynamic format")
	# the INSTALL command is not called. The user can use the variable 
	# CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS to use a custom install command and install them however they want.
		set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
		include(InstallRequiredSystemLibraries)
		install(PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS}
			DESTINATION ${RVC_RUNTIME_PATH}
			COMPONENT libraries)
	else()
		include(InstallRequiredSystemLibraries)
	endif()
endif()

include(CPack)

# 
if(INSTALL_INCLUDE_FILES)
	install(DIRECTORY Common DESTINATION ${RVC_INCLUDE_PATH} COMPONENT headers FILES_MATCHING PATTERN "*.h")
	install(FILES "${PROJECT_BINARY_DIR}/version.h" DESTINATION "${RVC_INCLUDE_PATH}/Common" COMPONENT headers)
endif()

file(GLOB BIN_FILES "${CMAKE_SOURCE_DIR}/addin/din/*")
install(FILES ${BIN_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
#install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/bin" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" COMPONENT libraries)
install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" COMPONENT scripts FILES_MATCHING PATTERN "*.ini")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/addin/cfg/shell.ini.in" ${CMAKE_BINARY_DIR}/shell.ini @ONLY)
install(FILES ${CMAKE_BINARY_DIR}/shell.ini DESTINATION ${RVC_CONFIG_PATH} COMPONENT scripts)
set(active_txt_file "${CMAKE_BINARY_DIR}/active.txt")
file(WRITE ${active_txt_file} "${RVC_VERSION}")
#install(CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPUT_VERSION_DIR_PATH})")
#install(CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E copy_if_different ${active_txt_file} ${OUTPUT_VERSION_DIR_PATH}/active.txt   )")

install(FILES ${active_txt_file} DESTINATION ${PACK_INSTALL_PREFIX_VERSION} COMPONENT scripts)
install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/hardwarecfg" DESTINATION "${PACK_INSTALL_PREFIX_ORIGIN}" COMPONENT scripts)
if(MSVC)
	file(GLOB BAT_SCRIPTS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/*.vbs")
else(MSVC)
	file(GLOB BAT_SCRIPTS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/*.sh")
endif(MSVC)

install(FILES ${BAT_SCRIPTS} DESTINATION "${PACK_INSTALL_PREFIX_VERSION}" COMPONENT scripts)



# if necessary
# install(DIRECTORY ${CMAKE_SOURCE_DIR}/addin/mod DESTINATION ${RVC_MODULE_PATH} COMPONENT modules)
# install(DIRECTORY ${CMAKE_SOURCE_DIR}/addin/dep DESTINATION ${RVC_VENDOR_PATH} COMPONENT vendors)
# install(PROGRAMS "")
# install(CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E remove_directory \"${CMAKE_INSTALL_PREFIX}/${RVC_INCLUDE_PATH}\")")