include (CMakeParseArguments)

#/////////////////////////////////////////////////////////////////////////////////////////////////
####################################
#set_output_dir
#  Description:
#    Change the output directory of the project to given folder
#       for all configurations
#
#  Syntax:
#    set_output_dir(foldername)
####################################
macro (set_output_dir DIR)
  foreach (CONFIG ${CMAKE_CONFIGURATION_TYPES})
    # make configuration variable upper case for CMAKE macros
    string(TOUPPER ${CONFIG} CONFIGUPPERCASE)

    # set directories
    set( CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CONFIGUPPERCASE} ${DIR})
    set( CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CONFIGUPPERCASE} ${DIR})
    set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CONFIGUPPERCASE} ${DIR})
    set( CMAKE_PDB_OUTPUT_DIRECTORY_${CONFIGUPPERCASE} ${DIR})
  endforeach (CONFIG ${CMAKE_CONFIGURATION_TYPES})
endmacro (set_output_dir)

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_TRANSLATE)

  # define file lists for all languages
  foreach(arg IN LISTS ARGN)
    set(TRANSLATION_FILES_ORIG
      ${TRANSLATION_FILES_ORIG}
      resources/${PROJECT_NAME}_${arg}_generated.ts
    )
    set(TRANSLATION_FILES
      ${TRANSLATION_FILES}
      resources/${PROJECT_NAME}_${arg}.ts
    )
    set(TRANSLATION_RESOURCE_LIST
      ${TRANSLATION_RESOURCE_LIST}
      "<file>${PROJECT_NAME}_${arg}.qm</file>"
    )
    if(NOT EXISTS ${CMAKE_CURRENT_LIST_DIR}/resources/${PROJECT_NAME}_${arg}.ts)
      configure_file(${TSEP_PROJECT_CMAKE}/Templates/Translation.Template.ts ${CMAKE_CURRENT_LIST_DIR}/resources/${PROJECT_NAME}_${arg}.ts COPYONLY)
    endif()
  endforeach()

  # replace all ";" from the resource list
  string(REPLACE ";" "\n    " TRANSLATION_RESOURCE_STRING "${TRANSLATION_RESOURCE_LIST}")

  if (WIN32)
    # copy project specific *translations.qrc to the resources folder
    configure_file(${TSEP_PROJECT_CMAKE}/Templates/Translations.Template.qrc ${CMAKE_CURRENT_LIST_DIR}/resources/${PROJECT_NAME}_translations.qrc @ONLY)
  endif()

  # call qt translation functions
  qt5_create_translation(ORIG_TRANSLATIONS ${CMAKE_CURRENT_LIST_DIR} ${TRANSLATION_FILES_ORIG})
  qt5_add_translation(QM_FILES ${TRANSLATION_FILES})
  configure_file(resources/${PROJECT_NAME}_translations.qrc ${CMAKE_BINARY_DIR}/${PROJECT_NAME} COPYONLY)

  # define TSEP_TRANSLATION_FILES in parent scope so it can be added to the project by add_executable or add_library
  set(TSEP_TRANSLATION_FILES_LOCAL ${TRANSLATION_FILES} ${TRANSLATION_FILES_ORIG} ${CMAKE_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}_translations.qrc)
  set(TSEP_TRANSLATION_FILES ${TSEP_TRANSLATION_FILES_LOCAL} PARENT_SCOPE)
  
  # Group the files in the solution 
  source_group("Translation Files"   FILES ${TSEP_TRANSLATION_FILES_LOCAL})

endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_SETUP_DLL_VERSION ComponentDescription)

  #------------------------------------------------------------------------------
  # Windows Version Description with Resource Files
  if(WIN32)
    add_definitions(-DVER_COMPANYNAME_STR="${TSEP_COMPANY_LONGNAME}")
    add_definitions(-DVER_FILEVERSION_STR="${TSEP_PRODUCT_VERSION}")
    add_definitions(-DVER_FILEVERSION=${TSEP_PRODUCT_VERSION})
    add_definitions(-DVER_FILEDESCRIPTION_STR="${ComponentDescription}")
    add_definitions(-DVER_LEGALCOPYRIGHT_STR="${TSEP_COPYRIGHT_STRING}")
    add_definitions(-DVER_PRODUCTNAME_STR="${TSEP_PROJECT}")

    set(AUTOMATED_VERSION_FILES
      ${TSEP_DLL_VERSION_RC}
    )
    source_group("Automated Version Files" FILES ${AUTOMATED_VERSION_FILES})
  else()
    # define entry point for shared library to print the version information
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-e,tsep_version_entry_point" PARENT_SCOPE)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-e,tsep_version_entry_point" PARENT_SCOPE)
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wl,-e,tsep_version_entry_point" PARENT_SCOPE)
    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wl,-e,tsep_version_entry_point" PARENT_SCOPE)
  endif()

  add_definitions(-DTSEP_VERSION="${TSEP_VERSION}")
  add_definitions(-DTSEP_VERSION_MAJOR=${TSEP_VERSION_MAJOR})
  add_definitions(-DTSEP_VERSION_MINOR=${TSEP_VERSION_MINOR})
  add_definitions(-DTSEP_VERSION_PATCH=${TSEP_VERSION_PATCH})
  add_definitions(-DTSEP_PRODUCT_NAME="${TSEP_PRODUCT_NAME}")
  add_definitions(-DTSEP_COPYRIGHT="${TSEP_COPYRIGHT_STRING}")
  add_definitions(-DTSEP_COMPANY_NAME="${TSEP_COMPANY_LONGNAME}")

endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_SETUP_APP_VERSION ComponentDescription)

  #------------------------------------------------------------------------------
  # Windows Version Description with Resource Files
  if(WIN32)
    add_definitions(-DVER_COMPANYNAME_STR="${TSEP_COMPANY_LONGNAME}")
    add_definitions(-DVER_FILEVERSION_STR="${TSEP_PRODUCT_VERSION}")
    add_definitions(-DVER_FILEVERSION=${TSEP_PRODUCT_VERSION})
    add_definitions(-DVER_FILEDESCRIPTION_STR="${ComponentDescription}")
    add_definitions(-DVER_LEGALCOPYRIGHT_STR="${TSEP_COPYRIGHT_STRING}")
    add_definitions(-DVER_PRODUCTNAME_STR="${TSEP_PROJECT}")

    set(AUTOMATED_VERSION_FILES
      ${TSEP_APP_VERSION_RC}
    )

    source_group("Automated Version Files" FILES ${AUTOMATED_VERSION_FILES})
  endif()

  add_definitions(-DTSEP_VERSION="${TSEP_VERSION}")
  add_definitions(-DTSEP_VERSION_MAJOR=${TSEP_VERSION_MAJOR})
  add_definitions(-DTSEP_VERSION_MINOR=${TSEP_VERSION_MINOR})
  add_definitions(-DTSEP_VERSION_PATCH=${TSEP_VERSION_PATCH})

endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_ADD_EXPORT_FILE )

  message(" Generating import cmake file for project / " ${PROJECT_NAME})

  set(TEMP_PRODUCT_NAME "Tsep.")
  string(APPEND TEMP_PRODUCT_NAME ${TSEP_PRODUCT_NAME})
  set(TEMP_PROJECT_COLON_NAME "")
  string(REPLACE "." "::" TEMP_PROJECT_COLON_NAME ${TEMP_PRODUCT_NAME})
  set(TEMP_PROJECT_SIMPLE_NAME "")
  string(REPLACE "." "" TEMP_PROJECT_SIMPLE_NAME ${TEMP_PRODUCT_NAME})
  set(TEMP_PROJECT_DOT_NAME ${TEMP_PRODUCT_NAME})
  string(TOUPPER ${TSEP_PRODUCT_NAME} TEMP_CMAKE_PROJECT_NAME)

  #message("Colon  " ${TEMP_PROJECT_COLON_NAME})
  #message("Dot    " ${TEMP_PROJECT_DOT_NAME})
  #message("Simple " ${TEMP_PROJECT_SIMPLE_NAME})

  # Copy the nuspec template file and configure it for the product
  configure_file( ${TSEP_PROJECT_CMAKE}/Templates/CMakeLists.Import.Template ${TSEP_EXPORT_DIR}/${TEMP_PROJECT_SIMPLE_NAME}Config.cmake @ONLY )

endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_ADD_EXPORT_HEADER HeaderList)

message(" Generating custom action to export header files for project / " ${PROJECT_NAME})

set_target_properties(${PROJECT_NAME} PROPERTIES PUBLIC_HEADER "${HeaderList}")

endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_ADD_PROJECT_NEXUS_UPLOAD)

# Lower case for configuration flag
string( TOLOWER ${TSEP_UPDATE_IN_NEXUS} TSEP_UPDATE_IN_NEXUS_LOWER )

# Add a new target if Nexus upload is requested
if( TSEP_UPDATE_IN_NEXUS_LOWER STREQUAL "true" )

  message(" Generating Nexus upload project for product  / " ${TSEP_PRODUCT_NAME})

  # Copy the nuspec template file and configure it for the product
  configure_file( ${TSEP_PROJECT_CMAKE}/Templates/CMake.nuspec.Template ${TSEP_EXPORT_DIR}/${TSEP_PRODUCT_NAME}.nuspec )

  # Copy the template nexus upload cmake file
  file(MAKE_DIRECTORY NEXUS_UPLOAD)
  file(COPY ${TSEP_PROJECT_CMAKE}/Templates/CMakeLists.Nexus.Template.cmake DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/NEXUS_UPLOAD )
  file(RENAME ${CMAKE_CURRENT_SOURCE_DIR}/NEXUS_UPLOAD/CMakeLists.Nexus.Template.cmake ${CMAKE_CURRENT_SOURCE_DIR}/NEXUS_UPLOAD/CMakeLists.txt )

  # Create a new project for the nexus upload
  add_subdirectory ( "NEXUS_UPLOAD" "${CMAKE_CURRENT_BINARY_DIR}/NEXUS_UPLOAD" )

