cmake_minimum_required(VERSION 3.3)

# Set project name.
project(XMSMeshOperation VERSION 1.0)

cmake_minimum_required(VERSION 3.8.2)
if (POLICY CMP0042)
  cmake_policy(SET CMP0042 NEW)
endif()
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
set(CMAKE_CXX_EXTENSIONS False)
set(CMAKE_MODULE_PATH
  "${SMTK_DIR}"
  ${CMAKE_MODULE_PATH}
)

#Add our Cmake directory to the module search path
list(APPEND CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/CMake)

if (DEFINED ENV{CONDA_BUILD})
  # Find path to smtkConfig.cmake
  set(glob_exp "$ENV{PREFIX}/lib/cmake/smtk/*/smtkConfig.cmake")
  file(GLOB_RECURSE config_match ${glob_exp})
  if (config_match)
    get_filename_component(smtk_DIR ${config_match} DIRECTORY)
    message("Found smtk_DIR=${smtk_DIR}")
  else()
    message(FATAL_ERROR "Unable to find smtk_DIR using glob expression ${glob_exp}")
  endif()
else()
  # Get xmsmesh pacakges using conan
  # Download automatically, you can also just copy the conan.cmake file
  if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
     message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
     file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/v0.14/conan.cmake"
                   "${CMAKE_BINARY_DIR}/conan.cmake")
  endif()

  include(${CMAKE_BINARY_DIR}/conan.cmake)

  # conan.cmake implicitly assumes that the cmake executable is accessible from
  # the command line. We therefore add its location to the local environment's
  # PATH when configuring the xms libraries.
  get_filename_component(cmake_exe_location ${CMAKE_COMMAND} DIRECTORY)
  set(envsep ":")
  set(path $ENV{PATH}${envsep}${cmake_exe_location})
  if (WIN32)
    # Windows has trouble with the path syntax (semicolons, backslashes, etc).
    # To install the XMS prerequisites on Windows, it appears that we only need
    # cmake in our path anyway.
    set(path ${cmake_exe_location})
  endif ()

  set(XMS_CONAN_REQUIREMENTS
    xmscore/[>=3.0.0,<4.0.0]@aquaveo/stable
    xmsinterp/[>=3.0.0,<4.0.0]@aquaveo/stable
    xmsgrid/[>=3.0.0,<4.0.0]@aquaveo/stable
    xmsmesher/[>=1.0.0,<99.99.99]@aquaveo/stable)
  conan_cmake_run(REQUIRES
    ${XMS_CONAN_REQUIREMENTS}
    BASIC_SETUP
    KEEP_RPATHS
    BUILD missing
    ENV PATH=${path})
  conan_define_targets()

  # Conan not setting dependency on threads, so we add it here
  find_package(Threads)
  set_property(TARGET CONAN_PKG::xmscore APPEND PROPERTY INTERFACE_LINK_LIBRARIES Threads::Threads)
endif()

# Set the directory where the binaries will be stored
set(EXECUTABLE_OUTPUT_PATH         ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)

include(XMSSMTKTestingMacros)

#Setup SMTK
#########################################################################
find_package(smtk REQUIRED)

# this is probably not the right way to do this, but we need the path to SMTK's
# include directory so EncodeStringFunctions.cmake finds things.
get_target_property(SMTK_INCLUDE_DIR smtkCore INTERFACE_INCLUDE_DIRECTORIES)
get_target_property(SMTK_LIB_DIR smtkCore LOCATION)
get_filename_component(SMTK_LIB_DIR ${SMTK_LIB_DIR} DIRECTORY)

include(SMTKMacros)
include(SMTKOperationXML)

if (TARGET smtkPluginSupport)
  find_package(ParaView REQUIRED)
  include(${PARAVIEW_USE_FILE})
endif()

