# Build CP2K as a static library

#  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
# Jun 2015: original version

# RKV & TD: improved and maintained over time
# Apr 2026: YL rewritten for CP2K 2026.1 (CMake-based build)
# see CMakeLists.txt.OLD for the old version

# YL 10/04/2026: CP2K completely restructured it builder system using CMake
set(CP2K_LATEST_RELEASE_VERSION "2026.2")
# YL 11/04/2026: hardcoding might be better than auto-detecting with GLOB
# TD 25/08/2026: Supported GPUs should also be updated when updating the version
set(CP2K_DBCSR_VERSION    "2.10.0")
set(CP2K_LIBXC_VERSION    "7.0.0")
set(CP2K_LIBINT_VERSION   "v2.13.1-cp2k-lmax-5")
set(CP2K_FFTW_VERSION     "3.3.11")
set(CP2K_OPENBLAS_VERSION "0.3.33")
# TD 26/08/2026: Introduced in 2026.2
set(CP2K_LIBXS_VERSION    "1.0.0")

include(ExternalProject)

# paths
set(CHEMSH_CP2K_LIB_DIR     ${CHEMSH_BUILD_DIR}/lib/cp2k)
set(CHEMSH_CP2K_INCLUDE_DIR ${CHEMSH_BUILD_DIR}/include/cp2k)
file(MAKE_DIRECTORY ${CHEMSH_CP2K_LIB_DIR})
file(MAKE_DIRECTORY ${CHEMSH_CP2K_INCLUDE_DIR})
set(CMAKE_Fortran_MODULE_DIRECTORY ${CHEMSH_BUILD_DIR}/modules/cp2k)
include_directories(${CHEMSH_BUILD_DIR}/modules
                    ${CHEMSH_BUILD_DIR}/modules/parallel
                    ${CHEMSH_BUILD_DIR}/modules/dl_py2f)


# without CP2K
if("${CP2K}" STREQUAL "")
    add_library(cp2k SHARED cp2k.f90 cp2k_dummies.f90 ${NOTLINKED})
    target_link_libraries(cp2k dl_py2f parallel)
    set_target_properties(cp2k PROPERTIES LINK_FLAGS "${CHEMSH_LINK_FLAGS}")
    return()
endif()

# TD 16/04/2026: I think C++ compiler is mandatory
if("${CMAKE_CXX_COMPILER}" STREQUAL "")
    message(FATAL_ERROR "ChemShell: Please specify a C++ compiler via --cpc for compiling CP2K")
endif()


get_filename_component(CP2K_ABSOLUTE "${CP2K}" ABSOLUTE)

# ----------------------------------------------------------------------
# determine CP2K source directory
# ----------------------------------------------------------------------

# from user-specified location (directory or tarball)
if(EXISTS ${CP2K_ABSOLUTE})

    if(IS_DIRECTORY ${CP2K})
        set(CP2K_DIR     ${CP2K})
        set(CP2K_SRC_DIR ${CP2K_DIR}/src)
    else()
        set(CP2K_DIR     ${CMAKE_CURRENT_SOURCE_DIR})
        set(CP2K_SRC_DIR ${CP2K_DIR}/src)
    endif()
    set(CP2K_DATA_DIR ${CP2K_DIR}/data)

    # detect version from source
    if("${CP2K_VERSION}" STREQUAL "")
        file(READ ${CP2K_SRC_DIR}/cp2k_info.F CP2K_INFO LIMIT 3000)
        string(REGEX MATCH "cp2k_version = \"CP2K version [+-]?([0-9]*[.])?[0-9]+" CP2K_VERSION ${CP2K_INFO})
        string(REGEX MATCH "[+-]?([0-9]*[.])?[0-9]+$" CP2K_VERSION ${CP2K_VERSION})
    endif()
    set(CP2K_NAME cp2k-${CP2K_VERSION})

# from GitHub repository (default)
else()
    message("${BoldWhite}CP2K${EndColour} repository URL: ${CP2K}")
    set(CP2K_VERSION  ${CP2K_LATEST_RELEASE_VERSION})
    set(CP2K_NAME     cp2k-${CP2K_VERSION})
    set(CP2K_GIT      ON)
    set(CP2K_GIT_REPO ${CP2K})
    set(CP2K_GIT_TAG  "v${CP2K_VERSION}")
    set(CP2K_DIR      ${CMAKE_CURRENT_LIST_DIR}/${CHEMSH_ARCH}/src/${CP2K_NAME})
    set(CP2K_SRC_DIR  ${CP2K_DIR}/src)
    set(CP2K_DATA_DIR ${CP2K_DIR}/data)
endif()

message("CP2K ${CP2K_VERSION} will be compiled")

# CP2K 2026.1 requires CMake >= 3.24
include(pip)
pip_install("cmake>=3.24")

