# 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.

macro(set_option_category name)
  set(ARROW_OPTION_CATEGORY ${name})
  list(APPEND "ARROW_OPTION_CATEGORIES" ${name})
endmacro()

macro(define_option name description default)
  option(${name} ${description} ${default})
  list(APPEND "ARROW_${ARROW_OPTION_CATEGORY}_OPTION_NAMES" ${name})
  set("${name}_OPTION_DESCRIPTION" ${description})
  set("${name}_OPTION_DEFAULT" ${default})
  set("${name}_OPTION_TYPE" "bool")
endmacro()

function(list_join lst glue out)
  if("${${lst}}" STREQUAL "")
    set(${out} "" PARENT_SCOPE)
    return()
  endif()

  list(GET ${lst} 0 joined)
  list(REMOVE_AT ${lst} 0)
  foreach(item ${${lst}})
    set(joined "${joined}${glue}${item}")
  endforeach()
  set(${out} ${joined} PARENT_SCOPE)
endfunction()

macro(define_option_string name description default)
  set(${name} ${default} CACHE STRING ${description})
  list(APPEND "ARROW_${ARROW_OPTION_CATEGORY}_OPTION_NAMES" ${name})
  set("${name}_OPTION_DESCRIPTION" ${description})
  set("${name}_OPTION_DEFAULT" "\"${default}\"")
  set("${name}_OPTION_TYPE" "string")

  set("${name}_OPTION_ENUM" ${ARGN})
  list_join("${name}_OPTION_ENUM" "|" "${name}_OPTION_ENUM")
  if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
    set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
  endif()
endmacro()

