CMakeMM.cmake

include_guard(GLOBAL)

if(NOT COMMAND colors)
  # Colorize
  macro(colors)
    if(NOT WIN32)
      string(ASCII 27 Esc)
      set(Reset "${Esc}[m")
      set(BoldRed "${Esc}[1;31m")
      set(BoldMagenta "${Esc}[1;35m")
      set(BoldYellow "${Esc}[1;33m")
      set(BoldGreen "${Esc}[1;32m")
    endif()
  endmacro()
endif()

# Test if raw from github is available
macro(check_accessible)
  file(DOWNLOAD "https://raw.githubusercontent.com/TestingRepositories/Ping/master/Ping.cmake" "${CMAKE_CURRENT_BINARY_DIR}/Ping.cmake" STATUS PING_STATUS)
  list(GET PING_STATUS 0 PING_RC)
  list(GET PING_STATUS 1 PING_MSG)
  if(${PING_RC})
    set(IS_ONLINE_RAW FALSE)
    set(IS_OFFLINE_RAW TRUE)
  else()
    include(${CMAKE_CURRENT_BINARY_DIR}/Ping.cmake)
    if(${PING_RESPONSE} STREQUAL "Pong")
      set(IS_ONLINE_RAW TRUE)
      set(IS_OFFLINE_RAW FALSE)
    else()
      set(IS_ONLINE_RAW FALSE)
      set(IS_OFFLINE_RAW TRUE)
    endif()
    unset(PING_RESPONSE)
  endif()
endmacro()

# Do the update check.

function(cmmm_changes CHANGELOG_VERSION)
  if(${CMMM_VERSION} VERSION_LESS ${CHANGELOG_VERSION})
    message("${BoldYellow}             - Changes in ${CHANGELOG_VERSION} :${Reset}")
    foreach(CMMM_CHANGE IN LISTS ARGN)
      message("${BoldYellow}               - ${CMMM_CHANGE}${Reset}")
    endforeach()
  endif()
endfunction()

function(print_changelog)
  if(NOT ${CMMM_VERSION} STREQUAL "master" AND NOT ${CMMM_VERSION} STREQUAL "main")
    if(NOT ${CMMM_VERSION} STREQUAL ${CMMM_LATEST_VERSION})
      message("${BoldYellow}## [CMakeMM] Using CMakeMM version ${CMMM_VERSION}. The latest is ${CMMM_LATEST_VERSION}.${Reset}")
      message("${BoldYellow}             Changes since ${CMMM_VERSION} include the following :${Reset}")
      changelog()
      message("${BoldYellow}             To update, simply change the value of VERSION in cmmm function.${Reset}")
      message("${BoldYellow}             You can disable these messages by setting IGNORE_NEW_VERSION in cmmm function. ##${Reset}")
    endif()
  endif()
endfunction()