# YL 10/04/2026: CP2K uses a script to install dependencies
set(CP2K_TOOLCHAIN_DIR  ${CP2K_DIR}/tools/toolchain)
set(CP2K_TOOLCHAIN_INST ${CP2K_TOOLCHAIN_DIR}/install)
set(CP2K_CMAKE_BUILD_DIR ${CP2K_DIR}/build)

# toolchain options: common flags for all architectures
set(CP2K_TOOLCHAIN_FLAGS # YL 12/04/2026: use generic CPU target for portability (avoids Intel's -xHost which fails on AMD or in containers)
                         --target-cpu=generic
                         --with-libxc=install
                         --with-libint=install
                         --with-dbcsr=install
                         # disable everything else
                         --with-elpa=no
                         --with-cosma=no
                         --with-libxsmm=no
                         --with-spglib=no
                         --with-libvori=no
                         --with-plumed=no
                         --with-sirius=no
                         --with-gsl=no
                         --with-hdf5=no
                         --with-spfft=no
                         --with-spla=no
                         --with-libtorch=no
                         --with-trexio=no
                         --with-greenx=no
                         --with-dftd4=no
                         --with-tblite=no
                         --with-libsmeagol=no
                         --with-ace=no)

#compile with cuda
if(GPU OR GPU_COMPILER OR GPU_ARCH)
    if("${GPU_LANGUAGE}" STREQUAL "CUDA")
        set(CP2K_TOOLCHAIN_FLAGS  ${CP2K_TOOLCHAIN_FLAGS} "--enable-cuda")

        # TD 25/08/2026: These values are supported in CP2K 2026.2
        #                Values taken from tools/toolchain/install_cp2k_toolchain.sh
        set(ARCHLIST 35 37 60 70 80 86 90 100 121 K20X K40 K80 P100 V100 A100 A40 H100 GB10 B200)

        if(NOT("${GPU_ARCH}" STREQUAL "") AND (NOT("${GPU_ARCH}" IN_LIST ARCHLIST)) )
            message(WARNING "CUDA GPU_ARCH is not supported. Possible values are ${ARCHLIST}")

        elseif(NOT("${GPU_ARCH}" STREQUAL ""))
            if(${GPU_ARCH} STREQUAL 35)
                set(GPU_ARCHNAME "K40")
                set(GPU_ARCHNUM 35)
            elseif(${GPU_ARCH} STREQUAL 37)
                set(GPU_ARCHNAME "K80")
                set(GPU_ARCHNUM 37)
            elseif(${GPU_ARCH} STREQUAL 60)
                set(GPU_ARCHNAME "P100")
                set(GPU_ARCHNUM 60)
            elseif(${GPU_ARCH} STREQUAL 70)
                set(GPU_ARCHNAME "V100")
                set(GPU_ARCHNUM 70)
            elseif(${GPU_ARCH} STREQUAL 80)
                set(GPU_ARCHNAME "A100")
                set(GPU_ARCHNUM 80)
            elseif(${GPU_ARCH} STREQUAL 86)
                set(GPU_ARCHNAME "A40")
                set(GPU_ARCHNUM 86)
            elseif(${GPU_ARCH} STREQUAL 90)
                set(GPU_ARCHNAME "H100")
                set(GPU_ARCHNUM 90)
            elseif(${GPU_ARCH} STREQUAL 121)
                set(GPU_ARCHNAME "GB100")
                set(GPU_ARCHNUM 121)
            elseif(${GPU_ARCH} STREQUAL "K20X")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 35)
            elseif(${GPU_ARCH} STREQUAL "K40")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 35)
            elseif(${GPU_ARCH} STREQUAL "K80")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 37)
            elseif(${GPU_ARCH} STREQUAL "P100")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 60)
            elseif(${GPU_ARCH} STREQUAL "V100")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 70)
            elseif(${GPU_ARCH} STREQUAL "A100")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 80)
            elseif(${GPU_ARCH} STREQUAL "A40")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 86)
            elseif(${GPU_ARCH} STREQUAL "H100")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 90)
            elseif(${GPU_ARCH} STREQUAL "GB10")
                set(GPU_ARCHNAME ${GPU_ARCH})
                set(GPU_ARCHNUM 121)
            endif()
        else()
            message(FATAL_ERROR "A CUDA build has been requested but the GPU_ARCH has not been set")
        endif()

        set(CP2K_TOOLCHAIN_FLAGS ${CP2K_TOOLCHAIN_FLAGS} "--gpu-ver=${GPU_ARCHNAME}")
    endif()
endif()

