#[[

shstk_define_option(name desc)

shstk_begin_project(name)

shstk_install(dir is_app target h_files)

shstk_is_parent_exists(out)

shstk_copy_to_parent()

shstk_add_directories()

shstk_add_directories_with_include(is_qt name)

shstk_set_find_dirs(name)

shstk_find_header(name filename add_find_info)

align_list(list out)

print_list(list title prefix)

]]


find_package(MinGW REQUIRED)
include(GenerateExportHeader)
include(DeployMacros)


macro(shstk_define_option name desc)
	if (NOT DEFINED ${name})
		option(${name} ${desc} ${ARGN})
		#message("define option ${name} ${desc} ${ARGN}")
	endif()
endmacro()


macro(shstk_begin_project name)
	string(TOLOWER "${name}" ${name}_lowercase)
	string(TOUPPER "${name}" ${name}_uppercase)
	set(INSTALL_PREFIX)
	set(_plugins_default_ 1)
	if (CMAKE_CROSSCOMPILING)
		if (DEFINED ANDROID_PLATFORM)
			set(INSTALL_PREFIX "${CMAKE_FIND_ROOT_PATH}/")
			set(_plugins_default_ 0)
		else()
			set(INSTALL_PREFIX "${CMAKE_STAGING_PREFIX}")
		endif()
	endif()
	if (NOT DEFINED BUILD_NUMBER)
		set(BUILD_NUMBER 9999)
	endif()
	if("x${BUILD_NUMBER}" STREQUAL "x")
		set(BUILD_NUMBER 0)
	endif()

	shstk_define_option(LOCAL "Local install" OFF)
	if (DEFINED ENV{QNX_HOST} OR PIP_FREERTOS)
		set(STATIC_LIB_DEFAULT ON)
	else()
		set(STATIC_LIB_DEFAULT OFF)
	endif()
	shstk_define_option(STATIC_LIB "Build static libraries" ${STATIC_LIB_DEFAULT})
	set(_path "local \"bin\", \"lib\" and \"include\"")
	if (NOT LOCAL)
		if (WIN32)
			if (MINGW)
				set(CMAKE_INSTALL_PREFIX ${MINGW_DIR})
			endif()
		else()
			if (DEFINED ANDROID_PLATFORM)
				set(CMAKE_INSTALL_PREFIX ${ANDROID_SYSTEM_LIBRARY_PATH}/usr)
			else()
				if (CMAKE_CROSSCOMPILING)
					set(CMAKE_INSTALL_PREFIX ${CMAKE_STAGING_PREFIX})
				else()
					set(CMAKE_INSTALL_PREFIX ${INSTALL_PREFIX}/usr/local)
				endif()
			endif()
		endif()
		set(_path "\"${CMAKE_INSTALL_PREFIX}\"")
	endif()
	if (NOT _install_msg)
		set(_install_msg ON) # CACHE STRING "shstk_install_msg")
		message(STATUS "Install to ${_path}")
	endif()

	if (CMAKE_BUILD_TYPE MATCHES Debug)
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g3 -Wall")
		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g3 -Wall")
	else()
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall")
		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -Wall")
	endif()

	if(MINGW)
		list(APPEND CMAKE_LIBRARY_PATH ${MINGW_LIB})
	endif()
	if(APPLE)
		set(CMAKE_INSTALL_RPATH "@executable_path/../Frameworks;@executable_path/lib;@loader_path/../lib")
		set(CMAKE_MACOSX_RPATH TRUE)
		if (CMAKE_CROSSCOMPILING)
			set(CMAKE_INSTALL_NAME_DIR "@rpath")
		else()
			include_directories(/usr/local/include)
			link_directories(/usr/local/lib)
		endif()
	else()
		set(CMAKE_INSTALL_RPATH "\$ORIGIN;\$ORIGIN/lib")
	endif()

	if (DEFINED ANDROID_PLATFORM)
		include_directories(${ANDROID_SYSTEM_LIBRARY_PATH}/usr/include)
	endif()

	set(_qt_libs )
	set(_qt_apps )
	set(_qt_plugs)
	if (NOT "x${name}" STREQUAL "x")
		set(BUILDING_${name} ON CACHE BOOL "build ${name}")
		set(${name}_ROOT_SRC "${CMAKE_CURRENT_SOURCE_DIR}" CACHE STRING "")
		set(${name}_ROOT_BIN "${CMAKE_CURRENT_BINARY_DIR}" CACHE STRING "")
		set(SET_TARGETS_${name} OFF CACHE BOOL "" FORCE)

		if(STATIC_LIB)
			add_definitions(-D${${name}_uppercase}_STATIC_DEFINE)
			set(${name}_LIB_TYPE STATIC)
			set(${name}_LIB_TYPE_MSG "Static")
		else()
			set(${name}_LIB_TYPE SHARED)
			set(${name}_LIB_TYPE_MSG "Shared")
		endif()

		if (CMAKE_BUILD_TYPE MATCHES Debug)
			set(${name}_BUILD_TYPE "Debug")
		else()
			set(${name}_BUILD_TYPE "Release")
		endif()

		set(${name}_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/${${name}_lowercase}_version.h")
		set_version(${name}
			MAJOR    "${${name}_MAJOR}"
			MINOR    "${${name}_MINOR}"
			REVISION "${${name}_REVISION}"
			BUILD    "${BUILD_NUMBER}"
			SUFFIX   "${${name}_SUFFIX}"
			OUTPUT   "${${name}_VERSION_FILE}")
		set_deploy_property(${name} ${${name}_LIB_TYPE}
			FULLNAME "${${name}_DOMAIN}.*"
			COMPANY  "${${name}_COMPANY}")

	endif()

endmacro()


macro(shstk_install _dir is_app _target _h_files)
	if((NOT ${is_app}) AND (NOT "x${_h_files}" STREQUAL "x"))
		if(LOCAL)
			install(FILES ${_h_files} DESTINATION include/${_dir})
		else()
			if(WIN32)
				install(FILES ${_h_files} DESTINATION ${MINGW_INCLUDE}/${_dir})
			else()
				install(FILES ${_h_files} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${_dir})
			endif()
		endif()
	endif()
	if (NOT "x${_target}" STREQUAL "x")
		if(LOCAL)
			if(${is_app})
				install(TARGETS ${_target} DESTINATION bin)
			else()
				if(WIN32)
					install(TARGETS ${_target} RUNTIME DESTINATION bin)
					install(TARGETS ${_target} ARCHIVE DESTINATION lib)
				else()
					install(TARGETS ${_target} DESTINATION lib)
				endif()
			endif()
		else()
			if(WIN32)
				if (${is_app})
					install(TARGETS ${_target} DESTINATION ${MINGW_BIN})
				else()
					install(TARGETS ${_target} ARCHIVE DESTINATION ${MINGW_LIB})
					install(TARGETS ${_target} RUNTIME DESTINATION ${MINGW_BIN})
				endif()
			else()
				if (${is_app})
					install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
				else()
					install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
				endif()
			endif()
		endif()
	endif()
endmacro()


macro(shstk_is_parent_exists _out)
	set(${_out} FALSE)
	get_property(_pd DIRECTORY PROPERTY PARENT_DIRECTORY)
	if (NOT "x${_pd}" STREQUAL "x")
		set(${_out} TRUE)
	endif()
endmacro()


macro(shstk_copy_to_parent)
	shstk_is_parent_exists(_pe)
	if (_pe)
		set(QT_MULTILIB_LIST ${QT_MULTILIB_LIST} PARENT_SCOPE)
		set(_qt_libs  ${_qt_libs}  PARENT_SCOPE)
		set(_qt_apps  ${_qt_apps}  PARENT_SCOPE)
		set(_qt_plugs ${_qt_plugs} PARENT_SCOPE)
	endif()
endmacro()


macro(shstk_add_directories)
	file(GLOB _dl "[^.]*")
	foreach(_d ${_dl})
		if(IS_DIRECTORY ${_d})
			add_subdirectory(${_d})
		endif()
	endforeach()
	shstk_copy_to_parent()
endmacro()


macro(shstk_add_directories_with_include is_qt name)
	set(DIRS)
	file(GLOB _dl "[^.]*")
	foreach(_d ${_dl})
		if(IS_DIRECTORY ${_d})
			list(APPEND DIRS ${_d})
		endif()
	endforeach()

	foreach(_d ${DIRS})
		get_filename_component(_dname "${_d}" NAME)
		if (${is_qt})
			list(APPEND QT_MULTILIB_LIST ${name}${_dname})
			#set(QT_MULTILIB_LIST "${QT_MULTILIB_LIST}" CACHE STRING "")
		endif()
	endforeach()

	foreach(_d ${DIRS})
		add_subdirectory(${_d})
	endforeach()

	shstk_copy_to_parent()
endmacro()


macro(shstk_set_find_dirs name)
	string(TOLOWER "${name}" ${name}_lowercase)
	set(${name}_INCDIR)
	set(${name}_LIBDIR)
	set(${name}_BINDIR)
	set(${name}_FIND_PROGRAM_ARG)
	set(${name}_BINEXT "")
	if(DEFINED ${name}_DIR)
		list(APPEND ${name}_LIBDIR "${${name}_DIR}/lib")
		list(APPEND ${name}_INCDIR "${${name}_DIR}/include/${${name}_lowercase}")
		list(APPEND ${name}_BINDIR "${${name}_DIR}/bin")
	endif()
	if(MINGW_INCLUDE)
		list(APPEND ${name}_INCDIR "${MINGW_INCLUDE}/${${name}_lowercase}")
		list(APPEND ${name}_LIBDIR "${MINGW_LIB}")
		list(APPEND ${name}_BINDIR "${MINGW_BIN}")
	endif()
	if(CMAKE_CROSSCOMPILING)
		list(APPEND ${name}_INCDIR "${CMAKE_PREFIX_PATH}/include/${${name}_lowercase}")
		list(APPEND ${name}_LIBDIR "${CMAKE_PREFIX_PATH}/lib")
		set(${name}_FIND_PROGRAM_ARG "NO_DEFAULT_PATH")
		list(APPEND ${name}_BINDIR "/usr/bin" "/usr/local/bin")
		include_directories(${CMAKE_PREFIX_PATH}/include)
		link_directories(${CMAKE_PREFIX_PATH}/lib)
	else()
		list(APPEND ${name}_BINDIR "${CMAKE_PREFIX_PATH}/bin")
		if(NOT WIN32)
			list(APPEND ${name}_INCDIR "/usr/include/${${name}_lowercase}" "/usr/local/include/${${name}_lowercase}")
			list(APPEND ${name}_LIBDIR "/usr/lib" "/usr/local/lib")
		endif()
		if(APPLE)
			include_directories(/usr/local/include)
			link_directories(/usr/local/lib)
		endif()
	endif()
	if ("x${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "xWindows")
		set(${name}_BINEXT ".exe")
		if (CMAKE_CROSSCOMPILING)
			set(${name}_FIND_PROGRAM_ARG)
		endif()
	endif()
endmacro()


macro(shstk_find_header name filename add_find_info)
	string(TOUPPER "${name}" ${name}_uppercase)
	if(NOT ${name}_VERSION)
		find_file(${name}_H_INCLUDE "${filename}" HINTS ${${name}_INCDIR} NO_CMAKE_FIND_ROOT_PATH)
		find_file(${name}_H_INCLUDE "${filename}" HINTS ${${name}_INCDIR})
		#message("${name}_H_INCLUDE \"${filename}\" HINTS \"${${name}_INCDIR}\" = \"${${name}_H_INCLUDE}\"")
		if (NOT ${name}_H_INCLUDE)
			message(FATAL_ERROR "Can`t find ${name} version file (\"${filename}\")!")
		endif()
		get_filename_component(_inc ${${name}_H_INCLUDE} PATH)
		set(${name}_INCLUDES "${_inc}" CACHE STRING "")
		include(CheckSymbolExists)
		check_symbol_exists(${${name}_uppercase}_VERSION_NAME "${${name}_H_INCLUDE}" _${name}_version_found)
		if (_${name}_version_found)
			file(STRINGS "${${name}_H_INCLUDE}" _version REGEX "^[ \t]*#define[ \t]+${${name}_uppercase}_VERSION_NAME+[ \t]+.*$")
			string(REGEX MATCH "\".*\"" _version ${_version})
			string(LENGTH ${_version} SL)
			math(EXPR SL ${SL}-2)
			string(SUBSTRING ${_version} 1 ${SL} _version)
			set(${name}_VERSION ${_version} CACHE STRING "${name}_VERSION")
			if (NOT _FIND_${name}_MSG)
				set(_FIND_${name}_MSG 1 CACHE BOOL "find_msg_${name}" FORCE)
				set(_afi)
				if (NOT "x${add_find_info}" STREQUAL "x")
					set(_afi ": ${add_find_info}")
				endif()
				message(STATUS "Found ${name}${_afi} (version \"${${name}_VERSION}\")")
			endif()
		else()
			message(FATAL_ERROR "Can`t find ${${name}_uppercase}_VERSION_NAME in \"${filename}\"!")
		endif()
	endif()
	if(${name}_FIND_VERSION VERSION_GREATER ${name}_VERSION)
		message(FATAL_ERROR "${name} version ${${name}_VERSION} is available, but ${${${name}_uppercase}_FIND_VERSION} requested!")
	endif()
endmacro()


macro(align_list _list _out)
	set(_max_len 0)
	foreach(_m ${_list})
		string(LENGTH "${_m}" _clen)
		if (_clen GREATER _max_len)
			set(_max_len ${_clen})
		endif()
	endforeach()
	set(${_out})
	foreach(_m ${_list})
		set(_am "${_m}")
		while(TRUE)
			string(LENGTH "${_am}" _clen)
			if (_clen GREATER_EQUAL ${_max_len})
				break()
			endif()
			string(APPEND _am " ")
		endwhile()
		list(APPEND ${_out} "${_am}")
	endforeach()
endmacro()


macro(print_list _list _title _prefix)
	if (NOT "x${_list}" STREQUAL "x")
		if (NOT "x${_title}" STREQUAL "x")
			message("${_title}")
		endif()
		foreach(_m ${_list})
			message("${_prefix}${_m}")
		endforeach()
	endif()
endmacro()