cmake_minimum_required(VERSION 3.13)
cmake_policy(SET CMP0048 NEW)
project(coot)
find_package(PkgConfig)

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

if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()

# C++20 is only used because newest versions of RDKit (March 2025 and newer) seems to require it
# Without RDKit, Coot currently needs C++17
set(CMAKE_CXX_STANDARD 20)

if (APPLE)
else()
   find_package(CCP4 REQUIRED ssm clipper-core clipper-ccp4 clipper-contrib clipper-minimol clipper-cif)
endif(APPLE)

find_package(BLAS)
find_package(GSL REQUIRED)
find_package(PNG REQUIRED)
find_package(GEMMI REQUIRED)
find_package(Threads REQUIRED)
find_package(Boost COMPONENTS iostreams regex thread serialization REQUIRED)
find_package(glm REQUIRED)
find_package(Doxygen REQUIRED)

set(THREADS_PREFER_PTHREAD_FLAG ON)

find_package(Python 3
  REQUIRED COMPONENTS Interpreter Development.Module
  OPTIONAL_COMPONENTS Development.SABIModule)

# Ask the installed nanobind for its own cmake directory. nanobind is noarch, so
# deriving the path from Python_STDLIB breaks where distros split arch/noarch dirs
# (e.g. Fedora: stdlib in /usr/lib64, but nanobind lands in /usr/lib). Querying the
# module returns the real location and keeps NB_DIR's relative layout (robin_map) intact.
if(NOT nanobind_DIR)
  execute_process(
    COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
    RESULT_VARIABLE _nanobind_query_result
    OUTPUT_VARIABLE _nanobind_cmake_dir
    OUTPUT_STRIP_TRAILING_WHITESPACE)
  if(_nanobind_query_result EQUAL 0 AND IS_DIRECTORY "${_nanobind_cmake_dir}")
    set(nanobind_DIR "${_nanobind_cmake_dir}")
  endif()
endif()
find_package(nanobind CONFIG REQUIRED)

# only via homebrew on macOS (not tried to compile them myself) - see below also though.
if (APPLE)
else()
   find_library(libelf elf)
   find_library(libdwarf dw)
endif(APPLE)

# From Charles
if (WIN32)
   string(REPLACE "\\" "/" Python_SITEARCH "${Python_SITEARCH}")
   string(REPLACE "\\" "/" Python_SITELIB  "${Python_SITELIB}")
endif(WIN32)

# Determine the install destination for Python files.
# - If the user set CMAKE_INSTALL_PREFIX explicitly, install relative to it.
# - Otherwise (default /usr/local), install directly to Python_SITELIB so that
#   venv builds land inside the venv rather than in /usr/local.
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
  set(Python_SITELIB_REL "${Python_SITELIB}")
else()
  set(Python_SITELIB_REL "lib/python${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}/site-packages")
endif()


set(coot_src ${CMAKE_CURRENT_SOURCE_DIR})

add_definitions(-DANALYSE_REFINEMENT_TIMING -DPACKAGE_VERSION="1.3.1"
  -DHAVE_CXX_THREAD -DHAVE_SSMLIB -DHAVE_BOOST -DUSE_LIBPNG=1 -DCLIPPER_HAS_TOP8000 -DUSE_GEMMI
  -DHAVE_BOOST_THREAD -DHAVE_GSL -DLIBCOOTAPI_BUILD
  -DPKGDATADIR="${CMAKE_INSTALL_PREFIX}/share/coot" -DXDATADIR="${CMAKE_INSTALL_PREFIX}/share")

# 20250314-PE: Charles, I guess that you will need to comment out this block
#
add_definitions(-DMAKE_ENHANCED_LIGAND_TOOLS="1")
message("-- Found ENHANCED_LIGAND_TOOLS setting - now requiring the RDKit")
find_package(Cairo REQUIRED)
# Boost::system is header-only since 1.69 but RDKit's cmake config references it as a target.
# Create it if missing (e.g. system Boost version mismatch with autobuild RDKit).
if(NOT TARGET Boost::system)
  add_library(Boost::system INTERFACE IMPORTED)