# YL 10/04/2026: flags for Intel oneAPI
if(${CHEMSH_ARCH} STREQUAL "intel")
    # with MKL we don't need separate FFTW
    list(APPEND CP2K_TOOLCHAIN_FLAGS --with-intel=system
                                     --with-ifx=yes
                                     --with-mkl=system
                                     --with-fftw=no
                                     --with-openblas=no
                                     --with-scalapack=no)
    if(WITH_MPI)
        list(APPEND CP2K_TOOLCHAIN_FLAGS --with-intelmpi=system --with-openmpi=no)
        set(CP2K_CMAKE_MPI_FLAG -DCP2K_USE_MPI=ON)
    else()
        list(APPEND CP2K_TOOLCHAIN_FLAGS --mpi-mode=no --with-intelmpi=no --with-openmpi=no)
        # also prevent CP2K from detecting any system MPI installation (e.g., system OpenMPI interferes with LIBINT configure)
        # YL 12/04/2026: repatched non-MPI as -DCMAKE_DISABLE_FIND_PACKAGE_MPI=TRUE was overkill
        set(CP2K_CMAKE_MPI_FLAG -DCP2K_USE_MPI=OFF -DCMAKE_DISABLE_FIND_PACKAGE_MPI=TRUE)
    endif()
elseif(${CHEMSH_ARCH} STREQUAL "gnu")
    list(APPEND CP2K_TOOLCHAIN_FLAGS  --with-gcc=system
                                      --with-scalapack=system
                                      # YL 10/04/2026: CP2K needs an MPI-version of FFTW
                                      --with-fftw=install)
    # TD 14/08/2026: Check for OpenBLAS
    find_library(SYSTEM_OPENBLAS libopenblas.a)
    if(SYSTEM_OPENBLAS)
        list(APPEND CP2K_TOOLCHAIN_FLAGS --with-openblas=system)
    else()
        list(APPEND CP2K_TOOLCHAIN_FLAGS --with-openblas=install)
    endif()
    if(WITH_MPI)
        list(APPEND CP2K_TOOLCHAIN_FLAGS --with-openmpi=system)
        set(CP2K_CMAKE_MPI_FLAG -DCP2K_USE_MPI=ON)
    else()
        list(APPEND CP2K_TOOLCHAIN_FLAGS --mpi-mode=no --with-openmpi=no)
        # YL 12/04/2026: repatched non-MPI as -DCMAKE_DISABLE_FIND_PACKAGE_MPI=TRUE was overkill
        set(CP2K_CMAKE_MPI_FLAG -DCP2K_USE_MPI=OFF -DCMAKE_DISABLE_FIND_PACKAGE_MPI=TRUE)
    endif()
elseif(${CHEMSH_ARCH} STREQUAL "cpe-gnu")
    set(ENV{MPI_MODE} "mpich")
    # TD 29/04/2026: --enable-cray changes defaults (but doesn't link Cray BLAS correctly?)
    #                So still building openblas
    list(APPEND CP2K_TOOLCHAIN_FLAGS --with-gcc=system
                                     --enable-cray
                                     --with-openblas=install
                                     --with-fftw=system
			             --with-scalapack=system)
    if(WITH_MPI)
        set(CP2K_CMAKE_MPI_FLAG -DCP2K_USE_MPI=ON)
    else()
        list(APPEND CP2K_TOOLCHAIN_FLAGS --mpi-mode=no --with-mpi=no)
        # YL 12/04/2026: repatched non-MPI as -DCMAKE_DISABLE_FIND_PACKAGE_MPI=TRUE was overkill
        set(CP2K_CMAKE_MPI_FLAG -DCP2K_USE_MPI=OFF -DCMAKE_DISABLE_FIND_PACKAGE_MPI=TRUE)
    endif()
endif()

# TD 06/05/2026: Set linker flags on the basis of system options to toolchain script
# TD 24/08/2026: NB CP2K toolchain builds only support the following LAPACK/BLAS options: acml, cray, mkl, and openblas
# OpenBLAS flags
if(--with-openblas=system IN_LIST CP2K_TOOLCHAIN_FLAGS)
    # TD 24/08/2026: Avoid assumption that ChemShell is using OpenBLAS
    list(APPEND CHEMSH_CP2K_LINK_FLAGS ${SYSTEM_OPENBLAS})
elseif(--with-openblas=install IN_LIST CP2K_TOOLCHAIN_FLAGS)
    list(APPEND CP2K_TOOLCHAIN_LIBS ${CP2K_TOOLCHAIN_INST}/openblas-${CP2K_OPENBLAS_VERSION}/lib/libopenblas.a)
endif()
# ScaLAPACK flags
if(--with-scalapack=system IN_LIST CP2K_TOOLCHAIN_FLAGS)
    list(APPEND CHEMSH_CP2K_LINK_FLAGS ${CHEMSH_ScaLAPACK_FLAGS})
endif()
# FFTW flags
if(--with-fftw=system IN_LIST CP2K_TOOLCHAIN_FLAGS)
    list(APPEND CHEMSH_CP2K_LINK_FLAGS ${FFTW_COMPILE_FLAGS})
