#cmake minimal version
cmake_minimum_required (VERSION 3.15)

# get the current git commit id
execute_process(
    COMMAND git rev-parse --short=8 HEAD
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    OUTPUT_VARIABLE GIT_COMMIT_ID
    OUTPUT_STRIP_TRAILING_WHITESPACE
)

# get the current git tag
execute_process(
    COMMAND git describe --tags --always
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    OUTPUT_VARIABLE GIT_TAG
    OUTPUT_STRIP_TRAILING_WHITESPACE
)

project(calrt VERSION 0.7.6)

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.9")
    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF)
endif()

option(PLD_MODE "enable PLD mode specs" OFF)
option(EMU_MODE "enable Emulator mode specs" OFF)
option(BUILD_SHARED_LIBS "build shared lib" OFF)
option(BUILD_NATIVE_ARCH "optimization for the build machine CPU" OFF)
option(BUILD_RELEASE "building and package lib" OFF)

#c++ standard
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)

IF(NOT CMAKE_BUILD_TYPE)
  SET(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build Type" FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)
# Set a value type to properly display CMAKE_BUILD_TYPE on GUI if the
# value type is "UNINITIALIZED".
GET_PROPERTY(cached_type CACHE CMAKE_BUILD_TYPE PROPERTY TYPE)
IF("${cached_type}" STREQUAL "UNINITIALIZED")
  SET(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING "Build Type" FORCE)
ENDIF("${cached_type}" STREQUAL "UNINITIALIZED")
# Check the Build Type.
# Convert the CMAKE_BUILD_TYPE to uppercase to perform a case-insensitive comparison.
string(TOUPPER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_UPPER)
IF(NOT "${CMAKE_BUILD_TYPE_UPPER}"
       MATCHES "^(DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL|NONE)\$")
  MESSAGE(FATAL_ERROR
          "Unknown keyword for CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}\n"
          "Acceptable keywords: Debug, Release, RelWithDebInfo, MinSizeRel, None")
ENDIF(NOT "${CMAKE_BUILD_TYPE_UPPER}"
       MATCHES "^(DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL|NONE)\$")

set(CALRT_DRIVER_PATH ${CMAKE_CURRENT_SOURCE_DIR}/driver)
set(CALRT_INCLUDE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/include)
set(CALRT_INTERNAL_PATH ${CMAKE_CURRENT_SOURCE_DIR}/internal_common)

configure_file(
    ${CALRT_INTERNAL_PATH}/version.h.in
    ${CALRT_INTERNAL_PATH}/version.h
    @ONLY
)

include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/calrt_cfg.cmake)
include(GNUInstallDirs)

set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
find_library(ELF_LIB elf REQUIRED)

add_library(calrt ${CALRT_SRC_FILES})
if(PLD_MODE)
    message(STATUS "Build PLD mode")
    target_compile_definitions(calrt PRIVATE PLD)
elseif(EMU_MODE)
    message(STATUS "Build emulator mode")
    target_compile_definitions(calrt PUBLIC EMU_MODE)
endif()
target_compile_features(calrt PUBLIC cxx_std_17)
target_compile_definitions(calrt PRIVATE CALRT_VERSION_MAJOR=1 CALRT_VERSION_MINOR=0 CALRT_VERSION_PATCH=0)

if("${CMAKE_BUILD_TYPE_UPPER}" MATCHES "RELEASE")
    add_compile_definitions(RELRT)
    message(STATUS "Building in Release mode: Disable Debug Log")

    target_compile_options(calrt PRIVATE 
        -O3
        #-march=x86-64
        #-mtune=generic
        -fno-ipa-icf
        -fPIC
        -fno-semantic-interposition
        -fno-stack-protector
        -fno-asynchronous-unwind-tables
        -fno-plt
        -fvisibility=hidden 
        -fvisibility-inlines-hidden
        -fno-exceptions
        -ffunction-sections
        -fdata-sections
    )
    target_link_options(calrt PRIVATE
        -fno-ipa-icf 
        -Wl,-z,now
        -Wl,-z,relro
        -Wl,--as-needed
        -Wl,-O1
        -Wl,--gc-sections
    )
endif()

target_link_libraries(calrt PRIVATE 
    Threads::Threads
    # libusb_vendor
    ${ELF_LIB}
    rt # rt for shm_open
    dl
)

string(TOLOWER "${CMAKE_SYSTEM_NAME}" PLATFORM_OS)

if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64")
    message(STATUS "Build x86 ARCH")
    set(PLATFORM_ARCH "x86_64")
    if (BUILD_NATIVE_ARCH)
        target_compile_options(calrt PRIVATE
            -march=native
            -mtune=native
        )
    else()
        target_compile_options(calrt PRIVATE
            -march=x86-64
            -mtune=generic
        )
    endif()
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64")
    message(STATUS "Build arm ARCH")
    set(PLATFORM_ARCH "arm64")
    target_compile_options(calrt PRIVATE
        -march=armv8-a
    )
else()
    set(PLATFORM_ARCH "${CMAKE_SYSTEM_PROCESSOR}")
endif()

set_target_properties(calrt PROPERTIES
    OUTPUT_NAME "calrt-${PLATFORM_OS}-${PLATFORM_ARCH}"
    VERSION 0.7.6
    SOVERSION 1  # linux ABI stable usage. SONAME
    C_VISIBILITY_PRESET hidden
    CXX_VISIBILITY_PRESET hidden
    VISIBILITY_INLINES_HIDDEN ON
)

if(NOT BUILD_SHARED_LIBS)
    message(STATUS "Build static lib")
    set_target_properties(calrt PROPERTIES POSITION_INDEPENDENT_CODE ON) # add for linking to libggml-calrt.a
endif()

target_include_directories(calrt 
PUBLIC 
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/calrt>
PRIVATE
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/internal_common>
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/driver>
)
set_target_properties(calrt PROPERTIES EXPORT_NAME calrt)

add_library(calrt::calrt ALIAS calrt)

# CMake config files for find_package
include(CMakePackageConfigHelpers)

install(TARGETS calrt
        EXPORT calrtLibTargets
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/calrt
)

export(
    EXPORT calrtLibTargets
    NAMESPACE calrt::
    FILE "${CMAKE_CURRENT_BINARY_DIR}/calrtLibTargets.cmake"
)

write_basic_package_version_file(
    "${CMAKE_CURRENT_BINARY_DIR}/calrtConfigVersion.cmake"
    VERSION ${PROJECT_VERSION}
    COMPATIBILITY AnyNewerVersion
)

configure_package_config_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/Config.cmake.in
    ${CMAKE_CURRENT_BINARY_DIR}/calrtConfig.cmake
    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/calrt
)

#set(calr_DIR ${CMAKE_CURRENT_BINARY_DIR} PARENT_SCOPE)

install(EXPORT calrtLibTargets
        FILE calrtLibTargets.cmake
        NAMESPACE calrt::
        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/calrt
        COMPONENT calrt
)

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/calrtConfig.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/calrtConfigVersion.cmake"
    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/calrt
    COMPONENT calrt
)

if(BUILD_RELEASE)
    string(TIMESTAMP TODAY %Y%m%d)
    set(CPACK_GENERATOR "TGZ")
    set(CPACK_PACKAGE_NAME "libcalrt")
    set(CPACK_PACKAGE_FILE_NAME
        "libcalrt_${GIT_COMMIT_ID}_${TODAY}"
    )
    include(CPack)
endif(BUILD_RELEASE)