# Top level cmake dir
if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
  #----------------------------------------------------------------------
  set_option_category("Compile and link")

  define_option_string(ARROW_CXXFLAGS "Compiler flags to append when compiling Arrow" "")

  define_option(ARROW_BUILD_STATIC "Build static libraries" ON)

  define_option(ARROW_BUILD_SHARED "Build shared libraries" ON)

  define_option(ARROW_NO_DEPRECATED_API "Exclude deprecated APIs from build" OFF)

  define_option(ARROW_USE_CCACHE "Use ccache when compiling (if available)" ON)

  define_option(ARROW_USE_LD_GOLD "Use ld.gold for linking on Linux (if available)" OFF)

  # Disable this option to exercise non-SIMD fallbacks
  define_option(ARROW_USE_SIMD "Build with SIMD optimizations" ON)

  define_option(ARROW_ALTIVEC "Build Arrow with Altivec" ON)

  define_option(ARROW_RPATH_ORIGIN "Build Arrow libraries with RATH set to \$ORIGIN" OFF)

  define_option(ARROW_INSTALL_NAME_RPATH
                "Build Arrow libraries with install_name set to @rpath" ON)

  define_option(ARROW_GGDB_DEBUG "Pass -ggdb flag to debug builds" ON)

  #----------------------------------------------------------------------
  set_option_category("Test and benchmark")

  define_option(ARROW_BUILD_EXAMPLES "Build the Arrow examples, default OFF" OFF)

  define_option(ARROW_BUILD_TESTS "Build the Arrow googletest unit tests, default OFF"
                OFF)

  define_option(ARROW_BUILD_INTEGRATION
                "Build the Arrow integration test executables, default OFF" OFF)

  define_option(ARROW_BUILD_BENCHMARKS "Build the Arrow micro benchmarks, default OFF"
                OFF)

  # Reference benchmarks are used to compare to naive implementation, or
  # discover various hardware limits.
  define_option(ARROW_BUILD_BENCHMARKS_REFERENCE
                "Build the Arrow micro reference benchmarks, default OFF." OFF)

  define_option_string(ARROW_TEST_LINKAGE
                       "Linkage of Arrow libraries with unit tests executables."
                       "shared"
                       "shared"
                       "static")

  define_option(ARROW_FUZZING "Build Arrow Fuzzing executables" OFF)

  #----------------------------------------------------------------------
  set_option_category("Lint")

  define_option(ARROW_ONLY_LINT "Only define the lint and check-format targets" OFF)

  define_option(ARROW_VERBOSE_LINT "If off, 'quiet' flags will be passed to linting tools"
                OFF)

  define_option(ARROW_GENERATE_COVERAGE "Build with C++ code coverage enabled" OFF)

  #----------------------------------------------------------------------
  set_option_category("Checks")

  define_option(ARROW_TEST_MEMCHECK "Run the test suite using valgrind --tool=memcheck"
                OFF)

  define_option(ARROW_USE_ASAN "Enable Address Sanitizer checks" OFF)

  define_option(ARROW_USE_TSAN "Enable Thread Sanitizer checks" OFF)

  define_option(ARROW_USE_UBSAN "Enable Undefined Behavior sanitizer checks" OFF)

  #----------------------------------------------------------------------
  set_option_category("Project component")

  define_option(ARROW_COMPUTE "Build the Arrow Compute Modules" ON)

  define_option(ARROW_DATASET "Build the Arrow Dataset Modules" ON)

  define_option(ARROW_FLIGHT
                "Build the Arrow Flight RPC System (requires GRPC, Protocol Buffers)" OFF)

  define_option(ARROW_GANDIVA "Build the Gandiva libraries" OFF)

  define_option(ARROW_PARQUET "Build the Parquet libraries" OFF)

  define_option(ARROW_IPC "Build the Arrow IPC extensions" ON)

  define_option(ARROW_BUILD_UTILITIES "Build Arrow commandline utilities" ON)

  define_option(ARROW_CUDA "Build the Arrow CUDA extensions (requires CUDA toolkit)" OFF)

  define_option(ARROW_ORC "Build the Arrow ORC adapter" OFF)

  define_option(ARROW_JNI "Build the Arrow JNI lib" OFF)

  define_option(ARROW_TENSORFLOW "Build Arrow with TensorFlow support enabled" OFF)

  define_option(ARROW_JEMALLOC "Build the Arrow jemalloc-based allocator" ON)

  define_option(ARROW_HDFS "Build the Arrow HDFS bridge" ON)

  define_option(ARROW_PYTHON "Build the Arrow CPython extensions" OFF)

  define_option(ARROW_HIVESERVER2 "Build the HiveServer2 client and Arrow adapter" OFF)

  define_option(ARROW_PLASMA "Build the plasma object store along with Arrow" OFF)

  define_option(ARROW_PLASMA_JAVA_CLIENT "Build the plasma object store java client" OFF)

  #----------------------------------------------------------------------
  set_option_category("Thirdparty toolchain")

  # Determine how we will look for dependencies
  # * AUTO: Guess which packaging systems we're running in and pull the
  #   dependencies from there. Build any missing ones through the
  #   ExternalProject setup. This is the default unless the CONDA_PREFIX
  #   environment variable is set, in which case the CONDA method is used
  # * BUNDLED: Build dependencies through CMake's ExternalProject facility. If
  #   you wish to build individual dependencies from source instead of using
  #   one of the other methods, pass -D$NAME_SOURCE=BUNDLED
  # * SYSTEM: Use CMake's find_package and find_library without any custom
  #   paths. If individual packages are on non-default locations, you can pass
  #   $NAME_ROOT arguments to CMake, or set environment variables for the same
  #   with CMake 3.11 and higher.  If your system packages are in a non-default
  #   location, or if you are using a non-standard toolchain, you can also pass
  #   ARROW_PACKAGE_PREFIX to set the *_ROOT variables to look in that
  #   directory
  # * CONDA: Same as system but set all *_ROOT variables to
  #   ENV{CONDA_PREFIX}. If this is run within an active conda environment,
  #   then ENV{CONDA_PREFIX} will be used for dependencies unless
  #   ARROW_DEPENDENCY_SOURCE is set explicitly to one of the other options
  # * BREW: Use SYSTEM but search for select packages with brew.
  if(NOT "$ENV{CONDA_PREFIX}" STREQUAL "")
    set(ARROW_DEPENDENCY_SOURCE_DEFAULT "CONDA")
  else()
    set(ARROW_DEPENDENCY_SOURCE_DEFAULT "AUTO")
  endif()
  define_option_string(ARROW_DEPENDENCY_SOURCE
                       "Method to use for acquiring arrow's build dependencies"
                       "${ARROW_DEPENDENCY_SOURCE_DEFAULT}"
                       "AUTO"
                       "BUNDLED"
                       "SYSTEM"
                       "CONDA"
                       "BREW")

  define_option(ARROW_VERBOSE_THIRDPARTY_BUILD
                "Show output from ExternalProjects rather than just logging to files" OFF)

  define_option(ARROW_BOOST_USE_SHARED "Rely on boost shared libraries where relevant" ON)

  define_option(ARROW_BOOST_VENDORED "Use vendored Boost instead of existing Boost. \
Note that this requires linking Boost statically. \
Deprecated. Use BOOST_SOURCE=BUNDLED instead." OFF)

  define_option(ARROW_PROTOBUF_USE_SHARED
                "Rely on Protocol Buffers shared libraries where relevant" ON)

  define_option(ARROW_GFLAGS_USE_SHARED "Rely on GFlags shared libraries where relevant"
                ON)

  define_option(ARROW_WITH_BACKTRACE "Build with backtrace support" ON)

  define_option(ARROW_USE_GLOG "Build libraries with glog support for pluggable logging"
                ON)

  define_option(ARROW_WITH_BROTLI "Build with Brotli compression" ON)

  define_option(ARROW_WITH_BZ2 "Build with BZ2 compression" OFF)

  define_option(ARROW_WITH_LZ4 "Build with lz4 compression" ON)

  define_option(ARROW_WITH_SNAPPY "Build with Snappy compression" ON)

  define_option(ARROW_WITH_ZLIB "Build with zlib compression" ON)

  if(CMAKE_VERSION VERSION_LESS 3.7)
    set(ARROW_WITH_ZSTD_DEFAULT OFF)
  else()
    # ExternalProject_Add(SOURCE_SUBDIR) is available since CMake 3.7.
    set(ARROW_WITH_ZSTD_DEFAULT ON)
  endif()
  define_option(ARROW_WITH_ZSTD "Build with zstd compression" ${ARROW_WITH_ZSTD_DEFAULT})

  #----------------------------------------------------------------------
  if(MSVC)
    set_option_category("MSVC")

    define_option(MSVC_LINK_VERBOSE
                  "Pass verbose linking options when linking libraries and executables"
                  OFF)

    define_option(ARROW_USE_CLCACHE "Use clcache if available" ON)

    define_option_string(BROTLI_MSVC_STATIC_LIB_SUFFIX
                         "Brotli static lib suffix used on Windows with MSVC" "-static")

    define_option_string(PROTOBUF_MSVC_STATIC_LIB_SUFFIX
                         "Protobuf static lib suffix used on Windows with MSVC" "")

    define_option_string(RE2_MSVC_STATIC_LIB_SUFFIX
                         "re2 static lib suffix used on Windows with MSVC" "_static")

    define_option_string(SNAPPY_MSVC_STATIC_LIB_SUFFIX
                         "Snappy static lib suffix used on Windows with MSVC" "_static")

    define_option_string(LZ4_MSVC_STATIC_LIB_SUFFIX
                         "Lz4 static lib suffix used on Windows with MSVC" "_static")

    define_option_string(ZSTD_MSVC_STATIC_LIB_SUFFIX
                         "ZStd static lib suffix used on Windows with MSVC" "_static")

    define_option(ARROW_USE_STATIC_CRT "Build Arrow with statically linked CRT" OFF)
  endif()

  #----------------------------------------------------------------------
  set_option_category("Parquet")

  define_option(PARQUET_MINIMAL_DEPENDENCY
                "Depend only on Thirdparty headers to build libparquet. \
Always OFF if building binaries" OFF)

  define_option(
    PARQUET_BUILD_EXECUTABLES
    "Build the Parquet executable CLI tools. Requires static libraries to be built." OFF)

  define_option(PARQUET_BUILD_EXAMPLES
                "Build the Parquet examples. Requires static libraries to be built." OFF)

  define_option(PARQUET_REQUIRE_ENCRYPTION
                "Build support for encryption. Fail if OpenSSL is not found" OFF)

  #----------------------------------------------------------------------
  set_option_category("Gandiva")

  define_option(ARROW_GANDIVA_JAVA "Build the Gandiva JNI wrappers" OFF)

  # ARROW-3860: Temporary workaround
  define_option(
    ARROW_GANDIVA_STATIC_LIBSTDCPP
    "Include -static-libstdc++ -static-libgcc when linking with Gandiva static libraries"
    OFF)

  define_option_string(ARROW_GANDIVA_PC_CXX_FLAGS
                       "Compiler flags to append when pre-compiling Gandiva operations"
                       "")

  #----------------------------------------------------------------------
  set_option_category("Advanced developer")

  define_option(ARROW_EXTRA_ERROR_CONTEXT
                "Compile with extra error context (line numbers, code)" OFF)

  define_option(ARROW_OPTIONAL_INSTALL
                "If enabled install ONLY targets that have already been built. Please be \
advised that if this is enabled 'install' will fail silently on components \
that have not been built" OFF)

  option(ARROW_BUILD_CONFIG_SUMMARY_JSON "Summarize build configuration in a JSON file"
         ON)
