cmake_minimum_required(VERSION 3.14)


# ******* MOUNT CONTROL COMPONENTS *******

project(mcc LANGUAGES C CXX Fortran VERSION 0.1)


# set(CMAKE_BUILD_TYPE Release)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")


# ******* LIBRARY OPTIONS *******

option(USE_SPDLOG "Use of SPDLOG library (add implementation of logger class based on this library)" ON)
option(USE_ERFA "Use of ERFA library (add implementation of CCTE based on this library)" ON)
option(USE_BSPLINE_PCM "Use of FITPACK bivariate splines for PCM" ON)


option(BUILD_TESTS "Build tests" ON)

find_package(Threads REQUIRED)

include(FetchContent)
include(ExternalProject)

# ******* SPDLOG LIBRARY *******

if (USE_SPDLOG)
    set(SPDLOG_USE_STD_FORMAT ON CACHE INTERNAL "Use of C++20 std::format")
    set(SPDLOG_FMT_EXTERNAL OFF CACHE INTERNAL "Turn off external fmt library")

    find_package(spdlog CONFIG)
    if (NOT ${spdlog_FOUND})
        FetchContent_Declare(spdlog
             GIT_REPOSITORY "https://github.com/gabime/spdlog.git"
             GIT_TAG "v1.15.1"
             GIT_SHALLOW TRUE
             GIT_SUBMODULES ""
             GIT_PROGRESS TRUE
             CMAKE_ARGS "-DSPDLOG_USE_STD_FORMAT=ON -DSPDLOG_FMT_EXTERNAL=OFF"
             OVERRIDE_FIND_PACKAGE
        )
        find_package(spdlog CONFIG)
    endif()
endif()

# ******* ERFA LIBRARY *******

find_program(MESON_PROG NAMES meson HINTS ENV PATHS)

if (NOT MESON_PROG)
    message(FATAL "meson executable can not be found!!!")
endif()

find_program(NINJA_PROG NAMES ninja ninja-build)

if (NOT NINJA_PROG)
    message(FATAL "ninja executable can not be found!!!")
endif()

find_package(PkgConfig REQUIRED)

pkg_check_modules(ERFALIB IMPORTED_TARGET GLOBAL erfa)

if (NOT ERFALIB_FOUND)
    message(STATUS "\tfetch erfa-lib ...")
    # ExternalProject_Add(erfalib
    #     PREFIX ${CMAKE_BINARY_DIR}/erfa_lib
    #     GIT_REPOSITORY "https://github.com/liberfa/erfa.git"
    #     GIT_TAG "v2.0.1"
    #     UPDATE_COMMAND ""
    #     PATCH_COMMAND ""
    #     LOG_CONFIGURE 1
    #     CONFIGURE_COMMAND meson setup --reconfigure -Ddefault_library=static -Dbuildtype=release
    #                               -Dprefix=${CMAKE_BINARY_DIR}/erfa_lib -Dlibdir= -Dincludedir= -Ddatadir= <SOURCE_DIR>
    #     BUILD_COMMAND ninja -C <BINARY_DIR>
    #     INSTALL_COMMAND meson install -C <BINARY_DIR>
    #     BUILD_BYPRODUCTS ${CMAKE_BINARY_DIR}/erfa_lib/liberfa.a
    # )

    # add_library(PkgConfig::ERFALIB STATIC IMPORTED GLOBAL)
    # set_target_properties(PkgConfig::ERFALIB PROPERTIES IMPORTED_LOCATION ${CMAKE_BINARY_DIR}/erfa_lib/liberfa.a)
    # set_target_properties(PkgConfig::ERFALIB PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_BINARY_DIR}/erfa_lib)
    # add_dependencies(PkgConfig::ERFALIB erfalib)

    # set(CACHE{ERFALIB_INCLUDE_DIRS} TYPE PATH VALUE "${CMAKE_BINARY_DIR}/erfa_lib")
    # set(CACHE{ERFALIB_LIBRARY_DIRS} TYPE PATH VALUE "${CMAKE_BINARY_DIR}/erfa_lib")
    # set(CACHE{ERFALIB_LIBRARIES} TYPE STRING VALUE "erfa;m")


    FetchContent_Declare(erfalib_project
        GIT_REPOSITORY "https://github.com/liberfa/erfa.git"
        GIT_TAG "v2.0.1"
        GIT_SHALLOW TRUE
        GIT_PROGRESS TRUE
    )

    FetchContent_MakeAvailable(erfalib_project)
    # message(STATUS "ERFA: ${erfalib_project_SOURCE_DIR}")

    message(STATUS "\tbuild erfa-lib ...")
    execute_process(
        COMMAND meson setup --reconfigure -Ddefault_library=static -Dbuildtype=release
                            -Dprefix=${CMAKE_BINARY_DIR}/erfa_lib -Dlibdir= -Dincludedir= -Ddatadir= ${CMAKE_BINARY_DIR}/erfa_lib ${erfalib_project_SOURCE_DIR}
    )

    execute_process(
        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/erfa_lib
        COMMAND ninja -C ${CMAKE_BINARY_DIR}/erfa_lib
    )

    execute_process(
        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/erfa_lib
        COMMAND meson install -C ${CMAKE_BINARY_DIR}/erfa_lib
    )

    set(ENV{PKG_CONFIG_PATH} "${CMAKE_BINARY_DIR}/erfa_lib/pkgconfig")
    pkg_check_modules(ERFALIB IMPORTED_TARGET GLOBAL erfa)
