# Variable that you can define to add automatic dependencies
# USE_SFML, USE_RENDERER, USE_INPUT, USE_SERIALIZER, USE_LUA, USE_SOL2, 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_INCLUDES

cmake_minimum_required(VERSION 3.1)
cmake_policy(VERSION 3.1)
#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})

        add_definitions(-static-libgcc -static-libstdc++)
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}")
        set(LIBRARY_NAME "")
        add_executable(${EXECUTABLE_NAME} ${EXEC_SRC_LIST} ${RESOURCES_FILES})
else()
	message(WARNING "NO SOURCE FILE PROVIDED")
endif()

add_definitions(-std=c++14)
add_definitions(-Wreorder)
add_definitions(-Wparentheses)
add_definitions(-Wsign-compare)
add_definitions(-Wunused-variable)
add_definitions(-pedantic-errors)

#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_SOL2)
	set(USE_LUA True)
	LIST(APPEND INCLUDE_PATHS ${INCLUDE_ROOT}/sol2)
	MESSAGE(STATUS "using sol2 headers")
endif()

if(USE_LUA)
	find_library(LUA_LIBRARY
		NAMES luajit-5.1 luajit
		PATHS ${LIB_PATHS}
	)

	MESSAGE(STATUS "using lua lib")

	add_definitions(-llua)

	LIST(APPEND INCLUDE_PATHS ${INCLUDE_ROOT}/luajit-2.0)
	LIST(APPEND INCLUDE_PATHS ${INCLUDE_ROOT}/luajit)
	LIST(APPEND LIB_DEPENDENCIES_LIST ${LUA_LIBRARY})

endif()

if(USE_SERIALIZER)
	find_library(SPARROW_SERIALIZER_LIBRARY
		NAMES
			SparrowSerializer
		PATHS
			${LIB_PATHS}
	)

#	LIST(APPEND INCLUDE_PATHS ${PROJECT_SOURCE_DIR}/../SparrowSerializer/src)
	LIST(APPEND LIB_DEPENDENCIES_LIST ${SPARROW_SERIALIZER_LIBRARY})
endif()

if(USE_IMGUI)
	find_library(IMGUI_LIBRARY
		NAMES
			imgui
		PATHS
			${LIB_PATHS}
	)

	LIST(APPEND LIB_DEPENDENCIES_LIST ${IMGUI_LIBRARY})
endif()

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)
            LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_WINDOW} gdi32)
		elseif(UNIX)
            LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_WINDOW} pthread X11 Xrandr udev)
		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)
			LIST(APPEND LIB_SFML_LIST ${SFML_LIBRARY_SYSTEM} 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} -lssleay32 -leay32)
#			LIST(APPEND LIB_DEPENDENCIES_LIST ${Qt5Network_LIBRARIES})
			add_definitions(${Qt5Network_DEFINITIONS})
			LIST(APPEND INCLUDES_PATHS ${Qt5Network_INCLUDES})
		endif()
	endif()
	if(";${QT_MODULE};" MATCHES ";websockets;")
		find_package(Qt5WebSockets REQUIRED)
		if(Qt5WebSockets_FOUND)
			MESSAGE(STATUS "found QT websockets")
			LIST(APPEND LIB_DEPENDENCIES_LIST ${Qt5WebSockets_LIBRARIES})
			LIST(APPEND INCLUDE_PATHS ${Qt5WebSockets_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)
    if(UNIX)
        LIST(APPEND LIB_DEPENDENCIES_LIST ${SPARROW_RENDERER_LIBRARY} dl)
    else()
        LIST(APPEND LIB_DEPENDENCIES_LIST ${SPARROW_RENDERER_LIBRARY})
    endif()
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}
)

MACRO(INSTALL_HEADERS_WITH_DIRECTORY HEADER_LIST)
	set(INSTALL_DESTINATION include/${LIBRARY_NAME})
	FOREACH(HEADER ${${HEADER_LIST}})
		file(RELATIVE_PATH HEADER ${PROJECT_SOURCE_DIR} ${HEADER})
		STRING(REGEX MATCH "(.\*)\[/\]" DIR ${HEADER})
		STRING(SUBSTRING ${DIR} 4 -1 DIR)
		INSTALL(FILES ${HEADER} DESTINATION ${INSTALL_DESTINATION}/${DIR})
	ENDFOREACH(HEADER)
	INSTALL(FILES "${PROJECT_BINARY_DIR}/Version.h" DESTINATION ${INSTALL_DESTINATION})
ENDMACRO(INSTALL_HEADERS_WITH_DIRECTORY)

#make rule for installing header
set(CMAKE_INSTALL_PREFIX ${DEPENDENCIES_ROOT})
INSTALL_HEADERS_WITH_DIRECTORY(LIB_HEAD_LIST)

if(UNIX)
	# -ldl seems to be required for linux executables
	LIST(APPEND LIB_DEPENDENCIES_LIST dl)
endif()

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