#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

# If cmake variable HDFSPP_LIBRARY_ONLY is set, then tests, examples, and
# tools will not be built. This allows for faster builds of the libhdfspp
# library alone, avoids looking for a JDK, valgrind, and gmock, and
# prevents the generation of multiple binaries that might not be relevant
# to other projects during normal use.
# Example of cmake invocation with HDFSPP_LIBRARY_ONLY enabled:
# cmake -DHDFSPP_LIBRARY_ONLY=1

project (libhdfspp)

cmake_minimum_required(VERSION 2.8)

find_package (Boost 1.72.0 REQUIRED COMPONENTS date_time)

enable_testing()
set(CMAKE_CXX_STANDARD 17)
include (CTest)

SET(BUILD_SHARED_HDFSPP TRUE CACHE STRING "BUILD_SHARED_HDFSPP defaulting to 'TRUE'")
SET(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake" ${CMAKE_MODULE_PATH})

# If there's a better way to inform FindCyrusSASL.cmake, let's make this cleaner:
SET(CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH};${CYRUS_SASL_DIR};${GSASL_DIR};$ENV{PROTOBUF_HOME}")

# Specify PROTOBUF_HOME so that find_package picks up the correct version
SET(CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH};$ENV{PROTOBUF_HOME}")

find_package(Doxygen)
find_package(OpenSSL REQUIRED)
find_package(Protobuf REQUIRED)
find_package(CyrusSASL)
find_package(GSasl)
find_package(Threads)

include(CheckCXXSourceCompiles)
include(CheckSymbolExists)
include(FetchContent)

if (NOT APPLE)
    # Install googletest
    # As per the approach documented in the GoogleTest repo -
    # https://github.com/google/googletest/blob/e649993a402d96afe25fbf3413749adf0f2947f6/googletest/README.md#incorporating-into-an-existing-cmake-project
    FetchContent_Declare(
      googletest
      URL https://github.com/google/googletest/archive/703bd9caab50b139428cea1aaff9974ebee5742e.zip
    )
    # The commit SHA 703bd9caab50b139428cea1aaff9974ebee5742e in the URL above corresponds to the
    # tag release-1.10.0 in the googletest repository.
    # For Windows: Prevent overriding the parent project's compiler/linker settings
    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
    FetchContent_MakeAvailable(googletest)
endif (NOT APPLE)

# Check if thread_local is supported
unset (THREAD_LOCAL_SUPPORTED CACHE)
set (CMAKE_CXX_STANDARD_REQUIRED ON)
set (CMAKE_REQUIRED_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
check_cxx_source_compiles(
    "#include <thread>
    int main(void) {
      thread_local int s;
      return 0;
    }"
    THREAD_LOCAL_SUPPORTED)
if (NOT THREAD_LOCAL_SUPPORTED)
  message(FATAL_ERROR
  "FATAL ERROR: The required feature thread_local storage is not supported by your compiler. \
  Known compilers that support this feature: GCC 4.8+, Visual Studio 2015+, Clang (community \
  version 3.3+), Clang (version for Xcode 8+ and iOS 9+).")
endif (NOT THREAD_LOCAL_SUPPORTED)

# Check if PROTOC library was compiled with the compatible compiler by trying
# to compile some dummy code
unset (PROTOC_IS_COMPATIBLE CACHE)
set (CMAKE_REQUIRED_INCLUDES ${PROTOBUF_INCLUDE_DIRS})
set (CMAKE_REQUIRED_LIBRARIES ${PROTOBUF_LIBRARY} ${PROTOBUF_PROTOC_LIBRARY})
check_cxx_source_compiles(
    "#include <google/protobuf/io/printer.h>
    #include <string>
    int main(void) {
      ::google::protobuf::io::ZeroCopyOutputStream *out = NULL;
      ::google::protobuf::io::Printer printer(out, '$');
      printer.PrintRaw(std::string(\"test\"));
      return 0;
    }"
    PROTOC_IS_COMPATIBLE)
if (NOT PROTOC_IS_COMPATIBLE)
  message(WARNING
  "WARNING: the Protocol Buffers Library and the Libhdfs++ Library must both be compiled \
  with the same (or compatible) compiler. Normally only the same major versions of the same \
  compiler are compatible with each other.")
endif (NOT PROTOC_IS_COMPATIBLE)

find_program(MEMORYCHECK_COMMAND valgrind HINTS ${VALGRIND_DIR} )
set(MEMORYCHECK_COMMAND_OPTIONS "--trace-children=no --leak-check=full --error-exitcode=1 --suppressions=${PROJECT_SOURCE_DIR}/tests/memcheck.supp")
message(STATUS "valgrind location: ${MEMORYCHECK_COMMAND}")

if (REQUIRE_VALGRIND AND MEMORYCHECK_COMMAND MATCHES "MEMORYCHECK_COMMAND-NOTFOUND" )
  message(FATAL_ERROR "valgrind was required but not found.  "
                      "The path can be included via a -DVALGRIND_DIR=... flag passed to CMake.")
endif (REQUIRE_VALGRIND AND MEMORYCHECK_COMMAND MATCHES "MEMORYCHECK_COMMAND-NOTFOUND" )

# Find the SASL library to use.  If you don't want to require a sasl library,
#    define -DNO_SASL=1 in your cmake call
# Prefer Cyrus SASL, but use GSASL if it is found
# Note that the packages can be disabled by setting CMAKE_DISABLE_FIND_PACKAGE_GSasl or
#    CMAKE_DISABLE_FIND_PACKAGE_CyrusSASL, respectively (case sensitive)
set (SASL_LIBRARIES)
set (SASL_INCLUDE_DIR)
if (NOT NO_SASL)
    if (CYRUS_SASL_FOUND)
        message(STATUS "Using Cyrus SASL; link with ${CYRUS_SASL_SHARED_LIB}")
        set (SASL_INCLUDE_DIR ${CYRUS_SASL_INCLUDE_DIR})
        set (SASL_LIBRARIES ${CYRUS_SASL_SHARED_LIB})
        set (CMAKE_USING_CYRUS_SASL 1)
        add_definitions(-DUSE_SASL -DUSE_CYRUS_SASL)
    else (CYRUS_SASL_FOUND)
        if (REQUIRE_CYRUS_SASL)
          message(FATAL_ERROR "Cyrus SASL was required but not found.  "
                                "The path can be included via a -DCYRUS_SASL_DIR=... flag passed to CMake.")
        endif (REQUIRE_CYRUS_SASL)

        # If we didn't pick Cyrus, use GSASL instead
        if (GSASL_FOUND)
          message(STATUS "Using GSASL; link with ${GSASL_LIBRARIES}")
          set (SASL_INCLUDE_DIR ${GSASL_INCLUDE_DIR})
          set (SASL_LIBRARIES ${GSASL_LIBRARIES})
          set (CMAKE_USING_GSASL 1)
          add_definitions(-DUSE_SASL -DUSE_GSASL)
        else (GSASL_FOUND)
          if (REQUIRE_GSASL)
            message(FATAL_ERROR "GSASL was required but not found.  "
                                "The path can be included via a -DGSASL_DIR=... flag passed to CMake.")
          endif (REQUIRE_GSASL)

          # No SASL was found, but NO_SASL was not defined
          message(FATAL_ERROR "Cound not find a SASL library (GSASL (gsasl) or Cyrus SASL (libsasl2).  "
                            "Install/configure one of them or define NO_SASL=1 in your cmake call")
        endif (GSASL_FOUND)
    endif (CYRUS_SASL_FOUND)
else (NOT NO_SASL)
    message(STATUS "Compiling with NO SASL SUPPORT")
endif (NOT NO_SASL)

check_symbol_exists(explicit_bzero "string.h" HAVE_EXPLICIT_BZERO)
if(HAVE_EXPLICIT_BZERO)
    add_definitions(-DHAVE_EXPLICIT_BZERO)
endif()

add_definitions(-DASIO_STANDALONE -DASIO_CPP11_DATE_TIME)

# Disable optimizations if compiling debug
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0")
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -O0")

if(UNIX)
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -g -fPIC -fno-strict-aliasing")
set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -fPIC -fno-strict-aliasing")
endif()

if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    add_definitions(-DASIO_HAS_STD_ADDRESSOF -DASIO_HAS_STD_ARRAY -DASIO_HAS_STD_ATOMIC -DASIO_HAS_CSTDINT -DASIO_HAS_STD_SHARED_PTR -DASIO_HAS_STD_TYPE_TRAITS -DASIO_HAS_VARIADIC_TEMPLATES -DASIO_HAS_STD_FUNCTION -DASIO_HAS_STD_CHRONO -DASIO_HAS_STD_SYSTEM_ERROR)
endif ()

# Mac OS 10.7 and later deprecates most of the methods in OpenSSL.
# Add -Wno-deprecated-declarations to avoid the warnings.
if(APPLE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -Wno-deprecated-declarations -Wno-unused-local-typedef")
endif()

if(DOXYGEN_FOUND)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/doc/Doxyfile @ONLY)
add_custom_target(doc ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doc/Doxyfile
                  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                  COMMENT "Generating API documentation with Doxygen" VERBATIM)
endif(DOXYGEN_FOUND)


# Copy files from the hadoop tree into the output/extern directory if
#    they've changed
function (copy_on_demand input_src_glob input_dest_dir)
  get_filename_component(src_glob ${input_src_glob} REALPATH)
  get_filename_component(dest_dir ${input_dest_dir} REALPATH)
  get_filename_component(src_dir ${src_glob} PATH)
  message(STATUS "Syncing ${src_glob} to ${dest_dir}")

  file(GLOB_RECURSE src_files ${src_glob})
  foreach(src_path ${src_files})
    file(RELATIVE_PATH relative_src ${src_dir} ${src_path})
    set(dest_path "${dest_dir}/${relative_src}")
    add_custom_command(TARGET copy_hadoop_files
     COMMAND ${CMAKE_COMMAND} -E copy_if_different "${src_path}" "${dest_path}"
    )
  endforeach()
endfunction()

# If we're building in the hadoop tree, pull the Hadoop files that
#     libhdfspp depends on.  This allows us to ensure that
#     the distribution will have a consistent set of headers and
#     .proto files
if(HADOOP_BUILD)
    set(HADOOP_IMPORT_DIR ${PROJECT_BINARY_DIR}/extern)
    get_filename_component(HADOOP_IMPORT_DIR ${HADOOP_IMPORT_DIR} REALPATH)

  add_custom_target(copy_hadoop_files ALL)

  # Gather the Hadoop files and resources that libhdfs++ needs to build
  copy_on_demand(../libhdfs/include/*.h* ${HADOOP_IMPORT_DIR}/include)
  if(MSVC)
    copy_on_demand(../libhdfs/os/windows/unistd.h ${HADOOP_IMPORT_DIR}/include)
  endif(MSVC)
  copy_on_demand(${CMAKE_CURRENT_LIST_DIR}/../../../../../hadoop-hdfs-client/src/main/proto/*.proto ${HADOOP_IMPORT_DIR}/proto/hdfs)
  copy_on_demand(${CMAKE_CURRENT_LIST_DIR}/../../../../../../hadoop-common-project/hadoop-common/src/main/proto/*.proto  ${HADOOP_IMPORT_DIR}/proto/hadoop)
  copy_on_demand(${CMAKE_CURRENT_LIST_DIR}/../../../../../../hadoop-common-project/hadoop-common/src/test/proto/*.proto  ${HADOOP_IMPORT_DIR}/proto/hadoop_test)
else(HADOOP_BUILD)
  set(HADOOP_IMPORT_DIR ${CMAKE_CURRENT_LIST_DIR}/extern)
endif(HADOOP_BUILD)

# Paths to find the imported files
set(PROTO_HDFS_DIR         ${HADOOP_IMPORT_DIR}/proto/hdfs)
set(PROTO_HADOOP_DIR       ${HADOOP_IMPORT_DIR}/proto/hadoop)
set(PROTO_HADOOP_TEST_DIR  ${HADOOP_IMPORT_DIR}/proto/hadoop_test)

include_directories(
  include
  lib
  ${HADOOP_IMPORT_DIR}/include
)

include_directories( SYSTEM
  ${PROJECT_BINARY_DIR}/lib/proto
  ${Boost_INCLUDE_DIRS}
  third_party/rapidxml-1.13
  if (NOT APPLE)
      ${gtest_SOURCE_DIR}/include
      ${gmock_SOURCE_DIR}/include
  endif (NOT APPLE)
  third_party/tr2
  third_party/protobuf
  third_party/uriparser2
  ${OPENSSL_INCLUDE_DIR}
  ${SASL_INCLUDE_DIR}
  ${PROTOBUF_INCLUDE_DIRS}
)

add_subdirectory(third_party/uriparser2)
add_subdirectory(lib)
if(NOT HDFSPP_LIBRARY_ONLY)
    if(NOT MSVC AND NOT APPLE)
        add_subdirectory(tests)
    endif(NOT MSVC AND NOT APPLE)
    add_subdirectory(examples)
    add_subdirectory(tools)
endif()

# create an empty file; hadoop_add_dual_library wraps add_library which
# requires at least one file as an argument
set(EMPTY_FILE_CC ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/empty.cc)
file(WRITE ${EMPTY_FILE_CC} "")

# Build the output libraries
if(NEED_LINK_DL)
   set(LIB_DL dl)
endif()

set(LIBHDFSPP_VERSION "0.1.0")
set(LIBHDFSPP_ALL_OBJECTS $<TARGET_OBJECTS:x_platform_obj> $<TARGET_OBJECTS:bindings_c_obj> $<TARGET_OBJECTS:fs_obj> $<TARGET_OBJECTS:rpc_obj> $<TARGET_OBJECTS:reader_obj> $<TARGET_OBJECTS:proto_obj> $<TARGET_OBJECTS:connection_obj> $<TARGET_OBJECTS:common_obj> $<TARGET_OBJECTS:uriparser2_obj>)
# HDFS-16464: We don't support building Hadoop DLL for Windows yet.
if (HADOOP_BUILD AND NOT MSVC)
  hadoop_add_dual_library(hdfspp ${EMPTY_FILE_CC} ${LIBHDFSPP_ALL_OBJECTS})
  hadoop_target_link_dual_libraries(hdfspp
    ${LIB_DL}
    ${PROTOBUF_LIBRARY}
    ${OPENSSL_LIBRARIES}
    ${SASL_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
    ${Boost_LIBRARIES})
  set_target_properties(hdfspp PROPERTIES SOVERSION ${LIBHDFSPP_VERSION})
  hadoop_dual_output_directory(hdfspp ${OUT_DIR})
else (HADOOP_BUILD AND NOT MSVC)
  add_library(hdfspp_static STATIC ${EMPTY_FILE_CC} ${LIBHDFSPP_ALL_OBJECTS})
  target_link_libraries(hdfspp_static PUBLIC
    ${LIB_DL}
    ${PROTOBUF_LIBRARY}
    ${OPENSSL_LIBRARIES}
    ${SASL_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
    ${Boost_LIBRARIES})
  if(BUILD_SHARED_HDFSPP AND NOT MSVC)
    add_library(hdfspp SHARED ${EMPTY_FILE_CC} ${LIBHDFSPP_ALL_OBJECTS})
    set_target_properties(hdfspp PROPERTIES SOVERSION ${LIBHDFSPP_VERSION})
  endif(BUILD_SHARED_HDFSPP AND NOT MSVC)
endif (HADOOP_BUILD AND NOT MSVC)

# Set up make install targets
# Can be installed to a particular location via "make DESTDIR=... install"
file(GLOB_RECURSE LIBHDFSPP_HEADER_FILES "${CMAKE_CURRENT_LIST_DIR}/include/*.h*")
file(GLOB_RECURSE LIBHDFS_HEADER_FILES "${HADOOP_IMPORT_DIR}/include/*.h*")
install(FILES ${LIBHDFSPP_HEADER_FILES} DESTINATION include/hdfspp)
install(FILES ${LIBHDFS_HEADER_FILES} DESTINATION include/hdfs)

install(TARGETS hdfspp_static ARCHIVE DESTINATION lib)
if(BUILD_SHARED_HDFSPP AND NOT MSVC)
  install(TARGETS hdfspp LIBRARY DESTINATION lib)
endif(BUILD_SHARED_HDFSPP AND NOT MSVC)

add_custom_target(
    InstallToBuildDirectory
    COMMAND "${CMAKE_MAKE_PROGRAM}" install DESTDIR=${PROJECT_BINARY_DIR}/output
)
set(LIBHDFSPP_DIR ${PROJECT_BINARY_DIR}/output)