endif()


message(STATUS "ERFA LIBS: ${ERFALIB_LIBRARIES}")
message(STATUS "ERFA LIB PATHS: ${ERFALIB_LIBRARY_DIRS}")
message(STATUS "ERFA INC PATHS: ${ERFALIB_INCLUDE_DIRS}")


if (USE_BSPLINE_PCM)
    # fitpack by P. Dierckx
    add_subdirectory(fitpack)
endif()

set(MCC_SRC mcc_concepts.h mcc_constants.h mcc_epoch.h mcc_angle.h mcc_coordinate.h mcc_error.h
    mcc_traits.h mcc_utils.h mcc_ccte_iers.h mcc_ccte_iers_default.h mcc_ccte_erfa.h mcc_pzone.h
    mcc_pzone_container.h mcc_pcm.h mcc_telemetry.h mcc_serializer.h)

if (USE_SPDLOG)
    list(APPEND MCC_SRC mcc_spdlog.h)
endif()

add_library(${PROJECT_NAME} INTERFACE ${MCC_SRC})
target_compile_features(${PROJECT_NAME} INTERFACE cxx_std_23)
target_link_libraries(${PROJECT_NAME} INTERFACE PkgConfig::ERFALIB)
# target_link_libraries(${PROJECT_NAME} INTERFACE PkgConfig::ERFALIB fitpack)
target_include_directories(
    ${PROJECT_NAME}
    INTERFACE
    # $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR};${ERFALIB_INCLUDE_DIRS};${FITPACK_INCLUDE_DIR};>
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR};${ERFALIB_INCLUDE_DIRS};>
    $<INSTALL_INTERFACE:include/${PROJECT_NAME}>
)
if (USE_BSPLINE_PCM)
    target_compile_definitions(${PROJECT_NAME} INTERFACE USE_BSPLINE_PCM)
    target_link_libraries(${PROJECT_NAME} INTERFACE fitpack)
    # target_include_directories(
    #     ${PROJECT_NAME}
    #     INTERFACE
    #     $<BUILD_INTERFACE:${FITPACK_INCLUDE_DIR};>)
endif()

# get_target_property(ZZ ${PROJECT_NAME} INTERFACE_INCLUDE_DIRECTORIES)

# message(STATUS "INT: ${ZZ}")



# add_executable(exe EXCLUDE_FROM_ALL main.cpp)
# target_link_libraries(exe PUBLIC ${PROJECT_NAME})

# get_target_property(ZZ exe INCLUDE_DIRECTORIES)

# message(STATUS "INT: ${ZZ_STRING}")


if (BUILD_TESTS)
    add_executable(mcc_telemetry_test tests/mcc_telemetry_test.cpp)
    target_link_libraries(mcc_telemetry_test PRIVATE ${PROJECT_NAME})

    add_executable(mcc_coord_test tests/mcc_coord_test.cpp)
    target_link_libraries(mcc_coord_test PRIVATE ${PROJECT_NAME})

    add_executable(mcc_pzone_test tests/mcc_pzone_test.cpp)
    target_link_libraries(mcc_pzone_test PRIVATE ${PROJECT_NAME})
else()
    # This is just a stub to allow access to the path and library settings for the ${PROJECT_NAME} target during development
    add_executable(just_stub EXCLUDE_FROM_ALL main.cpp)
    target_link_libraries(just_stub PUBLIC ${PROJECT_NAME})
endif()


include(CMakePackageConfigHelpers)
write_basic_package_version_file("${PROJECT_NAME}ConfigVersion.cmake"
                                 VERSION ${PROJECT_VERSION}
                                 COMPATIBILITY SameMajorVersion)


set(MCC_CONFIG_INSTALLDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} CACHE PATH "install path for generated library config files")
set(MCC_HEADERS_INSTALLDIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH "install path for headers")

configure_package_config_file("${PROJECT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in"
                              "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
                              INSTALL_DESTINATION
                              ${MCC_CONFIG_INSTALLDIR}
                              PATH_VARS MCC_HEADERS_INSTALLDIR)

#install(EXPORT ${PROJECT_NAME}_Targets FILE ${PROJECT_NAME}Targets.cmake NAMESPACE ${PROJECT_NAME_NAMESPACE}:: DESTINATION ${MCC_CONFIG_INSTALLDIR})
#install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake" DESTINATION ${MCC_CONFIG_INSTALLDIR})
#install(FILES ${MCC_SRC} DESTINATION include/${PROJECT_NAME})


# uninstall target
if(NOT TARGET uninstall)
    configure_file(
        "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
        "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
        IMMEDIATE @ONLY)

    add_custom_target(uninstall
        COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
endif()