cmake_minimum_required(VERSION 3.23)

project(
  AudioPathToneTester
  VERSION 0.1.0
  LANGUAGES CXX
)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

option(ENABLE_ASIO "Enable optional Steinberg ASIO SDK-backed integration" OFF)
option(APTT_STATIC_MSVC_RUNTIME
  "Link the MSVC runtime statically for one-file executable packaging"
  OFF
)
option(APTT_PACKAGE_ACK_ASIO_GPLV3_SOURCE
  "Acknowledge that ASIO-enabled packaging has GPLv3 source and license notices prepared"
  OFF
)
set(APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE ""
  CACHE STRING
  "Exact corresponding-source package name/path for ASIO-enabled packaging"
)
set(APTT_ASIO_CORRESPONDING_SOURCE_SHA256 ""
  CACHE STRING
  "SHA-256 of the exact corresponding-source package for ASIO-enabled packaging"
)
set(APTT_ASIO_SDK_DIR
  "${CMAKE_CURRENT_SOURCE_DIR}/ASIO-SDK_2.3.4_2025-10-15/ASIOSDK"
  CACHE PATH
  "Path to the Steinberg ASIO SDK root used only when ENABLE_ASIO is ON"
)

if(MSVC AND APTT_STATIC_MSVC_RUNTIME)
  set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
endif()