function(cmmm_check_updates)
  cmake_parse_arguments(CMMM "IGNORE_NEW_VERSION" "REPOSITORY" "" ${ARGN})
  
  if(NOT IS_ONLINE_RAW AND "${CMMM_PROVIDER}" STREQUAL "github")
    check_accessible()
    message("${BoldYellow}## [CMakeMM] https://raw.githubusercontent.com not accessible; Use https://cdn.jsdelivr.net ##${Reset}")
  endif()
  
  if("${IS_ONLINE_RAW}" STREQUAL "TRUE" AND "${CMMM_PROVIDER}" STREQUAL "github")
    set(CMMM_GIT_URL "https://raw.githubusercontent.com/${CMMM_REPOSITORY}/master")
  elseif("${IS_ONLINE_RAW}" STREQUAL "FALSE" AND "${CMMM_PROVIDER}" STREQUAL "github")
    set(CMMM_GIT_URL "https://cdn.jsdelivr.net/gh/${CMMM_REPOSITORY}@master")
  elseif("${CMMM_PROVIDER}" STREQUAL "gitlab")
    set(CMMM_GIT_URL "https://gitlab.com/${CMMM_REPOSITORY}/-/raw/master")
  elseif("${CMMM_PROVIDER}" STREQUAL "gitee")
    set(CMMM_GIT_URL "https://gitee.com/${CMMM_REPOSITORY}/raw/master")
  endif()
  
  # LatestVersion and Changelog must be up-to-date so must be in master
  set(CMMM_CHANGELOG_FILE "${CMMM_DESTINATION}/Changelog.cmake")
  set(CMMM_CHANGELOG_URL "${CMMM_GIT_URL}/Changelog.cmake")
  file(DOWNLOAD "${CMMM_CHANGELOG_URL}" "${CMMM_CHANGELOG_FILE}" STATUS CMMM_STATUS TIMEOUT ${CMMM_TIMEOUT} INACTIVITY_TIMEOUT ${CMMM_INACTIVITY_TIMEOUT})
  list(GET CMMM_STATUS 0 CMMM_RC)
  if(${CMMM_RC} EQUAL 0)
    include("${CMMM_CHANGELOG_FILE}")
    if(${CMMM_VERSION} VERSION_LESS ${CMMM_LATEST_VERSION})
      if(NOT ${CMMM_IGNORE_NEW_VERSION})
        print_changelog()
      endif()
    endif()
  else()
    message("${BoldYellow}** Error while downloading file ${CMMM_CHANGELOG_URL} **${Reset}")
  endif()
endfunction()

function(cmcm_module ARG_NAME)
  cmake_parse_arguments(ARG "" "REMOTE;LOCAL;VERSION" "ALSO" "${ARGV}")
  get_property(CMMM_NO_COLOR GLOBAL PROPERTY CMMM_NO_COLOR)
  if(NOT ${CMMM_NO_COLOR})
    colors()
  endif()
  if(NOT ARG_REMOTE AND NOT ARG_LOCAL)
    message("${BoldRed}!! [CMakeCM] Either LOCAL or REMOTE is required for cmmm_module !!${Reset}")
    message(FATAL_ERROR)
  endif()
  if(NOT ARG_VERSION)
    message("${BoldRed}!! [CMakeCM] Expected a VERSION for cmmm_module !!${Reset}")
    message(FATAL_ERROR)
  endif()
  file(MAKE_DIRECTORY "${CMMM_INSTALL_DESTINATION}")
  get_property(CMMM_URL_MODULES GLOBAL PROPERTY CMMM_URL_MODULES)
  if(ARG_REMOTE)
    file(WRITE "${CMMM_INSTALL_DESTINATION}/${ARG_NAME}" "cmmm_include_module([[${ARG_NAME}]] [[${ARG_REMOTE}]] [[${ARG_VERSION}]] [[${ARG_ALSO}]])\n")
  else()
    file(WRITE "${CMMM_INSTALL_DESTINATION}/${ARG_NAME}" "cmmm_include_module([[${ARG_NAME}]] [[${CMMM_URL_MODULES}/${ARG_LOCAL}]] [[${ARG_VERSION}]] [[${ARG_ALSO}]])\n")
  endif()
endfunction()