endif()
find_package(RDKit CONFIG COMPONENTS RDGeneral REQUIRED)
set(RDKit_libs_for_libcootapi RDKit::rdkit_base RDKit::Descriptors RDKit::DistGeomHelpers RDKit::PartialCharges RDKit::ForceFieldHelpers RDKit::ForceField RDKit::Optimizer RDKit::MolDraw2D  RDKit::MolChemicalFeatures)

# we can be on Apple, and also have access to homebrew dwarf and elf - but this typically not the case
# should this actually be ENABLE_BACKWARD? (util/backward.cpp is not conditionally compiled).
# This doesn't seem to wort at the moment though - maybe a  problem with libdwarf.
if (ENABLE_DWARF_ELF)
   find_library(libelf elf)
   find_library(libdwarf dw)
   add_definitions(-DBACKWARD_HAS_DW)
   message("-- Enabled dwarf and elf")
endif()

# OSPRay ray-tracing renderer for publication-quality image output.
# Use -DOSPRAY_PREFIX=/path/to/ospray to enable.
if (OSPRAY_PREFIX)
   list(APPEND CMAKE_PREFIX_PATH ${OSPRAY_PREFIX})
   find_package(ospray REQUIRED)
   add_definitions(-DHAVE_OSPRAY)
   message("-- Found OSPRay: ${OSPRAY_PREFIX}")
endif()

#  pyrogen, auxil, goograph, src ignored.

# gemmi-only MoleculesToTriangles library. The atom-identity token is
# const gemmi::Atom* throughout; the original mmdb-based .cpp files are
# deliberately NOT compiled here. Every mmdb-touching translation unit is
# replaced by its coot::m2t -gemmi twin; the remaining .cpp files are the
# mmdb-free geometry / rendering base classes that the twins rest on.
add_library(cootmoleculestotriangles SHARED
            # --- CXXSurface engine: gemmi twins ---
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXUtils-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXTriangle-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXTorusNode-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXSphereNode-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXSphereTriangleEdge-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXSphereTriangle-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXCircleNode-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXCircle-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXNewHood-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXBall-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXSphereElement-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXTorusElement-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXSurface-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXSurfaceMaker-gemmi.cc
            # --- CXXSurface: mmdb-free geometry support (no twin needed) ---
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXCoord.cpp
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXException.cpp
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXSurfaceVertex.cpp
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXVCN.cpp
            ${coot_src}/MoleculesToTriangles/CXXSurface/CXXChargeTable.cpp
            # --- CXXClasses: gemmi twins ---
            ${coot_src}/MoleculesToTriangles/CXXClasses/gemmi-selection.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/gemmi-bonds.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/gemmi-sse.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/MyMolecule-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/DishyBase-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/SolidColorRule-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/ColorScheme-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/DiscreteSegment-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/MolecularRepresentation-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/SurfacePrimitive-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/FlatFanPrimitive-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/CylindersPrimitive-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/SticksPrimitive-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/BoxSectionPrimitive-gemmi.cc
            # --- CXXClasses: mmdb-free rendering / geometry base classes ---
            ${coot_src}/MoleculesToTriangles/CXXClasses/BallsPrimitive.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/CXXMatrix.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/CylinderPoint.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/DirectedPositionedEntity.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/DisplayPrimitive.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/Light.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/LinesPrimitive.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/MolecularRepresentationInstance.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/NRStuff.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/oglPolyhedron.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/Polyhedron.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/PositionedEntity.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/Quaternion.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/Renderer.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/Representation.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/RepresentationInstance.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/RotatedTranslatedScaledEntity.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/SpherePrimitive.cpp
            # mmdb-free statics (knownColors, colorHexToColor) reused by SolidColorRule-gemmi.cc;
            # extracted from SolidColorRule.cpp so we don't drag in the mmdb-based CompoundSelection.
            ${coot_src}/MoleculesToTriangles/CXXClasses/SolidColorRule-statics-gemmi.cc
            ${coot_src}/MoleculesToTriangles/CXXClasses/Vector2.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/Vector3.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/VertexColorNormalPrimitive.cpp
            ${coot_src}/MoleculesToTriangles/CXXClasses/lfit.c
)


