set(ALSA_DEFAULT false)
set(PORTAUDIO_DEFAULT true)

if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	set(ALSA_DEFAULT true)
	set(PORTAUDIO_DEFAULT false)
endif("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")

# Define options and their default values
option(LIBDA_AUTODETECT_PLUGINS "Do not fail if deps for plugins cannot be found" true)
option(LIBDA_PLUGIN_ALSA "Enable ALSA capture and playback" ${ALSA_DEFAULT})
option(LIBDA_PLUGIN_GSTREAMER "Enable GStreamer capture device" false)
option(LIBDA_PLUGIN_JACK "Enable JACK capture and playback" true)
option(LIBDA_PLUGIN_PORTAUDIO "Enable Portaudio (v18 or v19) capture and playback" ${PORTAUDIO_DEFAULT})
option(LIBDA_PLUGIN_PULSE "Enable PulseAudio capture and playback" true)
option(LIBDA_PLUGIN_TESTING "Enable testing plugins (tone generator)" true)

if(LIBDA_PLUGIN_ALSA)
	find_package(ALSA 0.18)
	if(ALSA_FOUND)
		set(PLUGIN_ALSA_DESC "enabled")
		set(PLUGIN_ALSA true)
	else(ALSA_FOUND)
		if(LIBDA_AUTODETECT_PLUGINS)
			set(PLUGIN_ALSA_DESC "disabled (autodetect)")
		else(LIBDA_AUTODETECT_PLUGINS)
			message(FATAL_ERROR "Could not find ALSA, but explicitly required")
		endif(LIBDA_AUTODETECT_PLUGINS)
	endif(ALSA_FOUND)
else(LIBDA_PLUGIN_ALSA)
	set(PLUGIN_ALSA_DESC "disabled")
endif(LIBDA_PLUGIN_ALSA)

if(LIBDA_PLUGIN_GSTREAMER)
	find_package(GStreamer)
	if(GStreamer_FOUND)
		set(PLUGIN_GSTREAMER_DESC "enabled")
		set(PLUGIN_GSTREAMER true)
	else(GStreamer_FOUND)
		if(LIBDA_AUTODETECT_PLUGINS)
			set(PLUGIN_GSTREAMER_DESC "disabled (autodetect)")
		else(LIBDA_AUTODETECT_PLUGINS)
			message(FATAL_ERROR "Could not find PulseAudio, but explicitly required")
		endif(LIBDA_AUTODETECT_PLUGINS)
	endif(GStreamer_FOUND)
else(LIBDA_PLUGIN_GSTREAMER)
	set(PLUGIN_GSTREAMER_DESC "disabled")
endif(LIBDA_PLUGIN_GSTREAMER)

if(LIBDA_PLUGIN_JACK)
	find_package(Jack)
	if(Jack_FOUND)
		set(PLUGIN_JACK_DESC "enabled")
		set(PLUGIN_JACK true)
	else(Jack_FOUND)
		if(LIBDA_AUTODETECT_PLUGINS)
			set(PLUGIN_JACK_DESC "disabled (autodetect)")
		else(LIBDA_AUTODETECT_PLUGINS)
			message(FATAL_ERROR "Could not find JACK, but explicitly required")
		endif(LIBDA_AUTODETECT_PLUGINS)
	endif(Jack_FOUND)
else(LIBDA_PLUGIN_JACK)
	set(PLUGIN_JACK_DESC "disabled")
endif(LIBDA_PLUGIN_JACK)

if(LIBDA_PLUGIN_PORTAUDIO)
	find_package(Portaudio)
	if(Portaudio_FOUND)
		set(PLUGIN_PORTAUDIO_DESC "enabled, version ${Portaudio_VERSION}")
		set(PLUGIN_PORTAUDIO true)
	else(Portaudio_FOUND)
		if(LIBDA_AUTODETECT_PLUGINS)
			set(PLUGIN_PORTAUDIO_DESC "disabled (autodetect)")
		else(LIBDA_AUTODETECT_PLUGINS)
			message(FATAL_ERROR "Could not find Portaudio, but explicitly required")
		endif(LIBDA_AUTODETECT_PLUGINS)
	endif(Portaudio_FOUND)
else(LIBDA_PLUGIN_PORTAUDIO)
	set(PLUGIN_PORTAUDIO_DESC "disabled")
endif(LIBDA_PLUGIN_PORTAUDIO)

if(LIBDA_PLUGIN_PULSE)
	find_package(LibPulseSimple)
	if(LibPulseSimple_FOUND)
		set(PLUGIN_PULSE_DESC "enabled")
		set(PLUGIN_PULSE true)
	else(LibPulseSimple_FOUND)
		if(LIBDA_AUTODETECT_PLUGINS)
			set(PLUGIN_PULSE_DESC "disabled (autodetect)")
		else(LIBDA_AUTODETECT_PLUGINS)
			message(FATAL_ERROR "Could not find PulseAudio, but explicitly required")
		endif(LIBDA_AUTODETECT_PLUGINS)
	endif(LibPulseSimple_FOUND)
