# Variable that you need to define to use this template
# USE_SFML, USE_RENDERER, USE_INPUT, USE_BULLET, USE_OPENGL, USE_QT5
#
# Container for list of file to be compiled :
# LIB_SRC_LIST, LIB_HEAD_LIST, EXEC_SRC_LIST, EXEC_HEAD_LIST
#
# If you want to specify a supplementary folder for include, use :
# EXTRA_INCLUDE_PATHS

cmake_minimum_required(VERSION 2.8)
cmake_policy(VERSION 2.8)
cmake_policy(SET CMP0020 NEW)

set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)

if(NOT CMAKE_TEMPLATE_PATH)
    MESSAGE(WARNING "CMAKE_TEMPLATE_PATH not set. Using default value \"../cmaketemplate\"...")
    SET(CMAKE_TEMPLATE_PATH "../CMakeTemplate")
endif()

include(${CMAKE_TEMPLATE_PATH}/resource.cmake)

configure_file (
    "${CMAKE_TEMPLATE_PATH}/SparrowConfig.h.in"
    "${PROJECT_BINARY_DIR}/Version.h"
    )

#detect system and version
if(WIN32)
	set(LIB_DEBUG_FOLDER "libDebug/mingw32")
	set(LIB_RELEASE_FOLDER "libRelease/mingw32")
elseif(UNIX)
	if(${CMAKE_SYSTEM_VERSION} MATCHES "i686")
		set(LIB_DEBUG_FOLDER "libDebug/i686")
		set(LIB_RELEASE_FOLDER "libRelease/i686")
	elseif(${CMAKE_SYSTEM_VERSION} MATCHES "x86_64")
		set(LIB_DEBUG_FOLDER "libDebug/x86_64")
		set(LIB_RELEASE_FOLDER "libRelease/x86_64")
	endif()
endif()

#set dependencies paths
set(DEPENDENCIES_ROOT ${PROJECT_SOURCE_DIR}/../cpp_dependencies)
set(INCLUDE_ROOT ${DEPENDENCIES_ROOT}/include)

set(LIB_DEBUG_PATH ${DEPENDENCIES_ROOT}/${LIB_DEBUG_FOLDER})
set(LIB_RELEASE_PATH ${DEPENDENCIES_ROOT}/${LIB_RELEASE_FOLDER})

if(${CMAKE_BUILD_TYPE} MATCHES "Debug")
	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIB_DEBUG_PATH}) #for STATIC
	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIB_DEBUG_PATH}) #for SHARED

	list(APPEND LIB_PATHS ${LIB_DEBUG_PATH})
	list(APPEND LIB_PATHS ${LIB_RELEASE_PATH})
else()
	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIB_RELEASE_PATH}) #for STATIC
	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIB_RELEASE_PATH}) #for SHARED

	list(APPEND LIB_PATHS ${LIB_RELEASE_PATH})
endif()

#create library and executable
if(LIB_SRC_LIST)
	set(IS_LIBRARY True)
	set(LIBRARY_NAME ${PROJECT_NAME})
	add_library(${LIBRARY_NAME} STATIC ${LIB_SRC_LIST} ${RESOURCES_FILES})
	if(EXEC_SRC_LIST)
		set(EXECUTABLE_NAME "test${PROJECT_NAME}")
		add_executable(${EXECUTABLE_NAME} ${EXEC_SRC_LIST} ${RESOURCES_FILES})
	endif()
elseif(EXEC_SRC_LIST)
	set(EXECUTABLE_NAME "${PROJECT_NAME}")
	add_executable(${EXECUTABLE_NAME} ${EXEC_SRC_LIST} ${RESOURCES_FILES})
else()
	message(WARNING "NO SOURCE FILE PROVIDED")
endif()

add_definitions(-std=c++11)

#find libraries
set(LIB_DEPENDENCIES_LIST "")
set(INCLUDE_PATHS ${INCLUDE_ROOT})

# not used for now
# foreach(EXTENSION ${INCLUDE_PATHS_EXTENSION})
#     LIST(APPEND INCLUDE_PATHS ${INCLUDE_ROOT}${EXTENSION} " ")
# endforeach()

if(USE_ENGINE)
        find_library(SPARROW_ENGINE_LIBRARY
                NAMES
                        SparrowEngine
                PATHS
                        ${LIB_PATHS}
        )

        set(USE_RENDERER True)
		set(USE_INPUT True)
		set(USE_BULLET True)
		
		# window and system are already requested by sparrowInput
		LIST(APPEND SFML_MODULES graphics audio)

        LIST(APPEND INCLUDE_PATHS ${PROJECT_SOURCE_DIR}/../SparrowEngine/src)
        LIST(APPEND LIB_DEPENDENCIES_LIST ${SPARROW_ENGINE_LIBRARY})
endif()