elseif(--with-fftw=install IN_LIST CP2K_TOOLCHAIN_FLAGS)
    if(WITH_MPI)
        set(CP2K_FFTW_SUFFIX _mpi)
    endif()
    list(APPEND CP2K_TOOLCHAIN_LIBS ${CP2K_TOOLCHAIN_INST}/fftw-${CP2K_FFTW_VERSION}/lib/libfftw3.a)
    list(APPEND CP2K_TOOLCHAIN_LIBS ${CP2K_TOOLCHAIN_INST}/fftw-${CP2K_FFTW_VERSION}/lib/libfftw3${CP2K_FFTW_SUFFIX}.a)
    list(APPEND CP2K_TOOLCHAIN_LIBS ${CP2K_TOOLCHAIN_INST}/fftw-${CP2K_FFTW_VERSION}/lib/libfftw3_omp.a)
    # YL 12/04/2026: 1) prepend the toolchain FFTW pkgconfig dir to PKG_CONFIG_PATH to override system libfftw3-dev
    #                2) use $ENV{FFTW3_ROOT} as a fallback for cp2k_set_default_paths which ignores -DCP2K_FFTW3_ROOT
    #                   as it rewrites CP2K_FFTW3_ROOT via PARENT_SCOPE
    list(APPEND CP2K_CONFIGURE_FLAGS "PKG_CONFIG_PATH=${CP2K_TOOLCHAIN_INST}/fftw-${CP2K_FFTW_VERSION}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}")
    list(APPEND CP2K_CONFIGURE_FLAGS "FFTW3_ROOT=${CP2K_TOOLCHAIN_INST}/fftw-${CP2K_FFTW_VERSION}")
endif()

# recompile
if(${CP2K_RECOMPILE})
    set(CP2K_NEEDS_RECOMPILE ON)
    # do not overwrite the downloaded source code by a new clone (default: OFF)
    if(RECOMPILE_WITHOUT_DOWNLOAD)
        set(CP2K_GIT_REPO "")
        file(REMOVE_RECURSE ${CHEMSH_ARCH}/stamp)
        file(REMOVE_RECURSE ${CP2K_CMAKE_BUILD_DIR})
    else()
        file(REMOVE_RECURSE ${CHEMSH_ARCH})
    endif()
else()
    if(EXISTS ${CHEMSH_CP2K_LIB_DIR}/libcp2k.a)
        set(CP2K_NEEDS_RECOMPILE OFF)
        message("${BoldRed}CP2K_RECOMPILE${EndColour} set to 0: CP2K source code will not be recompiled")
    else()
        set(CP2K_NEEDS_RECOMPILE ON)
        file(REMOVE_RECURSE ${CHEMSH_ARCH}/stamp)
        message("${BoldRed}CP2K_RECOMPILE${EndColour} set to 0 but ${CHEMSH_CP2K_LIB_DIR}/libcp2k.a not found: CP2K will still be recompiled")
    endif()
endif()

