# Build XTB as a static library using its native Makefile

#  Copyright (C) 2017 The authors of Py-ChemShell
#
#  This file is part of Py-ChemShell.
#
#  Py-ChemShell is free software: you can redistribute it and/or modify
#  it under the terms of the GNU Lesser General Public License as
#  published by the Free Software Foundation, either version 3 of the
#  License, or (at your option) any later version.
#
#  Py-ChemShell is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU Lesser General Public License for more details.
#
#  You should have received a copy of the GNU Lesser General Public
#  License along with Py-ChemShell.  If not, see
#  <http://www.gnu.org/licenses/>.

# you.lu@stfc.ac.uk
# June 2015
# updated Aug 2021 for XTB 5

# YL 09/11/2021: since CMake 3.12 MPI_ROOT will be used for searching
#                see details by: cmake --help-policy CMP0074
# but seems not effective to the XTB5 CMake
if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.12")
    cmake_policy(SET CMP0074 NEW)
endif()

find_package(Git REQUIRED)

# YL 10/02/2026: v6.7.1 has a serious bug in gradients which was fixed on fc512bbc;
#                but we need at least b9976c7 which fixed the ifx OpenMP issue in klopmanohno.f90
set(XTB_DEFAULT_VERSION b9976c7)
set(XTB_NAME xtb-6)

# paths
file(MAKE_DIRECTORY ${CHEMSH_BUILD_DIR}/lib/xtb)
set(CHEMSH_XTB_LIB_DIR ${CHEMSH_BUILD_DIR}/lib/xtb)
set(CHEMSH_XTB_MOD_DIR ${CHEMSH_BUILD_DIR}/modules/xtb)
include_directories(
                    ${CHEMSH_BUILD_DIR}/modules/parallel
                    ${CHEMSH_BUILD_DIR}/modules/dl_py2f)

# without XTB
if("${XTB}" STREQUAL "")
    # compile libxtb.so
    add_library(xtb SHARED xtb.f90 xtb_dummies.f90 ${NOTLINKED})
    target_link_libraries(xtb dl_py2f parallel)
    set_target_properties(xtb PROPERTIES LINK_FLAGS "${CHEMSH_LINK_FLAGS}")
    return()
endif()

if(NOT ${XTB} STREQUAL "")
    get_filename_component(XTB_ABSOLUTE ${XTB} ABSOLUTE)
endif()

# debug options
if(DEBUG)
    set(XTB_CMAKE_OPTIONS "")
else()
    set(XTB_CMAKE_OPTIONS --no-warn-unused-cli -Wno-dev)
endif()

# user specified dir or archive
if(EXISTS ${XTB_ABSOLUTE})
    # if is directory
    if(IS_DIRECTORY ${XTB_ABSOLUTE})
        set(XTB_DIR     ${XTB_ABSOLUTE})
    # if file (tarball)
    else()
        set(XTB_TARBALL  ${XTB_ABSOLUTE})
        set(XTB_DEST_DIR ${CMAKE_CURRENT_LIST_DIR}/${CHEMSH_ARCH}/src)
        set(XTB_DIR      ${XTB_DEST_DIR})
        # YL 02/10/2020: FetchContent is not available until CMake 3.11 (Ubuntu 18.04 comes with CMake 3.10 only)
        if(${CMAKE_VERSION} VERSION_LESS "3.11")
            include(${CHEMSH_DIR}/chemsh/utils/cmake/fetch_content.cmake)
        else()
            include(FetchContent)
        endif()
        FetchContent_Declare(
            xtb_source
            URL ${XTB_TARBALL}
        )
        FetchContent_GetProperties(xtb_source)
        if(NOT xtb_source_POPULATED)
            FetchContent_Populate(
                xtb_source
                URL          ${XTB_TARBALL}
                SOURCE_DIR   ${XTB_DEST_DIR}
                BINARY_DIR   ${CMAKE_CURRENT_LIST_DIR}/${CHEMSH_ARCH}/build
                SUBBUILD_DIR ${CMAKE_CURRENT_LIST_DIR}/${CHEMSH_ARCH}/subbuild
            )
        endif()
    endif()
    set(XTB_SRC_DIR ${XTB_DIR})
    set(XTB_GIT_REPO  "")