else(LIBDA_PLUGIN_PULSE)
	set(PLUGIN_PULSE_DESC "disabled")
endif(LIBDA_PLUGIN_PULSE)

if(LIBDA_PLUGIN_TESTING)
	set(Boost_USE_STATIC_LIBS ON)
	set(Boost_USE_MULTITHREAD ON)
	find_package(Boost 1.34 REQUIRED COMPONENTS thread date_time)
	if(Boost_FOUND)
		set(PLUGIN_TESTING_DESC "enabled")
		set(PLUGIN_TESTING true)
	else(Boost_FOUND)
		if(LIBDA_AUTODETECT_PLUGINS)
			set(PLUGIN_TESTING_DESC "disabled (autodetect)")
		else(LIBDA_AUTODETECT_PLUGINS)
			message(FATAL_ERROR "Could not find Boost, but libda test plugin explicitly required")
		endif(LIBDA_AUTODETECT_PLUGINS)
	endif(Boost_FOUND)
else(LIBDA_PLUGIN_TESTING)
	set(PLUGIN_TESTING_DESC "disabled")
endif(LIBDA_PLUGIN_TESTING)

message("------------------------------------------------------------------")
message("                       LIBDA build summary                        ")
message("------------------------------------------------------------------")
message(" ALSA      : ${PLUGIN_ALSA_DESC}")
message(" Portaudio : ${PLUGIN_PORTAUDIO_DESC}")
message(" PulseAudio: ${PLUGIN_PULSE_DESC}")
message(" GStreamer : ${PLUGIN_GSTREAMER_DESC}")
message(" JACK      : ${PLUGIN_JACK_DESC}")
message(" Testing   : ${PLUGIN_TESTING_DESC}")
message("------------------------------------------------------------------")

if(PLUGIN_ALSA)
	include_directories(${ALSA_INCLUDE_DIR})
	include_directories(.) # for alsa/alsa.hpp
	add_library(da_audio_dev_alsa MODULE audio_dev_alsa.cpp)
	target_link_libraries(da_audio_dev_alsa ${ALSA_LIBRARIES})
	install(TARGETS da_audio_dev_alsa DESTINATION ${LIBDA_PLUGIN_DIR})
endif(PLUGIN_ALSA)

if(PLUGIN_GSTREAMER)
	include_directories(${GStreamer_INCLUDE_DIRS})
	add_library(da_audio_dev_gst MODULE audio_dev_gst.cpp)
	target_link_libraries(da_audio_dev_gst ${GStreamer_LIBRARIES})
	install(TARGETS da_audio_dev_gst DESTINATION ${LIBDA_PLUGIN_DIR})
	if(APPLE)
		target_link_libraries(da_audio_dev_gst da)
	endif(APPLE)
endif(PLUGIN_GSTREAMER)

if(PLUGIN_JACK)
	include_directories(${Jack_INCLUDE_DIRS})
	add_library(da_audio_dev_jack MODULE audio_dev_jack.cpp)
	target_link_libraries(da_audio_dev_jack ${Jack_LIBRARIES})
	if(APPLE)
		target_link_libraries(da_audio_dev_jack da)
	endif(APPLE)
	install(TARGETS da_audio_dev_jack DESTINATION ${LIBDA_PLUGIN_DIR})
endif(PLUGIN_JACK)

if(PLUGIN_PORTAUDIO)
	include_directories(${Portaudio_INCLUDE_DIRS})
	add_library(da_audio_dev_pa${Portaudio_VERSION} MODULE audio_dev_pa${Portaudio_VERSION}.cpp)
	target_link_libraries(da_audio_dev_pa${Portaudio_VERSION} ${Portaudio_LIBRARIES})
	install(TARGETS da_audio_dev_pa${Portaudio_VERSION} DESTINATION ${LIBDA_PLUGIN_DIR})
	if(APPLE)
		target_link_libraries(da_audio_dev_pa${Portaudio_VERSION} da)
	endif(APPLE)
endif(PLUGIN_PORTAUDIO)

if(PLUGIN_PULSE)
	include_directories(${LibPulseSimple_INCLUDE_DIRS})
	add_library(da_audio_dev_pulse MODULE audio_dev_pulse.cpp)
	target_link_libraries(da_audio_dev_pulse ${LibPulseSimple_LIBRARIES})
	install(TARGETS da_audio_dev_pulse DESTINATION ${LIBDA_PLUGIN_DIR})
endif(PLUGIN_PULSE)

if(PLUGIN_TESTING)
	include_directories(${Boost_INCLUDE_DIRS})
	add_library(da_audio_dev_tone MODULE audio_dev_tone.cpp)
	install(TARGETS da_audio_dev_tone DESTINATION ${LIBDA_PLUGIN_DIR})
	if(APPLE OR WIN32)
		target_link_libraries(da_audio_dev_tone da ${Boost_LIBRARIES})
	endif(APPLE OR WIN32)
endif(PLUGIN_TESTING)