# build commands
if(CP2K_NEEDS_RECOMPILE)
    # step 0: patch toolchain bugs before running it
    # YL 12/04/2026: fix LIBINT's -loopopt sed pattern that misses -loopopt=N variant and causes linker error on some systems
    set(CP2K_CMAKE_PATCH_LIBINT_COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_LIST_DIR}/patch_libint.py
                                        ${CP2K_TOOLCHAIN_DIR}/scripts/stage3/install_libint.sh)

    # YL 13/04/2026: patch install_dbcsr.sh to pass MPI compiler wrappers explicitly to CMake to prevent CMake from finding system
    #                OpenMPI instead of Intel MPI when both are available (on some systems like SCARF)
    set(CP2K_CMAKE_PATCH_DBCSR_MPI_COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_LIST_DIR}/patch_dbcsr_mpi.py
                                           ${CP2K_TOOLCHAIN_DIR}/scripts/stage9/install_dbcsr.sh)
    # step 1: configure CP2K with CMake
    #         only enable the features that ChemShell actually needs
    # locate the pip-installed cmake binary
    # TD 06/05/2026: Moved this step up so that the pip cmake can be used by toolchain
    execute_process(COMMAND ${Python3_EXECUTABLE} -c "import cmake; print(cmake.CMAKE_DATA)"
                    OUTPUT_VARIABLE CP2K_CMAKE_DIR
                    OUTPUT_STRIP_TRAILING_WHITESPACE
                    ERROR_QUIET)
    set(CP2K_CMAKE_EXECUTABLE ${CP2K_CMAKE_DIR}/bin/cmake)
    list(APPEND CP2K_TOOLCHAIN_FLAGS --with-cmake=${CP2K_CMAKE_DIR})

    # step 2: run the toolchain to install dependencies (dbcsr, libxc, libint, fftw, etc.)
    # YL 12/04/2026: LIBXC doesn't allow CMake >= v3.5!
    # TD 13/08/2026: Should respect CHEMSH_MAKE_NJOBS
    set(CP2K_TOOLCHAIN_COMMAND ${CMAKE_COMMAND} -E env CMAKE_POLICY_VERSION_MINIMUM=3.5 bash install_cp2k_toolchain.sh -j ${CHEMSH_MAKE_NJOBS} ${CP2K_TOOLCHAIN_FLAGS})


    # patch DBCSR version file as there is a bug resulting in "2026.1.v2026.1v2026.1" instead of "2.9.0"
    set(CP2K_DBCSR_VERSION_FILE ${CP2K_TOOLCHAIN_INST}/dbcsr-${CP2K_DBCSR_VERSION}/lib/cmake/dbcsr/DBCSRConfigVersion.cmake)
    set(CP2K_CMAKE_PATCH_DBCSR_COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_LIST_DIR}/patch_dbcsr.py
                                       ${CP2K_DBCSR_VERSION_FILE}
                                       ${CP2K_VERSION}.v${CP2K_VERSION}v${CP2K_VERSION}
                                       ${CP2K_DBCSR_VERSION})

    # YL 12/04/2026: patch cmake/CompilerConfiguration.cmake to prevent the unconditional MPI::MPI_Fortran linking for non-MPI builds
    set(CP2K_CMAKE_PATCH_MPI_COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_LIST_DIR}/patch_mpi.py
                                     ${CP2K_DIR}/cmake/CompilerConfiguration.cmake)

    # YL 12/04/2026: patch cmake/modules/FindMKL.cmake to prevent linking ScaLAPACK/BLACS when MPI is disabled
    set(CP2K_CMAKE_PATCH_MKL_COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_LIST_DIR}/patch_mkl.py
                                     ${CP2K_DIR}/cmake/modules/FindMKL.cmake)

    # YL 12/04/2026: for some platforms pass user-provided ScaLAPACK flags (e.g., ./setup --scalapack_flags='-lscalapack')
    #                directly to CP2K's FindSCALAPACK to bypass its pkg-config detection which may fail
    if(WITH_MPI AND NOT "${ScaLAPACK_FLAGS}" STREQUAL "")
        set(CP2K_CMAKE_SCALAPACK_FLAG -DCP2K_SCALAPACK_LINK_LIBRARIES=${ScaLAPACK_FLAGS})
    else()
        set(CP2K_CMAKE_SCALAPACK_FLAG "")
    endif()

    # configure CP2K with CMake
    set(CP2K_CMAKE_CONFIGURE_COMMAND ${CMAKE_COMMAND} -E env
                                     ${CP2K_CONFIGURE_FLAGS}
                                     ${CP2K_CMAKE_EXECUTABLE} -S ${CP2K_DIR} -B ${CP2K_CMAKE_BUILD_DIR}
                                     -DBUILD_SHARED_LIBS=OFF
                                     ${CP2K_CMAKE_MPI_FLAG}
                                     ${CP2K_CMAKE_SCALAPACK_FLAG}
                                     -DCP2K_USE_LIBXC=ON
                                     -DCP2K_USE_LIBINT2=ON
                                     -DCP2K_USE_FFTW3=ON
                                     -DCP2K_DATA_DIR=${CP2K_DATA_DIR}
                                     -DDBCSR_DIR=${CP2K_TOOLCHAIN_INST}/dbcsr-${CP2K_DBCSR_VERSION}/lib/cmake/dbcsr
                                     -DLibxc_DIR=${CP2K_TOOLCHAIN_INST}/libxc-${CP2K_LIBXC_VERSION}/lib/cmake/Libxc
                                     -DCMAKE_PREFIX_PATH=${CP2K_TOOLCHAIN_INST}/libint-${CP2K_LIBINT_VERSION}
                                     -DCMAKE_Fortran_COMPILER=${CMAKE_Fortran_COMPILER}
                                     -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
                                     -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER})

    #Build with cuda
    if(GPU OR GPU_COMPILER OR GPU_ARCH)
        if("${GPU_LANGUAGE}" STREQUAL "CUDA")
            set(CP2K_CMAKE_CONFIGURE_COMMAND ${CP2K_CMAKE_CONFIGURE_COMMAND} -DCP2K_USE_ACCEL=CUDA -DCMAKE_CUDA_ARCHITECTURES=${GPU_ARCHNUM})
        endif()
    endif()

    # step 3: build (pure CMake command)
    set(CP2K_CMAKE_BUILD_COMMAND ${CP2K_CMAKE_EXECUTABLE} --build ${CP2K_CMAKE_BUILD_DIR} -j ${CHEMSH_MAKE_NJOBS} --target cp2k)

    # step 4: install libcp2k.a and module files to ChemShell build directory
    set(CP2K_INSTALL_COMMAND ${CMAKE_COMMAND} -E copy ${CP2K_CMAKE_BUILD_DIR}/lib/libcp2k.a ${CHEMSH_CP2K_LIB_DIR})
    set(CP2K_INSTALL_MODS_COMMAND ${CMAKE_COMMAND} -E copy_directory ${CP2K_CMAKE_BUILD_DIR}/src/mod_files ${CHEMSH_CP2K_INCLUDE_DIR})