# Git
else()
    set(XTB_GIT_REPO  "${XTB}")
    set(XTB_DIR       ${CMAKE_CURRENT_LIST_DIR}/${CHEMSH_ARCH})
    set(XTB_BUILD_DIR ${CMAKE_CURRENT_LIST_DIR}/${CHEMSH_ARCH}/build)
    set(XTB_SRC_DIR   ${CMAKE_CURRENT_LIST_DIR}/src)
    if(EXISTS ${XTB_SRC_DIR}/source/xtb.F90 AND NOT ${XTB_RECOMPILE})
        set(XTB_GIT_REPO "")
    endif()
endif()

set(XTB_CMAKE_INSTALL_LIBDIR ${XTB_BUILD_DIR})

configure_file(xtb_interface.f90.in xtb_interface.f90 @ONLY)


# YL 22/12/2025: xtb does not yet support MPI parallelism
if(TRUE)
    message("${BoldWhite}XTB 5${EndColour} will be built with OpenMP support")

    set(XTB_Fortran_FLAGS "-fPIC ${CMAKE_Fortran_FLAGS}")

    set(XTB_CONFIGURE_COMMAND ${CMAKE_COMMAND} -S ${XTB_SRC_DIR} . -B ${XTB_BUILD_DIR}
                                               -DCMAKE_Fortran_COMPILER:STRING=${CMAKE_Fortran_COMPILER}
                                               -DCMAKE_Fortran_COMPILER_ID:STRING=${CMAKE_Fortran_COMPILER_ID}
                                               -DCMAKE_Fortran_COMPILER_VERSION:STRING=${CMAKE_Fortran_COMPILER_VERSION}
                                               -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
                                               -DCMAKE_C_STANDARD:STRING=17
                                               -DCMAKE_C_EXTENSIONS:BOOL=ON
                                               -DCMAKE_Fortran_FLAGS:STRING=${XTB_Fortran_FLAGS}
                                               -DCMAKE_Fortran_FLAGS_DEBUG="-g -O0 -traceback -check all -fpe0 -warn all"
                                               -DCMAKE_INSTALL_LIBDIR:PATH=${XTB_CMAKE_INSTALL_LIBDIR}
                                               -DCMAKE_BUILD_TYPE=Release
                                               -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=ON
                                               -DWITH_TBLITE:BOOL=OFF
                                               -DWITH_CPCMX:BOOL=OFF
                                               -DWITH_OBJECT:BOOL=OFF
                                               ${XTB_CMAKE_OPTIONS}
                                               )
endif()
    
# switch: recompile
set(XTB_CLEAN_COMMAND "")
set(XTB_BUILD_COMMAND ${CMAKE_COMMAND} --build ${XTB_BUILD_DIR})