macro(cmmm_include_module MODULE_NAME MODULE_URL version also)
  get_property(CMMM_NO_COLOR GLOBAL PROPERTY CMMM_NO_COLOR)
  if(NOT ${CMMM_NO_COLOR})
    colors()
  endif()

  get_property(CMMM_INSTALL_DESTINATION GLOBAL PROPERTY CMMM_DESTINATION)
  get_property(CMMM_DESTINATION_MODULES GLOBAL PROPERTY CMMM_DESTINATION_MODULES)
  get_property(CMMM_URL_MODULES GLOBAL PROPERTY CMMM_URL_MODULES)

  get_filename_component(CMMM_RESOLVED_DIR "${CMMM_DESTINATION_MODULES}" ABSOLUTE)
  get_filename_component(CMMM_RESOLVED "${CMMM_RESOLVED_DIR}/${MODULE_NAME}" ABSOLUTE)
  get_filename_component(CMMM_RESOLVED_STAMP "${CMMM_INSTALL_DESTINATION}/${MODULE_NAME}.whence" ABSOLUTE)
  set(CMMM_WHENCE_STRING "${CMMM_URL_MODULES}::${MODULE_URL}.${version}")
  set(DOWNLOAD_MODULE FALSE)
  if(EXISTS "${CMMM_RESOLVED}")
    file(READ "${CMMM_RESOLVED_STAMP}" CMMM_STAMP)
    if(NOT CMMM_STAMP STREQUAL CMMM_WHENCE_STRING)
      set(DOWNLOAD_MODULE TRUE)
    endif()
  else()
    set(DOWNLOAD_MODULE TRUE)
  endif()
  if(DOWNLOAD_MODULE)
    file(MAKE_DIRECTORY "${CMMM_RESOLVED_DIR}")
    message("${BoldMagenta}-- [CMakeCM] Downloading new module ${MODULE_NAME} --${Reset}")
    file(DOWNLOAD "${MODULE_URL}" "${CMMM_RESOLVED}" STATUS DOWNLOAD_STATUS)
    list(GET DOWNLOAD_STATUS 0 CODE)
    list(GET DOWNLOAD_STATUS 1 MESSAGE)
    if(CODE)
      message("${BoldRed}!! [CMakeCM] Error while downloading file from '${MODULE_URL}' to '${CMMM_RESOLVED}' [${CODE}]: ${MESSAGE} !!${Reset}")
      message(FATAL_ERROR)
    endif()
    file(WRITE "${CMMM_RESOLVED_STAMP}" "${CMMM_WHENCE_STRING}")
  endif()
  include("${CMMM_RESOLVED}")
endmacro()

