/**
 * Copyright 2014-2024, XGBoost Contributors
 */
#include <dmlc/common.h>
#include <dmlc/omp.h>
#include <xgboost/c_api.h>
#include <xgboost/context.h>
#include <xgboost/data.h>
#include <xgboost/logging.h>

#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <memory>
#include <limits>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include "../../src/c_api/c_api_error.h"
#include "../../src/c_api/c_api_utils.h"  // MakeSparseFromPtr
#include "../../src/common/threading_utils.h"
#include "../../src/data/array_interface.h"  // for ArrayInterface

#include "./xgboost_R.h"  // Must follow other includes.

namespace {

/* Note: this class is used as a throwable exception.
Some xgboost C functions that use callbacks will catch exceptions
that happen inside of the callback execution, hence it purposefully
doesn't inherit from 'std::exception' even if used as such. */
struct ErrorWithUnwind {};

void ThrowExceptionFromRError(void *, Rboolean jump) {
  if (jump) {
    throw ErrorWithUnwind();
  }
}

struct PtrToConstChar {
  const char *ptr;
};

SEXP WrappedMkChar(void *void_ptr) {
  return Rf_mkChar(static_cast<PtrToConstChar*>(void_ptr)->ptr);
}

SEXP SafeMkChar(const char *c_str, SEXP continuation_token) {
  PtrToConstChar ptr_struct{c_str};
  return R_UnwindProtect(
    WrappedMkChar, static_cast<void*>(&ptr_struct),
    ThrowExceptionFromRError, nullptr,
    continuation_token);
}

struct RFunAndEnv {
  SEXP R_fun;
  SEXP R_calling_env;
};

SEXP WrappedExecFun(void *void_ptr) {
  RFunAndEnv *r_fun_and_env = static_cast<RFunAndEnv*>(void_ptr);
  SEXP f_expr = Rf_protect(Rf_lang1(r_fun_and_env->R_fun));
  SEXP out = Rf_protect(Rf_eval(f_expr, r_fun_and_env->R_calling_env));
  Rf_unprotect(2);
  return out;
}

SEXP SafeExecFun(SEXP R_fun, SEXP R_calling_env, SEXP continuation_token) {
  RFunAndEnv r_fun_and_env{R_fun, R_calling_env};
  return R_UnwindProtect(
    WrappedExecFun, static_cast<void*>(&r_fun_and_env),
    ThrowExceptionFromRError, nullptr,
    continuation_token);
}

SEXP WrappedAllocReal(void *void_ptr) {
  size_t *size = static_cast<size_t*>(void_ptr);
  return Rf_allocVector(REALSXP, *size);
}

SEXP SafeAllocReal(size_t size, SEXP continuation_token) {
  return R_UnwindProtect(
    WrappedAllocReal, static_cast<void*>(&size),
    ThrowExceptionFromRError, nullptr,
    continuation_token);
}

SEXP WrappedAllocInteger(void *void_ptr) {
  size_t *size = static_cast<size_t*>(void_ptr);
  return Rf_allocVector(INTSXP, *size);
}

SEXP SafeAllocInteger(size_t size, SEXP continuation_token) {
  return R_UnwindProtect(
    WrappedAllocInteger, static_cast<void*>(&size),
    ThrowExceptionFromRError, nullptr,
    continuation_token);
}

[[nodiscard]] std::string MakeArrayInterfaceFromRMat(SEXP R_mat) {
  SEXP mat_dims = Rf_getAttrib(R_mat, R_DimSymbol);
  if (Rf_xlength(mat_dims) > 2) {
    LOG(FATAL) << "Passed input array with more than two dimensions, which is not supported.";
  }
  const int *ptr_mat_dims = INTEGER(mat_dims);

  // Lambda for type dispatch.
  auto make_matrix = [=](auto const *ptr) {
    using namespace xgboost;  // NOLINT
    using T = std::remove_pointer_t<decltype(ptr)>;

    auto m = linalg::MatrixView<T>{
        common::Span{ptr,
          static_cast<std::size_t>(ptr_mat_dims[0]) * static_cast<std::size_t>(ptr_mat_dims[1])},
        {ptr_mat_dims[0], ptr_mat_dims[1]},  // Shape
        DeviceOrd::CPU(),
        linalg::Order::kF  // R uses column-major
    };
    CHECK(m.FContiguous());
    return linalg::ArrayInterfaceStr(m);
  };

  const SEXPTYPE arr_type = TYPEOF(R_mat);
  switch (arr_type) {
    case REALSXP:
      return make_matrix(REAL(R_mat));
    case INTSXP:
      return make_matrix(INTEGER(R_mat));
    case LGLSXP:
      return make_matrix(LOGICAL(R_mat));
    default:
      LOG(FATAL) << "Array or matrix has unsupported type.";
  }

  LOG(FATAL) << "Not reachable";
  return "";
}

[[nodiscard]] std::string MakeArrayInterfaceFromRVector(SEXP R_vec) {
  const size_t vec_len = Rf_xlength(R_vec);

  // Lambda for type dispatch.
  auto make_vec = [=](auto const *ptr) {
    using namespace xgboost;  // NOLINT
    auto v = linalg::MakeVec(ptr, vec_len);
    return linalg::ArrayInterfaceStr(v);
  };

  const SEXPTYPE arr_type = TYPEOF(R_vec);
  switch (arr_type) {
    case REALSXP:
      return make_vec(REAL(R_vec));
    case INTSXP:
      return make_vec(INTEGER(R_vec));
    case LGLSXP:
      return make_vec(LOGICAL(R_vec));
    default:
      LOG(FATAL) << "Array or matrix has unsupported type.";
  }

  LOG(FATAL) << "Not reachable";
  return "";
}

[[nodiscard]] std::string MakeArrayInterfaceFromRDataFrame(SEXP R_df) {
  auto make_vec = [&](auto const *ptr, std::size_t len) {
    auto v = xgboost::linalg::MakeVec(ptr, len);
    return xgboost::linalg::ArrayInterface(v);
  };

  R_xlen_t n_features = Rf_xlength(R_df);
  std::vector<xgboost::Json> array(n_features);
  CHECK_GT(n_features, 0);
  std::size_t len = Rf_xlength(VECTOR_ELT(R_df, 0));

  // The `data.frame` in R actually converts all data into numeric. The other type
  // handlers here are not used. At the moment they are kept as a reference for when we
  // can avoid making data copies during transformation.
  for (R_xlen_t i = 0; i < n_features; ++i) {
    switch (TYPEOF(VECTOR_ELT(R_df, i))) {
      case INTSXP: {
        auto const *ptr = INTEGER(VECTOR_ELT(R_df, i));
        array[i] = make_vec(ptr, len);
        break;
      }
      case REALSXP: {
        auto const *ptr = REAL(VECTOR_ELT(R_df, i));
        array[i] = make_vec(ptr, len);
        break;
      }
      case LGLSXP: {
        auto const *ptr = LOGICAL(VECTOR_ELT(R_df, i));
        array[i] = make_vec(ptr, len);
        break;
      }
      default: {
        LOG(FATAL) << "data.frame has unsupported type.";
      }
    }
  }

  xgboost::Json jinterface{std::move(array)};
  return xgboost::Json::Dump(jinterface);
}

void AddMissingToJson(xgboost::Json *jconfig, SEXP missing, SEXPTYPE arr_type) {
  if (Rf_isNull(missing) || ISNAN(Rf_asReal(missing))) {
    // missing is not specified
    if (arr_type == REALSXP) {
      (*jconfig)["missing"] = std::numeric_limits<double>::quiet_NaN();
    } else {
      (*jconfig)["missing"] = R_NaInt;
    }
  } else {
    // missing specified
    (*jconfig)["missing"] = Rf_asReal(missing);
  }
}

[[nodiscard]] std::string MakeJsonConfigForArray(SEXP missing, SEXP n_threads, SEXPTYPE arr_type) {
  using namespace ::xgboost;  // NOLINT
  Json jconfig{Object{}};
  AddMissingToJson(&jconfig, missing, arr_type);
  jconfig["nthread"] = Rf_asInteger(n_threads);
  return Json::Dump(jconfig);
}

// Allocate a R vector and copy an array interface encoded object to it.
[[nodiscard]] SEXP CopyArrayToR(const char *array_str, SEXP ctoken) {
  xgboost::ArrayInterface<1> array{xgboost::StringView{array_str}};
  // R supports only int and double.
  bool is_int_type =
      xgboost::DispatchDType(array.type, [](auto t) { return std::is_integral_v<decltype(t)>; });
  bool is_float = xgboost::DispatchDType(
      array.type, [](auto v) { return std::is_floating_point_v<decltype(v)>; });
  CHECK(is_int_type || is_float) << "Internal error: Invalid DType.";
  CHECK(array.is_contiguous) << "Internal error: Return by XGBoost should be contiguous";

  // Note: the only case in which this will receive an integer type is
  // for the 'indptr' part of the quantile cut outputs, which comes
  // in sorted order, so the last element contains the maximum value.
  bool fits_into_C_int = xgboost::DispatchDType(array.type, [&](auto t) {
    using T = decltype(t);
    if (!std::is_integral_v<decltype(t)>) {
      return false;
    }
    auto ptr = static_cast<T const *>(array.data);
    T last_elt = ptr[array.n - 1];
    if (last_elt < 0) {
      last_elt = -last_elt;  // no std::abs overload for all possible types
    }
    return last_elt <= std::numeric_limits<int>::max();
  });
  bool use_int = is_int_type && fits_into_C_int;

  // Allocate memory in R
  SEXP out =
      Rf_protect(use_int ? SafeAllocInteger(array.n, ctoken) : SafeAllocReal(array.n, ctoken));

  xgboost::DispatchDType(array.type, [&](auto t) {
    using T = decltype(t);
    auto in_ptr = static_cast<T const *>(array.data);
    if (use_int) {
      auto out_ptr = INTEGER(out);
      std::copy_n(in_ptr, array.n, out_ptr);
    } else {
      auto out_ptr = REAL(out);
      std::copy_n(in_ptr, array.n, out_ptr);
    }
  });

  Rf_unprotect(1);
  return out;
}
}  // namespace