# YL 08/02/2026: we have dropped TBLITE which could produce results different from XTB and cause confusion
set(XTB_LIB_DIRECTORY ${XTB_SRC_DIR}/${XTB_CMAKE_INSTALL_LIBDIR})
set(XTB_INSTALL_LIB_COMMAND ${CMAKE_COMMAND} -E copy ${XTB_CMAKE_INSTALL_LIBDIR}/libxtb.a ${CHEMSH_XTB_LIB_DIR}
                    COMMAND ${CMAKE_COMMAND} -E copy ${XTB_CMAKE_INSTALL_LIBDIR}/_deps/mctc-lib-build/libmctc-lib.a       ${CHEMSH_XTB_LIB_DIR}
#                    COMMAND ${CMAKE_COMMAND} -E copy ${XTB_CMAKE_INSTALL_LIBDIR}/_deps/dftd4-build/libdftd4.a             ${CHEMSH_XTB_LIB_DIR}
#                    COMMAND ${CMAKE_COMMAND} -E copy ${XTB_CMAKE_INSTALL_LIBDIR}/_deps/multicharge-build/libmulticharge.a ${CHEMSH_XTB_LIB_DIR}
#                    COMMAND ${CMAKE_COMMAND} -E copy ${XTB_CMAKE_INSTALL_LIBDIR}/_deps/s-dftd3-build/libs-dftd3.a         ${CHEMSH_XTB_LIB_DIR}
#                    COMMAND ${CMAKE_COMMAND} -E copy ${XTB_CMAKE_INSTALL_LIBDIR}/_deps/toml-f-build/libtoml-f.a           ${CHEMSH_XTB_LIB_DIR}
#                    COMMAND ${CMAKE_COMMAND} -E copy ${XTB_CMAKE_INSTALL_LIBDIR}/_deps/tblite-build/libtblite.a           ${CHEMSH_XTB_LIB_DIR})
)
#                    COMMAND ${CMAKE_COMMAND} -E copy ${XTB_CMAKE_INSTALL_LIBDIR}/libxtb.so.6.7.1 ${CHEMSH_XTB_LIB_DIR}
#                    COMMAND ${CMAKE_COMMAND} -E create_symlink ${CHEMSH_XTB_LIB_DIR}/libxtb.so.6.7.1 ${CHEMSH_XTB_LIB_DIR}/libxtb-6.7.1.so)
set(XTB_INSTALL_MOD_COMMAND ${CMAKE_COMMAND} -E copy_directory ${XTB_CMAKE_INSTALL_LIBDIR}/include ${CHEMSH_XTB_MOD_DIR})
#                    COMMAND ${CMAKE_COMMAND} -E copy_directory ${XTB_CMAKE_INSTALL_LIBDIR}/_deps/tblite-build/include ${CHEMSH_XTB_MOD_DIR})



if(${XTB_RECOMPILE})
    set(XTB_RECOMPILE 1)
    file(REMOVE_RECURSE ${CHEMSH_ARCH})
    # do not overwrite the downloaded source code by a new clone (default: OFF)
    if(RECOMPILE_WITHOUT_DOWNLOAD)
        set(XTB_GIT_REPO "")
    endif()
else()
    if(EXISTS ${CHEMSH_XTB_LIB_DIR}/libxtb.a)
        set(XTB_RECOMPILE 0)
        set(XTB_CLEAN_COMMAND       ${CMAKE_COMMAND} -E cmake_echo_color --switch=$(COLOR) --blue --bold "Found all required static libraries. Skipped cleaning step")
        set(XTB_BUILD_COMMAND       ${CMAKE_COMMAND} -E cmake_echo_color --switch=$(COLOR) --blue --bold "Skipped recompile step")
        set(XTB_CONFIGURE_COMMAND   ${CMAKE_COMMAND} -E cmake_echo_color --switch=$(COLOR) --blue --bold "Skipped configure step")
        set(XTB_INSTALL_MOD_COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --switch=$(COLOR) --blue --bold "")
        message("${BoldRed}XTB_RECOMPILE${EndColour} set ${BoldWhite}OFF${EndColour}: will not recompile XTB")
    else()
        set(XTB_RECOMPILE 1)
        file(REMOVE_RECURSE ${CHEMSH_ARCH}/stamp)
        message("${Green}XTB_RECOMPILE${EndColour} set ${BoldWhite}OFF${EndColour} but necessary static libraries missing under ${Yellow}${CHEMSH_XTB_LIB_DIR}${EndColour}: XTB source code will still be recompiled")
    endif()
endif()