function(cmmm_modules_list)
  cmake_parse_arguments(CMMM "ALWAYS_DOWNLOAD" "URL;GIT_REPOSITORY;BRANCH;FOLDER;FILENAME;DESTINATION" "" "${ARGV}")

  get_property(CMMM_NO_COLOR GLOBAL PROPERTY CMMM_NO_COLOR)
  if(NOT ${CMMM_NO_COLOR})
    colors()
  endif()

  get_property(CMMM_INACTIVITY_TIMEOUT GLOBAL PROPERTY CMMM_INACTIVITY_TIMEOUT)
  get_property(CMMM_TIMEOUT GLOBAL PROPERTY CMMM_TIMEOUT)

  # Default modules list name
  if(NOT DEFINED CMMM_FILENAME)
    set(CMMM_FILENAME "ModulesList")
  endif()

  # Set default URL
  if(DEFINED CMMM_URL AND DEFINED CMMM_GIT_REPOSITORY)
    message("${BoldRed}!! [CMakeMM] URL and GIT_REPOSITORY can not appear at the same time !!${Reset}")
    message(FATAL_ERROR)
  elseif(NOT DEFINED CMMM_URL AND NOT DEFINED CMMM_GIT_REPOSITORY)
    message("${BoldRed}!! [CMakeMM] URL or GIT_REPOSITORY must be given !!${Reset}")
    message(FATAL_ERROR)
  endif()

  if(DEFINED CMMM_GIT_REPOSITORY)
    check_accessible()
    if(${IS_ONLINE_RAW})
      set(CMMM_URL "https://raw.githubusercontent.com/${CMMM_GIT_REPOSITORY}")
    else()
      set(CMMM_URL "https://cdn.jsdelivr.net/gh/${CMMM_GIT_REPOSITORY}")
    endif()
  endif()

  string(FIND ${CMMM_URL} "/" HAS_FLASH REVERSE)
  string(LENGTH ${CMMM_URL} CMMM_URL_LENGTH)
  math(EXPR HAS_FLASH_PLUS_ONE ${HAS_FLASH}+1)
  if(${HAS_FLASH_PLUS_ONE} STREQUAL ${CMMM_URL_LENGTH})
    string(SUBSTRING ${CMMM_URL} 0 ${HAS_FLASH} CMMM_URL)
  endif()

  if(DEFINED CMMM_GIT_REPOSITORY)
    if(NOT DEFINED CMMM_BRANCH)
      set(CMMM_BRANCH "master")
    endif()
    if(${IS_ONLINE_RAW})
      set(CMMM_URL "${CMMM_URL}/${CMMM_BRANCH}")
    else()
      set(CMMM_URL "${CMMM_URL}@${CMMM_BRANCH}")
    endif()
  endif()

  set_property(GLOBAL PROPERTY CMMM_URL_MODULES "${CMMM_URL}")

  get_property(CMMM_INSTALL_DESTINATION GLOBAL PROPERTY CMMM_DESTINATION)
  # Set default modules installation folders
  if(NOT DEFINED CMMM_DESTINATION)
    set(CMMM_DESTINATION_MODULES "${CMMM_INSTALL_DESTINATION}/Modules")
  else()
    get_filename_component(CMMM_DESTINATION_MODULES "${CMMM_DESTINATION}" ABSOLUTE BASE_DIR ${CMAKE_CURRENT_BINARY_DIR})
  endif()
  set_property(GLOBAL PROPERTY CMMM_DESTINATION_MODULES ${CMMM_DESTINATION_MODULES})

  if(NOT DEFINED CMMM_FOLDER)
    set(CMMM_COMPLET_URL "${CMMM_URL}")
  else()
    set(CMMM_COMPLET_URL "${CMMM_URL}/${CMMM_FOLDER}")
  endif()

  message("${BoldMagenta}-- [CMakeMM] Downloading ${CMMM_FILENAME}.cmake\n   From : ${CMMM_COMPLET_URL}/${CMMM_FILENAME}.cmake\n   To   : ${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}.cmake --${Reset}")

  file(DOWNLOAD "${CMMM_COMPLET_URL}/${CMMM_FILENAME}.cmake" "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}Temp.cmake" INACTIVITY_TIMEOUT ${CMMM_INACTIVITY_TIMEOUT} STATUS CMAKECM_STATUS TIMEOUT ${CMMM_TIMEOUT})
  list(GET CMAKECM_STATUS 0 CMAKECM_CODE)
  list(GET CMAKECM_STATUS 1 CMAKECM_MESSAGE)
  if(${CMAKECM_CODE})
    if(NOT EXISTS "${CMMM_DESTINATION_MODULES}/ModulesList.cmake")
      message("${BoldRed}!! [CMakeCM] Error downloading ${CMMM_FILENAME} : ${CMAKECM_MESSAGE} !!${Reset}")
      file(REMOVE "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}Temp.cmake")
      message(FATAL_ERROR)
    else()
      message("${BoldYellow}## [CMakeCM] Error downloading ${CMMM_FILENAME} : ${CMAKECM_MESSAGE} ##${Reset}")
      message("${BoldYellow}## [CMakeCM] Using the one already downloaded ##${Reset}")
      file(REMOVE "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}Temp.cmake")
      include("${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}.cmake")
    endif()
  elseif(${CMMM_ALWAYS_DOWNLOAD} OR NOT EXISTS "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}.cmake")
    file(RENAME "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}Temp.cmake" "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}.cmake")
    include("${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}.cmake")
  elseif(NOT ${CMMM_ALWAYS_DOWNLOAD})
    file(SHA256 "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}Temp.cmake" ModulesListTemp)
    file(SHA256 "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}.cmake" ModulesList)
    if(NOT ${ModulesListTemp} STREQUAL ${ModulesList})
      message("${BoldYellow}## [CMakeCM] ModulesList has been uploaded but ALWAYS_DOWNLOAD is set in cmmm_modules_list ##${Reset}")
    endif()
    file(REMOVE "${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}Temp.cmake")
    include("${CMMM_DESTINATION_MODULES}/${CMMM_FILENAME}.cmake")
  endif()

  message("${BoldGreen}** [CMakeCM] Modules will be installed in \"${CMMM_DESTINATION_MODULES}\" **${Reset}")