else()
    set(CP2K_CMAKE_PATCH_LIBINT_COMMAND     "")
    set(CP2K_CMAKE_PATCH_DBCSR_MPI_COMMAND "")
    set(CP2K_TOOLCHAIN_COMMAND              "")
    set(CP2K_CMAKE_PATCH_DBCSR_COMMAND  "")
    set(CP2K_CMAKE_PATCH_MPI_COMMAND    "")
    set(CP2K_CMAKE_PATCH_MKL_COMMAND    "")
    set(CP2K_CMAKE_CONFIGURE_COMMAND    "")
    set(CP2K_CMAKE_BUILD_COMMAND        "")
    set(CP2K_INSTALL_COMMAND            "")
    set(CP2K_INSTALL_MODS_COMMAND       "")
endif()

# download and build CP2K as an external project
#recompile without download does not work with every version of cmake by setting giturl to sourcedir or empty; so adding this option.
if(NOT(CP2K_NEEDS_RECOMPILE) OR RECOMPILE_WITHOUT_DOWNLOAD)
ExternalProject_Add(
    ${CP2K_NAME}
    PREFIX              ${CHEMSH_ARCH}
    STAMP_DIR           ${CHEMSH_ARCH}/stamp
    TMP_DIR             ${CHEMSH_ARCH}/tmp
    BUILD_ALWAYS        ${CP2K_NEEDS_RECOMPILE}
    SOURCE_DIR          ${CP2K_DIR}
    CONFIGURE_COMMAND   ""
    BUILD_COMMAND       ${CMAKE_COMMAND} -E cmake_echo_color --switch=$(COLOR) --magenta --bold "Architecture for which '${CP2K_NAME}' is built: '${CHEMSH_ARCH}'"
    INSTALL_COMMAND     ""
)
else()
ExternalProject_Add(
    ${CP2K_NAME}
    GIT_REPOSITORY      ${CP2K_GIT_REPO}
    GIT_TAG             ${CP2K_GIT_TAG}
    GIT_SHALLOW         1
    GIT_PROGRESS        ${DEBUG}
    GIT_CONFIG          advice.detachedHead=false
    UPDATE_DISCONNECTED 1
    PREFIX              ${CHEMSH_ARCH}
    STAMP_DIR           ${CHEMSH_ARCH}/stamp
    TMP_DIR             ${CHEMSH_ARCH}/tmp
    BUILD_ALWAYS        ${CP2K_NEEDS_RECOMPILE}
    SOURCE_DIR          ${CP2K_DIR}
    CONFIGURE_COMMAND   ""
    BUILD_COMMAND       ${CMAKE_COMMAND} -E cmake_echo_color --switch=$(COLOR) --magenta --bold "Architecture for which '${CP2K_NAME}' is built: '${CHEMSH_ARCH}'"
    INSTALL_COMMAND     ""
)
endif()
ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_PATCH_TOOLCHAIN
    COMMENT           "Patching CP2K toolchain scripts..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         configure
    COMMAND           ${CP2K_CMAKE_PATCH_LIBINT_COMMAND}
    WORKING_DIRECTORY ${CP2K_DIR}
)

ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_PATCH_DBCSR_MPI
    COMMENT           "Patching DBCSR install script for MPI compiler hints..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         CP2K_PATCH_TOOLCHAIN
    COMMAND           ${CP2K_CMAKE_PATCH_DBCSR_MPI_COMMAND}
    WORKING_DIRECTORY ${CP2K_DIR}
)

ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_TOOLCHAIN
    COMMENT           "Running CP2K toolchain to install dependencies..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         CP2K_PATCH_DBCSR_MPI
    COMMAND           ${CP2K_TOOLCHAIN_COMMAND}
    WORKING_DIRECTORY ${CP2K_TOOLCHAIN_DIR}
)

ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_PATCH_DBCSR
    COMMENT           "Patching DBCSR version file..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         CP2K_TOOLCHAIN
    COMMAND           ${CP2K_CMAKE_PATCH_DBCSR_COMMAND}
    WORKING_DIRECTORY ${CP2K_DIR}
)

ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_PATCH_MPI
    COMMENT           "Patching CompilerConfiguration.cmake MPI::MPI_Fortran guard..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         CP2K_PATCH_DBCSR
    COMMAND           ${CP2K_CMAKE_PATCH_MPI_COMMAND}
    WORKING_DIRECTORY ${CP2K_DIR}
)

ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_PATCH_MKL
    COMMENT           "Patching FindMKL.cmake ScaLAPACK/BLACS guard..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         CP2K_PATCH_MPI
    COMMAND           ${CP2K_CMAKE_PATCH_MKL_COMMAND}
    WORKING_DIRECTORY ${CP2K_DIR}
)

ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_CMAKE_CONFIGURE
    COMMENT           "Configuring CP2K..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         CP2K_PATCH_MKL
    COMMAND           ${CP2K_CMAKE_CONFIGURE_COMMAND}
    WORKING_DIRECTORY ${CP2K_DIR}
)

ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_BUILD
    COMMENT           "Building static library for '${CP2K_NAME}'..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         CP2K_CMAKE_CONFIGURE
    COMMAND           ${CMAKE_COMMAND} -E cmake_echo_color --switch=$(COLOR) --white --bold "This may take a while. Please be patient..."
    COMMAND           ${CP2K_CMAKE_BUILD_COMMAND}
    WORKING_DIRECTORY ${CP2K_DIR}
)