if(USE_INPUT)
        find_library(SPARROW_INPUT_LIBRARY
                NAMES
                        SparrowInput
                PATHS
                        ${LIB_PATHS}
        )

        LIST(APPEND SFML_MODULES window system)

        LIST(APPEND INCLUDE_PATHS ${PROJECT_SOURCE_DIR}/../SparrowInput/src)
        LIST(APPEND LIB_DEPENDENCIES_LIST ${SPARROW_INPUT_LIBRARY})
endif()

if(SFML_MODULES)
	add_definitions(-DSFML_STATIC)
	
	LIST(FIND SFML_MODULES "graphics" USE_SFML_GRAPHICS)
	LIST(FIND SFML_MODULES "window" USE_SFML_WINDOW)
	LIST(FIND SFML_MODULES "audio" USE_SFML_AUDIO)
	LIST(FIND SFML_MODULES "network" USE_SFML_NETWORK)
	LIST(FIND SFML_MODULES "system" USE_SFML_SYSTEM)
	
	if(${USE_SFML_GRAPHICS} GREATER -1)
		set(USE_SFML_WINDOW 1)
		set(USE_SFML_SYSTEM 1)
		
		find_library(SFML_LIBRARY_GRAPHICS
			NAMES sfml-graphics
			PATHS ${LIB_PATHS}
		)
		find_library(SFML_DEP_FREETYPE
			NAMES freetype
			PATHS ${LIB_PATHS}
		)
		find_library(SFML_DEP_JPEG
			NAMES jpeg
			PATHS ${LIB_PATHS}
		)
		
		LIST(APPEND LIB_SFML_LIST
			${SFML_LIBRARY_GRAPHICS}
			${SFML_DEP_FREETYPE}
			${SFML_DEP_JPEG}
		)
		MESSAGE(STATUS "using SFML graphics")
	endif()
	
	if(${USE_SFML_WINDOW} GREATER -1)
		set(USE_SFML_SYSTEM 1)
		set(USE_OPENGL True)
		
		find_library(SFML_LIBRARY_WINDOW
			NAMES sfml-window
			PATHS ${LIB_PATHS}
		)
		
		if(WIN32)
			find_library(SFML_DEP_GDI
				NAMES gdi32
				PATHS ${LIB_PATHS}
			)
			LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_WINDOW} ${SFML_DEP_GDI})
		elseif(UNIX)
			LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_WINDOW})
		endif()
		MESSAGE(STATUS "using SFML window")
	endif()
	
	if(${USE_SFML_AUDIO} GREATER -1)
		set(USE_SFML_SYSTEM 1)
		
		find_library(SFML_LIBRARY_AUDIO
			NAMES sfml-audio
			PATHS ${LIB_PATHS}
		)
		find_library(SFML_DEP_OPENAL
			NAMES openal openal32
			PATHS ${LIB_PATHS}
		)
		find_library(SFML_DEP_FLAC
			NAMES flac FLAC
			PATHS ${LIB_PATHS}
		)
		find_library(SFML_DEP_VORBISENC
			NAMES vorbisenc
			PATHS ${LIB_PATHS}
		)
		find_library(SFML_DEP_VORBISFILE
			NAMES vorbisfile
			PATHS ${LIB_PATHS}
		)
		find_library(SFML_DEP_VORBIS
			NAMES vorbis
			PATHS ${LIB_PATHS}
		)
		find_library(SFML_DEP_OGG
			NAMES ogg
			PATHS ${LIB_PATHS}
		)
		
		LIST(APPEND LIB_SFML_LIST
			${SFML_LIBRARY_AUDIO}
			${SFML_DEP_OPENAL}
			${SFML_DEP_FLAC}
			${SFML_DEP_VORBISENC}
			${SFML_DEP_VORBISFILE}
			${SFML_DEP_VORBIS}
			${SFML_DEP_OGG}
		)
		MESSAGE(STATUS "using SFML audio")
	endif()
	
	if(${USE_SFML_NETWORK} GREATER -1)
		set(USE_SFML_SYSTEM 1)
		
		find_library(SFML_LIBRARY_NETWORK
			NAMES sfml-network
			PATHS ${LIB_PATHS}
		)
		
		if(WIN32)
			find_library(SFML_DEP_WINSOCK
				NAMES ws2_32
				PATHS ${LIB_PATHS}
			)
			LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_NETWORK} ${SFML_DEP_WINSOCK})
		elseif(UNIX)
			LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_NETWORK})
		endif()
		MESSAGE(STATUS "using SFML network")
	endif()
	
	if(${USE_SFML_SYSTEM} GREATER -1)
		find_library(SFML_LIBRARY_SYSTEM
			NAMES sfml-system
			PATHS ${LIB_PATHS}
		)
		
		if(WIN32)
			find_library(SFML_DEP_WINMM
				NAMES winmm
				PATHS ${LIB_PATHS}
			)
			LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_SYSTEM} ${SFML_DEP_WINMM})
		elseif(UNIX)
			LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_SYSTEM})
		endif()
		MESSAGE(STATUS "using SFML system")
	endif()
	
    LIST(APPEND LIB_DEPENDENCIES_LIST ${LIB_SFML_LIST})