struct RRNGStateController {
  RRNGStateController() {
    GetRNGstate();
  }

  ~RRNGStateController() {
    PutRNGstate();
  }
};

/*!
 * \brief macro to annotate begin of api
 */
#define R_API_BEGIN()                           \
  try {                                         \
    RRNGStateController rng_controller{};

/* Note: an R error triggers a long jump, hence all C++ objects that
allocated memory through non-R allocators, including the exception
object, need to be destructed before triggering the R error.
In order to preserve the error message, it gets copied to a temporary
buffer, and the R error section is reached through a 'goto' statement
that bypasses usual function control flow. */
char cpp_ex_msg[512];
/*!
 * \brief macro to annotate end of api
 */
#define R_API_END()                             \
  } catch(std::exception &e) {                  \
    std::strncpy(cpp_ex_msg, e.what(), 512);    \
    goto throw_cpp_ex_as_R_err;                 \
  }                                             \
  if (false) {                                  \
    throw_cpp_ex_as_R_err:                      \
    Rf_error("%s", cpp_ex_msg);                 \
  }

/**
 * @brief Macro for checking XGBoost return code.
 */
#define CHECK_CALL(__rc)               \
  if ((__rc) != 0) {                   \
    Rf_error("%s", XGBGetLastError()); \
  }

using dmlc::BeginPtr;

XGB_DLL SEXP XGCheckNullPtr_R(SEXP handle) {
  return Rf_ScalarLogical(R_ExternalPtrAddr(handle) == nullptr);
}

XGB_DLL SEXP XGSetArrayDimNamesInplace_R(SEXP arr, SEXP dim_names) {
  Rf_setAttrib(arr, R_DimNamesSymbol, dim_names);
  return R_NilValue;
}

namespace {
void _DMatrixFinalizer(SEXP ext) {
  R_API_BEGIN();
  if (R_ExternalPtrAddr(ext) == NULL) return;
  CHECK_CALL(XGDMatrixFree(R_ExternalPtrAddr(ext)));
  R_ClearExternalPtr(ext);
  R_API_END();
}
} /* namespace */