add_library(cootapi SHARED
            ${coot_src}/utils/coot-utils.cc
            ${coot_src}/utils/base64-encode-decode.cc
            ${coot_src}/utils/atomic-numbers.cc
            ${coot_src}/utils/backward.cpp
            ${coot_src}/utils/colour-holder.cc
            ${coot_src}/utils/coot-fasta.cc
            ${coot_src}/utils/coot-utils.cc
            ${coot_src}/utils/dodec.cc
            ${coot_src}/utils/radix.cc
            ${coot_src}/utils/gdk-keysyms.cc
            ${coot_src}/utils/hsv-rgb.cc
            ${coot_src}/utils/pir-alignment.cc
            ${coot_src}/utils/setup-syminfo.cc
            ${coot_src}/utils/split-indices.cc
            ${coot_src}/utils/logging.cc
            ${coot_src}/utils/static-logging.cc
            ${coot_src}/utils/threads.cc
            ${coot_src}/utils/win-compat.cc
            ${coot_src}/coot-utils/coot-coord-utils-gemmi.cc
            ${coot_src}/coot-utils/coot-coord-utils-mmdb-free.cc
            ${coot_src}/geometry/residue-and-atom-specs-gemmi.cc
            )

# wretched mae - 20 Sept 2025
# 2026-04-07-PE back again. Turn off (again, failed to resolve on Ubuntu GitHub action)
# find_library(MAEPARSER_LIBS maeparser)
# target_link_libraries(cootapi PRIVATE ${MAEPARSER_LIBS})
# wretched mae - fixed by Jordan?
find_library(MAEPARSER_LIBS maeparser)
if(MAEPARSER_LIBS)
    get_filename_component(MAEPARSER_DIR ${MAEPARSER_LIBS} DIRECTORY)
    target_link_directories(cootapi PUBLIC ${MAEPARSER_DIR})
    target_link_libraries(cootapi PUBLIC ${MAEPARSER_LIBS})
endif()

# --- Embedded API docstrings -------------------------------------------------
# Chain: doxygen (curated .cfg) -> XML -> coot-make-docstrings -> generated .cc,
# which is compiled into the coot_headless_api module so the docstrings are
# available at runtime even when the source tree has been removed. Everything
# lives in the build tree; the source-code build only needs the XML, not
# sphinx/breathe/HTML.
set(COOT_DOCSTRINGS_GENERATED ${CMAKE_CURRENT_BINARY_DIR}/coot-docstrings-generated.cc)

add_executable(coot-make-docstrings ${coot_src}/api/make-docstrings-source.cc
                                    ${coot_src}/api/coot-docstring-extract.cc
                                    ${coot_src}/coot-utils/pugixml.cpp)
target_include_directories(coot-make-docstrings PRIVATE ${coot_src} ${coot_src}/api ${coot_src}/coot-utils)
target_compile_features(coot-make-docstrings PRIVATE cxx_std_17)

# Expand the @CMAKE_CURRENT_SOURCE_DIR@ / @CMAKE_CURRENT_BINARY_DIR@ tokens in the
# curated doxygen config into <build>/Doxyfile (this is the only place they are
# expanded). OUTPUT_DIRECTORY in the .cfg points at ${CMAKE_CURRENT_BINARY_DIR}/doxygen.
configure_file(
        ${CMAKE_CURRENT_SOURCE_DIR}/api/doxy-sphinx/coot-api-dox.cfg
        ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
        @ONLY
)