ExternalProject_Add_Step(
    ${CP2K_NAME} CP2K_INSTALL
    COMMENT           "Installing CP2K static library and module files..."
    ALWAYS            ${CP2K_NEEDS_RECOMPILE}
    DEPENDEES         CP2K_BUILD
    COMMAND           ${CP2K_INSTALL_COMMAND}
    COMMAND           ${CP2K_INSTALL_MODS_COMMAND}
    WORKING_DIRECTORY ${CP2K_DIR}
)

# cp2k_base_uses.f90 is required by ChemShell's CP2K interface
add_custom_target(cp2k_base_uses)
add_custom_command(TARGET cp2k_base_uses PRE_BUILD
                   COMMAND ${CMAKE_COMMAND} -E copy ${CP2K_SRC_DIR}/base/base_uses.f90 ${CMAKE_CURRENT_LIST_DIR}/cp2k_base_uses.f90)

add_library(cp2k SHARED cp2k.f90 cp2k_routines.f90 ${LINKED})
add_dependencies(cp2k ${CP2K_NAME} cp2k_base_uses)
add_dependencies(cp2k_base_uses ${CP2K_NAME})

# link the static library against libcp2k.so
target_link_libraries(cp2k dl_py2f parallel)
target_link_libraries(cp2k ${BLAS_LIBRARIES} ${LAPACK_LIBRARIES})
target_link_directories(cp2k PUBLIC ${CHEMSH_CP2K_LIB_DIR})
if(GPU OR GPU_COMPILER OR GPU_ARCH)
    if("${GPU_LANGUAGE}" STREQUAL "CUDA")
        target_link_libraries(cp2k ${CUDA_LIBRARIES})
        set(CUDA_LINK_FLAGS "-lstdc++")
        set(CHEMSH_CP2K_LINK_FLAGS ${CHEMSH_CP2K_LINK_FLAGS} ${CUDA_LINK_FLAGS})
	#set_target_properties(cp2k PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
	#set_property(TARGET cp2k APPEND PROPERTY INSTALL_RPATH "${CUDAToolkit_LIBRARY_DIR}")
        #set_property(TARGET cp2k APPEND PROPERTY INSTALL_RPATH "${CUDAToolkit_LIBRARY_DIRS}")
    endif()
endif()

# include directories for module files from the CP2K CMake build
target_include_directories(cp2k PUBLIC ${CHEMSH_CP2K_INCLUDE_DIR})
include_directories(${CHEMSH_CP2K_INCLUDE_DIR})

if(${CHEMSH_ARCH} STREQUAL "intel")
    set_target_properties(cp2k PROPERTIES COMPILE_FLAGS "-fpp -qopenmp -D__SHORT_FILE__='\"cp2k_routines.f90\"'")
    list(APPEND CHEMSH_CP2K_LINK_FLAGS "-qopenmp")
elseif(${CHEMSH_ARCH} STREQUAL "gnu")
    set_target_properties(cp2k PROPERTIES COMPILE_FLAGS "-cpp -ffree-line-length-none -fopenmp -D__SHORT_FILE__='\"cp2k_routines.f90\"'")
    list(APPEND CHEMSH_CP2K_LINK_FLAGS "-fopenmp")
elseif(${CHEMSH_ARCH} STREQUAL "cpe-gnu")
    set_target_properties(cp2k PROPERTIES COMPILE_FLAGS "-cpp -ffree-line-length-none -fopenmp -D__SHORT_FILE__='\"cp2k_routines.f90\"'")
    list(APPEND CHEMSH_CP2K_LINK_FLAGS "-fopenmp")
endif()

# Flatten link flags
list(JOIN CHEMSH_CP2K_LINK_FLAGS " " CHEMSH_CP2K_LINK_FLAGS)
list(JOIN CP2K_TOOLCHAIN_LIBS " " CP2K_TOOLCHAIN_LIBS)