include(ExternalProject)
# compile XTB as an external project using its original Makefile
ExternalProject_Add(
    ${XTB_NAME}
    GIT_REPOSITORY      ${XTB_GIT_REPO}
    GIT_SHALLOW         0
    GIT_PROGRESS        ${DEBUG}
#    GIT_PROGRESS        ${DEBUG}
    GIT_CONFIG          advice.detachedHead=false
    
    GIT_TAG             ${XTB_DEFAULT_VERSION}
    UPDATE_DISCONNECTED 1
    UPDATE_COMMAND      pwd
    PREFIX              ${CHEMSH_ARCH}
    STAMP_DIR           ${CHEMSH_ARCH}/stamp
    TMP_DIR             ${CHEMSH_ARCH}/tmp
    BUILD_ALWAYS        ${XTB_RECOMPILE}
    SOURCE_DIR          ${XTB_SRC_DIR}
    BINARY_DIR          ${XTB_DIR}/build
    CONFIGURE_COMMAND   ""
    BUILD_COMMAND       ${CMAKE_COMMAND} -E cmake_echo_color --switch=$(COLOR) --magenta --bold "Architecture for which '${XTB_NAME}' is built: '${CHEMSH_ARCH}'"
    INSTALL_COMMAND     ""
)

ExternalProject_Add_Step(
    ${XTB_NAME} XTB_CONFIGURE
    COMMENT           "Cleaning up previous binaries for '${XTB_NAME}'..."
    ALWAYS            ${XTB_RECOMPILE}
    DEPENDEES         configure
    COMMAND           ${XTB_CONFIGURE_COMMAND}
    WORKING_DIRECTORY ${XTB_SRC_DIR}
)

ExternalProject_Add_Step(
    ${XTB_NAME} XTB_HACK
    COMMENT           "Applying patches to ${XTB_SRC_DIR}..."
    ALWAYS            ${XTB_RECOMPILE}
    DEPENDEES         XTB_CONFIGURE
    # reset the source files to patch
    COMMAND           ${GIT_EXECUTABLE} -C ${XTB_SRC_DIR} checkout -- CMakeLists.txt src/scf_module.F90 src/api/environment.f90 src/api/calculator.f90
    # YL 27/12/2025: bug fix for Intel ifx (mdlst/mqlst pre-allocation) which hasn't been fixed in the upstream
    COMMAND           ${GIT_EXECUTABLE} -C ${XTB_SRC_DIR} apply ${CMAKE_CURRENT_LIST_DIR}/scf_module.F90.patch
    # YL 10/02/2026: bug fix for file descriptor leak in xtb C-API, see https://github.com/grimme-lab/xtb/issues/1388
    COMMAND           ${GIT_EXECUTABLE} -C ${XTB_SRC_DIR} apply ${CMAKE_CURRENT_LIST_DIR}/environment.f90.patch
    # YL 12/08/2026: added xtb_setBroydenDamping which is missing in the official C-API
    COMMAND           ${GIT_EXECUTABLE} -C ${XTB_SRC_DIR} apply ${CMAKE_CURRENT_LIST_DIR}/calculator.f90.patch
    # YL 13/02/2026: ifx throws out an ICE when compiling src/generate_wsc.f90
    #                see https://github.com/grimme-lab/xtb/issues/1390
    #                an ad hoc fix is to let ifx not compile this source file with OpenMP
    COMMAND           ${GIT_EXECUTABLE} -C ${XTB_SRC_DIR} apply ${CMAKE_CURRENT_LIST_DIR}/CMakeLists.txt.patch
    WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
)

ExternalProject_Add_Step(
    ${XTB_NAME} XTB_BUILD
    COMMENT           "Building static library for '${XTB_NAME}'..."
    ALWAYS            ${XTB_RECOMPILE}
    # always preceded by XTB_CONFIGURE
    DEPENDEES         XTB_HACK
    COMMAND           ${XTB_CLEAN_COMMAND} COMMAND ${XTB_BUILD_COMMAND}
    WORKING_DIRECTORY ${XTB_SRC_DIR}
)