# The molecules_container_t XML is the file the docstring extractor reads; it
# stands in for the whole xml/ tree as this command's output. Listing the parsed
# headers as DEPENDS means editing any of them re-runs doxygen. NB: doxygen_add_docs()
# is deliberately NOT used - it writes its own Doxyfile and ignores the curated
# INPUT/PREDEFINED in the .cfg.
set(COOT_DOCSTRING_XML ${CMAKE_CURRENT_BINARY_DIR}/doxygen/xml/classmolecules__container__t.xml)
set(COOT_DOXYGEN_INPUTS
    ${coot_src}/api/molecules-container.hh   ${coot_src}/api/coot-molecule.hh
    ${coot_src}/coot-utils/simple-mesh.hh    ${coot_src}/api/instancing.hh
    ${coot_src}/api/superpose-results.hh     ${coot_src}/api/validation-information.hh
    ${coot_src}/coot-utils/vertex.hh         ${coot_src}/geometry/residue-and-atom-specs.hh
    ${coot_src}/coot-utils/sfcalc-genmap.hh  ${coot_src}/coot-utils/coot-density-stats.hh
    ${coot_src}/coot-utils/coot-map-utils.hh ${coot_src}/coords/mmdb-crystal.hh
    ${coot_src}/coords/Cartesian.hh          ${coot_src}/api/generic-3d-lines.hh
    ${coot_src}/analysis/stats.hh            ${coot_src}/api/moorhen-h-bonds.hh
    ${coot_src}/api/coot-colour.hh           ${coot_src}/api/api-cell.hh
    ${coot_src}/coot-utils/g_triangle.hh     ${coot_src}/api/residue-validation-information.hh)

add_custom_command(
  OUTPUT ${COOT_DOCSTRING_XML}
  COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/doxygen
  COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
  DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile ${COOT_DOXYGEN_INPUTS}
  COMMENT "Generating API documentation XML with Doxygen"
  VERBATIM)

# Convenience target: `make docs` (re)generates just the XML.
add_custom_target(docs DEPENDS ${COOT_DOCSTRING_XML})

add_custom_command(
  OUTPUT ${COOT_DOCSTRINGS_GENERATED}
  COMMAND coot-make-docstrings ${COOT_DOCSTRING_XML} ${COOT_DOCSTRINGS_GENERATED}
  DEPENDS coot-make-docstrings ${COOT_DOCSTRING_XML}
  COMMENT "Generating embedded API docstrings from doxygen XML"
  VERBATIM)
# -----------------------------------------------------------------------------

# nanobind_add_module(coot_headless_api ${coot_src}/api/molecules-container-nanobind.cc
#                                       ${coot_src}/api/molecules-container-nanobind-functions.cc
#                                       ${coot_src}/api/coot-docstring-extract.cc
#                                       ${COOT_DOCSTRINGS_GENERATED})

# target_compile_definitions(coot_headless_api PRIVATE COOT_SOURCE_DIR="${coot_SOURCE_DIR}" COOT_GEMMI=1)

# on macOS only?
# target_compile_options(cootapi PRIVATE -fsanitize=address -fno-omit-frame-pointer)
# target_link_libraries(cootapi PRIVATE -fsanitize=address) # Linker flags

set(MAKE_COOT_HEADLESS_API_PYI 1)

# if (MAKE_COOT_HEADLESS_API_PYI)
#   # thanks Jordan (install coot_headless_api.pyi in the right place)
#   nanobind_add_stub(coot_headless_api_ext_stub
#     MODULE coot_headless_api
#     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/coot_headless_api.pyi
#     PYTHON_PATH $<TARGET_FILE_DIR:coot_headless_api>
#     DEPENDS coot_headless_api
#   )
#   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/coot_headless_api.pyi DESTINATION ${Python_SITELIB_REL})
#   # MARKER_FILE py.typed
# endif()

# macOS doesn't have libelf
if (ENABLE_DWARF)
  # find_library(libdwarf dw)
  #  add_definitions(-DBACKWARD_HAS_DW)
  #  message("-- Enabled dwarf (macOS)")
  find_library(LIBDWARF dwarf PATHS /opt/homebrew/lib)
     if (NOT LIBDWARF)
        message(FATAL_ERROR "libdwarf not found. Please install with 'brew install libdwarf'")
     endif()
  target_link_libraries(cootapi PRIVATE ${LIBDWARF})
endif()

target_include_directories(cootmoleculestotriangles PRIVATE
   ${CLIPPER-CORE_INCLUDE_DIR} ${coot_src} ${CLIPPER-MMDB_INCLUDE_DIR} ${CLIPPER-CCP4_INCLUDE_DIR} ${FFTW2_INCLUDE_DIRS})

