#
# Haupt CMakeLists.txt für das Projekt TDS
#
# $Id$
# $HeadURL$
# $Author$
#
# Setzen von CMAKE_INSTALL_PREFIX auf "/shd/CTC" falls nicht über Kommandozeile angegeben
#

CMAKE_MINIMUM_REQUIRED(VERSION 3.16)
IF(POLICY CMP0069)
  CMAKE_POLICY(SET CMP0069 NEW) # cmake >= 3.9.0 - INTERPROCEDURAL_OPTIMIZATION behavior
ENDIF()
IF(POLICY CMP0071)
  CMAKE_POLICY(SET CMP0071 NEW) # cmake >= 3.10.0 - automatically process generated sources with AUTOMOC
ENDIF()
IF(POLICY CMP0072)
  CMAKE_POLICY(SET CMP0072 NEW) # cmake >= 3.11.0 - prefer libOpenGL.so over legacy libGL.so
ENDIF()


IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
  SET(CMAKE_INSTALL_PREFIX "/shd/CTC" CACHE STRING "Install path prefix, prepended onto install directories." FORCE)
ENDIF()
#
# # Setzen von CMAKE_BUILD_TYPE auf "Debug" falls nicht über Kommandozeile angegeben
#
IF(NOT DEFINED CMAKE_BUILD_TYPE)
  SET(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel." FORCE)
ENDIF()
ADD_DEFINITIONS(-DEXPORT_BDV_TOPIC_AS_JSON)
SET(_ver "1.2.0")
IF(DEFINED LTS_VERSION_MAJOR AND DEFINED LTS_VERSION_MINOR AND DEFINED LTS_VERSION_PATCH)
  SET(_ver "${LTS_VERSION_MAJOR}.${LTS_VERSION_MINOR}.${LTS_VERSION_PATCH}")
ENDIF()
PROJECT(LTS VERSION ${_ver})
MESSAGE(STATUS "LTS Version: ${LTS_VERSION_MAJOR}.${LTS_VERSION_MINOR}.${LTS_VERSION_PATCH}")
SET(LTS_VERSION_DATE  "01.01.2018" CACHE STRING "The date when this software was compiled")
ADD_DEFINITIONS(-DLTS_VERSION_MAJOR=\"${LTS_VERSION_MAJOR}\")
ADD_DEFINITIONS(-DLTS_VERSION_MINOR=\"${LTS_VERSION_MINOR}\")
ADD_DEFINITIONS(-DLTS_VERSION_PATCH=\"${LTS_VERSION_PATCH}\")
ADD_DEFINITIONS(-DLTS_VERSION_DATE=\"${LTS_VERSION_DATE}\")
IF(JENKINS_BUILD_NUMBER)
  ADD_DEFINITIONS(-DJENKINS_BUILD_NUMBER=\"${JENKINS_BUILD_NUMBER}\")
ELSE()
  ADD_DEFINITIONS(-DJENKINS_BUILD_NUMBER=\"unknown\")
ENDIF()

ADD_DEFINITIONS(-DAPP6C)
SET(CMAKE_INCLUDE_CURRENT_DIR ON)
include_directories(${CMAKE_SOURCE_DIR}/include)
# Include directory for generated export headers
include_directories(${CMAKE_BINARY_DIR})
include_directories(${CMAKE_BINARY_DIR}/Z/src/NGLLogger)
# Include directories for external dependencies and internal modules
include_directories(${CMAKE_SOURCE_DIR}/Z/src/NGLLogger)
include_directories(${CMAKE_SOURCE_DIR}/Z/src/ngltools)
include_directories(${CMAKE_SOURCE_DIR}/Lts/Viewer/SituationMap/Symbology)
include_directories(${CMAKE_SOURCE_DIR}/Lts/Viewer/LtsDataView)
include_directories(${CMAKE_SOURCE_DIR}/Lts/Proxies/TrainingAreaBase)
include_directories(${CMAKE_SOURCE_DIR}/include/ProjectDataManagement)
include_directories(${CMAKE_SOURCE_DIR}/Lts/Proxies/GuezNasat)
SET(CMAKE_CXX_STANDARD 20)
SET(CMAKE_CXX_STANDARD_REQUIRED 14)
SET(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
SET(CMAKE_CXX_VISIBILITY_PRESET hidden)
SET(CMAKE_POSITION_INDEPENDENT_CODE ON)

IF(CMAKE_VERSION VERSION_GREATER 3.15.9)
  OPTION(USE_UNITY_BUILDS "Use Unity builds to speed up compilation (cmake 3.16 or newer required!)" OFF)
  IF (USE_UNITY_BUILDS)
    SET(CMAKE_UNITY_BUILD ON)
    SET(CMAKE_UNITY_BUILD_BATCH_SIZE 40)
  ENDIF()
ENDIF()

# Qt6 Migration: Options to disable modules with missing dependencies (WebEngine, XmlPatterns, ArcGIS)
# These can be enabled once the required system dependencies are available in the build environment
OPTION(BUILD_PLUGINS_PLANEDITOR "Build PlanEditor plugin (requires Qt6 WebEngine + ArcGIS SDK)" OFF)
OPTION(BUILD_PLUGINS_ONLINEHELP "Build OnlineHelp plugin (requires Qt6 WebEngine)" OFF)
OPTION(BUILD_PLUGINS_SERVICEMONITOR "Build ServiceMonitor plugin (requires Qt6 WebEngine)" OFF)
OPTION(BUILD_PLUGINS_PARTICIPANT_ORG_CHART "Build ParticipantOrgChart (requires Qt6 WebEngine)" OFF)
OPTION(BUILD_PLUGINS_MSDL "Build MSDL module (requires Qt6 XmlPatterns)" OFF)
OPTION(BUILD_PLUGINS_SAAB "Build Saab module (requires Qt6 XmlPatterns)" OFF)
OPTION(BUILD_RTI "Build RTI Connext DDS dependent modules" OFF)
OPTION(BUILD_ARCGIS "Build ArcGIS SDK dependent modules" ON)
OPTION(BUILD_FILTERMANAGEMENT "Build FilterManagement plugins (temporarily disabled for migration)" OFF)
OPTION(BUILD_CODIFICATION "Build CodificationManagement plugins (requires KDReports)" OFF)
OPTION(BUILD_GRANTLEE "Build CodeGen Grantlee templates (requires Grantlee5/Qt5)" OFF)
OPTION(BUILD_LTSWEBSOCKET "Build LtsWebSocket module (requires NGLLogger)" ON)

IF(WIN32)
  SET(EXTERNAL_LIBRARY_DIR "C:/Development/Projekte/SituationMap/ExtFw" CACHE STRING "Library dir with all external dependencies")
  LIST(APPEND CMAKE_PREFIX_PATH "${EXTERNAL_LIBRARY_DIR}")
  LIST(APPEND CMAKE_PROGRAM_PATH "${EXTERNAL_LIBRARY_DIR}/bin;${EXTERNAL_LIBRARY_DIR}/dev-utils/bin")
ELSE()
  # Linux: ArcGIS SDK Pfad konfigurieren
  # Use environment variable ARCGIS_ROOT if set, otherwise default to /repo/external/...
  IF(DEFINED ENV{ARCGIS_ROOT})
    SET(ARCGIS_SDK_DIR "$ENV{ARCGIS_ROOT}" CACHE STRING "ArcGIS Runtime SDK for Qt directory")
  ELSE()
    SET(ARCGIS_SDK_DIR "/repo/external/ArcGIS/MapsSDK_Qt_300.0.0/ArcGIS_Maps_SDK_Qt_300.0.0/qt300.0.0/sdk" CACHE STRING "ArcGIS Runtime SDK for Qt directory")
  ENDIF()
  IF(EXISTS "${ARCGIS_SDK_DIR}")
    LIST(APPEND CMAKE_PREFIX_PATH "${ARCGIS_SDK_DIR}")
    MESSAGE(STATUS "ArcGIS SDK found at: ${ARCGIS_SDK_DIR}")
  ELSE()
    MESSAGE(WARNING "ArcGIS SDK not found at: ${ARCGIS_SDK_DIR}")
  ENDIF()
ENDIF()

ENABLE_TESTING()
INCLUDE(CTest)
# Add migration tests
ADD_SUBDIRECTORY(tests)
CONFIGURE_FILE(CTestCustom.ctest ${CMAKE_BINARY_DIR}/CTestCustom.ctest COPYONLY)
CONFIGURE_FILE(lts-cc.conf ${CMAKE_BINARY_DIR}/lts-cc.conf.distrib COPYONLY)

SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
INCLUDE(FindLibraryWithDebug)
# Add bundled GeographicLib cmake config to find modern targets (GeographicLib::GeographicLib_SHARED)
LIST(APPEND CMAKE_PREFIX_PATH "${CMAKE_SOURCE_DIR}/include/GeographicLib/lib/cmake")
SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
IF(WIN32)
  SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
ELSE(WIN32)
  SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
ENDIF()

#
# Disallow in-source build
#
INCLUDE(MacroEnsureOutOfSourceBuild)

macro_ensure_out_of_source_build("In-Source build nicht erlaubt!")

#
# Qt ist wichtig - zuerst suchen
#
SET(CMAKE_AUTOMOC TRUE)
SET(CMAKE_AUTOUIC TRUE)
SET(QT_USE_IMPORTED_TARGETS TRUE)
# Prefer Qt6, fallback to Qt5. Create Qt6::*-aliases when Qt6 is found so existing CMakeLists continue to work.
# Find Qt6 with all required components in one call to ensure all targets are properly created
find_package(Qt6 6.8 COMPONENTS Concurrent Core Gui Location LinguistTools Network OpenGL PrintSupport
  Sensors Multimedia Sql Svg SerialPort Test UiTools WebSockets WebEngineCore WebEngineWidgets
  Widgets Xml XmlPatterns QUIET)
if(Qt6_FOUND)
  message(STATUS "Found Qt6: ${Qt6Core_VERSION}")
  # Map version variable for compatibility if available
  if(Qt6Core_VERSION)
    set(Qt5Core_VERSION ${Qt6Core_VERSION} CACHE INTERNAL "Compatibility Qt5Core_VERSION mapped from Qt6")
  endif()
  # Find rcc/lrelease programs as compatibility fallbacks
  find_program(_rcc_exec rcc-qt6 rcc)
  if(_rcc_exec)
    set(Qt5Core_RCC_EXECUTABLE ${_rcc_exec} CACHE INTERNAL "Compatibility rcc executable")
  endif()
  find_program(_lrelease_exec lrelease-qt6 lrelease)
  if(_lrelease_exec)
    set(Qt5_LRELEASE_EXECUTABLE ${_lrelease_exec} CACHE INTERNAL "Compatibility lrelease executable")
    if(TARGET Qt6::LinguistTools AND NOT TARGET Qt6::lrelease)
      add_executable(Qt6::lrelease IMPORTED)
      set_target_properties(Qt6::lrelease PROPERTIES IMPORTED_LOCATION ${Qt5_LRELEASE_EXECUTABLE})
    endif()
  endif()
else()
  find_package(Qt6 6.10.2 COMPONENTS Concurrent Core Gui LinguistTools
                                    Network OpenGL PrintSupport Multimedia
                                    Sql Svg SerialPort Test UiTools WebSockets
                                    Widgets Xml
                                    REQUIRED)
  find_package(Qt6 COMPONENTS Location Sensors WebEngineCore WebEngineWidgets XmlPatterns OPTIONAL)
  MESSAGE(STATUS "Qt version is ${Qt6Core_VERSION}")
endif()

MESSAGE(STATUS "Qt version is ${Qt6Core_VERSION}")

#
# RTI Connext DDS - manuelle Konfiguration da keine CMake Config Files vorhanden
#
IF(BUILD_RTI)
  SET(RTI_INSTALL_DIR "/repo/external/rti_connext_dds-7.7.0" CACHE PATH "RTI Connext DDS installation directory")
  IF(EXISTS "${RTI_INSTALL_DIR}")
    SET(RTI_LIB_DIR "${RTI_INSTALL_DIR}/lib/x64Linux4gcc8.5.0")
    SET(RTI_INCLUDE_DIR "${RTI_INSTALL_DIR}/include/ndds/hpp")
    
    # RTI hat vier Include-Pfade:
    # - include/ für ndds/... und andere Top-Level Headers (z.B. ndds/ndds_config_common.h)
    # - include/ndds/ für osapi/... Headers (z.B. osapi/osapi_platform.h)
    # - include/ndds/hpp für C++ Headers (dds/..., rti/...)
    # - include/rti für rti/... Headers
    SET(RTI_INCLUDE_DIRS 
        "${RTI_INSTALL_DIR}/include"
        "${RTI_INSTALL_DIR}/include/ndds"
        "${RTI_INSTALL_DIR}/include/ndds/hpp"
        "${RTI_INSTALL_DIR}/include/rti"
    )
    
    # IMPORTED Targets für RTI Libraries erstellen
    # Debug und Release Varianten korrekt konfigurieren
    FOREACH(lib nddsc nddscore nddscpp nddscpp2 nddsctesthelpers)
      ADD_LIBRARY(RTI::${lib} SHARED IMPORTED)
      
      # Debug Library
      IF(EXISTS "${RTI_LIB_DIR}/lib${lib}d.so")
        SET_TARGET_PROPERTIES(RTI::${lib} PROPERTIES
          IMPORTED_LOCATION_DEBUG "${RTI_LIB_DIR}/lib${lib}d.so"
        )
      ENDIF()
      
      # Release Library
      IF(EXISTS "${RTI_LIB_DIR}/lib${lib}.so")
        SET_TARGET_PROPERTIES(RTI::${lib} PROPERTIES
          IMPORTED_LOCATION_RELEASE "${RTI_LIB_DIR}/lib${lib}.so"
          IMPORTED_LOCATION_RELWITHDEBINFO "${RTI_LIB_DIR}/lib${lib}.so"
          IMPORTED_LOCATION_MINSIZEREL "${RTI_LIB_DIR}/lib${lib}.so"
        )
      ENDIF()
      
      # Include Verzeichnisse für alle Varianten
      SET_TARGET_PROPERTIES(RTI::${lib} PROPERTIES
        INTERFACE_INCLUDE_DIRECTORIES "${RTI_INCLUDE_DIRS}"
        INTERFACE_COMPILE_DEFINITIONS "RTI_LINUX"
      )
    ENDFOREACH()
  
    MESSAGE(STATUS "RTI Connext DDS found at: ${RTI_INSTALL_DIR}")
    MESSAGE(STATUS "RTI Libraries: ${RTI_LIB_DIR}")
    MESSAGE(STATUS "RTI Platform: RTI_LINUX")
  ELSE()
    MESSAGE(WARNING "RTI Connext DDS not found at: ${RTI_INSTALL_DIR}, BUILD_RTI will fail")
  ENDIF()
ENDIF(BUILD_RTI)

ADD_DEFINITIONS(-DQT_USE_QSTRINGBUILDER)
ADD_DEFINITIONS(-DQT_NO_CAST_TO_ASCII)
ADD_DEFINITIONS(-DQT_NO_CAST_FROM_ASCII)
ADD_DEFINITIONS(-DQT_NO_URL_CAST_FROM_STRING)
ADD_DEFINITIONS(-DQT_DEPRECATED_WARNINGS)
ADD_DEFINITIONS(-DQT_NO_CAST_FROM_BYTEARRAY)
#ADD_DEFINITIONS(-DQT_NO_DEPRECATED)
ADD_DEFINITIONS(-DQT_DISABLE_DEPRECATED_BEFORE=0x050900)
ADD_DEFINITIONS(-DQT_NO_FOREACH)
IF(NOT WIN32)
  ADD_DEFINITIONS(-DQT_STRICT_ITERATORS)
ENDIF()

#
# Ein paar NGL-spezifische Macros
#
INCLUDE(NGLMacros)

#
# Projektspezifische Einstellungen?
#
NGL_INSTALL(SV AAR WS FILES lts-cc.conf DESTINATION . RENAME lts-cc.conf.distrib)

OPTION(ETS_MODE "Build for ETS (No B-Contamination etc)" OFF)
IF(ETS_MODE)
  ADD_DEFINITIONS(-DETS_MODE)
ENDIF()
OPTION(TABLET_MODE "Build for TABLET " OFF)
IF(TABLET_MODE)
  ADD_DEFINITIONS(-DTABLET_MODE)
ENDIF()

OPTION(GUEZ_MODE "Build for GUEZ " ON)
IF(GUEZ_MODE)
  ADD_DEFINITIONS(-DGUEZ_MODE)
ENDIF()

#
# Doxygen
#
INCLUDE(DoxygenMacros)
IF(NOT DOXYGEN_OUT_DIR)
  SET(DOXYGEN_OUT_DIR ${CMAKE_BINARY_DIR}/doxygen)
ENDIF()
ADD_DOXYGEN_TARGET(TDS ${CMAKE_SOURCE_DIR}/doxygen/Doxyfile.in ${CMAKE_BINARY_DIR}/Doxyfile
                       ${CMAKE_SOURCE_DIR}/doxygen/rheinmetall_defence_logo.jpg
                       ${DOXYGEN_OUT_DIR})

IF(NOT DOXYGEN_OUT_DIR_2025)
  SET(DOXYGEN_OUT_DIR_2025 ${CMAKE_BINARY_DIR}/doxygen2025)
ENDIF()
ADD_DOXYGEN_TARGET(TDS2025 ${CMAKE_SOURCE_DIR}/doxygen/Doxyfile2025.in ${CMAKE_BINARY_DIR}/Doxyfile
                           ${CMAKE_SOURCE_DIR}/doxygen/rheinmetall_defence_logo.jpg
                           ${DOXYGEN_OUT_DIR_2025})

#
# Compilerflags
#
IF(WIN32)
  ADD_DEFINITIONS(-DWIN32 -D_USE_MATH_DEFINES -D_WIN32_WINNT=0x0501 -DUNICODE)
ELSE()
  ADD_DEFINITIONS(-D_LINUX)
ENDIF()

IF(MSVC)
  # C4250: 'class1' : inherits 'class2::member' via dominance
  # C4251: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
  # C4290: C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
  # C4496: 'function': was declared deprecated
  # C4267: 'var' : conversion from 'size_t' to 'type', possible loss of data
  ADD_DEFINITIONS(-wd4250
                  -wd4251
                  -wd4290
                  -wd4496
                  -wd4267
                  -D_CRT_SECURE_NO_DEPRECATE
                  -D_CRT_NONSTDC_NO_DEPRECATE
                  -D_SCL_SECURE_NO_WARNINGS
                  -D_WINSOCK_DEPRECATED_NO_WARNINGS
                  /bigobj
                  )
  # komplette Programmoptimierung
  SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} /MP")
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
  # .pdb - Datei nicht gefunden
  SET(CMAKE_EXE_LINKER_FLAGS    "${CMAKE_EXE_LINKER_FLAGS} /IGNORE:4099")
  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /IGNORE:4099")
  # min() und max() nicht als Macros
  ADD_DEFINITIONS(-DNOMINMAX)
  SET(CMAKE_MSVCIDE_RUN_PATH "" CACHE PATH "Run path to use when starting programs from MSVC")
ENDIF()

IF(UNIX)
  # Alle Warnungen aktivieren
  SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -Wall")
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra -Wmissing-include-dirs")
  # disable
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-overloaded-virtual")
  IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
    IF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8.0)
      MESSAGE(FATAL_ERROR "gcc 4.8 or higher is required to build TDS: ${CMAKE_CXX_COMPILER_VERSION}")
    ENDIF()
    IF(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9.99)
      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-strict-aliasing")
#      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsuggest-attribute=const")
#      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsuggest-final-types")
#      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsuggest-final-methods")
#      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsuggest-override")
    ENDIF()
  ENDIF()
ENDIF()

OPTION(USE_IPO "Use interprocedural optimizations (cmake 3.9 or higher required)" OFF)
IF (USE_IPO AND CMAKE_VERSION VERSION_GREATER 3.8.9)
  INCLUDE(CheckIPOSupported)
  check_ipo_supported(RESULT result OUTPUT output)
  IF(result)
    SET(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
  ELSE()
    MESSAGE(WARNING "IPO is not supported: ${output}")
  ENDIF()
ENDIF()

OPTION(USE_ASAN "Use Address Sanitizer (current Clang only)" OFF)
IF (USE_ASAN)
  IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
    MESSAGE(STATUS "enable Address Sanitizer with Clang (is: ${CMAKE_CXX_COMPILER_ID})")
    SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -fsanitize=address -fno-optimize-sibling-calls -fsanitize-address-use-after-scope -fno-omit-frame-pointer -g -O1")
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-optimize-sibling-calls -fsanitize-address-use-after-scope -fno-omit-frame-pointer -g -O1")
  ELSE()
    MESSAGE(STATUS "Address Sanitizer only supported with Clang (is: ${CMAKE_CXX_COMPILER_ID})")
  ENDIF()
ENDIF(USE_ASAN)

OPTION(USE_UBSAN "Use UndefinedBehavior Sanitizer (current Clang only)" OFF)
IF (USE_UBSAN)
  IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
    SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -fsanitize=undefined")
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined")
  ELSE()
    MESSAGE(STATUS "UndefinedBehavior only supported with Clang (is: ${CMAKE_CXX_COMPILER_ID})")
  ENDIF()
ENDIF(USE_UBSAN)

OPTION(BUILD_RPM "Build a RPM - install script in scripts subdir" OFF)

# Build component options for NGL_ADD_LIBRARY
OPTION(BUILD_ALL "Build all components" ON)
OPTION(BUILD_SV "Build SV component" ON)
OPTION(BUILD_WS "Build WS component" ON)
OPTION(BUILD_AAR "Build AAR component" ON)
OPTION(BUILD_TOOLSWS "Build TOOLSWS component" ON)
OPTION(BUILD_TOOLSSV "Build TOOLSSV component" ON)
OPTION(BUILD_HLA "Build HLA component" ON)

# If BUILD_ALL is ON, enable all individual component flags
IF(BUILD_ALL)
  SET(BUILD_SV ON CACHE BOOL "Build SV component" FORCE)
  SET(BUILD_WS ON CACHE BOOL "Build WS component" FORCE)
  SET(BUILD_AAR ON CACHE BOOL "Build AAR component" FORCE)
  SET(BUILD_TOOLSWS ON CACHE BOOL "Build TOOLSWS component" FORCE)
  SET(BUILD_TOOLSSV ON CACHE BOOL "Build TOOLSSV component" FORCE)
  SET(BUILD_HLA ON CACHE BOOL "Build HLA component" FORCE)
ENDIF()

IF(BUILD_RPM)
  ADD_SUBDIRECTORY(scripts)
ELSE()
  ADD_DEFINITIONS(-DLTS_DEBUG)
ENDIF()

IF (NOT DEFINED _pname)
 IF(GUEZ_MODE)
   SET (_pname "guez")
   ADD_DEFINITIONS(-DPROJECTBUILD="guez")
    MESSAGE(STATUS "NO ProjectName givin! BUT GUEZ_MODE set PROJECTBUILD to guez")
  ELSE()
    MESSAGE(WARNING "NO ProjectName givin! Can't install coresponding lts-cc.conf! and PROJECTBUILD is empty")
    ADD_DEFINITIONS(-DPROJECTBUILD="")
  ENDIF()
ELSE()
    MESSAGE(STATUS "ProjectName givin! PROJECTBUILD is ${_pname} ")
    ADD_DEFINITIONS(-DPROJECTBUILD=\"${_pname}\")
ENDIF()


#
# DDS benoetigt zwingend RTI
#
FIND_PACKAGE(RTI QUIET)
if(NOT RTI_FOUND)
  message(WARNING "RTI not found; creating placeholder RTI::* imported targets to allow configure without RTI installation")
  set(_rti_libs nddscore nddsc nddscpp2 rtiroutingservice)
  foreach(_lib ${_rti_libs})
    if(NOT TARGET RTI::${_lib})
      add_library(RTI::${_lib} UNKNOWN IMPORTED)
      set_property(TARGET RTI::${_lib} PROPERTY INTERFACE_INCLUDE_DIRECTORIES "")
    endif()
  endforeach()
endif()

# Respect MIGRATE_MODULE: when set to a relative path (e.g. "Lts/Common"), only add
# the top-level subdirectories required to configure/build that module. This allows
# per-module migration builds via -DMIGRATE_MODULE=<path>.
if(NOT DEFINED MIGRATE_MODULE)
  set(MIGRATE_MODULE "" CACHE STRING "If set, only add subdirectories covering this module (path relative to repo root)")
endif()

function(NGL_ADD_SUBDIR_GUARDED subdir)
  if(MIGRATE_MODULE STREQUAL "")
    add_subdirectory(${subdir})
  else()
    # normalize to forward slashes
    string(REPLACE "\\" "/" _mig "${MIGRATE_MODULE}")
    string(REPLACE "\\" "/" _sub "${subdir}")
    # also compare basenames so MIGRATE_MODULE=Lts/DDS matches subdir 'DDS' when called from Lts
    get_filename_component(_mig_base "${_mig}" NAME)
    get_filename_component(_sub_base "${_sub}" NAME)
    # If MIGRATE_MODULE either starts with the subdir, equals it, contains it as a path component,
    # or the basename matches, include the subdir. This makes nested paths like
    # 'Lts/Proxies/TrainingAreaBase' include both 'Lts' and its child 'Proxies'.
    if(_mig MATCHES "^${_sub}(/|$)" OR _sub MATCHES "^${_mig}(/|$)" OR _mig MATCHES ".*/${_sub}(/|$)" OR _sub MATCHES ".*/${_mig}(/|$)" OR _mig_base STREQUAL _sub OR _sub_base STREQUAL _mig)
      message(STATUS "Including subdir ${subdir} because MIGRATE_MODULE=${MIGRATE_MODULE}")
      add_subdirectory(${subdir})
    else()
      message(STATUS "Skipping subdir ${subdir} because MIGRATE_MODULE=${MIGRATE_MODULE}")
    endif()
  endif()
endfunction()

# Add only guarded subdirectories
NGL_ADD_SUBDIR_GUARDED(TetraIF)
NGL_ADD_SUBDIR_GUARDED(Z/src)
NGL_ADD_SUBDIR_GUARDED(Lts)
# TrainingAreaBase is included via Lts/Proxies when Lts is processed
# Special-case: when migrating TetraIF, also include ProjectDataManagement so generated headers
# and internal logger target are available in the same build tree for TetraIF dependents.
if(DEFINED MIGRATE_MODULE AND MIGRATE_MODULE STREQUAL "TetraIF")
  message(STATUS "Including helper modules for TetraIF migration: Lts/Plugins/ProjectDataManagement")
  add_subdirectory(Lts/Plugins/ProjectDataManagement)
endif()
# at last, to make sure we get all targets in NGL_TS_TARGETS property
NGL_ADD_SUBDIR_GUARDED(translations)
#-----------------------------------------------------------------------------------------------------


OPTION(BUILD_QAV "Build script for local QAV analysis" OFF)
IF (BUILD_QAV)
  ADD_SUBDIRECTORY(qav)
ENDIF()