endfunction()

macro(cmmm_entry)
  cmake_parse_arguments(CMMM "ALWAYS_DOWNLOAD;NO_COLOR" "REPOSITORY;VERSION;DESTINATION;TIMEOUT;INACTIVITY_TIMEOUT;VERBOSITY;PROVIDER" "" ${ARGN})
  
  if(NOT ${CMMM_NO_COLOR})
    colors()
  endif()
  set_property(GLOBAL PROPERTY CMMM_NO_COLOR ${CMMM_NO_COLOR})

  list(
    INSERT
    VERBOSITY
    0
    "FATAL_ERROR"
    "SEND_ERROR"
    "WARNING"
    "AUTHOR_WARNING"
    "DEPRECATION"
    "NOTICE"
    "STATUS"
    "VERBOSE"
    "DEBUG"
    "TRACE"
    )

  if(DEFINED CMMM_VERBOSITY)
    list(FIND VERBOSITY ${CMMM_VERBOSITY} FOUND)
    if(${FOUND} STREQUAL "-1")
      message("${BoldYellow}## [CMakeMM] VERBOSITY ${CMMM_VERBOSITY} unknown. VERBOSITY set to STATUS. ##${Reset}")
      set(CMMM_VERBOSITY "STATUS")
    endif()
  elseif(DEFINED CMAKE_MESSAGE_LOG_LEVEL)
    list(FIND VERBOSITY ${CMAKE_MESSAGE_LOG_LEVEL} FOUND)
    if(${FOUND} STREQUAL "-1")
      message("${BoldYellow}## [CMakeMM] VERBOSITY ${CMAKE_MESSAGE_LOG_LEVEL} unknown. VERBOSITY set to STATUS. ##${Reset}")
      set(CMMM_VERBOSITY "STATUS")
    else()
      set(CMMM_VERBOSITY ${CMAKE_MESSAGE_LOG_LEVEL})
    endif()
  else()
    set(CMMM_VERBOSITY "STATUS")
  endif()
  set_property(GLOBAL PROPERTY CMMM_VERBOSITY ${CMMM_VERBOSITY})

  if(NOT DEFINED CMMM_TIMEOUT)
    set(CMMM_TIMEOUT 10)
  endif()
  set_property(GLOBAL PROPERTY CMMM_TIMEOUT ${CMMM_TIMEOUT})

  if(NOT DEFINED CMMM_INACTIVITY_TIMEOUT)
    set(CMMM_INACTIVITY_TIMEOUT 5)
  endif()
  set_property(GLOBAL PROPERTY CMMM_INACTIVITY_TIMEOUT ${CMMM_INACTIVITY_TIMEOUT})

  if(NOT DEFINED CMMM_DESTINATION)
    set(CMMM_DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/CMakeMM")
  else()
    get_filename_component(CMMM_DESTINATION "${CMMM_DESTINATION}" ABSOLUTE BASE_DIR ${CMAKE_CURRENT_BINARY_DIR})
  endif()

  set(CMMM_DESTINATION "${CMMM_DESTINATION}/${CMMM_VERSION}")
  set_property(GLOBAL PROPERTY CMMM_DESTINATION ${CMMM_DESTINATION})

  # add the CMakeMM installation directory to CMAKE_MODULE_PATH
  list(INSERT CMAKE_MODULE_PATH 0 "${CMMM_DESTINATION}")
  list(REMOVE_DUPLICATES CMAKE_MODULE_PATH)
  set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" PARENT_SCOPE)

  cmmm_check_updates(${ARGN})
endmacro()