endif()

macro(config_summary)
  message(STATUS "---------------------------------------------------------------------")
  message(STATUS "Arrow version:                                 ${ARROW_VERSION}")
  message(STATUS)
  message(STATUS "Build configuration summary:")

  message(STATUS "  Generator: ${CMAKE_GENERATOR}")
  message(STATUS "  Build type: ${CMAKE_BUILD_TYPE}")
  message(STATUS "  Source directory: ${CMAKE_CURRENT_SOURCE_DIR}")
  if(${CMAKE_EXPORT_COMPILE_COMMANDS})
    message(
      STATUS "  Compile commands: ${CMAKE_CURRENT_BINARY_DIR}/compile_commands.json")
  endif()

  if(${ARROW_BUILD_CONFIG_SUMMARY_JSON})
    set(summary "${CMAKE_CURRENT_BINARY_DIR}/cmake_summary.json")
    message(STATUS "  Outputting build configuration summary to ${summary}")
    file(WRITE ${summary} "{\n")
  endif()

  foreach(category ${ARROW_OPTION_CATEGORIES})

    message(STATUS)
    message(STATUS "${category} options:")

    set(option_names ${ARROW_${category}_OPTION_NAMES})

    set(max_value_length 0)
    foreach(name ${option_names})
      string(LENGTH "\"${${name}}\"" value_length)
      if(${max_value_length} LESS ${value_length})
        set(max_value_length ${value_length})
      endif()
    endforeach()

    foreach(name ${option_names})
      if("${${name}_OPTION_TYPE}" STREQUAL "string")
        set(value "\"${${name}}\"")
      else()
        set(value "${${name}}")
      endif()

      set(default ${${name}_OPTION_DEFAULT})
      set(description ${${name}_OPTION_DESCRIPTION})
      string(LENGTH ${description} description_length)
      if(${description_length} LESS 70)
        string(
          SUBSTRING
            "                                                                     "
            ${description_length} -1 description_padding)
      else()
        set(description_padding "
                                                                           ")
      endif()

      set(comment "[${name}]")

      if("${value}" STREQUAL "${default}")
        set(comment "[default] ${comment}")
      endif()

      if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
        set(comment "${comment} [${${name}_OPTION_ENUM}]")
      endif()

      string(
        SUBSTRING "${value}                                                             "
                  0 ${max_value_length} value)

      message(STATUS "  ${description} ${description_padding} ${value} ${comment}")
    endforeach()

    if(${ARROW_BUILD_CONFIG_SUMMARY_JSON})
      foreach(name ${option_names})
        file(APPEND ${summary} "\"${name}\": \"${${name}}\",\n")
      endforeach()
    endif()

  endforeach()

  if(${ARROW_BUILD_CONFIG_SUMMARY_JSON})
    file(APPEND ${summary} "\"generator\": \"${CMAKE_GENERATOR}\",\n")
    file(APPEND ${summary} "\"build_type\": \"${CMAKE_BUILD_TYPE}\",\n")
    file(APPEND ${summary} "\"source_dir\": \"${CMAKE_CURRENT_SOURCE_DIR}\",\n")
    if(${CMAKE_EXPORT_COMPILE_COMMANDS})
      file(APPEND ${summary} "\"compile_commands\": "
                             "\"${CMAKE_CURRENT_BINARY_DIR}/compile_commands.json\",\n")
    endif()
    file(APPEND ${summary} "\"arrow_version\": \"${ARROW_VERSION}\"\n")
    file(APPEND ${summary} "}\n")
  endif()

endmacro()