# use MMDB2_INCLUDE_DIR to find the RDKIT for now.
target_include_directories(cootapi PRIVATE ${coot_src} ${coot_src}/coords ${coot_src}/utils ${coot_src}/ccp4mg-utils ${coot_src}/ccp4mg-utils/util ${coot_src}/ccp4mg-utils/pygl ${CLIPPER-CORE_INCLUDE_DIR} ${CLIPPER-MMDB_INCLUDE_DIR} ${CLIPPER-CCP4_INCLUDE_DIR} ${FFTW2_INCLUDE_DIRS} ${RDKit_INCLUDE_DIRS} ${GLM_INCLUDE_DIRS} ${GSL_INCLUDE_DIRS} ${PNG_PNG_INCLUDE_DIR} ${RDKit_INCLUDE_DIR})

target_link_libraries(cootmoleculestotriangles PRIVATE ${SSM_LIBRARY} ${CLIPPER-MINIMOL_LIBRARY} ${CLIPPER-MMDB_LIBRARY} ${CLIPPER-CIF_LIBRARY} ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY} ${CLIPPER-CONTRIB_LIBRARY} ${FFTW2_LIBRARY} ${RFFTW2_LIBRARY} ${CCP4C_LIBRARY} gemmi::gemmi_cpp)

# Charles adds Boost::iostreams Boost::filesystem Boost::system. I don't know why Boost::filesystem was added - I have removed it.
# 2025-09-20 14:15 PE: Boost::system is no longer a thing - I have removed it
target_link_libraries(cootapi PRIVATE cootmoleculestotriangles ${SSM_LIBRARY} ${CLIPPER-MINIMOL_LIBRARY} ${CLIPPER-MMDB_LIBRARY} ${CLIPPER-CIF_LIBRARY} ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY} ${CLIPPER-CONTRIB_LIBRARY} ${FFTW2_LIBRARY} ${RFFTW2_LIBRARY} ${CCP4C_LIBRARY} ${ZLIB_LIBRARIES} ${GSL_LIBRARIES} ${GSL_CBLAS_LIBRARY} ${RDKit_libs_for_libcootapi} ${PNG_LIBRARY} Boost::thread Boost::iostreams gemmi::gemmi_cpp ${libdwarf} ${libelf})

if (OSPRAY_PREFIX)
   target_link_libraries(cootapi PRIVATE ospray::ospray)
endif()

target_compile_features(cootapi PRIVATE cxx_std_17)


# Charles adds this MSVC CXX compiler test
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
  target_compile_options(cootapi PRIVATE
	/D_CRT_SECURE_NO_WARNINGS
	/D_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
	/bigobj
  )
  target_link_libraries(cootapi PRIVATE netapi32.lib)
endif()

# target_include_directories(coot_headless_api PRIVATE ${coot_src} ${coot_src}/coords ${coot_src}/utils ${coot_src}/ccp4mg-utils
#                                                     ${coot_src}/ccp4mg-utils/util ${coot_src}/ccp4mg-utils/pygl ${coot_src}/api
#                                                     ${CLIPPER-CORE_INCLUDE_DIR}
#                                                     ${CLIPPER-MMDB_INCLUDE_DIR} ${CLIPPER-CCP4_INCLUDE_DIR}
#                                                     ${FFTW2_INCLUDE_DIRS}
#                                                     ${RDKit_INCLUDE_DIRS} ${GLM_INCLUDE_DIRS}
#                                                     ${GSL_INCLUDE_DIRS} ${PNG_PNG_INCLUDE_DIR})

# add_executable(coot-findligand ${coot_src}/ligand/find-ligand.cc)

# add_executable(coot-findwaters ${coot_src}/ligand/find-waters.cc)

# add_executable(coot-mini-rsr ${coot_src}/ideal/mini-rsr.cc)

# add_executable(coot-res-tracer-libcootapi ${coot_src}/ligand/res-tracer.cc)

# add_executable(test-molecules-container ${coot_src}/api/test-molecules-container.cc
#                                         ${coot_src}/api/filo-tests.cc
#                                         ${coot_src}/api/lucrezia-tests.cc)

# add_executable(test-docking ${coot_src}/docking/test-docking.cc)

# add_executable(mmcif-tests ${coot_src}/api/mmcif-tests-main.cc ${coot_src}/api/mmcif-tests.cc)