XGB_DLL SEXP XGBSetGlobalConfig_R(SEXP json_str) {
  R_API_BEGIN();
  CHECK_CALL(XGBSetGlobalConfig(CHAR(Rf_asChar(json_str))));
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBGetGlobalConfig_R() {
  const char* json_str;
  R_API_BEGIN();
  CHECK_CALL(XGBGetGlobalConfig(&json_str));
  R_API_END();
  return Rf_mkString(json_str);
}

XGB_DLL SEXP XGDMatrixCreateFromURI_R(SEXP uri, SEXP silent, SEXP data_split_mode) {
  SEXP ret = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  SEXP uri_char = Rf_protect(Rf_asChar(uri));
  const char *uri_ptr = CHAR(uri_char);
  R_API_BEGIN();
  xgboost::Json jconfig{xgboost::Object{}};
  jconfig["uri"] = std::string(uri_ptr);
  jconfig["silent"] = Rf_asLogical(silent);
  jconfig["data_split_mode"] = Rf_asInteger(data_split_mode);
  const std::string sconfig = xgboost::Json::Dump(jconfig);
  DMatrixHandle handle;
  CHECK_CALL(XGDMatrixCreateFromURI(sconfig.c_str(), &handle));
  R_SetExternalPtrAddr(ret, handle);
  R_RegisterCFinalizerEx(ret, _DMatrixFinalizer, TRUE);
  R_API_END();
  Rf_unprotect(2);
  return ret;
}

XGB_DLL SEXP XGDMatrixCreateFromMat_R(SEXP mat, SEXP missing, SEXP n_threads) {
  SEXP ret = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  R_API_BEGIN();

  DMatrixHandle handle;
  int res_code;
  {
    auto array_str = MakeArrayInterfaceFromRMat(mat);
    auto config_str = MakeJsonConfigForArray(missing, n_threads, TYPEOF(mat));

    res_code = XGDMatrixCreateFromDense(array_str.c_str(), config_str.c_str(), &handle);
  }
  CHECK_CALL(res_code);
  R_SetExternalPtrAddr(ret, handle);
  R_RegisterCFinalizerEx(ret, _DMatrixFinalizer, TRUE);
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGDMatrixCreateFromDF_R(SEXP df, SEXP missing, SEXP n_threads) {
  SEXP ret = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  R_API_BEGIN();

  DMatrixHandle handle;
  std::int32_t rc{0};
  {
    const std::string sinterface = MakeArrayInterfaceFromRDataFrame(df);
    xgboost::Json jconfig{xgboost::Object{}};
    jconfig["missing"] = Rf_asReal(missing);
    jconfig["nthread"] = Rf_asInteger(n_threads);
    std::string sconfig = xgboost::Json::Dump(jconfig);

    rc = XGDMatrixCreateFromColumnar(sinterface.c_str(), sconfig.c_str(), &handle);
  }

  CHECK_CALL(rc);
  R_SetExternalPtrAddr(ret, handle);
  R_RegisterCFinalizerEx(ret, _DMatrixFinalizer, TRUE);
  R_API_END();
  Rf_unprotect(1);

  return ret;
}

namespace {
void CreateFromSparse(SEXP indptr, SEXP indices, SEXP data, std::string *indptr_str,
                      std::string *indices_str, std::string *data_str) {
  const int *p_indptr = INTEGER(indptr);
  const int *p_indices = INTEGER(indices);
  const double *p_data = REAL(data);

  auto nindptr = static_cast<std::size_t>(Rf_xlength(indptr));
  auto ndata = static_cast<std::size_t>(Rf_xlength(data));
  CHECK_EQ(ndata, p_indptr[nindptr - 1]);
  xgboost::detail::MakeSparseFromPtr(p_indptr, p_indices, p_data, nindptr, indptr_str, indices_str,
                                     data_str);
}
}  // namespace

XGB_DLL SEXP XGDMatrixCreateFromCSC_R(SEXP indptr, SEXP indices, SEXP data, SEXP num_row,
                                      SEXP missing, SEXP n_threads) {
  SEXP ret = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  R_API_BEGIN();
  std::int32_t threads = Rf_asInteger(n_threads);
  DMatrixHandle handle;

  int res_code;
  {
    using xgboost::Integer;
    using xgboost::Json;
    using xgboost::Object;
    std::string sindptr, sindices, sdata;
    CreateFromSparse(indptr, indices, data, &sindptr, &sindices, &sdata);
    auto nrow = static_cast<std::size_t>(INTEGER(num_row)[0]);

    Json jconfig{Object{}};
    // Construct configuration
    jconfig["nthread"] = Integer{threads};
    AddMissingToJson(&jconfig, missing, TYPEOF(data));
    std::string config;
    Json::Dump(jconfig, &config);
    res_code = XGDMatrixCreateFromCSC(sindptr.c_str(), sindices.c_str(), sdata.c_str(), nrow,
                                      config.c_str(), &handle);
  }
  CHECK_CALL(res_code);

  R_SetExternalPtrAddr(ret, handle);
  R_RegisterCFinalizerEx(ret, _DMatrixFinalizer, TRUE);
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGDMatrixCreateFromCSR_R(SEXP indptr, SEXP indices, SEXP data, SEXP num_col,
                                      SEXP missing, SEXP n_threads) {
  SEXP ret = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  R_API_BEGIN();
  std::int32_t threads = Rf_asInteger(n_threads);
  DMatrixHandle handle;

  int res_code;
  {
    using xgboost::Integer;
    using xgboost::Json;
    using xgboost::Object;

    std::string sindptr, sindices, sdata;
    CreateFromSparse(indptr, indices, data, &sindptr, &sindices, &sdata);
    auto ncol = static_cast<std::size_t>(INTEGER(num_col)[0]);

    Json jconfig{Object{}};
    // Construct configuration
    jconfig["nthread"] = Integer{threads};
    AddMissingToJson(&jconfig, missing, TYPEOF(data));
    std::string config;
    Json::Dump(jconfig, &config);
    res_code = XGDMatrixCreateFromCSR(sindptr.c_str(), sindices.c_str(), sdata.c_str(), ncol,
                                      config.c_str(), &handle);
  }
  CHECK_CALL(res_code);
  R_SetExternalPtrAddr(ret, handle);
  R_RegisterCFinalizerEx(ret, _DMatrixFinalizer, TRUE);
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGDMatrixSliceDMatrix_R(SEXP handle, SEXP idxset, SEXP allow_groups) {
  SEXP ret = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  R_API_BEGIN();
  R_xlen_t len = Rf_xlength(idxset);
  const int *idxset_ = INTEGER(idxset);
  DMatrixHandle res;

  int res_code;
  {
    std::vector<int> idxvec(len);
    #ifndef _MSC_VER
    #pragma omp simd
    #endif
    for (R_xlen_t i = 0; i < len; ++i) {
      idxvec[i] = idxset_[i] - 1;
    }
    res_code = XGDMatrixSliceDMatrixEx(R_ExternalPtrAddr(handle),
                                       BeginPtr(idxvec), len,
                                       &res,
                                       Rf_asLogical(allow_groups));
  }
  CHECK_CALL(res_code);
  R_SetExternalPtrAddr(ret, res);
  R_RegisterCFinalizerEx(ret, _DMatrixFinalizer, TRUE);
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGDMatrixSaveBinary_R(SEXP handle, SEXP fname, SEXP silent) {
  R_API_BEGIN();
  CHECK_CALL(XGDMatrixSaveBinary(R_ExternalPtrAddr(handle),
                                 CHAR(Rf_asChar(fname)),
                                 Rf_asInteger(silent)));
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGDMatrixSetInfo_R(SEXP handle, SEXP field, SEXP array) {
  R_API_BEGIN();
  SEXP field_ = Rf_protect(Rf_asChar(field));
  SEXP arr_dim = Rf_getAttrib(array, R_DimSymbol);
  int res_code;
  {
    const std::string array_str = Rf_isNull(arr_dim)?
      MakeArrayInterfaceFromRVector(array) : MakeArrayInterfaceFromRMat(array);
    res_code = XGDMatrixSetInfoFromInterface(
      R_ExternalPtrAddr(handle), CHAR(field_), array_str.c_str());
  }
  CHECK_CALL(res_code);
  Rf_unprotect(1);
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGDMatrixSetStrFeatureInfo_R(SEXP handle, SEXP field, SEXP array) {
  R_API_BEGIN();
  size_t len{0};
  if (!Rf_isNull(array)) {
    len = Rf_xlength(array);
  }

  SEXP str_info_holder = Rf_protect(Rf_allocVector(VECSXP, len));
  if (TYPEOF(array) == STRSXP) {
    for (size_t i = 0; i < len; ++i) {
      SET_VECTOR_ELT(str_info_holder, i, STRING_ELT(array, i));
    }
  } else {
    for (size_t i = 0; i < len; ++i) {
      SET_VECTOR_ELT(str_info_holder, i, Rf_asChar(VECTOR_ELT(array, i)));
    }
  }

  SEXP field_ = Rf_protect(Rf_asChar(field));
  const char *name = CHAR(field_);
  int res_code;
  {
    std::vector<std::string> str_info;
    str_info.reserve(len);
    for (size_t i = 0; i < len; ++i) {
      str_info.emplace_back(CHAR(VECTOR_ELT(str_info_holder, i)));
    }
    std::vector<char const*> vec(len);
    std::transform(str_info.cbegin(), str_info.cend(), vec.begin(),
                   [](std::string const &str) { return str.c_str(); });
    res_code = XGDMatrixSetStrFeatureInfo(R_ExternalPtrAddr(handle), name, vec.data(), len);
  }
  CHECK_CALL(res_code);
  Rf_unprotect(2);
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGDMatrixGetStrFeatureInfo_R(SEXP handle, SEXP field) {
  SEXP ret;
  R_API_BEGIN();
  char const **out_features{nullptr};
  bst_ulong len{0};
  const char *name = CHAR(Rf_asChar(field));
  XGDMatrixGetStrFeatureInfo(R_ExternalPtrAddr(handle), name, &len, &out_features);

  if (len > 0) {
    ret = Rf_protect(Rf_allocVector(STRSXP, len));
    for (size_t i = 0; i < len; ++i) {
      SET_STRING_ELT(ret, i, Rf_mkChar(out_features[i]));
    }
  } else {
    ret = Rf_protect(R_NilValue);
  }
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGDMatrixGetFloatInfo_R(SEXP handle, SEXP field) {
  SEXP ret;
  R_API_BEGIN();
  bst_ulong olen;
  const float *res;
  CHECK_CALL(XGDMatrixGetFloatInfo(R_ExternalPtrAddr(handle), CHAR(Rf_asChar(field)), &olen, &res));
  ret = Rf_protect(Rf_allocVector(REALSXP, olen));
  std::copy(res, res + olen, REAL(ret));
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGDMatrixGetUIntInfo_R(SEXP handle, SEXP field) {
  SEXP ret;
  R_API_BEGIN();
  bst_ulong olen;
  const unsigned *res;
  CHECK_CALL(XGDMatrixGetUIntInfo(R_ExternalPtrAddr(handle), CHAR(Rf_asChar(field)), &olen, &res));
  ret = Rf_protect(Rf_allocVector(INTSXP, olen));
  std::copy(res, res + olen, INTEGER(ret));
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGDMatrixNumRow_R(SEXP handle) {
  bst_ulong nrow;
  R_API_BEGIN();
  CHECK_CALL(XGDMatrixNumRow(R_ExternalPtrAddr(handle), &nrow));
  R_API_END();
  return Rf_ScalarInteger(static_cast<int>(nrow));
}

XGB_DLL SEXP XGDMatrixNumCol_R(SEXP handle) {
  bst_ulong ncol;
  R_API_BEGIN();
  CHECK_CALL(XGDMatrixNumCol(R_ExternalPtrAddr(handle), &ncol));
  R_API_END();
  return Rf_ScalarInteger(static_cast<int>(ncol));
}

XGB_DLL SEXP XGProxyDMatrixCreate_R() {
  SEXP out = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  R_API_BEGIN();
  DMatrixHandle proxy_dmat_handle;
  CHECK_CALL(XGProxyDMatrixCreate(&proxy_dmat_handle));
  R_SetExternalPtrAddr(out, proxy_dmat_handle);
  R_RegisterCFinalizerEx(out, _DMatrixFinalizer, TRUE);
  Rf_unprotect(1);
  R_API_END();
  return out;
}

XGB_DLL SEXP XGProxyDMatrixSetDataDense_R(SEXP handle, SEXP R_mat) {
  R_API_BEGIN();
  DMatrixHandle proxy_dmat = R_ExternalPtrAddr(handle);
  int res_code;
  {
    std::string array_str = MakeArrayInterfaceFromRMat(R_mat);
    res_code = XGProxyDMatrixSetDataDense(proxy_dmat, array_str.c_str());
  }
  CHECK_CALL(res_code);
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGProxyDMatrixSetDataCSR_R(SEXP handle, SEXP lst) {
  R_API_BEGIN();
  DMatrixHandle proxy_dmat = R_ExternalPtrAddr(handle);
  int res_code;
  {
    std::string array_str_indptr = MakeArrayInterfaceFromRVector(VECTOR_ELT(lst, 0));
    std::string array_str_indices = MakeArrayInterfaceFromRVector(VECTOR_ELT(lst, 1));
    std::string array_str_data = MakeArrayInterfaceFromRVector(VECTOR_ELT(lst, 2));
    const int ncol = Rf_asInteger(VECTOR_ELT(lst, 3));
    res_code = XGProxyDMatrixSetDataCSR(proxy_dmat,
                                        array_str_indptr.c_str(),
                                        array_str_indices.c_str(),
                                        array_str_data.c_str(),
                                        ncol);
  }
  CHECK_CALL(res_code);
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGProxyDMatrixSetDataColumnar_R(SEXP handle, SEXP lst) {
  R_API_BEGIN();
  DMatrixHandle proxy_dmat = R_ExternalPtrAddr(handle);
  int res_code;
  {
    std::string sinterface = MakeArrayInterfaceFromRDataFrame(lst);
    res_code = XGProxyDMatrixSetDataColumnar(proxy_dmat, sinterface.c_str());
  }
  CHECK_CALL(res_code);
  R_API_END();
  return R_NilValue;
}

namespace {

struct _RDataIterator {
  SEXP f_next;
  SEXP f_reset;
  SEXP calling_env;
  SEXP continuation_token;

  _RDataIterator(
    SEXP f_next, SEXP f_reset, SEXP calling_env, SEXP continuation_token) :
  f_next(f_next), f_reset(f_reset), calling_env(calling_env),
  continuation_token(continuation_token) {}

  void reset() {
    SafeExecFun(this->f_reset, this->calling_env, this->continuation_token);
  }

  int next() {
    SEXP R_res = Rf_protect(
      SafeExecFun(this->f_next, this->calling_env, this->continuation_token));
    int res = Rf_asInteger(R_res);
    Rf_unprotect(1);
    return res;
  }
};

void _reset_RDataIterator(DataIterHandle iter) {
  static_cast<_RDataIterator*>(iter)->reset();
}

int _next_RDataIterator(DataIterHandle iter) {
  return static_cast<_RDataIterator*>(iter)->next();
}

SEXP XGDMatrixCreateFromCallbackGeneric_R(
  SEXP f_next, SEXP f_reset, SEXP calling_env, SEXP proxy_dmat,
  SEXP n_threads, SEXP missing, SEXP max_bin, SEXP ref_dmat,
  SEXP cache_prefix, bool as_quantile_dmatrix) {
  SEXP continuation_token = Rf_protect(R_MakeUnwindCont());
  SEXP out = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  R_API_BEGIN();
  DMatrixHandle out_dmat;

  int res_code;
  try {
    _RDataIterator data_iterator(f_next, f_reset, calling_env, continuation_token);

    std::string str_cache_prefix;
    xgboost::Json jconfig{xgboost::Object{}};
    jconfig["missing"] = Rf_asReal(missing);
    if (!Rf_isNull(n_threads)) {
      jconfig["nthread"] = Rf_asInteger(n_threads);
    }
    if (as_quantile_dmatrix) {
      if (!Rf_isNull(max_bin)) {
        jconfig["max_bin"] = Rf_asInteger(max_bin);
      }
    } else {
      str_cache_prefix = std::string(CHAR(Rf_asChar(cache_prefix)));
      jconfig["cache_prefix"] = str_cache_prefix;
    }
    std::string json_str = xgboost::Json::Dump(jconfig);

    DMatrixHandle ref_dmat_handle = nullptr;
    if (as_quantile_dmatrix && !Rf_isNull(ref_dmat)) {
      ref_dmat_handle = R_ExternalPtrAddr(ref_dmat);
    }

    if (as_quantile_dmatrix) {
      res_code = XGQuantileDMatrixCreateFromCallback(
        &data_iterator,
        R_ExternalPtrAddr(proxy_dmat),
        ref_dmat_handle,
        _reset_RDataIterator,
        _next_RDataIterator,
        json_str.c_str(),
        &out_dmat);
    } else {
      res_code = XGDMatrixCreateFromCallback(
        &data_iterator,
        R_ExternalPtrAddr(proxy_dmat),
        _reset_RDataIterator,
        _next_RDataIterator,
        json_str.c_str(),
        &out_dmat);
    }
  } catch (ErrorWithUnwind &e) {
    R_ContinueUnwind(continuation_token);
  }
  CHECK_CALL(res_code);

  R_SetExternalPtrAddr(out, out_dmat);
  R_RegisterCFinalizerEx(out, _DMatrixFinalizer, TRUE);
  Rf_unprotect(2);
  R_API_END();
  return out;
}

} /* namespace */

XGB_DLL SEXP XGQuantileDMatrixCreateFromCallback_R(
  SEXP f_next, SEXP f_reset, SEXP calling_env, SEXP proxy_dmat,
  SEXP n_threads, SEXP missing, SEXP max_bin, SEXP ref_dmat) {
  return XGDMatrixCreateFromCallbackGeneric_R(
    f_next, f_reset, calling_env, proxy_dmat,
    n_threads, missing, max_bin, ref_dmat,
    R_NilValue, true);
}

XGB_DLL SEXP XGDMatrixCreateFromCallback_R(
  SEXP f_next, SEXP f_reset, SEXP calling_env, SEXP proxy_dmat,
  SEXP n_threads, SEXP missing, SEXP cache_prefix) {
  return XGDMatrixCreateFromCallbackGeneric_R(
    f_next, f_reset, calling_env, proxy_dmat,
    n_threads, missing, R_NilValue, R_NilValue,
    cache_prefix, false);
}

XGB_DLL SEXP XGDMatrixFree_R(SEXP proxy_dmat) {
  _DMatrixFinalizer(proxy_dmat);
  return R_NilValue;
}

XGB_DLL SEXP XGGetRNAIntAsDouble() {
  double sentinel_as_double = static_cast<double>(R_NaInt);
  return Rf_ScalarReal(sentinel_as_double);
}

XGB_DLL SEXP XGDuplicate_R(SEXP obj) {
  return Rf_duplicate(obj);
}

XGB_DLL SEXP XGPointerEqComparison_R(SEXP obj1, SEXP obj2) {
  return Rf_ScalarLogical(R_ExternalPtrAddr(obj1) == R_ExternalPtrAddr(obj2));
}

XGB_DLL SEXP XGDMatrixGetQuantileCut_R(SEXP handle) {
  const char *out_names[] = {"indptr", "data", ""};
  SEXP continuation_token = Rf_protect(R_MakeUnwindCont());
  SEXP out = Rf_protect(Rf_mkNamed(VECSXP, out_names));
  R_API_BEGIN();
  const char *out_indptr;
  const char *out_data;
  CHECK_CALL(XGDMatrixGetQuantileCut(R_ExternalPtrAddr(handle), "{}", &out_indptr, &out_data));
  try {
    SET_VECTOR_ELT(out, 0, CopyArrayToR(out_indptr, continuation_token));
    SET_VECTOR_ELT(out, 1, CopyArrayToR(out_data, continuation_token));
  } catch (ErrorWithUnwind &e) {
    R_ContinueUnwind(continuation_token);
  }
  R_API_END();
  Rf_unprotect(2);
  return out;
}

XGB_DLL SEXP XGDMatrixNumNonMissing_R(SEXP handle) {
  SEXP out = Rf_protect(Rf_allocVector(REALSXP, 1));
  R_API_BEGIN();
  bst_ulong out_;
  CHECK_CALL(XGDMatrixNumNonMissing(R_ExternalPtrAddr(handle), &out_));
  REAL(out)[0] = static_cast<double>(out_);
  R_API_END();
  Rf_unprotect(1);
  return out;
}

XGB_DLL SEXP XGDMatrixGetDataAsCSR_R(SEXP handle) {
  const char *out_names[] = {"indptr", "indices", "data", "ncols", ""};
  SEXP out = Rf_protect(Rf_mkNamed(VECSXP, out_names));
  R_API_BEGIN();

  bst_ulong nrows, ncols, nnz;
  CHECK_CALL(XGDMatrixNumRow(R_ExternalPtrAddr(handle), &nrows));
  CHECK_CALL(XGDMatrixNumCol(R_ExternalPtrAddr(handle), &ncols));
  CHECK_CALL(XGDMatrixNumNonMissing(R_ExternalPtrAddr(handle), &nnz));
  if (std::max(nrows, ncols) > std::numeric_limits<int>::max()) {
    Rf_error("%s", "Error: resulting DMatrix data does not fit into R 'dgRMatrix'.");
  }

  SET_VECTOR_ELT(out, 0, Rf_allocVector(INTSXP, nrows + 1));
  SET_VECTOR_ELT(out, 1, Rf_allocVector(INTSXP, nnz));
  SET_VECTOR_ELT(out, 2, Rf_allocVector(REALSXP, nnz));
  SET_VECTOR_ELT(out, 3, Rf_ScalarInteger(ncols));

  std::unique_ptr<bst_ulong[]> indptr(new bst_ulong[nrows + 1]);
  std::unique_ptr<unsigned[]> indices(new unsigned[nnz]);
  std::unique_ptr<float[]> data(new float[nnz]);

  CHECK_CALL(XGDMatrixGetDataAsCSR(R_ExternalPtrAddr(handle),
                                   "{}",
                                   indptr.get(),
                                   indices.get(),
                                   data.get()));

  std::copy(indptr.get(), indptr.get() + nrows + 1, INTEGER(VECTOR_ELT(out, 0)));
  std::copy(indices.get(), indices.get() + nnz, INTEGER(VECTOR_ELT(out, 1)));
  std::copy(data.get(), data.get() + nnz, REAL(VECTOR_ELT(out, 2)));

  R_API_END();
  Rf_unprotect(1);
  return out;
}

// functions related to booster
namespace {
void _BoosterFinalizer(SEXP R_ptr) {
  if (R_ExternalPtrAddr(R_ptr) == NULL) return;
  CHECK_CALL(XGBoosterFree(R_ExternalPtrAddr(R_ptr)));
  R_ClearExternalPtr(R_ptr);
}

/* Booster is represented as an altrep list with one element which
corresponds to an 'externalptr' holding the C object, forbidding
modification by not implementing setters, and adding custom serialization. */
R_altrep_class_t XGBAltrepPointerClass;

R_xlen_t XGBAltrepPointerLength_R(SEXP R_altrepped_obj) {
  return 1;
}

SEXP XGBAltrepPointerGetElt_R(SEXP R_altrepped_obj, R_xlen_t idx) {
  return R_altrep_data1(R_altrepped_obj);
}

SEXP XGBMakeEmptyAltrep() {
  SEXP class_name = Rf_protect(Rf_mkString("xgb.Booster"));
  SEXP elt_names = Rf_protect(Rf_mkString("ptr"));
  SEXP R_ptr = Rf_protect(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
  SEXP R_altrepped_obj = Rf_protect(R_new_altrep(XGBAltrepPointerClass, R_ptr, R_NilValue));
  Rf_setAttrib(R_altrepped_obj, R_NamesSymbol, elt_names);
  Rf_setAttrib(R_altrepped_obj, R_ClassSymbol, class_name);
  Rf_unprotect(4);
  return R_altrepped_obj;
}

/* Note: the idea for separating this function from the one above is to be
able to trigger all R allocations first before doing non-R allocations. */
void XGBAltrepSetPointer(SEXP R_altrepped_obj, BoosterHandle handle) {
  SEXP R_ptr = R_altrep_data1(R_altrepped_obj);
  R_SetExternalPtrAddr(R_ptr, handle);
  R_RegisterCFinalizerEx(R_ptr, _BoosterFinalizer, TRUE);
}

SEXP XGBAltrepSerializer_R(SEXP R_altrepped_obj) {
  R_API_BEGIN();
  BoosterHandle handle = R_ExternalPtrAddr(R_altrep_data1(R_altrepped_obj));
  char const *serialized_bytes;
  bst_ulong serialized_length;
  CHECK_CALL(XGBoosterSerializeToBuffer(
    handle, &serialized_length, &serialized_bytes));
  SEXP R_state = Rf_protect(Rf_allocVector(RAWSXP, serialized_length));
  if (serialized_length != 0) {
    std::memcpy(RAW(R_state), serialized_bytes, serialized_length);
  }
  Rf_unprotect(1);
  return R_state;
  R_API_END();
  return R_NilValue; /* <- should not be reached */
}

SEXP XGBAltrepDeserializer_R(SEXP unused, SEXP R_state) {
  SEXP R_altrepped_obj = Rf_protect(XGBMakeEmptyAltrep());
  R_API_BEGIN();
  BoosterHandle handle = nullptr;
  CHECK_CALL(XGBoosterCreate(nullptr, 0, &handle));
  int res_code = XGBoosterUnserializeFromBuffer(handle,
                                                RAW(R_state),
                                                Rf_xlength(R_state));
  if (res_code != 0) {
    XGBoosterFree(handle);
  }
  CHECK_CALL(res_code);
  XGBAltrepSetPointer(R_altrepped_obj, handle);
  R_API_END();
  Rf_unprotect(1);
  return R_altrepped_obj;
}

// https://purrple.cat/blog/2018/10/14/altrep-and-cpp/
Rboolean XGBAltrepInspector_R(
  SEXP x, int pre, int deep, int pvec,
  void (*inspect_subtree)(SEXP, int, int, int)) {
  Rprintf("Altrepped external pointer [address:%p]\n",
          R_ExternalPtrAddr(R_altrep_data1(x)));
  return TRUE;
}

SEXP XGBAltrepDuplicate_R(SEXP R_altrepped_obj, Rboolean deep) {
  R_API_BEGIN();
  if (!deep) {
    SEXP out = Rf_protect(XGBMakeEmptyAltrep());
    R_set_altrep_data1(out, R_altrep_data1(R_altrepped_obj));
    Rf_unprotect(1);
    return out;
  } else {
    SEXP out = Rf_protect(XGBMakeEmptyAltrep());
    char const *serialized_bytes;
    bst_ulong serialized_length;
    CHECK_CALL(XGBoosterSerializeToBuffer(
      R_ExternalPtrAddr(R_altrep_data1(R_altrepped_obj)),
      &serialized_length, &serialized_bytes));
    BoosterHandle new_handle = nullptr;
    CHECK_CALL(XGBoosterCreate(nullptr, 0, &new_handle));
    int res_code = XGBoosterUnserializeFromBuffer(new_handle,
                                                  serialized_bytes,
                                                  serialized_length);
    if (res_code != 0) {
      XGBoosterFree(new_handle);
    }
    CHECK_CALL(res_code);
    XGBAltrepSetPointer(out, new_handle);
    Rf_unprotect(1);
    return out;
  }
  R_API_END();
  return R_NilValue; /* <- should not be reached */
}

} /* namespace */

XGB_DLL void XGBInitializeAltrepClass_R(DllInfo *dll) {
  XGBAltrepPointerClass = R_make_altlist_class("XGBAltrepPointerClass", "xgboost", dll);
  R_set_altrep_Length_method(XGBAltrepPointerClass, XGBAltrepPointerLength_R);
  R_set_altlist_Elt_method(XGBAltrepPointerClass, XGBAltrepPointerGetElt_R);
  R_set_altrep_Inspect_method(XGBAltrepPointerClass, XGBAltrepInspector_R);
  R_set_altrep_Serialized_state_method(XGBAltrepPointerClass, XGBAltrepSerializer_R);
  R_set_altrep_Unserialize_method(XGBAltrepPointerClass, XGBAltrepDeserializer_R);
  R_set_altrep_Duplicate_method(XGBAltrepPointerClass, XGBAltrepDuplicate_R);
}

XGB_DLL SEXP XGBoosterCreate_R(SEXP dmats) {
  SEXP out = Rf_protect(XGBMakeEmptyAltrep());
  R_API_BEGIN();
  R_xlen_t len = Rf_xlength(dmats);
  BoosterHandle handle;

  int res_code;
  {
    std::vector<void*> dvec(len);
    for (R_xlen_t i = 0; i < len; ++i) {
      dvec[i] = R_ExternalPtrAddr(VECTOR_ELT(dmats, i));
    }
    res_code = XGBoosterCreate(BeginPtr(dvec), dvec.size(), &handle);
  }
  CHECK_CALL(res_code);
  XGBAltrepSetPointer(out, handle);
  R_API_END();
  Rf_unprotect(1);
  return out;
}

XGB_DLL SEXP XGBoosterCopyInfoFromDMatrix_R(SEXP booster, SEXP dmat) {
  R_API_BEGIN();
  char const **feature_names;
  bst_ulong len_feature_names = 0;
  CHECK_CALL(XGDMatrixGetStrFeatureInfo(R_ExternalPtrAddr(dmat),
                                        "feature_name",
                                        &len_feature_names,
                                        &feature_names));
  if (len_feature_names) {
    CHECK_CALL(XGBoosterSetStrFeatureInfo(R_ExternalPtrAddr(booster),
                                          "feature_name",
                                          feature_names,
                                          len_feature_names));
  }

  char const **feature_types;
  bst_ulong len_feature_types = 0;
  CHECK_CALL(XGDMatrixGetStrFeatureInfo(R_ExternalPtrAddr(dmat),
                                        "feature_type",
                                        &len_feature_types,
                                        &feature_types));
  if (len_feature_types) {
    CHECK_CALL(XGBoosterSetStrFeatureInfo(R_ExternalPtrAddr(booster),
                                          "feature_type",
                                          feature_types,
                                          len_feature_types));
  }
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterSetStrFeatureInfo_R(SEXP handle, SEXP field, SEXP features) {
  R_API_BEGIN();
  SEXP field_char = Rf_protect(Rf_asChar(field));
  bst_ulong len_features = Rf_xlength(features);

  int res_code;
  {
    std::vector<const char*> str_arr(len_features);
    for (bst_ulong idx = 0; idx < len_features; idx++) {
      str_arr[idx] = CHAR(STRING_ELT(features, idx));
    }
    res_code = XGBoosterSetStrFeatureInfo(R_ExternalPtrAddr(handle),
                                          CHAR(field_char),
                                          str_arr.data(),
                                          len_features);
  }
  CHECK_CALL(res_code);
  Rf_unprotect(1);
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterGetStrFeatureInfo_R(SEXP handle, SEXP field) {
  R_API_BEGIN();
  bst_ulong len;
  const char **out_features;
  SEXP field_char = Rf_protect(Rf_asChar(field));
  CHECK_CALL(XGBoosterGetStrFeatureInfo(R_ExternalPtrAddr(handle),
                                        CHAR(field_char), &len, &out_features));
  SEXP out = Rf_protect(Rf_allocVector(STRSXP, len));
  for (bst_ulong idx = 0; idx < len; idx++) {
    SET_STRING_ELT(out, idx, Rf_mkChar(out_features[idx]));
  }
  Rf_unprotect(2);
  return out;
  R_API_END();
  return R_NilValue; /* <- should not be reached */
}

XGB_DLL SEXP XGBoosterBoostedRounds_R(SEXP handle) {
  SEXP out = Rf_protect(Rf_allocVector(INTSXP, 1));
  R_API_BEGIN();
  CHECK_CALL(XGBoosterBoostedRounds(R_ExternalPtrAddr(handle), INTEGER(out)));
  R_API_END();
  Rf_unprotect(1);
  return out;
}

/* Note: R's integer class is 32-bit-and-signed only, while xgboost
supports more, so it returns it as a floating point instead */
XGB_DLL SEXP XGBoosterGetNumFeature_R(SEXP handle) {
  SEXP out = Rf_protect(Rf_allocVector(REALSXP, 1));
  R_API_BEGIN();
  bst_ulong res;
  CHECK_CALL(XGBoosterGetNumFeature(R_ExternalPtrAddr(handle), &res));
  REAL(out)[0] = static_cast<double>(res);
  R_API_END();
  Rf_unprotect(1);
  return out;
}

XGB_DLL SEXP XGBoosterSetParam_R(SEXP handle, SEXP name, SEXP val) {
  R_API_BEGIN();
  SEXP name_ = Rf_protect(Rf_asChar(name));
  SEXP val_ = Rf_protect(Rf_asChar(val));
  CHECK_CALL(XGBoosterSetParam(R_ExternalPtrAddr(handle),
                               CHAR(name_),
                               CHAR(val_)));
  Rf_unprotect(2);
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterUpdateOneIter_R(SEXP handle, SEXP iter, SEXP dtrain) {
  R_API_BEGIN();
  CHECK_CALL(XGBoosterUpdateOneIter(R_ExternalPtrAddr(handle),
                                    Rf_asInteger(iter),
                                    R_ExternalPtrAddr(dtrain)));
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterTrainOneIter_R(SEXP handle, SEXP dtrain, SEXP iter, SEXP grad, SEXP hess) {
  R_API_BEGIN();
  CHECK_EQ(Rf_xlength(grad), Rf_xlength(hess)) << "gradient and hess must have same length.";
  SEXP gdim = Rf_getAttrib(grad, R_DimSymbol);
  SEXP hdim = Rf_getAttrib(hess, R_DimSymbol);

  int res_code;
  {
    const std::string s_grad = Rf_isNull(gdim)?
      MakeArrayInterfaceFromRVector(grad) : MakeArrayInterfaceFromRMat(grad);
    const std::string s_hess = Rf_isNull(hdim)?
      MakeArrayInterfaceFromRVector(hess) : MakeArrayInterfaceFromRMat(hess);
    res_code = XGBoosterTrainOneIter(R_ExternalPtrAddr(handle), R_ExternalPtrAddr(dtrain),
                                     Rf_asInteger(iter), s_grad.c_str(), s_hess.c_str());
  }
  CHECK_CALL(res_code);

  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterEvalOneIter_R(SEXP handle, SEXP iter, SEXP dmats, SEXP evnames) {
  const char *ret;
  R_API_BEGIN();
  CHECK_EQ(Rf_xlength(dmats), Rf_xlength(evnames))
      << "dmats and evnams must have same length";
  R_xlen_t len = Rf_xlength(dmats);
  SEXP evnames_lst = Rf_protect(Rf_allocVector(VECSXP, len));
  for (R_xlen_t i = 0; i < len; i++) {
    SET_VECTOR_ELT(evnames_lst, i, Rf_asChar(VECTOR_ELT(evnames, i)));
  }

  int res_code;
  {
    std::vector<void*> vec_dmats(len);
    std::vector<std::string> vec_names;
    vec_names.reserve(len);
    std::vector<const char*> vec_sptr(len);
    for (R_xlen_t i = 0; i < len; ++i) {
      vec_dmats[i] = R_ExternalPtrAddr(VECTOR_ELT(dmats, i));
      vec_names.emplace_back(CHAR(VECTOR_ELT(evnames_lst, i)));
    }
    for (R_xlen_t i = 0; i < len; ++i) {
      vec_sptr[i] = vec_names[i].c_str();
    }
    res_code = XGBoosterEvalOneIter(R_ExternalPtrAddr(handle),
                                    Rf_asInteger(iter),
                                    BeginPtr(vec_dmats),
                                    BeginPtr(vec_sptr),
                                    len, &ret);
  }
  CHECK_CALL(res_code);
  Rf_unprotect(1);
  R_API_END();
  return Rf_mkString(ret);
}

namespace {

struct ProxyDmatrixError : public std::exception {};

struct ProxyDmatrixWrapper {
  DMatrixHandle proxy_dmat_handle;

  ProxyDmatrixWrapper() {
    int res_code = XGProxyDMatrixCreate(&this->proxy_dmat_handle);
    if (res_code != 0) {
      throw ProxyDmatrixError();
    }
  }

  ~ProxyDmatrixWrapper() {
    if (this->proxy_dmat_handle) {
      XGDMatrixFree(this->proxy_dmat_handle);
      this->proxy_dmat_handle = nullptr;
    }
  }

  DMatrixHandle get_handle() {
    return this->proxy_dmat_handle;
  }
};

std::unique_ptr<ProxyDmatrixWrapper> GetProxyDMatrixWithBaseMargin(SEXP base_margin) {
  if (Rf_isNull(base_margin)) {
    return std::unique_ptr<ProxyDmatrixWrapper>(nullptr);
  }

  SEXP base_margin_dim = Rf_getAttrib(base_margin, R_DimSymbol);
  int res_code;
  try {
    const std::string array_str = Rf_isNull(base_margin_dim)?
      MakeArrayInterfaceFromRVector(base_margin) : MakeArrayInterfaceFromRMat(base_margin);
    std::unique_ptr<ProxyDmatrixWrapper> proxy_dmat(new ProxyDmatrixWrapper());
    res_code = XGDMatrixSetInfoFromInterface(proxy_dmat->get_handle(),
                                             "base_margin",
                                             array_str.c_str());
    if (res_code != 0) {
      throw ProxyDmatrixError();
    }
    return proxy_dmat;
  } catch(ProxyDmatrixError &err) {
    Rf_error("%s", XGBGetLastError());
  }
}

enum class PredictionInputType {DMatrix, DenseMatrix, CSRMatrix, DataFrame};

SEXP XGBoosterPredictGeneric(SEXP handle, SEXP input_data, SEXP json_config,
                                    PredictionInputType input_type, SEXP missing,
                                    SEXP base_margin) {
  SEXP r_out_result = R_NilValue;
  R_API_BEGIN();
  SEXP json_config_ = Rf_protect(Rf_asChar(json_config));
  char const *c_json_config = CHAR(json_config_);

  bst_ulong out_dim;
  bst_ulong const *out_shape;
  float const *out_result;

  int res_code;
  {
    switch (input_type) {
      case PredictionInputType::DMatrix: {
        res_code = XGBoosterPredictFromDMatrix(R_ExternalPtrAddr(handle),
                                               R_ExternalPtrAddr(input_data), c_json_config,
                                               &out_shape, &out_dim, &out_result);
        break;
      }

      case PredictionInputType::CSRMatrix: {
        std::unique_ptr<ProxyDmatrixWrapper> proxy_dmat = GetProxyDMatrixWithBaseMargin(
          base_margin);
        DMatrixHandle proxy_dmat_handle = proxy_dmat.get()? proxy_dmat->get_handle() : nullptr;

        SEXP indptr = VECTOR_ELT(input_data, 0);
        SEXP indices = VECTOR_ELT(input_data, 1);
        SEXP data = VECTOR_ELT(input_data, 2);
        const int ncol_csr = Rf_asInteger(VECTOR_ELT(input_data, 3));
        const SEXPTYPE type_data = TYPEOF(data);
        CHECK_EQ(type_data, REALSXP);
        std::string sindptr, sindices, sdata;
        CreateFromSparse(indptr, indices, data, &sindptr, &sindices, &sdata);

        xgboost::StringView json_str(c_json_config);
        xgboost::Json new_json = xgboost::Json::Load(json_str);
        AddMissingToJson(&new_json, missing, type_data);
        const std::string new_c_json = xgboost::Json::Dump(new_json);

        res_code = XGBoosterPredictFromCSR(
          R_ExternalPtrAddr(handle), sindptr.c_str(), sindices.c_str(), sdata.c_str(),
          ncol_csr, new_c_json.c_str(), proxy_dmat_handle, &out_shape, &out_dim, &out_result);
        break;
      }

      case PredictionInputType::DenseMatrix: {
        std::unique_ptr<ProxyDmatrixWrapper> proxy_dmat = GetProxyDMatrixWithBaseMargin(
          base_margin);
        DMatrixHandle proxy_dmat_handle = proxy_dmat.get()? proxy_dmat->get_handle() : nullptr;
        const std::string array_str = MakeArrayInterfaceFromRMat(input_data);

        xgboost::StringView json_str(c_json_config);
        xgboost::Json new_json = xgboost::Json::Load(json_str);
        AddMissingToJson(&new_json, missing, TYPEOF(input_data));
        const std::string new_c_json = xgboost::Json::Dump(new_json);

        res_code = XGBoosterPredictFromDense(
          R_ExternalPtrAddr(handle), array_str.c_str(), new_c_json.c_str(),
          proxy_dmat_handle, &out_shape, &out_dim, &out_result);
        break;
      }

      case PredictionInputType::DataFrame: {
        std::unique_ptr<ProxyDmatrixWrapper> proxy_dmat = GetProxyDMatrixWithBaseMargin(
          base_margin);
        DMatrixHandle proxy_dmat_handle = proxy_dmat.get()? proxy_dmat->get_handle() : nullptr;

        const std::string df_str = MakeArrayInterfaceFromRDataFrame(input_data);

        xgboost::StringView json_str(c_json_config);
        xgboost::Json new_json = xgboost::Json::Load(json_str);
        AddMissingToJson(&new_json, missing, REALSXP);
        const std::string new_c_json = xgboost::Json::Dump(new_json);

        res_code = XGBoosterPredictFromColumnar(
          R_ExternalPtrAddr(handle), df_str.c_str(), new_c_json.c_str(),
          proxy_dmat_handle, &out_shape, &out_dim, &out_result);
        break;
      }
    }
  }
  CHECK_CALL(res_code);

  SEXP r_out_shape = Rf_protect(Rf_allocVector(INTSXP, out_dim));
  size_t len = 1;
  int *r_out_shape_ = INTEGER(r_out_shape);
  for (size_t i = 0; i < out_dim; ++i) {
    r_out_shape_[out_dim - i - 1] = out_shape[i];
    len *= out_shape[i];
  }
  r_out_result = Rf_protect(Rf_allocVector(REALSXP, len));
  std::copy(out_result, out_result + len, REAL(r_out_result));

  if (out_dim > 1) {
    Rf_setAttrib(r_out_result, R_DimSymbol, r_out_shape);
  }

  R_API_END();
  Rf_unprotect(3);

  return r_out_result;
}

}  // namespace

XGB_DLL SEXP XGBoosterPredictFromDMatrix_R(SEXP handle, SEXP dmat, SEXP json_config)  {
  return XGBoosterPredictGeneric(handle, dmat, json_config,
                                 PredictionInputType::DMatrix, R_NilValue, R_NilValue);
}

XGB_DLL SEXP XGBoosterPredictFromDense_R(SEXP handle, SEXP R_mat, SEXP missing,
                                         SEXP json_config, SEXP base_margin) {
  return XGBoosterPredictGeneric(handle, R_mat, json_config,
                                 PredictionInputType::DenseMatrix, missing, base_margin);
}

XGB_DLL SEXP XGBoosterPredictFromCSR_R(SEXP handle, SEXP lst, SEXP missing,
                                       SEXP json_config, SEXP base_margin) {
  return XGBoosterPredictGeneric(handle, lst, json_config,
                                 PredictionInputType::CSRMatrix, missing, base_margin);
}

XGB_DLL SEXP XGBoosterPredictFromColumnar_R(SEXP handle, SEXP R_df, SEXP missing,
                                            SEXP json_config, SEXP base_margin) {
  return XGBoosterPredictGeneric(handle, R_df, json_config,
                                 PredictionInputType::DataFrame, missing, base_margin);
}

XGB_DLL SEXP XGBoosterLoadModel_R(SEXP handle, SEXP fname) {
  R_API_BEGIN();
  CHECK_CALL(XGBoosterLoadModel(R_ExternalPtrAddr(handle), CHAR(Rf_asChar(fname))));
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterSaveModel_R(SEXP handle, SEXP fname) {
  R_API_BEGIN();
  CHECK_CALL(XGBoosterSaveModel(R_ExternalPtrAddr(handle), CHAR(Rf_asChar(fname))));
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterLoadModelFromRaw_R(SEXP handle, SEXP raw) {
  R_API_BEGIN();
  CHECK_CALL(XGBoosterLoadModelFromBuffer(R_ExternalPtrAddr(handle),
                                          RAW(raw),
                                          Rf_xlength(raw)));
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterSaveModelToRaw_R(SEXP handle, SEXP json_config) {
  SEXP ret;
  R_API_BEGIN();
  bst_ulong olen;
  char const *c_json_config = CHAR(Rf_asChar(json_config));
  char const *raw;
  CHECK_CALL(XGBoosterSaveModelToBuffer(R_ExternalPtrAddr(handle), c_json_config, &olen, &raw))
  ret = Rf_protect(Rf_allocVector(RAWSXP, olen));
  if (olen != 0) {
    std::memcpy(RAW(ret), raw, olen);
  }
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGBoosterSaveJsonConfig_R(SEXP handle) {
  const char* ret;
  R_API_BEGIN();
  bst_ulong len {0};
  CHECK_CALL(XGBoosterSaveJsonConfig(R_ExternalPtrAddr(handle),
                                     &len,
                                     &ret));
  R_API_END();
  return Rf_mkString(ret);
}

XGB_DLL SEXP XGBoosterLoadJsonConfig_R(SEXP handle, SEXP value) {
  R_API_BEGIN();
  CHECK_CALL(XGBoosterLoadJsonConfig(R_ExternalPtrAddr(handle), CHAR(Rf_asChar(value))));
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterSerializeToBuffer_R(SEXP handle) {
  SEXP ret;
  R_API_BEGIN();
  bst_ulong out_len;
  const char *raw;
  CHECK_CALL(XGBoosterSerializeToBuffer(R_ExternalPtrAddr(handle), &out_len, &raw));
  ret = Rf_protect(Rf_allocVector(RAWSXP, out_len));
  if (out_len != 0) {
    memcpy(RAW(ret), raw, out_len);
  }
  R_API_END();
  Rf_unprotect(1);
  return ret;
}

XGB_DLL SEXP XGBoosterUnserializeFromBuffer_R(SEXP handle, SEXP raw) {
  R_API_BEGIN();
  CHECK_CALL(XGBoosterUnserializeFromBuffer(R_ExternalPtrAddr(handle),
                                 RAW(raw),
                                 Rf_xlength(raw)));
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterDumpModel_R(SEXP handle, SEXP fmap, SEXP with_stats, SEXP dump_format) {
  SEXP out;
  SEXP continuation_token = Rf_protect(R_MakeUnwindCont());
  SEXP dump_format_ = Rf_protect(Rf_asChar(dump_format));
  SEXP fmap_ = Rf_protect(Rf_asChar(fmap));
  R_API_BEGIN();
  bst_ulong olen;
  const char **res;
  const char *fmt = CHAR(dump_format_);
  CHECK_CALL(XGBoosterDumpModelEx(R_ExternalPtrAddr(handle),
                                CHAR(fmap_),
                                Rf_asInteger(with_stats),
                                fmt,
                                &olen, &res));
  out = Rf_protect(Rf_allocVector(STRSXP, olen));
  try {
    if (!strcmp("json", fmt)) {
      std::stringstream stream;
      stream <<  "[\n";
      for (size_t i = 0; i < olen; ++i) {
        stream << res[i];
        if (i < olen - 1) {
          stream << ",\n";
        } else {
          stream << "\n";
        }
      }
      stream <<  "]";
      const std::string temp_str = stream.str();
      SET_STRING_ELT(out, 0, SafeMkChar(temp_str.c_str(), continuation_token));
    } else {
      for (size_t i = 0; i < olen; ++i) {
        std::stringstream stream;
        stream <<  "booster[" << i <<"]\n" << res[i];
        const std::string temp_str = stream.str();
        SET_STRING_ELT(out, i, SafeMkChar(temp_str.c_str(), continuation_token));
      }
    }
  } catch (ErrorWithUnwind &e) {
    R_ContinueUnwind(continuation_token);
  }
  R_API_END();
  Rf_unprotect(4);
  return out;
}

XGB_DLL SEXP XGBoosterGetAttr_R(SEXP handle, SEXP name) {
  SEXP out;
  R_API_BEGIN();
  int success;
  const char *val;
  CHECK_CALL(XGBoosterGetAttr(R_ExternalPtrAddr(handle),
                              CHAR(Rf_asChar(name)),
                              &val,
                              &success));
  if (success) {
    out = Rf_protect(Rf_allocVector(STRSXP, 1));
    SET_STRING_ELT(out, 0, Rf_mkChar(val));
  } else {
    out = Rf_protect(R_NilValue);
  }
  R_API_END();
  Rf_unprotect(1);
  return out;
}

XGB_DLL SEXP XGBoosterSetAttr_R(SEXP handle, SEXP name, SEXP val) {
  R_API_BEGIN();
  const char *v = nullptr;
  SEXP name_ = Rf_protect(Rf_asChar(name));
  SEXP val_;
  int n_protected = 1;
  if (!Rf_isNull(val)) {
    val_ = Rf_protect(Rf_asChar(val));
    n_protected++;
    v = CHAR(val_);
  }

  CHECK_CALL(XGBoosterSetAttr(R_ExternalPtrAddr(handle),
                              CHAR(name_), v));
  Rf_unprotect(n_protected);
  R_API_END();
  return R_NilValue;
}

XGB_DLL SEXP XGBoosterGetAttrNames_R(SEXP handle) {
  SEXP out;
  R_API_BEGIN();
  bst_ulong len;
  const char **res;
  CHECK_CALL(XGBoosterGetAttrNames(R_ExternalPtrAddr(handle),
                                   &len, &res));
  if (len > 0) {
    out = Rf_protect(Rf_allocVector(STRSXP, len));
    for (size_t i = 0; i < len; ++i) {
      SET_STRING_ELT(out, i, Rf_mkChar(res[i]));
    }
  } else {
    out = Rf_protect(R_NilValue);
  }
  R_API_END();
  Rf_unprotect(1);
  return out;
}

XGB_DLL SEXP XGBoosterFeatureScore_R(SEXP handle, SEXP json_config) {
  SEXP out_features_sexp;
  SEXP out_scores_sexp;
  SEXP out_shape_sexp;
  SEXP r_out = Rf_protect(Rf_allocVector(VECSXP, 3));

  R_API_BEGIN();
  char const *c_json_config = CHAR(Rf_asChar(json_config));
  bst_ulong out_n_features;
  char const **out_features;

  bst_ulong out_dim;
  bst_ulong const *out_shape;
  float const *out_scores;

  CHECK_CALL(XGBoosterFeatureScore(R_ExternalPtrAddr(handle), c_json_config,
                                   &out_n_features, &out_features,
                                   &out_dim, &out_shape, &out_scores));
  out_shape_sexp = Rf_protect(Rf_allocVector(INTSXP, out_dim));
  size_t len = 1;
  int *out_shape_sexp_ = INTEGER(out_shape_sexp);
  for (size_t i = 0; i < out_dim; ++i) {
    out_shape_sexp_[i] = out_shape[i];
    len *= out_shape[i];
  }

  out_features_sexp = Rf_protect(Rf_allocVector(STRSXP, out_n_features));
  for (size_t i = 0; i < out_n_features; ++i) {
    SET_STRING_ELT(out_features_sexp, i, Rf_mkChar(out_features[i]));
  }

  out_scores_sexp = Rf_protect(Rf_allocVector(REALSXP, len));
  std::copy(out_scores, out_scores + len, REAL(out_scores_sexp));

  SET_VECTOR_ELT(r_out, 0, out_features_sexp);
  SET_VECTOR_ELT(r_out, 1, out_shape_sexp);
  SET_VECTOR_ELT(r_out, 2, out_scores_sexp);

  R_API_END();
  Rf_unprotect(4);

  return r_out;
}

XGB_DLL SEXP XGBoosterSlice_R(SEXP handle, SEXP begin_layer, SEXP end_layer, SEXP step) {
  SEXP out = Rf_protect(XGBMakeEmptyAltrep());
  R_API_BEGIN();
  BoosterHandle handle_out = nullptr;
  CHECK_CALL(XGBoosterSlice(R_ExternalPtrAddr(handle),
                            Rf_asInteger(begin_layer),
                            Rf_asInteger(end_layer),
                            Rf_asInteger(step),
                            &handle_out));
  XGBAltrepSetPointer(out, handle_out);
  R_API_END();
  Rf_unprotect(1);
  return out;
}

XGB_DLL SEXP XGBoosterSliceAndReplace_R(SEXP handle, SEXP begin_layer, SEXP end_layer, SEXP step) {
  R_API_BEGIN();
  BoosterHandle old_handle = R_ExternalPtrAddr(handle);
  BoosterHandle new_handle = nullptr;
  CHECK_CALL(XGBoosterSlice(old_handle,
                            Rf_asInteger(begin_layer),
                            Rf_asInteger(end_layer),
                            Rf_asInteger(step),
                            &new_handle));
  R_SetExternalPtrAddr(handle, new_handle);
  CHECK_CALL(XGBoosterFree(old_handle));
  R_API_END();
  return R_NilValue;
}