endif()
	
if(USE_BULLET)
	find_library(BULLET_COLLISION_LIBRARY
		NAMES
			BulletCollision
		PATHS
			${LIB_PATHS}
	)

	find_library(BULLET_DYNAMICS_LIBRARY
		NAMES
			BulletDynamics
		PATHS
			${LIB_PATHS}
	)

	find_library(LINEAR_MATH_LIBRARY
		NAMES
			LinearMath
		PATHS
			${LIB_PATHS}
	)
	LIST(APPEND LIB_DEPENDENCIES_LIST
		${BULLET_DYNAMICS_LIBRARY}
		${BULLET_COLLISION_LIBRARY}
		${LINEAR_MATH_LIBRARY}
	)
	LIST(APPEND INCLUDE_PATHS ${INCLUDE_ROOT}/bullet)
endif()

if(QT_MODULE)
	MESSAGE(STATUS "using QT5 modules : ${QT_MODULE}")
        if(";${QT_MODULE};" MATCHES ";core;")
		find_package(Qt5Core REQUIRED)
		if(Qt5Core_FOUND)
			MESSAGE(STATUS "found QT core")
			LIST(APPEND LIB_DEPENDENCIES_LIST ${Qt5Core_LIBRARIES})
			add_definitions(${Qt5Core_DEFINITIONS})
			LIST(APPEND INCLUDES_PATHS ${Qt5Core_INCLUDES})
		endif()
	endif()
	if(";${QT_MODULE};" MATCHES ";gui;")
		find_package(Qt5Gui REQUIRED)
		if(Qt5Gui_FOUND)
			MESSAGE(STATUS "found QT gui")
			LIST(APPEND LIB_DEPENDENCIES_LIST ${Qt5Gui_LIBRARIES})
			add_definitions(${Qt5Gui_DEFINITIONS})
			LIST(APPEND INCLUDES_PATHS ${Qt5Gui_INCLUDES})
		endif()
	endif()
	if(";${QT_MODULE};" MATCHES ";opengl;")
		find_package(Qt5OpenGL REQUIRED)
		if(Qt5OpenGL_FOUND)
			MESSAGE(STATUS "found QT opengl")
			LIST(APPEND LIB_DEPENDENCIES_LIST ${Qt5OpenGL_LIBRARIES})
			add_definitions(${Qt5OpenGL_DEFINITIONS})
			LIST(APPEND INCLUDE_PATHS ${Qt5OpenGL_INCLUDES})
		endif()
	endif()
	if(";${QT_MODULE};" MATCHES ";widgets;")
		find_package(Qt5Widgets REQUIRED)
		if(Qt5Widgets_FOUND)
			MESSAGE(STATUS "found QT widgets")
			LIST(APPEND LIB_DEPENDENCIES_LIST ${Qt5Widgets_LIBRARIES})
			add_definitions(${Qt5Widgets_DEFINITIONS})
			LIST(APPEND INCLUDE_PATHS ${Qt5Widgets_INCLUDES})
		endif()
	endif()
	if(";${QT_MODULE};" MATCHES ";network;")
		find_package(Qt5Network REQUIRED)
		if(Qt5Network_FOUND)
			MESSAGE(STATUS "found QT network")
			LIST(APPEND LIB_DEPENDENCIES_LIST ${Qt5Network_LIBRARIES})
			add_definitions(${Qt5Network_DEFINITIONS})
			LIST(APPEND INCLUDES_PATHS ${Qt5Network_INCLUDES})
		endif()
	endif()
endif()

if(USE_RENDERER)
	find_library(SPARROW_RENDERER_LIBRARY
		NAMES
			SparrowRenderer
		PATHS
			${LIB_PATHS}
	)

	add_definitions(-DGLEW_STATIC)

	set(USE_OPENGL True)

	LIST(APPEND INCLUDE_PATHS ${PROJECT_SOURCE_DIR}/../SparrowRenderer/src)
	LIST(APPEND LIB_DEPENDENCIES_LIST ${SPARROW_RENDERER_LIBRARY})
endif()

if(USE_OPENGL)
	find_package(OpenGL REQUIRED)
	if(OPENGL_FOUND)
		LIST(APPEND LIB_DEPENDENCIES_LIST ${OPENGL_LIBRARIES})
	endif()
endif()

include_directories(
    ${INCLUDE_PATHS}
    ${EXTRA_INCLUDES}
)

if(LIB_SRC_LIST)
	target_link_libraries(
		${LIBRARY_NAME}
		${LIB_DEPENDENCIES_LIST}
        )
	if(EXEC_SRC_LIST)
		target_link_libraries(
			${EXECUTABLE_NAME}
			${LIBRARY_NAME}
		)
	endif()
elseif(EXEC_SRC_LIST)
	target_link_libraries(
		${EXECUTABLE_NAME}
		${LIB_DEPENDENCIES_LIST}
	)
endif()