# gemmi-native MoleculesToTriangles selection module (mmdb->gemmi migration, Phase 1).
# Self-contained: only needs the selection sources + gemmi.
add_executable(test-gemmi-selection
   ${coot_src}/MoleculesToTriangles/CXXClasses/test-gemmi-selection.cc
   ${coot_src}/MoleculesToTriangles/CXXClasses/gemmi-selection.cc)
target_link_libraries(test-gemmi-selection PRIVATE gemmi::gemmi_cpp)

add_executable(test-gemmi-bonds
   ${coot_src}/MoleculesToTriangles/CXXClasses/test-gemmi-bonds.cc
   ${coot_src}/MoleculesToTriangles/CXXClasses/gemmi-bonds.cc)
target_link_libraries(test-gemmi-bonds PRIVATE gemmi::gemmi_cpp)

# gemmi-native MoleculesToTriangles end-to-end driver: coords -> representation -> glTF.
# Links the whole coot::m2t engine (cootmoleculestotriangles) and brings in the
# simple_mesh_t glTF exporter directly (header-data only, no extra coot-utils lib).
add_executable(m2t-gemmi-to-gltf
   ${coot_src}/MoleculesToTriangles/gemmi-testing/m2t-gemmi-to-gltf.cc
   ${coot_src}/coot-utils/gltf-export.cc)
target_include_directories(m2t-gemmi-to-gltf PRIVATE ${coot_src} ${coot_src}/coot-utils ${GLM_INCLUDE_DIRS})
target_link_libraries(m2t-gemmi-to-gltf PRIVATE cootmoleculestotriangles gemmi::gemmi_cpp glm::glm)

# target_compile_features(coot-mini-rsr PRIVATE cxx_std_17)

# target_compile_features(coot-res-tracer-libcootapi PRIVATE cxx_std_17)

# target_link_libraries(coot_headless_api PUBLIC cootapi  ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY}
#                       ${RDKit_libs_for_libcootapi} ${libdwarf} ${libelf})

# target_include_directories(coot-findligand PRIVATE ${CLIPPER-CORE_INCLUDE_DIR} ${coot_src})

# target_include_directories(coot-findwaters PRIVATE ${CLIPPER-CORE_INCLUDE_DIR} ${coot_src})

# target_include_directories(coot-mini-rsr PRIVATE ${coot_src} ${PNG_INCLUDE_DIR})

# target_include_directories(coot-res-tracer-libcootapi PRIVATE ${coot_src} ${PNG_INCLUDE_DIR})

# target_link_libraries(coot-findligand PUBLIC cootapi ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY} Boost::thread Threads::Threads)

# target_link_libraries(coot-findwaters PUBLIC cootapi ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY})

# target_link_libraries(coot-mini-rsr PUBLIC cootapi ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY} Threads::Threads)

# target_link_libraries(coot-res-tracer-libcootapi PUBLIC cootapi ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY} Threads::Threads)

# target_include_directories(test-molecules-container PRIVATE ${coot_src} ${coot_src}/coords ${coot_src}/utils ${coot_src}/ccp4mg-utils ${coot_src}/ccp4mg-utils/util ${coot_src}/ccp4mg-utils/pygl ${CLIPPER-CORE_INCLUDE_DIR} ${CLIPPER-MMDB_INCLUDE_DIR} ${CLIPPER-CCP4_INCLUDE_DIR} ${FFTW2_INCLUDE_DIRS} ${RDKit_INCLUDE_DIRS} ${PNG_INCLUDE_DIR})

# target_link_libraries(test-molecules-container PUBLIC cootapi ${SSM_LIBRARY} ${CLIPPER-MINIMOL_LIBRARY} ${CLIPPER-MMDB_LIBRARY} ${CLIPPER-CIF_LIBRARY} ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY} ${CLIPPER-CONTRIB_LIBRARY} ${FFTW2_LIBRARY} ${RFFTW2_LIBRARY} ${CCP4C_LIBRARY} ${ZLIB_LIBRARIES} ${GSL_LIBRARIES} ${RDKit_libs_for_libcootapi} ${PNG_LIBRARY} gemmi::gemmi_cpp ${libdwarf} ${libelf} Threads::Threads)