# Setting this ensures that "make install" will leave rpaths to external
# libraries (not part of the build-tree e.g. Qt, ffmpeg, etc.) intact on
# "make install". This ensures that one can install a version of ParaView on the
# build machine without any issues. If this not desired, simply specify
# CMAKE_INSTALL_RPATH_USE_LINK_PATH when configuring and "make install" will
# strip all rpaths, which is default behavior.
if (NOT CMAKE_INSTALL_RPATH_USE_LINK_PATH)
  set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
endif ()

#Setup up the option to enable the testing directory
option(ENABLE_TESTING "Enable Testing" OFF)

#Setup up the option to enable python wrapping using pybind11
option(ENABLE_PYTHON_WRAPPING "Build Python Wrappings" OFF)

include(CMakeDependentOption)

cmake_dependent_option(
  INSTALL_PYTHON_TO_SITE_PACKAGES
  "Install Python modules to the interpreter's site-packages directory or into CMAKE_INSTALL_PREFIX?"
  OFF
  ENABLE_PYTHON_WRAPPING OFF)

if(ENABLE_PYTHON_WRAPPING)
  set(CMAKE_POSITION_INDEPENDENT_CODE ON)

  # by including the correct python cmake scripts before adding pybind11, we
  # work around pybind11's custom python cmake scripts without having to patch
  # pybind11.
  if (NOT PYTHONINTERP_FOUND)
    find_package(PythonInterp 2.7 REQUIRED)
  endif ()

  if (NOT PYTHONLIBS_FOUND)
    find_package(PythonLibs REQUIRED)
  endif ()

  if(MSVC)
    set(PYTHON_MODULE_EXTENSION ".pyd")
  else()
    set(PYTHON_MODULE_EXTENSION ".so")
  endif()
  set(PYTHON_MODULE_PREFIX "")

  find_package(pybind11 REQUIRED)

  set(PYBIND11_FLAGS " ")
  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR
      CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR
      CMAKE_CXX_COMPILER_ID MATCHES "Intel")
    set(PYBIND11_FLAGS "${PYBIND11_FLAGS} -Wno-shadow")
  endif()

  # Initialize PYTHON_MODULEDIR.
  # This stores the location where we'll install our Python modules.
  # Note that PYTHON_MODULEDIR may be provided if the project is being
  # built as a submodule or as part of a superbuild.
  if (NOT DEFINED PYTHON_MODULEDIR)
    if (INSTALL_PYTHON_TO_SITE_PACKAGES)
      execute_process(
        COMMAND
        ${PYTHON_EXECUTABLE}
        -c "import site; print(site.getsitepackages())[-1]"
        RESULT_VARIABLE PYTHON_MODULEDIR
        )
    elseif(WIN32)
      set(PYTHON_MODULEDIR
        "bin/Lib/site-packages")
    else()
      set(PYTHON_MODULEDIR
        "lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages")
    endif()
  endif()
endif()

if(ENABLE_TESTING)
  enable_testing()

  set(CMAKE_INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib/")
endif()

###  Header locations
#
# Locations of dependent package headers
include_directories(
  "${CMAKE_CURRENT_SOURCE_DIR}"
  "${CMAKE_CURRENT_BINARY_DIR}"
)

# Build the project
add_subdirectory(smtk)

# Construct install CMake logic
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
  "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
  VERSION ${${PROJECT_NAME}_VERSION}
  COMPATIBILITY AnyNewerVersion
)

export(EXPORT xms_smtk
  FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Targets.cmake"
)
get_property(SMTK_PLUGINS GLOBAL PROPERTY SMTK_PLUGINS)

configure_file(${PROJECT_SOURCE_DIR}/CMake/${PROJECT_NAME}Config.cmake.in
  ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake @ONLY)

set(ConfigPackageLocation lib/cmake/${PROJECT_NAME})
install(EXPORT xms_smtk
  FILE
    ${PROJECT_NAME}Targets.cmake
  DESTINATION
    ${ConfigPackageLocation}
)
install(
  FILES
    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
  DESTINATION
    ${ConfigPackageLocation}
  COMPONENT
    Devel
)