add_library(aptt_core
  src/core/audio_types.cpp
  src/core/device_lifecycle.cpp
  src/core/device_discovery.cpp
  src/core/diagnostic_log.cpp
  src/core/diagnostic_planner.cpp
  src/core/diagnostic_bundle.cpp
  src/core/dop_generator.cpp
  src/core/native_dsd_generator.cpp
  src/core/pcm_sample_conversion.cpp
  src/core/pcm_diagnostics.cpp
  src/core/signal_generator.cpp
)
target_include_directories(aptt_core PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/src")
target_compile_definitions(aptt_core PUBLIC
  APTT_PROJECT_VERSION="${PROJECT_VERSION}"
)
if(ENABLE_ASIO)
  target_compile_definitions(aptt_core PUBLIC APTT_ENABLE_ASIO=1)
else()
  target_compile_definitions(aptt_core PUBLIC APTT_ENABLE_ASIO=0)
endif()

add_library(aptt_backends
  src/backends/asio_driver_discovery.cpp
  src/backends/asio_native_dsd_backend.cpp
  src/backends/asio_pcm_backend.cpp
  src/backends/directsound_device_discovery.cpp
  src/backends/directsound_pcm_backend.cpp
  src/backends/kernel_streaming_discovery.cpp
  src/backends/kernel_streaming_pcm_backend.cpp
  src/backends/mme_device_discovery.cpp
  src/backends/mme_pcm_backend.cpp
  src/backends/null_backend.cpp
  src/backends/wasapi_endpoint_discovery.cpp
  src/backends/wasapi_error.cpp
  src/backends/wasapi_exclusive_pcm_backend.cpp
  src/backends/wasapi_format_probe.cpp
  src/backends/wasapi_shared_pcm_backend.cpp
  src/backends/audio_thread_scheduling.cpp
)
set(APTT_BACKEND_SYSTEM_LIBS
  advapi32
  avrt
  dsound
  ole32
  setupapi
  uuid
  winmm
)
if(MINGW)
  list(APPEND APTT_BACKEND_SYSTEM_LIBS ksguid)
endif()
target_link_libraries(aptt_backends
  PUBLIC aptt_core
  PRIVATE ${APTT_BACKEND_SYSTEM_LIBS}
)
target_compile_definitions(aptt_backends PUBLIC
  WIN32_LEAN_AND_MEAN
  NOMINMAX
)
if(ENABLE_ASIO)
  set(APTT_ASIO_SDK_SOURCES
    "${APTT_ASIO_SDK_DIR}/common/asio.cpp"
    "${APTT_ASIO_SDK_DIR}/host/asiodrivers.cpp"
    "${APTT_ASIO_SDK_DIR}/host/pc/asiolist.cpp"
  )
  target_sources(aptt_backends PRIVATE
    ${APTT_ASIO_SDK_SOURCES}
  )
  target_compile_definitions(aptt_backends PUBLIC APTT_ENABLE_ASIO=1)
  target_include_directories(aptt_backends PRIVATE
    "${APTT_ASIO_SDK_DIR}/common"
    "${APTT_ASIO_SDK_DIR}/host"
    "${APTT_ASIO_SDK_DIR}/host/pc"
  )
  if(MSVC)
    set_source_files_properties(
      ${APTT_ASIO_SDK_SOURCES}
      PROPERTIES COMPILE_OPTIONS "/FIunknwn.h"
    )
  endif()
else()
  target_compile_definitions(aptt_backends PUBLIC APTT_ENABLE_ASIO=0)
endif()

add_library(aptt_diagnostics
  src/diagnostics/null_diagnostic_session.cpp
)
target_link_libraries(aptt_diagnostics PUBLIC
  aptt_backends
  aptt_core
)

add_library(aptt_app_model
  src/app/command_line_args.cpp
  src/app/diagnostic_ui_state.cpp
)
target_link_libraries(aptt_app_model PUBLIC
  aptt_diagnostics
  aptt_core
)

add_library(aptt_imgui
  third_party/imgui/imgui.cpp
  third_party/imgui/imgui_draw.cpp
  third_party/imgui/imgui_tables.cpp
  third_party/imgui/imgui_widgets.cpp
  third_party/imgui/backends/imgui_impl_win32.cpp
  third_party/imgui/backends/imgui_impl_dx11.cpp
)
target_include_directories(aptt_imgui PUBLIC
  "${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui"
  "${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui/backends"
)
target_link_libraries(aptt_imgui PUBLIC
  d3d11
  dxgi
  d3dcompiler
  dwmapi
)

add_executable(audio_path_tone_tester WIN32
  src/app/main.cpp
)
target_link_libraries(audio_path_tone_tester PRIVATE
  aptt_app_model
  aptt_core
  aptt_imgui
  shell32
  user32
  gdi32
)
target_compile_definitions(audio_path_tone_tester PRIVATE
  UNICODE
  _UNICODE
  WIN32_LEAN_AND_MEAN
  NOMINMAX
)

if(MINGW)
  target_link_options(audio_path_tone_tester PRIVATE -static)
endif()

if(MSVC)
  target_compile_options(audio_path_tone_tester PRIVATE /utf-8)
endif()

if(CMAKE_SIZEOF_VOID_P EQUAL 8)
  set(APTT_PACKAGE_ARCH "x64")
else()
  set(APTT_PACKAGE_ARCH "x86")
endif()

if(CMAKE_BUILD_TYPE)
  set(APTT_PACKAGE_BUILD_TYPE "${CMAKE_BUILD_TYPE}")
else()
  set(APTT_PACKAGE_BUILD_TYPE "$<CONFIG>")
endif()

if(MSVC AND APTT_STATIC_MSVC_RUNTIME)
  set(APTT_PACKAGE_RUNTIME "MSVC static runtime")
elseif(MSVC)
  set(APTT_PACKAGE_RUNTIME "MSVC dynamic runtime")
elseif(MINGW)
  set(APTT_PACKAGE_RUNTIME "MinGW static link options")
else()
  set(APTT_PACKAGE_RUNTIME "toolchain default runtime")
endif()

if(ENABLE_ASIO)
  set(APTT_PACKAGE_ASIO_STATUS "enabled")
  set(APTT_PACKAGE_FLAVOR "asio-gplv3")
  set(APTT_PACKAGE_ASIO_GATE_SUMMARY
      "ASIO SDK integration is enabled; packaging requires GPLv3 source and license notice acknowledgement.")
  set(APTT_PACKAGE_ASIO_NOTICE
      "Steinberg ASIO SDK integration is enabled in this build. The package must be distributed only with GPLv3-compatible source availability and preserved Steinberg SDK notices. Do not bundle vendor ASIO drivers or use the ASIO logo.")
else()
  set(APTT_PACKAGE_ASIO_STATUS "disabled")
  set(APTT_PACKAGE_FLAVOR "no-asio")
  set(APTT_PACKAGE_ASIO_GATE_SUMMARY
      "ASIO SDK integration is disabled in this package build.")
  set(APTT_PACKAGE_ASIO_NOTICE
      "Steinberg ASIO SDK integration is disabled in this package build; ASIO SDK source is not compiled into this executable.")
endif()

set(APTT_PACKAGE_BASENAME
    "audio_path_tone_tester-${PROJECT_VERSION}-${APTT_PACKAGE_FLAVOR}-windows-${APTT_PACKAGE_ARCH}")
set(APTT_PACKAGE_EXE_NAME "${APTT_PACKAGE_BASENAME}.exe")
set(APTT_PACKAGE_DIR
    "${CMAKE_CURRENT_SOURCE_DIR}/dist/${APTT_PACKAGE_BASENAME}")
set(APTT_PACKAGE_EXE_PATH "${APTT_PACKAGE_DIR}/${APTT_PACKAGE_EXE_NAME}")
set(APTT_PACKAGE_GENERATED_DIR
    "${CMAKE_CURRENT_BINARY_DIR}/package_metadata")
set(APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE_RESOLVED "")

if(ENABLE_ASIO AND APTT_PACKAGE_ACK_ASIO_GPLV3_SOURCE
   AND NOT APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE STREQUAL ""
   AND NOT APTT_ASIO_CORRESPONDING_SOURCE_SHA256 STREQUAL "")
  if(IS_ABSOLUTE "${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE}")
    set(APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE_RESOLVED
        "${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE}")
  elseif(EXISTS
         "${CMAKE_CURRENT_SOURCE_DIR}/${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE}")
    set(APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE_RESOLVED
        "${CMAKE_CURRENT_SOURCE_DIR}/${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE}")
  elseif(EXISTS
         "${CMAKE_CURRENT_SOURCE_DIR}/external_review_source/${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE}")
    set(APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE_RESOLVED
        "${CMAKE_CURRENT_SOURCE_DIR}/external_review_source/${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE}")
  else()
    message(FATAL_ERROR
            "Refusing ASIO-enabled packaging: corresponding source package does not exist: ${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE}")
  endif()

  file(SHA256
       "${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE_RESOLVED}"
       APTT_ASIO_CORRESPONDING_SOURCE_ACTUAL_SHA256)
  string(TOUPPER
         "${APTT_ASIO_CORRESPONDING_SOURCE_ACTUAL_SHA256}"
         APTT_ASIO_CORRESPONDING_SOURCE_ACTUAL_SHA256)
  string(TOUPPER
         "${APTT_ASIO_CORRESPONDING_SOURCE_SHA256}"
         APTT_ASIO_CORRESPONDING_SOURCE_EXPECTED_SHA256)
  if(NOT APTT_ASIO_CORRESPONDING_SOURCE_ACTUAL_SHA256 STREQUAL
     APTT_ASIO_CORRESPONDING_SOURCE_EXPECTED_SHA256)
    message(FATAL_ERROR
            "Refusing ASIO-enabled packaging: corresponding source package SHA-256 mismatch. expected=${APTT_ASIO_CORRESPONDING_SOURCE_EXPECTED_SHA256} actual=${APTT_ASIO_CORRESPONDING_SOURCE_ACTUAL_SHA256}")
  endif()
endif()

configure_file(
  cmake/release_manifest.txt.in
  "${APTT_PACKAGE_GENERATED_DIR}/RELEASE_MANIFEST.txt"
  @ONLY
)
configure_file(
  cmake/third_party_notices.txt.in
  "${APTT_PACKAGE_GENERATED_DIR}/THIRD_PARTY_NOTICES.txt"
  @ONLY
)
configure_file(
  cmake/asio_distribution_gate.txt.in
  "${APTT_PACKAGE_GENERATED_DIR}/ASIO_DISTRIBUTION_GATE.txt"
  @ONLY
)
configure_file(
  cmake/source_availability.txt.in
  "${APTT_PACKAGE_GENERATED_DIR}/SOURCE_AVAILABILITY.txt"
  @ONLY
)
configure_file(
  cmake/release_smoke_checklist.md.in
  "${APTT_PACKAGE_GENERATED_DIR}/SMOKE_CHECKLIST.md"
  @ONLY
)

set(APTT_PACKAGE_GATE_COMMANDS)
if(ENABLE_ASIO AND NOT APTT_PACKAGE_ACK_ASIO_GPLV3_SOURCE)
  list(APPEND APTT_PACKAGE_GATE_COMMANDS
    COMMAND ${CMAKE_COMMAND} -E echo
            "Refusing ASIO-enabled packaging: configure with -DAPTT_PACKAGE_ACK_ASIO_GPLV3_SOURCE=ON only after GPLv3 source and Steinberg SDK notices are prepared."
    COMMAND ${CMAKE_COMMAND} -E false
  )
endif()
if(ENABLE_ASIO AND APTT_PACKAGE_ACK_ASIO_GPLV3_SOURCE
   AND (APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE STREQUAL ""
        OR APTT_ASIO_CORRESPONDING_SOURCE_SHA256 STREQUAL ""))
  list(APPEND APTT_PACKAGE_GATE_COMMANDS
    COMMAND ${CMAKE_COMMAND} -E echo
            "Refusing ASIO-enabled packaging: provide -DAPTT_ASIO_CORRESPONDING_SOURCE_PACKAGE=<path-or-name> and -DAPTT_ASIO_CORRESPONDING_SOURCE_SHA256=<sha256> for the exact GPLv3 corresponding source package."
    COMMAND ${CMAKE_COMMAND} -E false
  )
endif()

set(APTT_PACKAGE_ASIO_COPY_COMMANDS)
if(ENABLE_ASIO)
  list(APPEND APTT_PACKAGE_ASIO_COPY_COMMANDS
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "${APTT_ASIO_SDK_DIR}/LICENSE.txt"
            "${APTT_PACKAGE_DIR}/licenses/steinberg_asio_sdk_LICENSE.txt"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "${APTT_ASIO_SDK_DIR}/README.md"
            "${APTT_PACKAGE_DIR}/licenses/steinberg_asio_sdk_README.md"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "${APTT_ASIO_SDK_DIR}/common/LICENSE.txt"
            "${APTT_PACKAGE_DIR}/licenses/steinberg_asio_sdk_common_LICENSE.txt"
  )
endif()

add_custom_target(package_onefile
  ${APTT_PACKAGE_GATE_COMMANDS}
  COMMAND ${CMAKE_COMMAND} -E rm -rf "${APTT_PACKAGE_DIR}"
  COMMAND ${CMAKE_COMMAND} -E make_directory "${APTT_PACKAGE_DIR}"
  COMMAND ${CMAKE_COMMAND} -E make_directory "${APTT_PACKAGE_DIR}/licenses"
  COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:audio_path_tone_tester>"
          "${APTT_PACKAGE_EXE_PATH}"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${APTT_PACKAGE_GENERATED_DIR}/RELEASE_MANIFEST.txt"
          "${APTT_PACKAGE_DIR}/RELEASE_MANIFEST.txt"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${APTT_PACKAGE_GENERATED_DIR}/THIRD_PARTY_NOTICES.txt"
          "${APTT_PACKAGE_DIR}/THIRD_PARTY_NOTICES.txt"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${APTT_PACKAGE_GENERATED_DIR}/ASIO_DISTRIBUTION_GATE.txt"
          "${APTT_PACKAGE_DIR}/ASIO_DISTRIBUTION_GATE.txt"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${APTT_PACKAGE_GENERATED_DIR}/SOURCE_AVAILABILITY.txt"
          "${APTT_PACKAGE_DIR}/SOURCE_AVAILABILITY.txt"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${APTT_PACKAGE_GENERATED_DIR}/SMOKE_CHECKLIST.md"
          "${APTT_PACKAGE_DIR}/SMOKE_CHECKLIST.md"
  COMMAND ${CMAKE_COMMAND}
          -DAPTT_VERIFY_ENABLE_ASIO=$<BOOL:${ENABLE_ASIO}>
          -DAPTT_VERIFY_SOURCE_AVAILABILITY=${APTT_PACKAGE_DIR}/SOURCE_AVAILABILITY.txt
          -DAPTT_VERIFY_SOURCE_PACKAGE=${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE_RESOLVED}
          -DAPTT_VERIFY_SOURCE_PACKAGE_LABEL=${APTT_ASIO_CORRESPONDING_SOURCE_PACKAGE}
          -DAPTT_VERIFY_SOURCE_SHA256=${APTT_ASIO_CORRESPONDING_SOURCE_SHA256}
          -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/verify_asio_source_availability.cmake"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${CMAKE_CURRENT_SOURCE_DIR}/docs/THIRD_PARTY.md"
          "${APTT_PACKAGE_DIR}/THIRD_PARTY.md"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${CMAKE_CURRENT_SOURCE_DIR}/docs/decisions/0002-asio-license-and-trademark.md"
          "${APTT_PACKAGE_DIR}/ASIO_LICENSE_DECISION.md"
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
          "${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui/LICENSE.txt"
          "${APTT_PACKAGE_DIR}/licenses/dear_imgui_LICENSE.txt"
  ${APTT_PACKAGE_ASIO_COPY_COMMANDS}
  DEPENDS
    audio_path_tone_tester
    "${APTT_PACKAGE_GENERATED_DIR}/RELEASE_MANIFEST.txt"
    "${APTT_PACKAGE_GENERATED_DIR}/THIRD_PARTY_NOTICES.txt"
    "${APTT_PACKAGE_GENERATED_DIR}/ASIO_DISTRIBUTION_GATE.txt"
    "${APTT_PACKAGE_GENERATED_DIR}/SOURCE_AVAILABILITY.txt"
    "${APTT_PACKAGE_GENERATED_DIR}/SMOKE_CHECKLIST.md"
    docs/THIRD_PARTY.md
    docs/decisions/0002-asio-license-and-trademark.md
    third_party/imgui/LICENSE.txt
  COMMENT "Packaging ${APTT_PACKAGE_EXE_NAME}"
  VERBATIM
)

add_custom_target(package_onefile_smoke
  COMMAND ${CMAKE_COMMAND} -E chdir "${APTT_PACKAGE_DIR}"
          "${APTT_PACKAGE_EXE_PATH}" --smoke
  DEPENDS package_onefile
  COMMENT "Running clean-directory package smoke test"
  VERBATIM
)

enable_testing()

add_test(NAME aptt_app_smoke_tests COMMAND audio_path_tone_tester --smoke)

add_executable(aptt_smoke_tests
  tests/smoke/smoke_main.cpp
)
target_link_libraries(aptt_smoke_tests PRIVATE aptt_core)

if(MINGW)
  target_link_options(aptt_smoke_tests PRIVATE -static)
endif()

add_test(NAME aptt_smoke_tests COMMAND aptt_smoke_tests)

add_executable(aptt_core_tests
  tests/core/core_model_tests.cpp
)
target_link_libraries(aptt_core_tests PRIVATE aptt_core)

if(MINGW)
  target_link_options(aptt_core_tests PRIVATE -static)
endif()

add_test(NAME aptt_core_tests COMMAND aptt_core_tests)

add_executable(aptt_device_discovery_tests
  tests/core/device_discovery_tests.cpp
)
target_link_libraries(aptt_device_discovery_tests PRIVATE aptt_core)
target_compile_definitions(aptt_device_discovery_tests PRIVATE
  APTT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
)

if(MINGW)
  target_link_options(aptt_device_discovery_tests PRIVATE -static)
endif()

add_test(NAME aptt_device_discovery_tests COMMAND aptt_device_discovery_tests)

add_executable(aptt_diagnostic_log_tests
  tests/core/diagnostic_log_tests.cpp
)
target_link_libraries(aptt_diagnostic_log_tests PRIVATE aptt_core)
target_compile_definitions(aptt_diagnostic_log_tests PRIVATE
  APTT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
)

if(MINGW)
  target_link_options(aptt_diagnostic_log_tests PRIVATE -static)
endif()

add_test(NAME aptt_diagnostic_log_tests COMMAND aptt_diagnostic_log_tests)

add_executable(aptt_pcm_diagnostics_tests
  tests/core/pcm_diagnostics_tests.cpp
)
target_link_libraries(aptt_pcm_diagnostics_tests PRIVATE aptt_core)

if(MINGW)
  target_link_options(aptt_pcm_diagnostics_tests PRIVATE -static)
endif()

add_test(NAME aptt_pcm_diagnostics_tests COMMAND aptt_pcm_diagnostics_tests)

add_executable(aptt_dop_generator_tests
  tests/core/dop_generator_tests.cpp
)
target_link_libraries(aptt_dop_generator_tests PRIVATE aptt_core)
target_compile_definitions(aptt_dop_generator_tests PRIVATE
  APTT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
)

if(MINGW)
  target_link_options(aptt_dop_generator_tests PRIVATE -static)
endif()

add_test(NAME aptt_dop_generator_tests COMMAND aptt_dop_generator_tests)

add_executable(aptt_native_dsd_generator_tests
  tests/core/native_dsd_generator_tests.cpp
)
target_link_libraries(aptt_native_dsd_generator_tests PRIVATE aptt_core)

if(MINGW)
  target_link_options(aptt_native_dsd_generator_tests PRIVATE -static)
endif()

add_test(NAME aptt_native_dsd_generator_tests
         COMMAND aptt_native_dsd_generator_tests)

add_executable(aptt_signal_generator_tests
  tests/core/signal_generator_tests.cpp
)
target_link_libraries(aptt_signal_generator_tests PRIVATE aptt_core)

if(MINGW)
  target_link_options(aptt_signal_generator_tests PRIVATE -static)
endif()

add_test(NAME aptt_signal_generator_tests COMMAND aptt_signal_generator_tests)

add_executable(aptt_null_backend_tests
  tests/backends/null_backend_tests.cpp
)
target_link_libraries(aptt_null_backend_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_null_backend_tests PRIVATE -static)
endif()

add_test(NAME aptt_null_backend_tests COMMAND aptt_null_backend_tests)

add_executable(aptt_wasapi_endpoint_discovery_tests
  tests/backends/wasapi_endpoint_discovery_tests.cpp
)
target_link_libraries(aptt_wasapi_endpoint_discovery_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_wasapi_endpoint_discovery_tests PRIVATE -static)
endif()

add_test(NAME aptt_wasapi_endpoint_discovery_tests
         COMMAND aptt_wasapi_endpoint_discovery_tests)

add_executable(aptt_asio_driver_discovery_tests
  tests/backends/asio_driver_discovery_tests.cpp
)
target_link_libraries(aptt_asio_driver_discovery_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_asio_driver_discovery_tests PRIVATE -static)
endif()

add_test(NAME aptt_asio_driver_discovery_tests
         COMMAND aptt_asio_driver_discovery_tests)

add_executable(aptt_audio_thread_scheduling_tests
  tests/backends/audio_thread_scheduling_tests.cpp
)
target_link_libraries(aptt_audio_thread_scheduling_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_audio_thread_scheduling_tests PRIVATE -static)
endif()

add_test(NAME aptt_audio_thread_scheduling_tests
         COMMAND aptt_audio_thread_scheduling_tests)

add_executable(aptt_kernel_streaming_discovery_tests
  tests/backends/kernel_streaming_discovery_tests.cpp
)
target_link_libraries(aptt_kernel_streaming_discovery_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_kernel_streaming_discovery_tests PRIVATE -static)
endif()

add_test(NAME aptt_kernel_streaming_discovery_tests
         COMMAND aptt_kernel_streaming_discovery_tests)

add_executable(aptt_kernel_streaming_pcm_backend_tests
  tests/backends/kernel_streaming_pcm_backend_tests.cpp
)
target_link_libraries(aptt_kernel_streaming_pcm_backend_tests PRIVATE aptt_backends)
target_compile_definitions(aptt_kernel_streaming_pcm_backend_tests PRIVATE
  APTT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
)

if(MINGW)
  target_link_options(aptt_kernel_streaming_pcm_backend_tests PRIVATE -static)
endif()

add_test(NAME aptt_kernel_streaming_pcm_backend_tests
         COMMAND aptt_kernel_streaming_pcm_backend_tests)

add_executable(aptt_asio_pcm_backend_tests
  tests/backends/asio_pcm_backend_tests.cpp
)
target_link_libraries(aptt_asio_pcm_backend_tests PRIVATE aptt_backends)
target_compile_definitions(aptt_asio_pcm_backend_tests PRIVATE
  APTT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
)

if(MINGW)
  target_link_options(aptt_asio_pcm_backend_tests PRIVATE -static)
endif()

add_test(NAME aptt_asio_pcm_backend_tests
         COMMAND aptt_asio_pcm_backend_tests)

add_executable(aptt_asio_native_dsd_backend_tests
  tests/backends/asio_native_dsd_backend_tests.cpp
)
target_link_libraries(aptt_asio_native_dsd_backend_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_asio_native_dsd_backend_tests PRIVATE -static)
endif()

add_test(NAME aptt_asio_native_dsd_backend_tests
         COMMAND aptt_asio_native_dsd_backend_tests)

add_executable(aptt_directsound_device_discovery_tests
  tests/backends/directsound_device_discovery_tests.cpp
)
target_link_libraries(aptt_directsound_device_discovery_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_directsound_device_discovery_tests PRIVATE -static)
endif()

add_test(NAME aptt_directsound_device_discovery_tests
         COMMAND aptt_directsound_device_discovery_tests)

add_executable(aptt_directsound_pcm_backend_tests
  tests/backends/directsound_pcm_backend_tests.cpp
)
target_link_libraries(aptt_directsound_pcm_backend_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_directsound_pcm_backend_tests PRIVATE -static)
endif()

add_test(NAME aptt_directsound_pcm_backend_tests
         COMMAND aptt_directsound_pcm_backend_tests)

add_executable(aptt_mme_device_discovery_tests
  tests/backends/mme_device_discovery_tests.cpp
)
target_link_libraries(aptt_mme_device_discovery_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_mme_device_discovery_tests PRIVATE -static)
endif()

add_test(NAME aptt_mme_device_discovery_tests
         COMMAND aptt_mme_device_discovery_tests)

add_executable(aptt_mme_pcm_backend_tests
  tests/backends/mme_pcm_backend_tests.cpp
)
target_link_libraries(aptt_mme_pcm_backend_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_mme_pcm_backend_tests PRIVATE -static)
endif()

add_test(NAME aptt_mme_pcm_backend_tests
         COMMAND aptt_mme_pcm_backend_tests)

add_executable(aptt_wasapi_format_probe_tests
  tests/backends/wasapi_format_probe_tests.cpp
)
target_link_libraries(aptt_wasapi_format_probe_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_wasapi_format_probe_tests PRIVATE -static)
endif()

add_test(NAME aptt_wasapi_format_probe_tests
         COMMAND aptt_wasapi_format_probe_tests)

add_executable(aptt_wasapi_shared_pcm_backend_tests
  tests/backends/wasapi_shared_pcm_backend_tests.cpp
)
target_link_libraries(aptt_wasapi_shared_pcm_backend_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_wasapi_shared_pcm_backend_tests PRIVATE -static)
endif()

add_test(NAME aptt_wasapi_shared_pcm_backend_tests
         COMMAND aptt_wasapi_shared_pcm_backend_tests)

add_executable(aptt_wasapi_exclusive_pcm_backend_tests
  tests/backends/wasapi_exclusive_pcm_backend_tests.cpp
)
target_link_libraries(aptt_wasapi_exclusive_pcm_backend_tests PRIVATE aptt_backends)

if(MINGW)
  target_link_options(aptt_wasapi_exclusive_pcm_backend_tests PRIVATE -static)
endif()

add_test(NAME aptt_wasapi_exclusive_pcm_backend_tests
         COMMAND aptt_wasapi_exclusive_pcm_backend_tests)

add_executable(aptt_diagnostic_planner_tests
  tests/core/diagnostic_planner_tests.cpp
)
target_link_libraries(aptt_diagnostic_planner_tests PRIVATE aptt_core)
target_compile_definitions(aptt_diagnostic_planner_tests PRIVATE
  APTT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
)

if(MINGW)
  target_link_options(aptt_diagnostic_planner_tests PRIVATE -static)
endif()

add_test(NAME aptt_diagnostic_planner_tests COMMAND aptt_diagnostic_planner_tests)

add_executable(aptt_diagnostic_bundle_tests
  tests/core/diagnostic_bundle_tests.cpp
)
target_link_libraries(aptt_diagnostic_bundle_tests PRIVATE aptt_core)
target_compile_definitions(aptt_diagnostic_bundle_tests PRIVATE
  APTT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
)

if(MINGW)
  target_link_options(aptt_diagnostic_bundle_tests PRIVATE -static)
endif()

add_test(NAME aptt_diagnostic_bundle_tests COMMAND aptt_diagnostic_bundle_tests)

add_executable(aptt_high_load_diagnostics_tests
  tests/core/high_load_diagnostics_tests.cpp
)
target_link_libraries(aptt_high_load_diagnostics_tests PRIVATE aptt_core)

if(MINGW)
  target_link_options(aptt_high_load_diagnostics_tests PRIVATE -static)
endif()

add_test(NAME aptt_high_load_diagnostics_tests
         COMMAND aptt_high_load_diagnostics_tests)

add_executable(aptt_null_diagnostic_session_tests
  tests/diagnostics/null_diagnostic_session_tests.cpp
)
target_link_libraries(aptt_null_diagnostic_session_tests PRIVATE aptt_diagnostics)

if(MINGW)
  target_link_options(aptt_null_diagnostic_session_tests PRIVATE -static)
endif()

add_test(NAME aptt_null_diagnostic_session_tests COMMAND aptt_null_diagnostic_session_tests)

add_executable(aptt_diagnostic_ui_state_tests
  tests/app/diagnostic_ui_state_tests.cpp
)
target_link_libraries(aptt_diagnostic_ui_state_tests PRIVATE aptt_app_model)

if(MINGW)
  target_link_options(aptt_diagnostic_ui_state_tests PRIVATE -static)
endif()

add_test(NAME aptt_diagnostic_ui_state_tests COMMAND aptt_diagnostic_ui_state_tests)

add_executable(aptt_source_package_hygiene_tests
  tests/package/source_package_hygiene_tests.cpp
)
target_compile_definitions(aptt_source_package_hygiene_tests PRIVATE
  APTT_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}"
  APTT_DEFAULT_SOURCE_REVIEW_PACKAGE_DIR="${CMAKE_CURRENT_SOURCE_DIR}/external_review_source/audio_path_tone_tester-0.1.0-ks-wavert-playback-source-20260621"
)

if(MINGW)
  target_link_options(aptt_source_package_hygiene_tests PRIVATE -static)
endif()

add_test(NAME aptt_source_package_hygiene_tests
         COMMAND aptt_source_package_hygiene_tests)