# linking Intel MKL
if(${CHEMSH_ARCH} STREQUAL "intel")
    set(CP2K_MATH_LINK_FLAGS "${CHEMSH_MKL_FLAGS}")
    if(WITH_MPI AND NOT "${CHEMSH_ScaLAPACK_FLAGS}" STREQUAL "")
        set(CP2K_MATH_LINK_FLAGS "${CHEMSH_ScaLAPACK_FLAGS}")
    endif()

    # link all CP2K and dependency static libraries into the shared library
    set_target_properties(cp2k PROPERTIES LINK_FLAGS "-Wl,--allow-multiple-definition      \
                                                      -Wl,--whole-archive                  \
                                                      ${CHEMSH_CP2K_LIB_DIR}/libcp2k.a     \
                                                      ${CP2K_TOOLCHAIN_INST}/dbcsr-${CP2K_DBCSR_VERSION}/lib/libdbcsr.a  \
                                                      ${CP2K_TOOLCHAIN_INST}/libxc-${CP2K_LIBXC_VERSION}/lib/libxcf03.a  \
                                                      ${CP2K_TOOLCHAIN_INST}/libxc-${CP2K_LIBXC_VERSION}/lib/libxc.a     \
                                                      ${CP2K_TOOLCHAIN_INST}/libint-${CP2K_LIBINT_VERSION}/lib/libint2.a \
                                                      ${CP2K_TOOLCHAIN_INST}/libxs-${CP2K_LIBXS_VERSION}/lib/libxs.a     \
                                                      ${CP2K_TOOLCHAIN_LIBS}               \
                                                      -Wl,--no-whole-archive               \
                                                      ${CP2K_MATH_LINK_FLAGS}              \
                                                      ${CHEMSH_CP2K_LINK_FLAGS}            \
                                                      -lstdc++                             \
                                                      -Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/export.map \
                                                      ${CHEMSH_LINK_FLAGS}")


elseif(${CHEMSH_ARCH} STREQUAL "gnu")

    # link all CP2K and dependency static libraries into the shared library
    set_target_properties(cp2k PROPERTIES LINK_FLAGS "-Wl,--allow-multiple-definition      \
                                                      -Wl,--whole-archive                  \
                                                      ${CHEMSH_CP2K_LIB_DIR}/libcp2k.a     \
                                                      ${CP2K_TOOLCHAIN_INST}/dbcsr-${CP2K_DBCSR_VERSION}/lib/libdbcsr.a  \
                                                      ${CP2K_TOOLCHAIN_INST}/libxc-${CP2K_LIBXC_VERSION}/lib/libxcf03.a  \
                                                      ${CP2K_TOOLCHAIN_INST}/libxc-${CP2K_LIBXC_VERSION}/lib/libxc.a     \
                                                      ${CP2K_TOOLCHAIN_INST}/libint-${CP2K_LIBINT_VERSION}/lib/libint2.a \
                                                      ${CP2K_TOOLCHAIN_INST}/libxs-${CP2K_LIBXS_VERSION}/lib/libxs.a     \
                                                      ${CP2K_TOOLCHAIN_LIBS}               \
                                                      -Wl,--no-whole-archive               \
                                                      ${CHEMSH_CP2K_LINK_FLAGS}            \
                                                      -lstdc++                             \
                                                      -Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/export.map \
                                                      ${CHEMSH_LINK_FLAGS}")


elseif(${CHEMSH_ARCH} STREQUAL "cpe-gnu")

    # link all CP2K and dependency static libraries into the shared library
    set_target_properties(cp2k PROPERTIES LINK_FLAGS "-Wl,--allow-multiple-definition      \
                                                      -Wl,--whole-archive                  \
                                                      ${CHEMSH_CP2K_LIB_DIR}/libcp2k.a     \
                                                      ${CP2K_TOOLCHAIN_INST}/dbcsr-${CP2K_DBCSR_VERSION}/lib/libdbcsr.a  \
                                                      ${CP2K_TOOLCHAIN_INST}/libxc-${CP2K_LIBXC_VERSION}/lib/libxcf03.a  \
                                                      ${CP2K_TOOLCHAIN_INST}/libxc-${CP2K_LIBXC_VERSION}/lib/libxc.a     \
                                                      ${CP2K_TOOLCHAIN_INST}/libint-${CP2K_LIBINT_VERSION}/lib/libint2.a \
                                                      ${CP2K_TOOLCHAIN_INST}/libxs-${CP2K_LIBXS_VERSION}/lib/libxs.a     \
                                                      ${CP2K_TOOLCHAIN_LIBS}               \
                                                      -Wl,--no-whole-archive               \
                                                      ${CHEMSH_CP2K_LINK_FLAGS}            \
                                                      -lstdc++                             \
                                                      -Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/export.map \
                                                      ${CHEMSH_LINK_FLAGS}")


endif()


