# ########################################################################
# Copyright 2013 Advanced Micro Devices, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ########################################################################

if( WIN32 )
	# We require 2.8.3 for windows because of a bug in cmake that prevented vs2010 from generating
	# executables properly with multiple periods
	cmake_minimum_required( VERSION 2.8.3 )
else( )
	cmake_minimum_required( VERSION 2.6 )
endif( )

if( CMAKE_GENERATOR MATCHES "NMake" )
	option( NMAKE_COMPILE_VERBOSE "Print compile and link strings to the console" OFF )
	if( NMAKE_COMPILE_VERBOSE )
		set( CMAKE_START_TEMP_FILE "" )
		set( CMAKE_END_TEMP_FILE "" )
		set( CMAKE_VERBOSE_MAKEFILE 1 )
	endif( )
endif( )

# This becomes the name of the solution file
project( clFFT )

# Define a version for the code
if( NOT DEFINED CLFFT_VERSION_MAJOR )
	set( CLFFT_VERSION_MAJOR 2 )
endif( )

if( NOT DEFINED CLFFT_VERSION_MINOR )
	set( CLFFT_VERSION_MINOR 12 )
endif( )

if( NOT DEFINED CLFFT_VERSION_PATCH )
	set( CLFFT_VERSION_PATCH 2 )
endif( )

set( CLFFT_VERSION "${CLFFT_VERSION_MAJOR}.${CLFFT_VERSION_MINOR}.${CLFFT_VERSION_PATCH}")

# This is incremented when the ABI to the library changes
set( CLFFT_SOVERSION 2 )

set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR} )

# On windows, it's convenient to change the default install prefix such that it does NOT point to 'program files'
# Need to check out CMAKE_RUNTIME_OUTPUT_DIRECTORY variable, and see if that eliminates the need to modify install path
if( WIN32 AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT )
	set( CMAKE_INSTALL_PREFIX "${PROJECT_BINARY_DIR}/package" CACHE PATH "Install path prefix, prepended onto install directories" FORCE )
endif( )

# Set the default of CMAKE_BUILD_TYPE to be release, unless user specifies with -D.  MSVC_IDE does not use CMAKE_BUILD_TYPE
if( NOT MSVC_IDE AND NOT CMAKE_BUILD_TYPE )
	set( CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE )
endif()

# Options that the user or driver program can set to control various components of the build
option( BUILD_RUNTIME "Build the FFT runtime library" ON )
option( BUILD_CLIENT "Build a command line clFFT client program with a variety of configurable parameters (dependency on Boost)" OFF )
option( BUILD_TEST "Build the library testing suite (dependency on google test, Boost, and FFTW)" OFF )
option( BUILD_LOADLIBRARIES "Build the optional dynamic load libraries that the FFT runtime will search for" ON )
option( BUILD_SHARED_LIBS "Build shared libraries." ON )
option( BUILD_EXAMPLES "Build examples." ON )
option( BUILD_CALLBACK_CLIENT "Build a command line clFFT client program that tests callback functionality (dependency on Boost)" OFF )

# If BOOST_ROOT is defined as an environment value, use that value and cache it so it's visible in the cmake-gui.
# Otherwise, create a sensible default that the user can change
if( DEFINED ENV{BOOST_ROOT} )
	set( BOOST_ROOT $ENV{BOOST_ROOT} CACHE PATH "Environment variable defining the root of the Boost installation" )
endif( )

# Currently, linux has a problem outputing both narrow and wide characters,
# which happens in our client because openCL only supports narrow characters
if( WIN32 )
	option( UNICODE "Build with Unicode Support" ON )
	if( UNICODE )
		message( STATUS "UNICODE build" )
	endif( )
else( )
	set( UNICODE OFF )
	message( STATUS "UNICODE feature disabled on linux" )
endif()

if( MSVC_IDE )
	set_property( GLOBAL PROPERTY USE_FOLDERS TRUE )
	set( BUILD64 ${CMAKE_CL_64} )