# target_include_directories(test-docking PRIVATE ${coot_src} ${coot_src}/coords ${coot_src}/utils ${coot_src}/ccp4mg-utils ${coot_src}/ccp4mg-utils/util ${coot_src}/ccp4mg-utils/pygl ${CLIPPER-CORE_INCLUDE_DIR} ${CLIPPER-CCP4_INCLUDE_DIR} ${GSL_INCLUDE_DIRS} ${GLM_INCLUDE_DIRS})

# target_link_libraries(test-docking PUBLIC cootapi ${CLIPPER-CORE_LIBRARY} ${CLIPPER-CCP4_LIBRARY} ${GSL_LIBRARIES} glm::glm Threads::Threads)

# target_include_directories(mmcif-tests PRIVATE ${CLIPPER-MMDB_INCLUDE_DIR})

# target_link_libraries(mmcif-tests PUBLIC)

set_target_properties(cootapi PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")

set_target_properties(cootapi PROPERTIES INSTALL_RPATH_USE_LINK_PATH TRUE)

# set_target_properties(coot_headless_api PROPERTIES INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")

# set_target_properties(coot_headless_api PROPERTIES INSTALL_RPATH_USE_LINK_PATH TRUE)

install(TARGETS cootmoleculestotriangles cootapi)

install(FILES standard-residues.pdb  DESTINATION share/coot)

install(FILES cod-types-db-normalized.bin DESTINATION share/coot)

install(FILES data/syminfo.lib       DESTINATION share/coot/data)

install(DIRECTORY rama-data          DESTINATION share/coot)

install(DIRECTORY data/metal         DESTINATION share/coot/data)

install(DIRECTORY data/cho-acedrg    DESTINATION share/coot/data)

install(DIRECTORY data/cho-models    DESTINATION share/coot/data)

install(DIRECTORY data/cho-links     DESTINATION share/coot/data)

install(DIRECTORY data/pdb-templates DESTINATION share/coot/data)

install(DIRECTORY ${coot_src}/analysis     DESTINATION include/coot/analysis     FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/angles       DESTINATION include/coot/angles       FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/api          DESTINATION include/coot/api          FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/auxil        DESTINATION include/coot/auxil        FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/build        DESTINATION include/coot/build        FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/ccp4mg-utils DESTINATION include/coot/ccp4mg-utils FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/compat       DESTINATION include/coot/compat       FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/coot-utils   DESTINATION include/coot/coot-utils   FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/cootaneer    DESTINATION include/coot/cootaneer    FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/cootilus     DESTINATION include/coot/cootilus     FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/coords       DESTINATION include/coot/coords       FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/db-main      DESTINATION include/coot/db-main      FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/geometry     DESTINATION include/coot/geometry     FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/high-res     DESTINATION include/coot/high-res     FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/ideal        DESTINATION include/coot/ideal        FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/lidia-core   DESTINATION include/coot/lidia-core   FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/ligand       DESTINATION include/coot/ligand       FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/mini-mol     DESTINATION include/coot/mini-mol     FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/pli          DESTINATION include/coot/pli          FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/protein_db   DESTINATION include/coot/protein_db   FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/pyrogen      DESTINATION include/coot/pyrogen      FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/skeleton     DESTINATION include/coot/skeleton     FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/utils        DESTINATION include/coot/utils        FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/density-contour      DESTINATION include/coot/density-contour      FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")
install(DIRECTORY ${coot_src}/MoleculesToTriangles DESTINATION include/coot/MoleculesToTriangles FILES_MATCHING PATTERN "*.hh" PATTERN "*.h")

install(DIRECTORY ${CMAKE_SOURCE_DIR}/monomers DESTINATION share/coot/lib/data
        FILES_MATCHING PATTERN "*" PATTERN "*Makefile.*" EXCLUDE)

# Thanks Charles B.
# install(TARGETS coot_headless_api DESTINATION ${Python_SITELIB_REL})

# install(TARGETS coot_headless_api DESTINATION lib)

# thanks merkys
set_target_properties(cootapi PROPERTIES SOVERSION 1.2)
set_target_properties(cootmoleculestotriangles PROPERTIES SOVERSION 1.2)