endif()

endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_THIRDPARTY_NEXUS_UPLOAD)

# Lower case for configuration flag
string( TOLOWER ${TSEP_UPDATE_IN_NEXUS} TSEP_UPDATE_IN_NEXUS_LOWER )

# Add a new target if Nexus upload is requested
if( TSEP_UPDATE_IN_NEXUS_LOWER STREQUAL "true" )

  message(" Executing Nexus upload for third party product  / " ${TSEP_PRODUCT_NAME})

  # Create package
  execute_process( WORKING_DIRECTORY ${TSEP_EXPORT_DIR}
                   COMMAND ${TSEP_NUGET_APPLICATION} pack  ${TSEP_EXPORT_DIR}/${TSEP_PRODUCT_NAME}.nuspec -outputdirectory  ${TSEP_EXPORT_DIR} -BasePath ${TSEP_EXPORT_DIR} -verbosity detailed
                 )

  execute_process( WORKING_DIRECTORY ${TSEP_EXPORT_DIR}
                   COMMAND ${TSEP_NUGET_APPLICATION} push *.nupkg ${TSEP_NEXUS_GUID} -source ${TSEP_NEXUS_URL}/Development/ -verbosity detailed
                 )

endif()

endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_ADD_PROJECT_CODE_ANALYZER)

# Visual Studio
if(WIN32)

  message(" Generating Visual Studio Code Analyzer project for product  / " ${TSEP_PRODUCT_NAME})

  # Copy the template Nexus upload CMake file
  file(MAKE_DIRECTORY VS_CODE_ANALYZER)
  file(COPY ${TSEP_PROJECT_CMAKE}/Templates/CMakeLists.VS_CodeAnalyzer.Template.cmake DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/VS_CODE_ANALYZER )
  file(RENAME ${CMAKE_CURRENT_SOURCE_DIR}/VS_CODE_ANALYZER/CMakeLists.VS_CodeAnalyzer.Template.cmake ${CMAKE_CURRENT_SOURCE_DIR}/VS_CODE_ANALYZER/CMakeLists.txt )

  # Create a new project for the Visual Studio CodeAnalyzer
  add_subdirectory ( "VS_CODE_ANALYZER" "${CMAKE_CURRENT_BINARY_DIR}/VS_CODE_ANALYZER" )

endif()

endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
MACRO(TSEP_GET_HEADER_DIRECTORIES return_list target_dir)

  FILE(GLOB_RECURSE new_list ${target_dir}/*.h)
  SET(dir_list "")
  FOREACH(file_path ${new_list})
    GET_FILENAME_COMPONENT(dir_path ${file_path} PATH)
    SET(dir_list ${dir_list} ${dir_path})
  ENDFOREACH()
  LIST(REMOVE_DUPLICATES dir_list)
  SET(${return_list} ${dir_list})

ENDMACRO()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_ADD_OS_SPECIFIC_SETTINGS)

IF (WIN32)
    target_link_libraries(${PROJECT_NAME} PUBLIC Iphlpapi.lib)
    target_link_libraries(${PROJECT_NAME} PUBLIC Shlwapi.lib)
    target_link_libraries(${PROJECT_NAME} PUBLIC Ws2_32.lib)
ENDIF()

IF (LINUX)
    target_link_libraries(${PROJECT_NAME} PUBLIC dl)
    target_link_libraries(${PROJECT_NAME} PUBLIC pthread)
    target_link_libraries(${PROJECT_NAME} PUBLIC rt)
    target_link_libraries(${PROJECT_NAME} PUBLIC stdc++fs)
ENDIF()

    set_target_properties(${PROJECT_NAME} PROPERTIES DEBUG_POSTFIX d)
endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_CREATE_LINK_FOR_DIRECTORY directory_for_search)

if(WIN32)
  #- Get all files from the given directory
  file(GLOB FILES_TO_LINK ${directory_for_search}/bin/*.dll ${directory_for_search}/bin/*.exe)

  #- Loop over all files
  foreach(file_and_path_to_link ${FILES_TO_LINK})

     #- Get the file name from the complete path
     get_filename_component(file_to_link ${file_and_path_to_link} NAME)

     #- convert the path into an operating system depending format
     file(TO_NATIVE_PATH ${file_and_path_to_link} native_file_and_path_to_link)

     #- create the link
     if(EXISTS "${PROJECT_BINARY_DIR}/Debug/bin/${file_to_link}")
     file(REMOVE "${PROJECT_BINARY_DIR}/Debug/bin/${file_to_link}")
     endif()
     execute_process( WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/Debug/bin
                      COMMAND cmd.exe /c mklink "${file_to_link}" "${native_file_and_path_to_link}"
                      OUTPUT_QUIET)

     #- create the link
     if(EXISTS "${PROJECT_BINARY_DIR}/Release/bin/${file_to_link}")
     file(REMOVE "${PROJECT_BINARY_DIR}/Release/bin/${file_to_link}")
     endif()
     execute_process( WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/Release/bin
                      COMMAND cmd.exe /c mklink "${file_to_link}" "${native_file_and_path_to_link}"
                      OUTPUT_QUIET)

  endforeach()

endif()

endmacro()

#//////////////////////////////////////////////////////////////////////
macro(TSEP_USE_GOOGLE_TESTING)

  message(" Enabling the Google Test Framework ")

  enable_testing()

if(WIN32)
  set(GTEST_ROOT ${TSEP_PROJECT_GOOGLE.TEST}/${TSEP_CMAKE_GENERATOR}) # <- Working hand-in-hand with the google export!
endif()

  find_package(GTest REQUIRED)

if(WIN32)
  TSEP_CREATE_LINK_FOR_DIRECTORY(${TSEP_PROJECT_GOOGLE.TEST}/${TSEP_CMAKE_GENERATOR})
endif()

endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_CREATE_EXPORT)

  #- Only for developer build
  if(NOT TSEP_PRODUCT_BUILD)

    message(" Generating custom action to export files for project / " ${PROJECT_NAME})

    install(TARGETS ${PROJECT_NAME}
        EXPORT ${MAIN_PROJECT_NAME}Config
        RUNTIME DESTINATION bin/${TSEP_CMAKE_GENERATOR}
        LIBRARY DESTINATION bin/${TSEP_CMAKE_GENERATOR}
        ARCHIVE DESTINATION bin/${TSEP_CMAKE_GENERATOR}
        PUBLIC_HEADER DESTINATION inc
        )

    if (WIN32 AND NOT ${ARGC})
	   install (FILES $<TARGET_PDB_FILE:${PROJECT_NAME}> DESTINATION bin/${TSEP_CMAKE_GENERATOR} OPTIONAL)
    endif()

    install(EXPORT ${MAIN_PROJECT_NAME}Config
        DESTINATION bin/${TSEP_CMAKE_GENERATOR}/cmake
        NAMESPACE Tsep::
        )
  endif()
endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_PROVIDE_UNITTEST_FILES TestFileList)

message(" Generating custom action to provide the test file in the tmp directory / " ${PROJECT_NAME})

if (WIN32)
  file(TO_NATIVE_PATH $ENV{TMP}/${PROJECT_NAME} DEST_DIR)
else()
  file(TO_NATIVE_PATH /tmp/${PROJECT_NAME} DEST_DIR)
endif()

#- Add pre-link step to the copy the source files
add_custom_command(TARGET ${PROJECT_NAME}
                   DEPENDS ${TestFileList}
                   COMMENT "Provide Unit Test Files..."
                   POST_BUILD
                   VERBATIM
                   WORKING_DIRECTORY
                   COMMAND_EXPAND_LISTS
                   COMMAND ${CMAKE_COMMAND} -E remove_directory ${DEST_DIR}
                   COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
                   COMMAND ${CMAKE_COMMAND} -E copy_if_different ${TestFileList} ${DEST_DIR}
)

endmacro()


#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_PROVIDE_APPLICATION_DATA_FILES ApplicationName AppDataFileList)

message(" Generating custom action to provide the application data file in the application data directory / " ${ApplicationName})

# Calculate the length of the loop
list(LENGTH ${AppDataFileList} len1)
math(EXPR len2 "${len1} / 2")

# Loop over the array
foreach(val RANGE 0 ${len2} 2)
  # Calculate the next idx
  math(EXPR valN "${val} + 1")

  # Get the items
  list(GET ${AppDataFileList} ${val} SubFolder)
  list(GET ${AppDataFileList} ${valN} FileName)

  # Do copy
  if("${SubFolder}" STREQUAL "")
	  TSEP_PROVIDE_APPLICATION_DATA_FILES_IN_ROOTFOLDER(${ApplicationName} ${FileName})
	else()
    TSEP_PROVIDE_APPLICATION_DATA_FILES_IN_SUBFOLDER(${ApplicationName} ${SubFolder} ${FileName})
 	endif()

#  message(STATUS "${val1}  ${val2}")
endforeach()

endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_PROVIDE_APPLICATION_DATA_FILES_IN_ROOTFOLDER ApplicationName AppDataFile)

message(" Generating custom action to provide the application data file -> ${AppDataFile}")

if (WIN32)
  file(TO_NATIVE_PATH $ENV{PROGRAMDATA}/Tsep/${ApplicationName} DEST_DIR)
else()
  file(TO_NATIVE_PATH $ENV{HOME}/.local/share DEST_DIR)
endif()

#- Add pre-link step to the copy the source files
add_custom_command(TARGET ${PROJECT_NAME}
                   DEPENDS ${AppDataFileList}
                   POST_BUILD
                   VERBATIM
                   WORKING_DIRECTORY
                   COMMAND_EXPAND_LISTS
                   COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
                   COMMAND ${CMAKE_COMMAND} -E copy_if_different ${AppDataFile} ${DEST_DIR}
)

endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
macro(TSEP_PROVIDE_APPLICATION_DATA_FILES_IN_SUBFOLDER ApplicationName SubFolder AppDataFile)

message(" Generating custom action to provide the application data file in folder ${SubFolder} -> ${AppDataFile}")

if (WIN32)
  file(TO_NATIVE_PATH $ENV{PROGRAMDATA}/Tsep/${ApplicationName}/${SubFolder} DEST_DIR)
else()
  file(TO_NATIVE_PATH $ENV{HOME}/.local/share/${SubFolder} DEST_DIR)
endif()

#- Add pre-link step to the copy the source files
add_custom_command(TARGET ${PROJECT_NAME}
                   DEPENDS ${AppDataFileList}
                   POST_BUILD
                   VERBATIM
                   WORKING_DIRECTORY
                   COMMAND_EXPAND_LISTS
                   COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
                   COMMAND ${CMAKE_COMMAND} -E copy_if_different ${AppDataFile} ${DEST_DIR}
)

endmacro()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_GENERATE_DEPENDENCY_LINKS)
  message(" Generating executable links for all dependencies")
  
  # Generate the link only if we are in developer mode
  if(NOT TSEP_PRODUCT_BUILD)
     # Debug ----------------------------------------------------------------------------------------
     TSEP_GENERATE_DEPENDENCY_LINKS_FOR_CONFIGURATION(Debug)
     TSEP_GENERATE_ADDED_DEPENDENCY_LINKS_FOR_CONFIGURATION(Debug)
  
     # Release ----------------------------------------------------------------------------------------
     TSEP_GENERATE_DEPENDENCY_LINKS_FOR_CONFIGURATION(Release)
     TSEP_GENERATE_ADDED_DEPENDENCY_LINKS_FOR_CONFIGURATION(Release)
  endif()
endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_GENERATE_DEPENDENCY_LINKS_FOR_CONFIGURATION)
  
  get_target_property(ExecutableLinks ${PROJECT_NAME} LINK_LIBRARIES)
  set (CONTAINS_QT_PROJECT_GLOBAL FALSE)
  
  # For all files --------------------------------------------------------------------------------
  foreach (Executable ${ExecutableLinks})
    set (CONTAINS_QT_PROJECT FALSE)
    set (CONTAINS_SSL_PROJECT FALSE)
    set (CONTAINS_CRYPTO_PROJECT FALSE)
    set (CONTAINS_TSEP_PROJECT FALSE)
  
    string(FIND ${Executable} "Tsep::" TsepExecutable)
    if (TsepExecutable GREATER -1)
        set (CONTAINS_TSEP_PROJECT TRUE)
      endif()
    if(WIN32)
      string(FIND ${Executable} "Qt5::" QtExecutable)
      if (QtExecutable GREATER -1)
        set (CONTAINS_QT_PROJECT TRUE)
        set (CONTAINS_QT_PROJECT_GLOBAL TRUE)
      endif()
      string(FIND ${Executable} "OpenSSL::SSL" OpenSslExecutable)
      if (OpenSslExecutable GREATER -1)
        set (CONTAINS_SSL_PROJECT TRUE)
      endif()
      string(FIND ${Executable} "OpenSSL::Crypto" OpenSslExecutable)
      if (OpenSslExecutable GREATER -1)
        set (CONTAINS_CRYPTO_PROJECT TRUE)
      endif()
    endif()
  
    if(CONTAINS_TSEP_PROJECT OR CONTAINS_QT_PROJECT OR CONTAINS_SSL_PROJECT OR CONTAINS_CRYPTO_PROJECT)
      # at the moment not needed for linux
      if(WIN32)
        if(CONTAINS_SSL_PROJECT)
          set(LinkFile ${OPENSSL_ROOT_DIR}/bin/libssl-1_1-x64.dll)
        elseif(CONTAINS_CRYPTO_PROJECT)
          set(LinkFile ${OPENSSL_ROOT_DIR}/bin/libcrypto-1_1-x64.dll)
        elseif (${ARGV0} STREQUAL Debug)
          get_target_property(LinkFile ${Executable} LOCATION_DEBUG)
        else()
          get_target_property(LinkFile ${Executable} LOCATION_RELEASE)
        endif()
  
        #- Get the file name from the complete path
        get_filename_component(LinkFileName ${LinkFile} NAME)
  
        #- convert the path into an operating system depending format
        file(TO_NATIVE_PATH ${LinkFile} LinkFileNative)
  
        #- remove the file if it exists
        if(EXISTS "${PROJECT_BINARY_DIR}/${ARGV0}/bin/${LinkFileName}")
          file(REMOVE "${PROJECT_BINARY_DIR}/${ARGV0}/bin/${LinkFileName}")
        endif()
  
        #- convert the path into an operating system depending format
        file(TO_NATIVE_PATH ${LinkFileName} LinkFileNameNative)
        execute_process( WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/${ARGV0}/bin
                                           COMMAND cmd.exe /c mklink "${LinkFileNameNative}" "${LinkFileNative}"
                                           OUTPUT_QUIET)
      endif()
    endif()
  endforeach()
  
  # Qt platforms and iconengines have special destination folders
  if(${CONTAINS_QT_PROJECT_GLOBAL})
    set(PLATFORMS_DIR ${Qt5_DIR}/../../../plugins/platforms)
    file(TO_NATIVE_PATH ${PLATFORMS_DIR} NATIVE_PLATFORMS_DIR)
    execute_process(WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/${ARGV0}/bin
                    COMMAND cmd.exe /c mklink /D platforms "${NATIVE_PLATFORMS_DIR}"
                    OUTPUT_QUIET)
  
    set(ICONENGINES_DIR ${Qt5_DIR}/../../../plugins/iconengines)
    file(TO_NATIVE_PATH ${ICONENGINES_DIR} NATIVE_ICONENGINES_DIR)
    execute_process(WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/${ARGV0}/bin
                    COMMAND cmd.exe /c mklink /D iconengines "${NATIVE_ICONENGINES_DIR}"
                    OUTPUT_QUIET)
  endif()
  
endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
# creates dependency links for dynamically loaded libraries under windows and extends the rpath under linux
function(TSEP_GENERATE_ADDED_DEPENDENCY_LINKS_FOR_CONFIGURATION)

get_target_property(ExecutableLinks ${PROJECT_NAME} MANUALLY_ADDED_DEPENDENCIES)

# For all files --------------------------------------------------------------------------------
foreach (Executable ${ExecutableLinks})
  set (CONTAINS_TSEP_PROJECT FALSE)

  string(FIND ${Executable} "Tsep::" TsepExecutable)
  if (TsepExecutable GREATER -1)
    set (CONTAINS_TSEP_PROJECT TRUE)
  endif()

  if(CONTAINS_TSEP_PROJECT)

    if (${ARGV0} STREQUAL Debug)
      get_target_property(LinkFile ${Executable} LOCATION_DEBUG)
    else()
      get_target_property(LinkFile ${Executable} LOCATION_RELEASE)
    endif()

    if(WIN32)
      #- Get the file name from the complete path
      get_filename_component(LinkFileName ${LinkFile} NAME)

      #- convert the path into an operating system depending format
      file(TO_NATIVE_PATH ${LinkFile} LinkFileNative)

      #- create the link

      #- remove the file if it exists
      if(EXISTS "${PROJECT_BINARY_DIR}/${ARGV0}/bin/${LinkFileName}")
        file(REMOVE "${PROJECT_BINARY_DIR}/${ARGV0}/bin/${LinkFileName}")
      endif()

      #- convert the path into an operating system depending format
      file(TO_NATIVE_PATH ${LinkFileName} LinkFileNameNative)
      execute_process( WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/${ARGV0}/bin
                                         COMMAND cmd.exe /c mklink "${LinkFileNameNative}" "${LinkFileNative}"
                                         OUTPUT_QUIET)
    else()
      #- Get the path of the file
      get_filename_component(LinkDirectoryName ${LinkFile} DIRECTORY)
      get_target_property(OLD_RPATH ${PROJECT_NAME} BUILD_RPATH)
      if (${OLD_PATH})
        set_property(TARGET ${PROJECT_NAME} PROPERTY BUILD_RPATH "${OLD_RPATH};${LinkDirectoryName}")
      else()
        set_property(TARGET ${PROJECT_NAME} PROPERTY BUILD_RPATH "$ORIGIN;${LinkDirectoryName}")
      endif()
    endif()

  endif()
endforeach()

endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_GENERATE_CUSTOM_DEPENDENCY_LINK)
message(" Generating executable links for all dependencies")

# Debug ----------------------------------------------------------------------------------------
TSEP_GENERATE_CUSTOM_DEPENDENCY_LINK_FOR_CONFIGURATION(Debug ${ARGV0} ${ARGV1})

# Release ----------------------------------------------------------------------------------------
TSEP_GENERATE_CUSTOM_DEPENDENCY_LINK_FOR_CONFIGURATION(Release ${ARGV0} ${ARGV1})

endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_GENERATE_CUSTOM_DEPENDENCY_LINK_FOR_CONFIGURATION)
  #- Get the file name from the complete path
  set(LinkFile ${ARGV1})
  get_filename_component(LinkFileName ${LinkFile} NAME)

  if(${ARGC} GREATER 2)
    set(LinkFileName ${ARGV2}/${LinkFileName})
    file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/${ARGV0}/bin/${ARGV2})
  endif()

  #- convert the path into an operating system depending format
  file(TO_NATIVE_PATH ${LinkFile} LinkFileNative)

  #- create the link
  if(WIN32)
    #- remove the file if it exists
    if(EXISTS "${PROJECT_BINARY_DIR}/${ARGV0}/bin/${LinkFileName}")
      file(REMOVE "${PROJECT_BINARY_DIR}/${ARGV0}/bin/${LinkFileName}")
    endif()

    #- convert the path into an operating system depending format
    file(TO_NATIVE_PATH ${LinkFileName} LinkFileNameNative)
    execute_process( WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/${ARGV0}/bin
                                       COMMAND cmd.exe /c mklink "${LinkFileNameNative}" "${LinkFileNative}"
                                       OUTPUT_QUIET)
  else()
    file(COPY ${LinkFile} DESTINATION ${PROJECT_BINARY_DIR}/bin/)
  endif()
endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_GENERATE_CUSTOM_DEPENDENCY_TARGET_LINK)
message(" Generating executable links for all dependencies")

# Debug ----------------------------------------------------------------------------------------
TSEP_GENERATE_CUSTOM_DEPENDENCY_TARGET_LINK_FOR_CONFIGURATION(Debug ${ARGV0} ${ARGV1})

# Release ----------------------------------------------------------------------------------------
TSEP_GENERATE_CUSTOM_DEPENDENCY_TARGET_LINK_FOR_CONFIGURATION(Release ${ARGV0} ${ARGV1})

endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_GENERATE_CUSTOM_DEPENDENCY_TARGET_LINK_FOR_CONFIGURATION)
  #- Get the file name from the complete path
  set(Executable ${ARGV1})

  if (${ARGV0} STREQUAL Debug)
      get_target_property(LinkFile ${Executable} LOCATION_DEBUG)
    else()
      get_target_property(LinkFile ${Executable} LOCATION_RELEASE)
    endif()

  get_filename_component(LinkFileName ${LinkFile} NAME)

  if(${ARGC} GREATER 2)
    set(LinkFileName ${ARGV2}/${LinkFileName})
    file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/${ARGV0}/bin/${ARGV2})
  endif()

  #- create the link
  if(WIN32)
    #- convert the path into an operating system depending format
    file(TO_NATIVE_PATH ${LinkFile} LinkFileNative)

    #- remove the file if it exists
    if(EXISTS "${PROJECT_BINARY_DIR}/${ARGV0}/bin/${LinkFileName}")
      file(REMOVE "${PROJECT_BINARY_DIR}/${ARGV0}/bin/${LinkFileName}")
    endif()

    #- convert the path into an operating system depending format
    file(TO_NATIVE_PATH ${LinkFileName} LinkFileNameNative)
    execute_process( WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/${ARGV0}/bin
                                       COMMAND cmd.exe /c mklink "${LinkFileNameNative}" "${LinkFileNative}"
                                       OUTPUT_QUIET)
  else()
    message("${LinkFile} -> ${PROJECT_BINARY_DIR}/bin/${LinkFileName}")
    file(COPY ${LinkFile} DESTINATION ${PROJECT_BINARY_DIR}/bin/)
  endif()
endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_USE_CODE_ANALYSIS ProjectName)

if (WIN32)
  #- generate the poperty file only if it not exists
  if(NOT EXISTS "${PROJECT_BINARY_DIR}/${TSEP_VS_PROP_FILE}")
    message(" Create VS property sheet for code analysing for project / " ${ProjectName})

    set(TsepConfigPropFile ${TSEP_PROJECT_CMAKE}/${TSEP_CA_RULESET_DIR}/${TSEP_VS_PROP_FILE})
  file(TO_NATIVE_PATH ${TsepConfigPropFile} TsepConfigPropFileNative)

    set(TsepCAFile ${TSEP_PROJECT_CMAKE}/${TSEP_CA_RULESET_DIR}/${TSEP_CA_RULESET_FILE})
  file(TO_NATIVE_PATH ${TsepCAFile} TsepCAFileNative)

    # Copy the nuspec template file and configure it for the product
    configure_file(${TsepConfigPropFileNative} ${PROJECT_BINARY_DIR}/${TSEP_VS_PROP_FILE} @ONLY )

  endif()

  #- set the property
  set_target_properties(${ProjectName} PROPERTIES VS_USER_PROPS ../${TSEP_VS_PROP_FILE})

endif()

endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_ADD_AUTOBUILD_UNITTEST UnitExecutableName)
   get_property(local_prop GLOBAL PROPERTY TSEP_AUTOBUILD_UNITTEST)
   set(local_prop "${local_prop};${UnitExecutableName}")
   set_property(GLOBAL PROPERTY TSEP_AUTOBUILD_UNITTEST ${local_prop})
   #message("list " ${local_prop})
endfunction()

#/////////////////////////////////////////////////////////////////////////////////////////////////
function(TSEP_ADD_AUTOBUILD MainProjectName)

IF (INTIME)
   set(TSEP_AUTOBUILD_DIR "${PROJECT_BINARY_DIR}/../../AutoBuild/INtime")
elseif (WIN32)
   set(TSEP_AUTOBUILD_DIR "${PROJECT_BINARY_DIR}/../../AutoBuild/Windows")
elseif (LINUX)
   set(TSEP_AUTOBUILD_DIR "${PROJECT_BINARY_DIR}/../AutoBuild/linux")
endif()
   
   set(TSEP_AUTOBUILD_PROJECT ${MainProjectName})
   
   get_property(local_prop GLOBAL PROPERTY TSEP_AUTOBUILD_UNITTEST)
   
   message("-------------------------------------------------------")
   message(" Auto Build Solution name : " ${TSEP_AUTOBUILD_PROJECT})
   
   # Create the auto build directory
   message(" Prepare auto build dir    : " ${TSEP_AUTOBUILD_DIR})
   if(EXISTS ${TSEP_AUTOBUILD_DIR})
      file(REMOVE_RECURSE ${TSEP_AUTOBUILD_DIR})
   endif()
   file(MAKE_DIRECTORY ${TSEP_AUTOBUILD_DIR})
   file(MAKE_DIRECTORY ${TSEP_AUTOBUILD_DIR}/scripts)
   
   # Copy the files for the build, os dependend
   IF (INTIME)
      configure_file(${TSEP_PROJECT_CMAKE}/AutoBuild/BuildVs2017INtimeProject.cmd ${TSEP_AUTOBUILD_DIR}/scripts COPYONLY)
      foreach (TSEP_AUTOBUILD_UNIT_EXE ${local_prop})
         if("${TSEP_AUTOBUILD_USED_UNITTEST}" STREQUAL "") 
         	set(TSEP_AUTOBUILD_USED_UNITTEST "${TSEP_AUTOBUILD_UNIT_EXE}")
         else()
         	set(TSEP_AUTOBUILD_USED_UNITTEST "${TSEP_AUTOBUILD_USED_UNITTEST},${TSEP_AUTOBUILD_UNIT_EXE}")
         endif()
      endforeach()
      message(" Auto Build Unittest       : " ${TSEP_AUTOBUILD_USED_UNITTEST})
      configure_file(${TSEP_PROJECT_CMAKE}/AutoBuild/BuildAllVS2017INtime.cmd ${TSEP_AUTOBUILD_DIR}/BuildAll.cmd @ONLY)
   elseif (WIN32)
      set(TSEP_AUTOBUILD_USED_UNITTEST "")
      configure_file(${TSEP_PROJECT_CMAKE}/AutoBuild/BuildVS2017Project.cmd ${TSEP_AUTOBUILD_DIR}/scripts COPYONLY)
      foreach (TSEP_AUTOBUILD_UNIT_EXE ${local_prop})
         if("${TSEP_AUTOBUILD_USED_UNITTEST}" STREQUAL "") 
           set(TSEP_AUTOBUILD_USED_UNITTEST "${TSEP_AUTOBUILD_UNIT_EXE}")
         else()
           set(TSEP_AUTOBUILD_USED_UNITTEST "${TSEP_AUTOBUILD_USED_UNITTEST},${TSEP_AUTOBUILD_UNIT_EXE}")
         endif()
      endforeach()
      message(" Auto Build Unittest       : " ${TSEP_AUTOBUILD_USED_UNITTEST})
      configure_file(${TSEP_PROJECT_CMAKE}/AutoBuild/BuildAllVS2017.cmd ${TSEP_AUTOBUILD_DIR}/BuildAll.cmd @ONLY)
   elseif (LINUX)
      configure_file(${TSEP_PROJECT_CMAKE}/AutoBuild/BuildLinuxProject.sh ${TSEP_AUTOBUILD_DIR}/scripts COPYONLY)
      configure_file(${TSEP_PROJECT_CMAKE}/AutoBuild/RunUnitTest.sh ${TSEP_AUTOBUILD_DIR}/scripts COPYONLY)
      foreach (TSEP_AUTOBUILD_UNIT_EXE ${local_prop})
         if("${TSEP_AUTOBUILD_USED_UNITTEST}" STREQUAL "") 
           set(TSEP_AUTOBUILD_USED_UNITTEST "${TSEP_AUTOBUILD_UNIT_EXE}")
         else()
           set(TSEP_AUTOBUILD_USED_UNITTEST "${TSEP_AUTOBUILD_USED_UNITTEST},${TSEP_AUTOBUILD_UNIT_EXE}")
         endif()
      endforeach()
      message(" Auto Build Unittest       : " ${TSEP_AUTOBUILD_USED_UNITTEST})
      configure_file(${TSEP_PROJECT_CMAKE}/AutoBuild/BuildAllLinux.sh ${TSEP_AUTOBUILD_DIR}/BuildAll.sh @ONLY)
   endif()
 
endfunction()