else()
	option( BUILD64 "Build a 64-bit product" ON )

	if( IS_DIRECTORY ${PROJECT_SOURCE_DIR}/tests )
		option( CODE_COVERAGE "Build makefiles with code coverage instrumentation" OFF )
		if( CODE_COVERAGE )
			message( STATUS "Code coverage instrumentation on" )
		endif()
	endif()
endif()

# These variables are meant to contain string which should be appended to the installation paths
# of library and executable binaries, respectively.  They are meant to be user configurable/overridable.
set( SUFFIX_LIB_DEFAULT "" )
set( SUFFIX_BIN_DEFAULT "" )

# Modify the global find property to help us find libraries like Boost in the correct paths for 64-bit
# Essentially, find_library calls will look for /lib64 instead of /lib; works for windows and linux
if( BUILD64 )
	set_property( GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS TRUE )
	message( STATUS "64bit build - FIND_LIBRARY_USE_LIB64_PATHS TRUE" )
	if( NOT APPLE )
		set( SUFFIX_LIB_DEFAULT "64" )
	endif()
else( )
	set_property( GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS FALSE )
	message( STATUS "32bit build - FIND_LIBRARY_USE_LIB64_PATHS FALSE" )
endif( )

set( SUFFIX_LIB ${SUFFIX_LIB_DEFAULT} CACHE STRING "String to append to 'lib' install path" )
set( SUFFIX_BIN ${SUFFIX_BIN_DEFAULT} CACHE STRING "String to append to 'bin' install path" )

# Useful variables to configure FindBoost.cake
# set( Boost_USE_MULTITHREADED ON )
# set( Boost_DETAILED_FAILURE_MSG   ON )
# set( Boost_DEBUG ON )
# set( Boost_NO_SYSTEM_PATHS ON )

# Client is built only if boost is found; on windows, we need vs10 or higher
# Find Boost on the system, and configure the type of boost build we want
if( NOT DEFINED Boost_USE_STATIC_LIBS )
	set( Boost_USE_STATIC_LIBS   ON )
endif( )

if( NOT DEFINED Boost_USE_STATIC_RUNTIME )
	set( Boost_USE_STATIC_RUNTIME OFF )
endif( )

# This will define Boost_FOUND
find_package( Boost 1.33.0 COMPONENTS program_options )
if( Boost_FOUND )
	message( STATUS "Boost_PROGRAM_OPTIONS_LIBRARY: ${Boost_PROGRAM_OPTIONS_LIBRARY}" )
else( )
	message( WARNING "Try setting Boost_DEBUG and Boost_DETAILED_FAILURE_MSG for more information" )
endif( )

# This will define OPENCL_FOUND
find_package( OpenCL )

# This will define FFTW_FOUND
find_package( FFTW )

# Enable building of the clACML client if both requested and all dependencies are found
if( BUILD_CLIENT AND Boost_FOUND )
	set( FFT_CLIENT ON )
else( )
	set( FFT_CLIENT OFF )
endif( )

# Enable building of the googletest unit test framework if requested and all dependencies are found
set( UNIT_TEST OFF )
if( BUILD_TEST )
	include(gtest.cmake)
	if( GTEST_FOUND AND Boost_FOUND AND FFTW_FOUND )
		set( UNIT_TEST ON )
	else( )
		message( "GoogleTest unit testing will NOT be built" )
	endif( )
endif( )

# Enable building of the callback client if requested and all dependencies are found
if( BUILD_CALLBACK_CLIENT AND Boost_FOUND AND FFTW_FOUND )
	set( FFT_CALLBACK_CLIENT ON )
else( )
	set( FFT_CALLBACK_CLIENT OFF )
endif( )