ExternalProject_Add_Step(
    ${XTB_NAME} XTB_INSTALL
    COMMENT           "Installing static library to ${CHEMSH_XTB_LIB_DIR}"
    ALWAYS            1#${XTB_RECOMPILE}
    # always preceded by XTB_BUILD
    DEPENDEES         XTB_BUILD
    COMMAND           ${XTB_INSTALL_LIB_COMMAND} COMMAND ${XTB_INSTALL_MOD_COMMAND}
    WORKING_DIRECTORY ${XTB_SRC_DIR}
)


# ${XTB_SRC_DIR}/src/prog/argparser.f90
list(APPEND XTB_SOURCE_FILES ${XTB_SRC_DIR}/src/prog/argparser.f90
                             ${XTB_SRC_DIR}/src/prog/dock.f90
                             ${XTB_SRC_DIR}/src/prog/info.f90
                             ${XTB_SRC_DIR}/src/prog/irmod.f90
                             ${XTB_SRC_DIR}/src/prog/submodules.f90
                             ${XTB_SRC_DIR}/src/prog/thermo.f90
                             ${XTB_SRC_DIR}/src/prog/topology.f90
                             ${XTB_SRC_DIR}/src/prog/main.F90
    )

# compile libxtb.so (containing only Py-ChemShell interface files)
# YL 05/10/2021: the main routine file will be released with XTB 5 and renamed to 
add_library(xtb SHARED xtb.f90 xtb_interface.f90 ${LINKED})
#add_executable(xtb.x xtb_dummies.f90)

target_include_directories(xtb BEFORE PRIVATE ${XTB_SRC_DIR}
                                      PRIVATE ${CHEMSH_XTB_MOD_DIR})

# add_dependencies to make sure target_link_libraries is performed only after ExternalProject_Add_Step is finished
add_dependencies(xtb ${XTB_NAME} dl_py2f parallel)

set_target_properties(xtb PROPERTIES Fortran_MODULE_DIRECTORY ${CHEMSH_XTB_MOD_DIR})

find_package(OpenMP REQUIRED)

if(${CHEMSH_ARCH} STREQUAL "gnu")

    find_package(BLAS REQUIRED)
    find_package(LAPACK REQUIRED)

    target_compile_options(xtb PRIVATE -cpp -fopenmp)
    target_link_libraries(xtb PRIVATE dl_py2f parallel BLAS::BLAS LAPACK::LAPACK)

elseif(${CHEMSH_ARCH} STREQUAL "intel")

    target_compile_options(xtb PRIVATE -fpp -qopenmp -fpscomp logicals)

endif()

target_link_options(xtb PRIVATE "LINKER:--whole-archive")
target_link_options(xtb PRIVATE ${CHEMSH_XTB_LIB_DIR}/libxtb.a)
target_link_options(xtb PRIVATE ${CHEMSH_XTB_LIB_DIR}/libmctc-lib.a)
#target_link_options(xtb PRIVATE ${CHEMSH_XTB_LIB_DIR}/libdftd4.a)
#target_link_options(xtb PRIVATE ${CHEMSH_XTB_LIB_DIR}/libmulticharge.a)
#target_link_options(xtb PRIVATE ${CHEMSH_XTB_LIB_DIR}/libs-dftd3.a)
#target_link_options(xtb PRIVATE ${CHEMSH_XTB_LIB_DIR}/libtblite.a)
#target_link_options(xtb PRIVATE ${CHEMSH_XTB_LIB_DIR}/libtoml-f.a)
target_link_options(xtb PRIVATE "LINKER:--no-whole-archive")

target_link_libraries(xtb PRIVATE OpenMP::OpenMP_Fortran)
#if(${CHEMSH_ARCH} STREQUAL "gnu")
#elseif(${CHEMSH_ARCH} STREQUAL "cpe-gnu")
#elseif(${CHEMSH_ARCH} STREQUAL "intel")
#endif()

set_target_properties(xtb PROPERTIES LINK_FLAGS "-rdynamic -Wl,--export-dynamic                            \
                                                 -Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/export.map \
                                                ")