# FFLAGS depend on the compiler, grab the compiler name from the path
get_filename_component( C_COMPILER_NAME ${CMAKE_C_COMPILER} NAME_WE )
# message( "C_COMPILER_NAME: " ${C_COMPILER_NAME} )
# message( "CMAKE_C_COMPILER: " ${CMAKE_C_COMPILER} )

if( APPLE )
	# avoid warning on newer cmake versions
	set( CMAKE_MACOSX_RPATH 0 )
endif()

# Set common compile and link options
if( MSVC )
	# Following options for nMake
	message( STATUS "Detected MSVS Ver: " ${MSVC_VERSION} )

	# CMake sets huge stack frames for windows, for whatever reason.  We go with compiler default.
	string( REGEX REPLACE "/STACK:[0-9]+" "" CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}" )
	string( REGEX REPLACE "/STACK:[0-9]+" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}" )
	string( REGEX REPLACE "/STACK:[0-9]+" "" CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}" )

elseif( CMAKE_COMPILER_IS_GNUCXX )
	message( STATUS "Detected GNU fortran compiler." )
	EXEC_PROGRAM( ${CMAKE_CXX_COMPILER} ARGS --version OUTPUT_VARIABLE vnum )
	STRING( REGEX REPLACE ".*([0-9])\\.([0-9])\\.([0-9]).*" "\\1\\2\\3" vnum ${vnum} )
	if( ${vnum} STREQUAL "452" )
		# we only want c++0x if we're using gcc 4.5.2
		set( CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}" )
	endif( )

	set( CMAKE_CXX_FLAGS "-pthread ${CMAKE_CXX_FLAGS}" )
	set( CMAKE_C_FLAGS "-pthread ${CMAKE_C_FLAGS}" )

	# For linux debug builds, define the same preprocessing symbols as win to keep it simple
	if( CMAKE_BUILD_TYPE MATCHES "Debug" )
		add_definitions( "/D_DEBUG" )
	endif( )

	if( BUILD64 )
		set( CMAKE_CXX_FLAGS "-m64 ${CMAKE_CXX_FLAGS}" )
		set( CMAKE_C_FLAGS "-m64 ${CMAKE_C_FLAGS}" )
	else( )
		set( CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}" )
		set( CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}" )
	endif( )

	if( CODE_COVERAGE )
		set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage" )
		set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage" )
	endif( )
endif( )

# If UNICODE is defined for microsoft compilers, pass extra definitions
if( MSVC AND UNICODE )
	add_definitions( "/DUNICODE /D_UNICODE" )
endif( )

# Print out compiler flags for viewing/debug
message( STATUS "CMAKE_CXX_COMPILER flags: " ${CMAKE_CXX_FLAGS} )
message( STATUS "CMAKE_CXX_COMPILER debug flags: " ${CMAKE_CXX_FLAGS_DEBUG} )
message( STATUS "CMAKE_CXX_COMPILER release flags: " ${CMAKE_CXX_FLAGS_RELEASE} )
message( STATUS "CMAKE_CXX_COMPILER relwithdebinfo flags: " ${CMAKE_CXX_FLAGS_RELWITHDEBINFO} )
message( STATUS "CMAKE_EXE_LINKER link flags: " ${CMAKE_EXE_LINKER_FLAGS} )

if( NOT BUILD_SHARED_LIBS )
	set( CLFFT_STATIC ON )
endif( )
# configure a header file to pass the CMake version settings to the source, and package the header files in the output archive
configure_file( "${PROJECT_SOURCE_DIR}/include/clFFT.version.h.in" "${PROJECT_BINARY_DIR}/include/clFFT.version.h" )
install( FILES
		"${PROJECT_BINARY_DIR}/include/clFFT.version.h"
		"include/clFFT.h"
		"include/clAmdFft.h"
		"include/clAmdFft.version.h"
	DESTINATION
		"./include" )

# Recurse into subdirectory and start building files there
if( BUILD_RUNTIME AND IS_DIRECTORY "${PROJECT_SOURCE_DIR}/library" )
	add_subdirectory( library )
else( )
	message( "Runtime library will NOT be built" )
endif( )

if( IS_DIRECTORY "${PROJECT_SOURCE_DIR}/scripts/perf" )
	add_subdirectory( scripts/perf )
endif( )

# We only want to build the following if the user options are set
if( FFT_CLIENT AND IS_DIRECTORY "${PROJECT_SOURCE_DIR}/client" )
	add_subdirectory( client )
else( )
	message( "FFT clients will NOT be built" )
endif( )

# Recurse into subdirectory and start building files there
if( BUILD_LOADLIBRARIES AND IS_DIRECTORY "${PROJECT_SOURCE_DIR}/statTimer" )
	add_subdirectory( statTimer )
else( )
	message( "LoadLibraries will NOT be built" )
endif( )

if( UNIT_TEST AND IS_DIRECTORY "${PROJECT_SOURCE_DIR}/tests" )
	# enable_testing( )
	add_subdirectory( tests )
else( )
	message( "GoogleTest unit tests will NOT be built" )
endif( )

# We only want to build the following if the user options are set
if( FFT_CALLBACK_CLIENT AND IS_DIRECTORY "${PROJECT_SOURCE_DIR}/callback-client" )
	add_subdirectory( callback-client )
else( )
	message( "FFT callback client will NOT be built" )
endif( )

if( BUILD_EXAMPLES )
	add_subdirectory( examples )
endif( )

if( WIN32 )
	set( destdir CMake )
else( )
	set( destdir lib${SUFFIX_LIB}/cmake/clFFT )
endif( )
string( REGEX REPLACE "[^/]+" ".." reldir "${destdir}" )
configure_file(
	${CMAKE_CURRENT_SOURCE_DIR}/clFFTConfigVersion.cmake.in
	${CMAKE_CURRENT_BINARY_DIR}/clFFTConfigVersion.cmake
	@ONLY )
configure_file(
	${CMAKE_CURRENT_SOURCE_DIR}/clFFTConfig.cmake.in
	${CMAKE_CURRENT_BINARY_DIR}/clFFTConfig.cmake
	@ONLY )
install( EXPORT Library DESTINATION ${destdir} FILE clFFTTargets.cmake )
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/clFFTConfigVersion.cmake
	${CMAKE_CURRENT_BINARY_DIR}/clFFTConfig.cmake
	DESTINATION ${destdir} )

# The following code is setting variables to control the behavior of CPack to generate our
if( WIN32 )
	set( CPACK_SOURCE_GENERATOR "ZIP" )
	set( CPACK_GENERATOR "ZIP" )
else( )
	set( CPACK_SOURCE_GENERATOR "TGZ" )
	set( CPACK_GENERATOR "TGZ" )
endif( )

if( BUILD64 )
	set( CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${CLFFT_VERSION}-${CMAKE_HOST_SYSTEM_NAME}-x64" )
else( )
	set( CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${CLFFT_VERSION}-${CMAKE_HOST_SYSTEM_NAME}-x32" )
endif( )

set( CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${CLFFT_VERSION}-${CMAKE_HOST_SYSTEM_NAME}-Source" )

set( CPACK_PACKAGE_VERSION_MAJOR ${CLFFT_VERSION_MAJOR} )
set( CPACK_PACKAGE_VERSION_MINOR ${CLFFT_VERSION_MINOR} )
set( CPACK_PACKAGE_VERSION_PATCH ${CLFFT_VERSION_PATCH} )
set( CPACK_PACKAGE_DESCRIPTION_SUMMARY "OpenCL implementation of an FFT library" )
set( CPACK_PACKAGE_VENDOR "Neutral" )
set( CPACK_SOURCE_IGNORE_FILES "/\\\\.hg/;/\\\\.svn/;/\\\\.git/" )

# Define all variables that influence CPack before including CPack, such as install targets
include( CPack )