#include <chrono>
#include <cmath>
#include <cstring>
#include <functional>
#include <future>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>

#include "npbuffer.h"
#include "util.h"
#include <pybind11/numpy.h>
#include <pybind11/pybind11.h>
#include <pybind11/pytypes.h>
#include <pybind11/stl.h>

#include <tiledb/tiledb.h>              // C
#include <tiledb/tiledb>                // C++
#include <tiledb/tiledb_experimental.h> // C
#include <tiledb/tiledb_experimental>   // C++

// clang-format off
// do not re-order these headers
#include "py_arrowio"
#include "py_arrow_io_impl.h"
// clang-format on

#if defined(TILEDB_SERIALIZATION)
#include <tiledb/tiledb_serialization.h> // C
#endif

#include "../external/tsl/robin_map.h"

#if !defined(NDEBUG)
// #include "debug.cc"
#endif

#include "query_condition.cc"

namespace tiledbpy {

using namespace tiledb;
namespace py = pybind11;
using namespace pybind11::literals;

using TimerType = std::chrono::duration<double>;
struct StatsInfo {
  std::map<std::string, TimerType> counters;
};

bool config_has_key(tiledb::Config config, std::string key) {
  return config.contains(key);
}

struct PAPair {
  int64_t get_array() {
    if (!exported_) {
      TPY_ERROR_LOC("Cannot export uninitialized array!");
    }
    return (int64_t)&array_;
  };
  int64_t get_schema() {
    if (!exported_) {
      TPY_ERROR_LOC("Cannot export uninitialized schema!");
    }
    return (int64_t)&schema_;
  }

  ArrowSchema schema_;
  ArrowArray array_;
  bool exported_ = false;
};

// global stats counters
static std::unique_ptr<StatsInfo> g_stats;

// forward declaration
py::dtype tiledb_dtype(tiledb_datatype_t type, uint32_t cell_val_num);

struct BufferInfo {
  BufferInfo(std::string name, size_t data_nbytes, tiledb_datatype_t data_type,
             uint32_t cell_val_num, size_t offsets_num, size_t validity_num,
             bool isvar = false, bool isnullable = false)

      : name(name), type(data_type), cell_val_num(cell_val_num), isvar(isvar),
        isnullable(isnullable) {
    try {
      dtype = tiledb_dtype(data_type, cell_val_num);
      elem_nbytes = tiledb_datatype_size(type);
      data = py::array(py::dtype("uint8"), data_nbytes);
      offsets = py::array_t<uint64_t>(offsets_num);
      validity = py::array_t<uint8_t>(validity_num);
    } catch (py::error_already_set &e) {
      TPY_ERROR_LOC(e.what())
    }
    // TODO use memset here for zero'd buffers in debug mode
  }

  string name;
  tiledb_datatype_t type;
  py::dtype dtype;
  size_t elem_nbytes = 1;
  uint64_t data_vals_read = 0;
  uint32_t cell_val_num;
  uint64_t offsets_read = 0;
  uint64_t validity_vals_read = 0;
  bool isvar;
  bool isnullable;

  py::array data;
  py::array_t<uint64_t> offsets;
  py::array_t<uint8_t> validity;
};

struct BufferHolder {
  py::object data;
  py::object offsets;
  py::object validity;

  BufferHolder(py::object d, py::object o, py::object v)
      : data(d), offsets(o), validity(v) {}

  static void free_buffer_holder(BufferHolder *self) { delete self; }
};

py::dtype tiledb_dtype(tiledb_datatype_t type, uint32_t cell_val_num) {
  if (cell_val_num == 1) {
    auto np = py::module::import("numpy");
    auto datetime64 = np.attr("datetime64");
    switch (type) {
    case TILEDB_INT32:
      return py::dtype("int32");
    case TILEDB_INT64:
      return py::dtype("int64");
    case TILEDB_FLOAT32:
      return py::dtype("float32");
    case TILEDB_FLOAT64:
      return py::dtype("float64");
    case TILEDB_INT8:
      return py::dtype("int8");
    case TILEDB_UINT8:
      return py::dtype("uint8");
    case TILEDB_INT16:
      return py::dtype("int16");
    case TILEDB_UINT16:
      return py::dtype("uint16");
    case TILEDB_UINT32:
      return py::dtype("uint32");
    case TILEDB_UINT64:
      return py::dtype("uint64");
    case TILEDB_STRING_ASCII:
      return py::dtype("S1");
    case TILEDB_STRING_UTF8:
      return py::dtype("U1");
    case TILEDB_STRING_UTF16:
    case TILEDB_STRING_UTF32:
      TPY_ERROR_LOC("Unimplemented UTF16 or UTF32 string conversion!");
    case TILEDB_STRING_UCS2:
    case TILEDB_STRING_UCS4:
      TPY_ERROR_LOC("Unimplemented UCS2 or UCS4 string conversion!");
    case TILEDB_CHAR:
      return py::dtype("S1");
    case TILEDB_DATETIME_YEAR:
      return py::dtype("M8[Y]");
    case TILEDB_DATETIME_MONTH:
      return py::dtype("M8[M]");
    case TILEDB_DATETIME_WEEK:
      return py::dtype("M8[W]");
    case TILEDB_DATETIME_DAY:
      return py::dtype("M8[D]");
    case TILEDB_DATETIME_HR:
      return py::dtype("M8[h]");
    case TILEDB_DATETIME_MIN:
      return py::dtype("M8[m]");
    case TILEDB_DATETIME_SEC:
      return py::dtype("M8[s]");
    case TILEDB_DATETIME_MS:
      return py::dtype("M8[ms]");
    case TILEDB_DATETIME_US:
      return py::dtype("M8[us]");
    case TILEDB_DATETIME_NS:
      return py::dtype("M8[ns]");
    case TILEDB_DATETIME_PS:
      return py::dtype("M8[ps]");
    case TILEDB_DATETIME_FS:
      return py::dtype("M8[fs]");
    case TILEDB_DATETIME_AS:
      return py::dtype("M8[as]");

    /* duration types map to timedelta */
    case TILEDB_TIME_HR:
      return py::dtype("m8[h]");
    case TILEDB_TIME_MIN:
      return py::dtype("m8[m]");
    case TILEDB_TIME_SEC:
      return py::dtype("m8[s]");
    case TILEDB_TIME_MS:
      return py::dtype("m8[ms]");
    case TILEDB_TIME_US:
      return py::dtype("m8[us]");
    case TILEDB_TIME_NS:
      return py::dtype("m8[ns]");
    case TILEDB_TIME_PS:
      return py::dtype("m8[ps]");
    case TILEDB_TIME_FS:
      return py::dtype("m8[fs]");
    case TILEDB_TIME_AS:
      return py::dtype("m8[as]");
    case TILEDB_BLOB:
      return py::dtype("byte");
    case TILEDB_BOOL:
      return py::dtype("bool");
#if TILEDB_VERSION_MAJOR >= 2 && TILEDB_VERSION_MINOR >= 21
    case TILEDB_GEOM_WKB:
      return py::dtype("byte");
    case TILEDB_GEOM_WKT:
      return py::dtype("S");
#endif

    case TILEDB_ANY:
      break;
    }
  } else if (cell_val_num == 2 && type == TILEDB_FLOAT32) {
    return py::dtype("complex64");
  } else if (cell_val_num == 2 && type == TILEDB_FLOAT64) {
    return py::dtype("complex128");
  } else if (type == TILEDB_CHAR || type == TILEDB_STRING_UTF8 ||
             type == TILEDB_STRING_ASCII) {
    std::string base_str;
    switch (type) {
    case TILEDB_CHAR:
    case TILEDB_STRING_ASCII:
      base_str = "|S";
      break;
    case TILEDB_STRING_UTF8:
      base_str = "|U";
      break;
    default:
      TPY_ERROR_LOC("internal error: unhandled string type");
    }
    if (cell_val_num < TILEDB_VAR_NUM) {
      base_str = base_str + std::to_string(cell_val_num);
    }
    return py::dtype(base_str);
  } else if (cell_val_num == TILEDB_VAR_NUM) {
    return tiledb_dtype(type, 1);
  } else if (cell_val_num > 1) {
    py::dtype base_dtype = tiledb_dtype(type, 1);
    py::tuple rec_elem = py::make_tuple("", base_dtype);
    py::list rec_list;
    for (size_t i = 0; i < cell_val_num; i++)
      rec_list.append(rec_elem);
    auto np = py::module::import("numpy");
    // note: we call the 'dtype' constructor b/c py::dtype does not accept list
    auto np_dtype = np.attr("dtype");
    return np_dtype(rec_list);
  }

  TPY_ERROR_LOC("tiledb datatype not understood ('" +
                tiledb::impl::type_to_str(type) +
                "', cell_val_num: " + std::to_string(cell_val_num) + ")");
}

py::array_t<uint8_t>
uint8_bool_to_uint8_bitmap(py::array_t<uint8_t> validity_array) {
  // TODO profile, probably replace; avoid inplace reassignment
  auto np = py::module::import("numpy");
  auto packbits = np.attr("packbits");
  auto tmp = packbits(validity_array, "bitorder"_a = "little");
  return tmp;
}

uint64_t count_zeros(py::array_t<uint8_t> a) {
  uint64_t count = 0;
  for (Py_ssize_t idx = 0; idx < a.size(); idx++)
    count += (a.data()[idx] == 0) ? 1 : 0;
  return count;
}

class PyAgg {
  using ByteBuffer = py::array_t<uint8_t>;
  using AggToBufferMap = std::map<std::string, ByteBuffer>;
  using AttrToAggsMap = std::map<std::string, AggToBufferMap>;

private:
  Context ctx_;
  std::shared_ptr<tiledb::Array> array_;
  std::shared_ptr<tiledb::Query> query_;
  AttrToAggsMap result_buffers_;
  AttrToAggsMap validity_buffers_;

  py::dict original_input_;
  std::vector<std::string> attrs_;

public:
  PyAgg() = delete;

  PyAgg(const Context &ctx, py::object py_array, py::object py_layout,
        py::dict attr_to_aggs_input)
      : ctx_(ctx), original_input_(attr_to_aggs_input) {
    tiledb_array_t *c_array_ = (py::capsule)py_array.attr("__capsule__")();

    // We never own this pointer; pass own=false
    array_ = std::make_shared<tiledb::Array>(ctx_, c_array_, false);
    query_ = std::make_shared<tiledb::Query>(ctx_, *array_, TILEDB_READ);

    bool issparse = array_->schema().array_type() == TILEDB_SPARSE;
    tiledb_layout_t layout = (tiledb_layout_t)py_layout.cast<int32_t>();
    if (!issparse && layout == TILEDB_UNORDERED) {
      TPY_ERROR_LOC("TILEDB_UNORDERED read is not supported for dense arrays")
    }
    query_->set_layout(layout);

    // Iterate through the requested attributes
    for (auto attr_to_aggs : attr_to_aggs_input) {
      auto attr_name = attr_to_aggs.first.cast<std::string>();
      auto aggs = attr_to_aggs.second.cast<std::vector<std::string>>();

      tiledb::Attribute attr = array_->schema().attribute(attr_name);
      attrs_.push_back(attr_name);

      // For non-nullable attributes, applying max and min to the empty set is
      // undefined. To check for this, we need to also run the count aggregate
      // to make sure count != 0
      bool requested_max =
          std::find(aggs.begin(), aggs.end(), "max") != aggs.end();
      bool requested_min =
          std::find(aggs.begin(), aggs.end(), "min") != aggs.end();
      if (!attr.nullable() && (requested_max || requested_min)) {
        // If the user already also requested count, then we don't need to
        // request it again
        if (std::find(aggs.begin(), aggs.end(), "count") == aggs.end()) {
          aggs.push_back("count");
        }
      }

      // Iterate through the aggreate operations to apply on the given attribute
      for (auto agg_name : aggs) {
        _apply_agg_operator_to_attr(agg_name, attr_name);

        // Set the result data buffers
        auto *res_buf = &result_buffers_[attr_name][agg_name];
        if ("count" == agg_name || "null_count" == agg_name ||
            "mean" == agg_name) {
          // count and null_count use uint64 and mean uses float64
          *res_buf = py::array(py::dtype("uint8"), 8);
        } else {
          // max, min, and sum use the dtype of the attribute
          py::dtype dt(tiledb_dtype(attr.type(), attr.cell_size()));
          *res_buf = py::array(py::dtype("uint8"), dt.itemsize());
        }
        query_->set_data_buffer(attr_name + agg_name, (void *)res_buf->data(),
                                1);

        if (attr.nullable()) {
          // For nullable attributes, if the input set for the aggregation
          // contains all NULL values, we will not get an aggregate value back
          // as this operation is undefined. We need to check the validity
          // buffer beforehand to see if we had a valid result
          if (!("count" == agg_name || "null_count" == agg_name)) {
            auto *val_buf = &validity_buffers_[attr.name()][agg_name];
            *val_buf = py::array(py::dtype("uint8"), 1);
            query_->set_validity_buffer(attr_name + agg_name,
                                        (uint8_t *)val_buf->data(), 1);
          }
        }
      }
    }
  }

  void _apply_agg_operator_to_attr(const std::string &op_label,
                                   const std::string &attr_name) {
    using AggregateFunc =
        std::function<ChannelOperation(const Query &, const std::string &)>;

    std::unordered_map<std::string, AggregateFunc> label_to_agg_func = {
        {"sum", QueryExperimental::create_unary_aggregate<SumOperator>},
        {"min", QueryExperimental::create_unary_aggregate<MinOperator>},
        {"max", QueryExperimental::create_unary_aggregate<MaxOperator>},
        {"mean", QueryExperimental::create_unary_aggregate<MeanOperator>},
        {"null_count",
         QueryExperimental::create_unary_aggregate<NullCountOperator>},
    };

    QueryChannel default_channel =
        QueryExperimental::get_default_channel(*query_);

    if (label_to_agg_func.find(op_label) != label_to_agg_func.end()) {
      AggregateFunc create_unary_aggregate = label_to_agg_func.at(op_label);
      ChannelOperation op = create_unary_aggregate(*query_, attr_name);
      default_channel.apply_aggregate(attr_name + op_label, op);
    } else if ("count" == op_label) {
      default_channel.apply_aggregate(attr_name + op_label, CountOperation());
    } else {
      TPY_ERROR_LOC("Invalid channel operation " + op_label +
                    " passed to apply_aggregate.");
    }
  }

  py::dict get_aggregate() {
    query_->submit();

    // Cast the results to the correct dtype and output this as a Python dict
    py::dict output;
    for (auto attr_to_agg : original_input_) {
      // Be clear in our variable names for strings as py::dict uses py::str
      // keys whereas std::map uses std::string keys
      std::string attr_cpp_name = attr_to_agg.first.cast<string>();

      py::str attr_py_name(attr_cpp_name);
      output[attr_py_name] = py::dict();

      tiledb::Attribute attr = array_->schema().attribute(attr_cpp_name);

      for (auto agg_py_name : original_input_[attr_py_name]) {
        std::string agg_cpp_name = agg_py_name.cast<string>();

        if (_is_invalid(attr, agg_cpp_name)) {
          output[attr_py_name][agg_py_name] =
              _is_integer_dtype(attr) ? py::none() : py::cast(NAN);
        } else {
          output[attr_py_name][agg_py_name] = _set_result(attr, agg_cpp_name);
        }
      }
    }
    return output;
  }

  bool _is_invalid(tiledb::Attribute attr, std::string agg_name) {
    if (attr.nullable()) {
      if ("count" == agg_name || "null_count" == agg_name)
        return false;

      // For nullable attributes, check if the validity buffer returned false
      const void *val_buf = validity_buffers_[attr.name()][agg_name].data();
      return *((uint8_t *)(val_buf)) == 0;
    } else {
      // For non-nullable attributes, max and min are undefined for the empty
      // set, so we must check the count == 0
      if ("max" == agg_name || "min" == agg_name) {
        const void *count_buf = result_buffers_[attr.name()]["count"].data();
        return *((uint64_t *)(count_buf)) == 0;
      }
      return false;
    }
  }

  bool _is_integer_dtype(tiledb::Attribute attr) {
    switch (attr.type()) {
    case TILEDB_INT8:
    case TILEDB_INT16:
    case TILEDB_UINT8:
    case TILEDB_INT32:
    case TILEDB_INT64:
    case TILEDB_UINT16:
    case TILEDB_UINT32:
    case TILEDB_UINT64:
      return true;
    default:
      return false;
    }
  }

  py::object _set_result(tiledb::Attribute attr, std::string agg_name) {
    const void *agg_buf = result_buffers_[attr.name()][agg_name].data();

    if ("mean" == agg_name)
      return py::cast(*((double *)agg_buf));

    if ("count" == agg_name || "null_count" == agg_name)
      return py::cast(*((uint64_t *)agg_buf));

    switch (attr.type()) {
    case TILEDB_FLOAT32:
      return py::cast("sum" == agg_name ? *((double *)agg_buf)
                                        : *((float *)agg_buf));
    case TILEDB_FLOAT64:
      return py::cast(*((double *)agg_buf));
    case TILEDB_INT8:
      return py::cast(*((int8_t *)agg_buf));
    case TILEDB_UINT8:
      return py::cast(*((uint8_t *)agg_buf));
    case TILEDB_INT16:
      return py::cast(*((int16_t *)agg_buf));
    case TILEDB_UINT16:
      return py::cast(*((uint16_t *)agg_buf));
    case TILEDB_UINT32:
      return py::cast(*((uint32_t *)agg_buf));
    case TILEDB_INT32:
      return py::cast(*((int32_t *)agg_buf));
    case TILEDB_INT64:
      return py::cast(*((int64_t *)agg_buf));
    case TILEDB_UINT64:
      return py::cast(*((uint64_t *)agg_buf));
    default:
      TPY_ERROR_LOC(
          "[_cast_agg_result] Invalid tiledb dtype for aggregation result")
    }
  }

  void set_subarray(py::object py_subarray) {
    query_->set_subarray(*py_subarray.cast<tiledb::Subarray *>());
  }

  void set_cond(py::object cond) {
    py::object init_pyqc = cond.attr("init_query_condition");

    try {
      init_pyqc(array_->uri(), attrs_, ctx_);
    } catch (tiledb::TileDBError &e) {
      TPY_ERROR_LOC(e.what());
    } catch (py::error_already_set &e) {
      TPY_ERROR_LOC(e.what());
    }
    auto pyqc = (cond.attr("c_obj")).cast<PyQueryCondition>();
    auto qc = pyqc.ptr().get();
    query_->set_condition(*qc);
  }
};

class PyQuery {
private:
  Context ctx_;
  std::shared_ptr<tiledb::Domain> domain_;
  std::shared_ptr<tiledb::ArraySchema> array_schema_;
  std::shared_ptr<tiledb::Array> array_;
  std::shared_ptr<tiledb::Query> query_;
  std::vector<std::string> attrs_;
  std::vector<std::string> dims_;
  std::map<std::string, BufferInfo> buffers_;
  std::vector<std::string> buffers_order_;

  bool deduplicate_ = true;
  bool use_arrow_ = false;
  // initialize the query buffers with exactly `init_buffer_bytes`
  // rather than the estimated result size. for incomplete testing.
  bool exact_init_bytes_ = false;
  uint64_t init_buffer_bytes_ = DEFAULT_INIT_BUFFER_BYTES;
  uint64_t alloc_max_bytes_ = DEFAULT_ALLOC_MAX_BYTES;
  tiledb_layout_t layout_ = TILEDB_ROW_MAJOR;

  // label buffer list
  unordered_map<string, uint64_t> label_input_buffer_data_;

public:
  tiledb_ctx_t *c_ctx_;
  tiledb_array_t *c_array_;
  bool preload_metadata_ = false;
  bool return_incomplete_ = false;
  size_t retries_ = 0;

public:
  PyQuery() = delete;

  PyQuery(const Context &ctx, py::object array, py::iterable attrs,
          py::iterable dims, py::object py_layout, py::object use_arrow)
      : ctx_(ctx) {
    init_config();
    // initialize arrow argument from user, if provided
    // call after init_config
    if (!use_arrow.is(py::none())) {
      use_arrow_ = py::cast<bool>(use_arrow);
    }

    tiledb_array_t *c_array_ = (py::capsule)array.attr("__capsule__")();

    // we never own this pointer, pass own=false
    array_ = std::make_shared<tiledb::Array>(ctx_, c_array_, false);

    array_schema_ = std::make_shared<tiledb::ArraySchema>(array_->schema());

    domain_ = std::make_shared<tiledb::Domain>(array_schema_->domain());

    bool issparse = array_->schema().array_type() == TILEDB_SPARSE;

    std::string mode = py::str(array.attr("mode"));
    auto query_mode = TILEDB_READ;
    if (mode == "r") {
      query_mode = TILEDB_READ;
    } else if (mode == "d") {
      query_mode = TILEDB_DELETE;
    } else {
      throw std::invalid_argument("Invalid query mode: " + mode);
    }

    // initialize the dims that we are asked to read
    for (auto d : dims) {
      dims_.push_back(d.cast<string>());
    }

    // initialize the attrs that we are asked to read
    for (auto a : attrs) {
      attrs_.push_back(a.cast<string>());
    }

    if (query_mode == TILEDB_READ) {
      py::object pre_buffers = array.attr("_buffers");
      if (!pre_buffers.is(py::none())) {
        py::dict pre_buffers_dict = pre_buffers.cast<py::dict>();

        // iterate over (key, value) pairs
        for (std::pair<py::handle, py::handle> b : pre_buffers_dict) {
          py::str name = b.first.cast<py::str>();

          // unpack value tuple of (data, offsets)
          auto bfrs = b.second.cast<std::pair<py::handle, py::handle>>();
          auto data_array = bfrs.first.cast<py::array>();
          auto offsets_array = bfrs.second.cast<py::array>();

          import_buffer(name, data_array, offsets_array);
        }
      }
    }

    query_ = std::make_shared<tiledb::Query>(ctx_, *array_, query_mode);
    //        [](Query* p){} /* note: no deleter*/);

    if (query_mode == TILEDB_READ) {
      layout_ = (tiledb_layout_t)py_layout.cast<int32_t>();
      if (!issparse && layout_ == TILEDB_UNORDERED) {
        TPY_ERROR_LOC("TILEDB_UNORDERED read is not supported for dense arrays")
      }
      query_->set_layout(layout_);
    }

    if (use_arrow_) {
      // enable arrow mode in the Query
      auto tmp_config = ctx_.config();
      tmp_config.set("sm.var_offsets.bitsize", "64");
      tmp_config.set("sm.var_offsets.mode", "elements");
      tmp_config.set("sm.var_offsets.extra_element", "true");
      ctx_.handle_error(tiledb_query_set_config(
          ctx_.ptr().get(), query_->ptr().get(), tmp_config.ptr().get()));
    }
  }

  void set_subarray(py::object py_subarray) {
    query_->set_subarray(*py_subarray.cast<tiledb::Subarray *>());
  }

#if defined(TILEDB_SERIALIZATION)
  void set_serialized_query(py::buffer serialized_query) {
    int rc;
    tiledb_query_t *c_query;
    tiledb_buffer_t *c_buffer;
    tiledb_ctx_t *c_ctx = ctx_.ptr().get();

    rc = tiledb_buffer_alloc(c_ctx, &c_buffer);
    if (rc == TILEDB_ERR)
      TPY_ERROR_LOC("Could not allocate c_buffer.");

    py::buffer_info buffer_info = serialized_query.request();
    rc = tiledb_buffer_set_data(c_ctx, c_buffer, buffer_info.ptr,
                                buffer_info.shape[0]);
    if (rc == TILEDB_ERR)
      TPY_ERROR_LOC("Could not set c_buffer.");

    c_query = query_.get()->ptr().get();
    rc = tiledb_deserialize_query(c_ctx, c_buffer, TILEDB_CAPNP, 0, c_query);
    if (rc == TILEDB_ERR)
      TPY_ERROR_LOC("Could not deserialize query.");
  }
#endif

  void set_cond(py::object cond) {
    py::object init_pyqc = cond.attr("init_query_condition");

    try {
      init_pyqc(array_->uri(), attrs_, ctx_);
    } catch (tiledb::TileDBError &e) {
      TPY_ERROR_LOC(e.what());
    } catch (py::error_already_set &e) {
      TPY_ERROR_LOC(e.what());
    }
    auto pyqc = (cond.attr("c_obj")).cast<PyQueryCondition>();
    auto qc = pyqc.ptr().get();
    query_->set_condition(*qc);
  }

  bool is_dimension(std::string name) { return domain_->has_dimension(name); }

  bool is_attribute(std::string name) {
    return array_schema_->has_attribute(name);
  }

  bool is_dimension_label(std::string name) {
    return ArraySchemaExperimental::has_dimension_label(ctx_, *array_schema_,
                                                        name);
  }

  bool is_var(std::string name) {
    if (is_dimension(name)) {
      auto dim = domain_->dimension(name);
      return dim.cell_val_num() == TILEDB_VAR_NUM;
    } else if (is_attribute(name)) {
      auto attr = array_schema_->attribute(name);
      return attr.cell_val_num() == TILEDB_VAR_NUM;
    } else if (is_dimension_label(name)) {
      auto dim_label =
          ArraySchemaExperimental::dimension_label(ctx_, *array_schema_, name);
      return dim_label.label_cell_val_num() == TILEDB_VAR_NUM;
    } else {
      TPY_ERROR_LOC("Unknown buffer type for is_var check (expected attribute "
                    "or dimension)")
    }
  }

  bool is_nullable(std::string name) {
    if (is_dimension(name) || is_dimension_label(name)) {
      return false;
    }

    auto attr = array_schema_->attribute(name);
    return attr.nullable();
  }

  std::pair<tiledb_datatype_t, uint32_t> buffer_type(std::string name) {
    tiledb_datatype_t type;
    uint32_t cell_val_num;
    if (is_dimension(name)) {
      type = domain_->dimension(name).type();
      cell_val_num = domain_->dimension(name).cell_val_num();
    } else if (is_attribute(name)) {
      type = array_schema_->attribute(name).type();
      cell_val_num = array_schema_->attribute(name).cell_val_num();
    } else if (is_dimension_label(name)) {
      auto dim_label =
          ArraySchemaExperimental::dimension_label(ctx_, *array_schema_, name);
      type = dim_label.label_type();
      cell_val_num = dim_label.label_cell_val_num();
    } else {
      TPY_ERROR_LOC("Unknown buffer '" + name + "'");
    }
    return {type, cell_val_num};
  }

  uint32_t buffer_ncells(std::string name) {
    if (is_dimension(name)) {
      return domain_->dimension(name).cell_val_num();
    } else if (is_attribute(name)) {
      return array_schema_->attribute(name).cell_val_num();
    }
    TPY_ERROR_LOC("Unknown buffer '" + name + "' for buffer_ncells");
  }

  py::dtype buffer_dtype(std::string name) {
    try {
      auto t = buffer_type(name);
      return tiledb_dtype(t.first, t.second);
    } catch (TileDBError &e) {
      (void)e;
      return py::none();
    }
  }

  bool is_sparse() { return array_->schema().array_type() == TILEDB_SPARSE; }

  void import_buffer(std::string name, py::array data, py::array offsets) {
    tiledb_datatype_t type;
    uint32_t cell_val_num;
    std::tie(type, cell_val_num) = buffer_type(name);
    auto dtype = tiledb_dtype(type, cell_val_num);

    buffers_order_.push_back(name);
    // set nbytes and noffsets=0 here to avoid allocation; buffers set below
    auto buffer_info = BufferInfo(name, 0, type, cell_val_num, 0,
                                  0, // TODO
                                  is_var(name), is_nullable(name));
    buffer_info.data = data;
    buffer_info.offsets = offsets;
    buffers_.insert({name, buffer_info});
  }

  void alloc_buffer(std::string name) {
    tiledb_datatype_t type;
    uint32_t cell_val_num;
    uint64_t cell_nbytes;
    bool var;
    bool nullable;
    uint64_t buf_nbytes = 0;
    uint64_t offsets_num = 0;
    uint64_t validity_num = 0;
    bool dense = array_schema_->array_type() == TILEDB_DENSE;
    if (is_dimension_label(name)) {
      auto dim_label =
          ArraySchemaExperimental::dimension_label(ctx_, *array_schema_, name);
      type = dim_label.label_type();
      cell_val_num = dim_label.label_cell_val_num();
      var = cell_val_num == TILEDB_VAR_NUM;
      nullable = false;

      cell_nbytes = tiledb_datatype_size(type);
      uint64_t ncells = label_input_buffer_data_[name];

      if (!var) {
        cell_nbytes *= cell_val_num;
      } else {
        offsets_num = ncells;
      }
      buf_nbytes = ncells * cell_nbytes;
    } else {
      std::tie(type, cell_val_num) = buffer_type(name);
      cell_nbytes = tiledb_datatype_size(type);
      if (cell_val_num != TILEDB_VAR_NUM) {
        cell_nbytes *= cell_val_num;
      }
      var = is_var(name);
      nullable = is_nullable(name);

      if (retries_ < 1 && dense) {
        // we must not call after submitting
        if (nullable && var) {
          auto sizes = query_->est_result_size_var_nullable(name);
          offsets_num = sizes[0];
          buf_nbytes = sizes[1];
          validity_num = sizes[2] / sizeof(uint8_t);
        } else if (nullable && !var) {
          auto sizes = query_->est_result_size_nullable(name);
          buf_nbytes = sizes[0];
          validity_num = sizes[1] / sizeof(uint8_t);
        } else if (!nullable && var) {
          auto size_pair = query_->est_result_size_var(name);
          buf_nbytes = size_pair[0];
          offsets_num = size_pair[1];
        } else { // !nullable && !var
          buf_nbytes = query_->est_result_size(name);
        }

        // Add extra offset to estimate in order to avoid incomplete resubmit
        // libtiledb 2.7.* does not include extra element in estimate.
        // Remove this section after resolution of SC-16301.
        offsets_num += (var && use_arrow_) ? 1 : 0;
      }
    }

    // - for sparse arrays: don't try to allocate more than alloc_max_bytes_
    // - for dense arrays: the estimate should be exact, so don't cap
    if (is_sparse() && buf_nbytes > alloc_max_bytes_) {
      buf_nbytes = alloc_max_bytes_;
    }
    // use max to avoid overflowing to zero in the multiplication, in case the
    //   estimate is too large
    if (max(validity_num, validity_num * sizeof(uint8_t)) > alloc_max_bytes_) {
      validity_num = alloc_max_bytes_ / sizeof(uint8_t);
    }
    if (max(offsets_num, offsets_num * sizeof(uint64_t)) > alloc_max_bytes_) {
      offsets_num = alloc_max_bytes_ / sizeof(uint64_t);
    }

    // use init_buffer_bytes configuration option if the
    // estimate is smaller
    if ((var || is_sparse()) &&
        (buf_nbytes < init_buffer_bytes_ || exact_init_bytes_)) {
      buf_nbytes = init_buffer_bytes_;
      offsets_num = init_buffer_bytes_ / sizeof(uint64_t);
      validity_num = init_buffer_bytes_ / cell_nbytes;
    }

    buffers_order_.push_back(name);
    buffers_.insert(
        {name, BufferInfo(name, buf_nbytes, type, cell_val_num, offsets_num,
                          validity_num, var, nullable)});
  }

  void add_label_buffer(std::string &label_name, uint64_t ncells) {
    label_input_buffer_data_[label_name] = ncells;
  }

  py::object get_buffers() {
    py::dict rmap;
    for (auto &bp : buffers_) {
      py::list result;
      const auto name = bp.first;
      const BufferInfo b = bp.second;
      result.append(b.data);
      result.append(b.offsets);
      rmap[py::str{name}] = result;
    }
    return std::move(rmap);
  }

  void set_buffers() {
    for (auto bp : buffers_) {
      auto name = bp.first;
      const BufferInfo b = bp.second;

      size_t offsets_read = b.offsets_read;
      size_t data_vals_read = b.data_vals_read;
      size_t validity_vals_read = b.validity_vals_read;

      void *data_ptr =
          (void *)((char *)b.data.data() + (data_vals_read * b.elem_nbytes));
      uint64_t data_nelem =
          (b.data.size() - (data_vals_read * b.elem_nbytes)) / b.elem_nbytes;

      // Experimental version of API call is needed to support type-checking
      // on dimension label buffers.
      QueryExperimental::set_data_buffer(*query_, b.name, data_ptr, data_nelem);

      if (b.isvar) {
        size_t offsets_size = b.offsets.size() - offsets_read;
        uint64_t *offsets_ptr = (uint64_t *)b.offsets.data() + offsets_read;

        query_->set_offsets_buffer(b.name, (uint64_t *)(offsets_ptr),
                                   offsets_size);
      }
      if (b.isnullable) {
        uint64_t validity_size = b.validity.size() - validity_vals_read;
        uint8_t *validity_ptr =
            (uint8_t *)b.validity.data() + validity_vals_read;

        query_->set_validity_buffer(b.name, validity_ptr, validity_size);
      }
    }
  }

  void update_read_elem_num() {
    auto result_elements =
        QueryExperimental::result_buffer_elements_nullable_labels(*query_);

    for (const auto &read_info : result_elements) {
      auto name = read_info.first;
      uint64_t offset_elem_num = 0, data_vals_num = 0, validity_elem_num = 0;
      std::tie(offset_elem_num, data_vals_num, validity_elem_num) =
          read_info.second;

      BufferInfo &buf = buffers_.at(name);

      // TODO if we ever support per-attribute read offset bitsize
      // then need to handle here. Currently this is hard-coded to
      // 64-bit to match query config.
      auto offset_ptr = buf.offsets.mutable_data();

      if (buf.isvar) {
        if (offset_elem_num > 0) {
          // account for 'sm.var_offsets.extra_element'
          offset_elem_num -= (use_arrow_) ? 1 : 0;
        }

        if (buf.offsets_read > 0) {
          if (offset_ptr[buf.offsets_read] == 0) {
            auto last_size = (buf.data_vals_read * buf.elem_nbytes);

            for (uint64_t i = 0; i < offset_elem_num; i++) {
              offset_ptr[buf.offsets_read + i] += last_size;
            }
          }
        }
      }

      buf.data_vals_read += data_vals_num;
      buf.offsets_read += offset_elem_num;
      buf.validity_vals_read += validity_elem_num;

      if ((Py_ssize_t)(buf.data_vals_read * buf.elem_nbytes) >
          (Py_ssize_t)buf.data.size()) {
        throw TileDBError(
            "After read query, data buffer out of bounds: " + name + " (" +
            std::to_string(buf.data_vals_read * buf.elem_nbytes) + " > " +
            std::to_string(buf.data.size()) + ")");
      }
      if ((Py_ssize_t)buf.offsets_read > buf.offsets.size()) {
        throw TileDBError("After read query, offsets buffer out of bounds: " +
                          name + " (" + std::to_string(buf.offsets_read) +
                          " > " + std::to_string(buf.offsets.size()) + ")");
      }
      if ((Py_ssize_t)buf.validity_vals_read > buf.validity.size()) {
        throw TileDBError("After read query, validity buffer out of bounds: " +
                          name + " (" + std::to_string(buf.validity_vals_read) +
                          " > " + std::to_string(buf.validity.size()) + ")");
      }
    }
  }

  void reset_read_elem_num() {
    for (auto &bp : buffers_) {
      auto &buf = bp.second;

      buf.offsets_read = 0;
      buf.data_vals_read = 0;
      buf.validity_vals_read = 0;
    }
  }

  uint64_t get_max_retries() {
    // should make this a templated getter for any key w/ default
    std::string tmp_str;
    size_t max_retries;
    try {
      tmp_str = ctx_.config().get("py.max_incomplete_retries");
      max_retries = std::stoull(tmp_str);
    } catch (const std::invalid_argument &e) {
      (void)e;
      throw TileDBError(
          "Failed to convert 'py.max_incomplete_retries' to uint64_t ('" +
          tmp_str + "')");
    } catch (tiledb::TileDBError &e) {
      (void)e;
      max_retries = 100;
    }
    return max_retries;
  }

  void resubmit_read() {
    tiledb_query_status_details_t status_details;
    tiledb_query_get_status_details(ctx_.ptr().get(), query_.get()->ptr().get(),
                                    &status_details);

    if (status_details.incomplete_reason == TILEDB_REASON_USER_BUFFER_SIZE) {
      auto start_incomplete_buffer_update =
          std::chrono::high_resolution_clock::now();
      for (auto &bp : buffers_) {
        auto &buf = bp.second;

        // Check if values buffer should be resized
        if ((buf.data_vals_read == 0) ||
            (int64_t)(buf.data_vals_read * buf.elem_nbytes) >
                (buf.data.nbytes() + 1) / 2) {
          size_t new_size = buf.data.size() * 2;
          buf.data.resize({new_size}, false);
        }

        // Check if offset buffer should be resized
        if ((buf.isvar && buf.offsets_read == 0) ||
            ((int64_t)(buf.offsets_read * sizeof(uint64_t)) >
             (buf.offsets.nbytes() + 1) / 2)) {
          size_t new_offsets_size = buf.offsets.size() * 2;
          buf.offsets.resize({new_offsets_size}, false);
        }

        // Check if validity buffer should be resized
        if ((buf.isnullable && buf.validity_vals_read == 0) ||
            ((int64_t)(buf.validity_vals_read * sizeof(uint8_t)) >
             (buf.validity.nbytes() + 1) / 2)) {
          size_t new_validity_size = buf.validity.size() * 2;
          buf.validity.resize({new_validity_size}, false);
        }
      }

      // note: this block confuses lldb. continues from here unless bp set after
      // block.
      set_buffers();

      if (g_stats) {
        auto now = std::chrono::high_resolution_clock::now();
        g_stats.get()
            ->counters["py.read_query_incomplete_buffer_resize_time"] +=
            now - start_incomplete_buffer_update;
      }
    }

    {
      py::gil_scoped_release release;
      query_->submit();
    }

    if (query_->query_status() == Query::Status::UNINITIALIZED) {
      TPY_ERROR_LOC("Unexpected state: Query::Submit returned uninitialized");
    }

    update_read_elem_num();

    return;
  }

  void resize_output_buffers() {
    // resize the output buffers to match the final read total
    // the higher level code uses the size of the buffers to
    // determine how much to unpack, but we may have over-allocated

    // account for the extra element at the end of offsets in arrow mode
    size_t arrow_offset_size = use_arrow_ ? 1 : 0;

    for (auto &bp : buffers_) {
      auto name = bp.first;
      auto &buf = bp.second;

      Py_ssize_t final_data_nbytes = buf.data_vals_read * buf.elem_nbytes;
      Py_ssize_t final_offsets_count = buf.offsets_read + arrow_offset_size;
      Py_ssize_t final_validity_count = buf.validity_vals_read;

      assert(final_data_nbytes <= buf.data.size());
      assert(final_offsets_count <=
             (Py_ssize_t)(buf.offsets.size() + arrow_offset_size));

      buf.data.resize({final_data_nbytes});
      buf.offsets.resize({final_offsets_count});
      buf.validity.resize({final_validity_count});

      if (use_arrow_) {
        if (retries_ > 0) {
          // we need to write the final size to the final offset slot
          // because core doesn't track size between incomplete submits
          buf.offsets.mutable_data()[buf.offsets_read] = final_data_nbytes;
        }

        // reset bytes-read so that set_buffers uses the full buffer size
        buf.data_vals_read = 0;
        buf.offsets_read = 0;
        buf.validity_vals_read = 0;
      }
    }
    if (use_arrow_) {
      // this is a very light hack:
      // call set_buffers here to reset the buffers to the *full*
      // buffer in case there were incomplete queries. without this call,
      // the active tiledb::Query only knows about the buffer ptr/size
      // for the *last* submit loop, so we don't get full result set.
      // ArrowAdapter gets the buffer sizes from tiledb::Query.
      set_buffers();
    }
  }

  void allocate_buffers() {
    // allocate buffers for dims
    //   - we want to return dims first, if any requested
    for (size_t dim_idx = 0; dim_idx < domain_->ndim(); dim_idx++) {
      auto dim = domain_->dimension(dim_idx);
      if ((std::find(dims_.begin(), dims_.end(), dim.name()) == dims_.end()) &&
          // we need to also check if this is an attr for backward-compatibility
          (std::find(attrs_.begin(), attrs_.end(), dim.name()) ==
           attrs_.end())) {
        continue;
      }
      alloc_buffer(dim.name());
    }

    // allocate buffers for label dimensions
    for (const auto &label_data : label_input_buffer_data_) {
      alloc_buffer(label_data.first);
    }

    // allocate buffers for attributes
    //   - schema.attributes() is unordered, but we need to return ordered
    //   results
    for (size_t attr_idx = 0; attr_idx < array_schema_->attribute_num();
         attr_idx++) {
      auto attr = array_schema_->attribute(attr_idx);
      if (std::find(attrs_.begin(), attrs_.end(), attr.name()) ==
          attrs_.end()) {
        continue;
      }
      alloc_buffer(attr.name());
    }
  }

  void submit_read() {
    if (retries_ > 0 &&
        query_->query_status() == tiledb::Query::Status::INCOMPLETE) {
      buffers_.clear();
      assert(buffers_.size() == 0);

      buffers_order_.clear();
      // reset_read_elem_num();
    } else if (buffers_.size() != 0) {
      // we have externally imported buffers
      return;
    }

    // start time
    auto start = std::chrono::high_resolution_clock::now();

    // Initiate a metadata API request to make libtiledb fetch the
    // metadata ahead of time. In some queries we know we will always
    // access metadata, so initiating this call saves time when loading
    // from remote arrays because metadata i/o is lazy in core.
    /*
    // This section is disabled pending final disposition of SC-11720
    // This call is not currently safe as of TileDB 2.5, and has caused
    // reproducible deadlocks with the subesequent calls to
    // Array::est_result_sizes from the main thread.
    //
    std::future<uint64_t> metadata_num_preload;
    if (preload_metadata_) {
      metadata_num_preload = std::async(
          std::launch::async, [this]() { return array_->metadata_num(); });
    }
    */

    allocate_buffers();

    // set the buffers on the Query
    set_buffers();

    size_t max_retries = get_max_retries();

    auto start_submit = std::chrono::high_resolution_clock::now();
    {
      py::gil_scoped_release release;
      query_->submit();
    }

    if (query_->query_status() == Query::Status::UNINITIALIZED) {
      TPY_ERROR_LOC("Unexpected state: Query::Submit returned uninitialized");
    }

    if (g_stats) {
      auto now = std::chrono::high_resolution_clock::now();
      g_stats.get()->counters["py.core_read_query_initial_submit_time"] +=
          now - start_submit;
    }

    // update the BufferInfo read-counts to match the query results read
    update_read_elem_num();

    // fetch the result of the metadata get task
    // this will block if not yet completed
    /*
    // disabled, see comment above
    if (preload_metadata_) {
      metadata_num_preload.get();
    }
    */

    auto incomplete_start = std::chrono::high_resolution_clock::now();

    // TODO: would be nice to have a callback here for custom realloc strategy
    while (!return_incomplete_ &&
           query_->query_status() == Query::Status::INCOMPLETE) {
      if (++retries_ > max_retries)
        TPY_ERROR_LOC(
            "Exceeded maximum retries ('py.max_incomplete_retries': '" +
            std::to_string(max_retries) + "')");

      resubmit_read();
    }

    if (g_stats && retries_ > 0) {
      auto now = std::chrono::high_resolution_clock::now();
      g_stats.get()->counters["py.core_read_query_incomplete_retry_time"] +=
          now - incomplete_start;
    }

    // update TileDB-Py stat counter
    if (g_stats) {
      auto now = std::chrono::high_resolution_clock::now();
      g_stats.get()->counters["py.core_read_query_total_time"] += now - start;
    }

    if (g_stats) {
      g_stats.get()->counters["py.query_retries_count"] += TimerType(retries_);
    }

    resize_output_buffers();

    if (return_incomplete_) {
      // increment in case we submit again
      retries_++;
    }
  }

  py::array unpack_buffer(std::string name, py::array buf,
                          py::array_t<uint64_t> off) {
    auto start = std::chrono::high_resolution_clock::now();

    if (off.size() < 1)
      TPY_ERROR_LOC(std::string("Unexpected empty offsets array ('") + name +
                    "')");

    auto dtype = buffer_dtype(name);
    bool is_unicode = dtype.is(py::dtype("U"));
    bool is_str = dtype.is(py::dtype("S"));
    if (is_unicode || is_str) {
      dtype = py::dtype("O");
    }

    // Hashmap for string deduplication
    // fastest so far:
    typedef tsl::robin_map<size_t, uint64_t> MapType;
    MapType map;
    std::vector<py::object> object_v;
    if (is_unicode) {
      map.reserve(size_t(off.size() / 10) + 1);
    }

    auto result_array = py::array(py::dtype("O"), off.size());
    auto result_p = (py::object *)result_array.mutable_data();
    uint64_t last = 0;
    uint64_t cur = 0;
    size_t size = 0;
    uint64_t create = 0;

    auto off_data = off.data();
    last = off_data[0]; // initial should always be 0
    for (auto i = 1; i < off.size() + 1; i++) {
      if (i == off.size())
        cur = buf.nbytes();
      else {
        cur = off_data[i];
      }

      size = cur - last;

      py::object o;
      auto data_ptr = (char *)buf.data() + last;
      if (is_unicode)
        if (size == 0 || (data_ptr[0] == '\0' && size == 1)) {
          o = py::str("");
        } else {
          if (!deduplicate_) {
            o = py::str(data_ptr, size);
          } else {
            auto v = std::string_view{data_ptr, size};
            auto h = std::hash<std::string_view>()(v);
            auto needle = map.find(h);
            if (needle == map.end()) {
              o = py::str(data_ptr, size);
              map.insert(needle, {h, create});
              object_v.push_back(o);
              create++;
            } else {
              auto idx = needle->second;
              o = object_v[idx];
            }
          }
        }
      else if (is_str)
        if (size == 0 || (data_ptr[0] == '\0' && size == 1)) {
          o = py::bytes("");
        } else {
          o = py::bytes(data_ptr, size);
        }
      else {
        o = py::array(py::dtype("uint8"), size, data_ptr);
        o.attr("dtype") = dtype;
      }

      result_p[i - 1] = o;
      last = cur;
    }

    if (g_stats) {
      auto now = std::chrono::high_resolution_clock::now();
      g_stats.get()->counters["py.buffer_conversion_time"] += now - start;
    }

    return result_array;
  }

  void submit_write() {}

  void submit() {
    if (array_->query_type() == TILEDB_READ) {
      submit_read();
    } else if (array_->query_type() == TILEDB_WRITE) {
      submit_write();
    } else if (array_->query_type() == TILEDB_DELETE) {
      query_->submit();
      if (query_->query_status() == Query::Status::UNINITIALIZED) {
        TPY_ERROR_LOC("Unexpected state: Query::Submit returned uninitialized");
      }
    } else {
      TPY_ERROR_LOC("Unknown query type!")
    }
  }

  py::dict results() {
    py::dict results;
    for (auto &buffer_name : buffers_order_) {
      auto bp = buffers_.at(buffer_name);
      results[py::str(buffer_name)] =
          py::make_tuple(bp.data, bp.offsets, bp.validity);
    }
    return results;
  }

  std::unique_ptr<PAPair> buffer_to_pa(std::string name) {
    if (query_->query_status() != tiledb::Query::Status::COMPLETE)
      TPY_ERROR_LOC("Cannot convert buffers unless Query is complete");

    tiledb::arrow::ArrowAdapter adapter(&ctx_, query_.get());

    std::unique_ptr<PAPair> pa_pair(new PAPair());

    adapter.export_buffer(name.c_str(), &(pa_pair->array_), &(pa_pair->schema_),
                          nullptr, nullptr);
    pa_pair->exported_ = true;

    return pa_pair;
  }

  py::object buffers_to_pa_table() {
    using namespace pybind11::literals;

    auto pa = py::module::import("pyarrow");
    auto pa_array_import = pa.attr("Array").attr("_import_from_c");

    tiledb::arrow::ArrowAdapter adapter(&ctx_, query_.get());

    py::list names;
    py::list results;
    for (auto &buffer_name : buffers_order_) {
      BufferInfo &buffer_info = buffers_.at(buffer_name);

      auto buffer_holder = new BufferHolder(
          buffer_info.data, buffer_info.validity, buffer_info.offsets);

      ArrowArray c_pa_array;
      ArrowSchema c_pa_schema;
      adapter.export_buffer(buffer_name.c_str(),
                            static_cast<void *>(&c_pa_array),
                            static_cast<void *>(&c_pa_schema),
                            (tiledb::arrow::ArrowAdapter::release_cb)
                                BufferHolder::free_buffer_holder,
                            buffer_holder);

      if (is_nullable(buffer_name)) {
        // count zeros before converting to bitmap
        c_pa_array.null_count = count_zeros(buffer_info.validity);
        // convert to bitmap
        buffer_info.validity = uint8_bool_to_uint8_bitmap(buffer_info.validity);
        c_pa_array.buffers[0] = buffer_info.validity.data();
        c_pa_array.n_buffers = is_var(buffer_name) ? 3 : 2;
        c_pa_schema.flags |= ARROW_FLAG_NULLABLE;
      } else if (!is_var(buffer_name)) {
        // reset the number of buffers for non-nullable data
        c_pa_array.n_buffers = 2;
      }

      // work around for SC-11522: metadata field must be set to nullptr
      c_pa_schema.metadata = nullptr;
      py::object pa_array = pa_array_import(py::int_((ptrdiff_t)&c_pa_array),
                                            py::int_((ptrdiff_t)&c_pa_schema));

      results.append(pa_array);
      names.append(buffer_name);
    }

    auto pa_table =
        pa.attr("Table").attr("from_arrays")(results, "names"_a = names);
    return pa_table;
  }

  py::object is_incomplete() {
    if (!query_) {
      throw TileDBPyError("Internal error: PyQuery not initialized!");
    }
    return py::cast<bool>(query_->query_status() ==
                          tiledb::Query::Status::INCOMPLETE);
  }

  py::object estimated_result_sizes() {
    // vector of names to estimate
    std::vector<std::string> estim_names;

    for (size_t dim_idx = 0; dim_idx < domain_->ndim(); dim_idx++) {
      auto dim = domain_->dimension(dim_idx);
      if ((std::find(dims_.begin(), dims_.end(), dim.name()) == dims_.end()) &&
          // we need to also check if this is an attr for backward-compatibility
          (std::find(attrs_.begin(), attrs_.end(), dim.name()) ==
           attrs_.end())) {
        continue;
      }
      estim_names.push_back(dim.name());
    }

    // iterate by idx: schema.attributes() is unordered, but we need to
    //                 return ordered results
    for (size_t attr_idx = 0; attr_idx < array_schema_->attribute_num();
         attr_idx++) {
      auto attr = array_schema_->attribute(attr_idx);
      if (std::find(attrs_.begin(), attrs_.end(), attr.name()) ==
          attrs_.end()) {
        continue;
      }
      estim_names.push_back(attr.name());
    }

    py::dict results;

    for (auto const &name : estim_names) {
      size_t est_offsets = 0, est_data_bytes = 0;

      if (is_var(name)) {
        query_->est_result_size_var(name);
        auto est_sizes = query_->est_result_size_var(name);
        est_offsets = std::get<0>(est_sizes);
        est_data_bytes = std::get<1>(est_sizes);
      } else {
        est_data_bytes = query_->est_result_size(name);
      }
      results[py::str(name)] = py::make_tuple(est_offsets, est_data_bytes);
    }

    return std::move(results);
  }

  py::array _test_array() {
    py::array_t<uint8_t> a;
    a.resize({10});

    a.resize({20});
    return std::move(a);
  }

  uint64_t _test_init_buffer_bytes() {
    // test helper to get the configured init_buffer_bytes
    return init_buffer_bytes_;
  }
  uint64_t _test_alloc_max_bytes() {
    // test helper to get the configured init_buffer_bytes
    return alloc_max_bytes_;
  }

  std::string get_stats() { return query_->stats(); }

private:
  void init_config() {
    // get config parameters
    std::string tmp_str;
    if (config_has_key(ctx_.config(), "py.init_buffer_bytes")) {
      tmp_str = ctx_.config().get("py.init_buffer_bytes");
      try {
        init_buffer_bytes_ = std::stoull(tmp_str);
      } catch (const std::invalid_argument &e) {
        (void)e;
        throw std::invalid_argument(
            "Failed to convert 'py.init_buffer_bytes' to uint64_t ('" +
            tmp_str + "')");
      }
    }

    if (config_has_key(ctx_.config(), "py.alloc_max_bytes")) {
      tmp_str = ctx_.config().get("py.alloc_max_bytes");
      try {
        alloc_max_bytes_ = std::stoull(tmp_str);
      } catch (const std::invalid_argument &e) {
        (void)e;
        throw std::invalid_argument(
            "Failed to convert 'py.alloc_max_bytes' to uint64_t ('" + tmp_str +
            "')");
      }
      if (alloc_max_bytes_ < pow(1024, 2)) {
        throw std::invalid_argument("Invalid parameter: 'py.alloc_max_bytes' "
                                    "must be >= 1 MB (1024 ** 2 bytes)");
      };
    }

    if (config_has_key(ctx_.config(), "py.deduplicate")) {
      tmp_str = ctx_.config().get("py.deduplicate");
      if (tmp_str == "true") {
        deduplicate_ = true;
      } else if (tmp_str == "false") {
        deduplicate_ = false;
      } else {
        throw std::invalid_argument(
            "Failed to convert configuration 'py.deduplicate' to bool ('" +
            tmp_str + "')");
      }
    }

    if (config_has_key(ctx_.config(), "py.exact_init_buffer_bytes")) {
      tmp_str = ctx_.config().get("py.exact_init_buffer_bytes");
      if (tmp_str == "true") {
        exact_init_bytes_ = true;
      } else if (tmp_str == "false") {
        exact_init_bytes_ = false;
      } else {
        throw std::invalid_argument("Failed to convert configuration "
                                    "'py.exact_init_buffer_bytes' to bool ('" +
                                    tmp_str + "')");
      }
    }

    if (config_has_key(ctx_.config(), "py.use_arrow")) {
      tmp_str = ctx_.config().get("py.use_arrow");
      if (tmp_str == "True") {
        use_arrow_ = true;
      } else if (tmp_str == "False") {
        use_arrow_ = false;
      } else {
        throw std::invalid_argument(
            "Failed to convert configuration 'py.use_arrow' to bool ('" +
            tmp_str + "')");
      }
    }
  }

}; // namespace tiledbpy

void init_stats() {
  g_stats.reset(new StatsInfo());

  auto stats_counters = g_stats.get()->counters;
  stats_counters["py.core_read_query_initial_submit_time"] = TimerType();
  stats_counters["py.core_read_query_total_time"] = TimerType();
  stats_counters["py.core_read_query_incomplete_retry_time"] = TimerType();
  stats_counters["py.buffer_conversion_time"] = TimerType();
  stats_counters["py.read_query_incomplete_buffer_resize_time"] = TimerType();
  stats_counters["py.query_retries_count"] = TimerType();
}

void disable_stats() { g_stats.reset(nullptr); }

bool stats_enabled() { return (bool)g_stats; }

void increment_stat(std::string key, double value) {
  auto &stats_counters = g_stats.get()->counters;

  if (stats_counters.count(key) == 0)
    stats_counters[key] = TimerType();

  auto &timer = stats_counters[key];
  auto incr = std::chrono::duration<double>(value);
  timer += incr;
}

bool use_stats() { return (bool)g_stats; }

py::object get_stats() {
  if (!g_stats) {
    TPY_ERROR_LOC("Stats counters are not uninitialized!")
  }

  auto &stats_counters = g_stats.get()->counters;

  py::dict res;
  for (auto iter = stats_counters.begin(); iter != stats_counters.end();
       ++iter) {
    auto val = std::chrono::duration<double>(iter->second);
    res[py::str(iter->first)] = py::float_(val.count());
  }
  return std::move(res);
}

py::object python_internal_stats(bool dict = false) {
  if (!g_stats) {
    TPY_ERROR_LOC("Stats counters are not uninitialized!")
  }

  auto counters = g_stats.get()->counters;
  auto rq_time = counters["py.core_read_query_initial_submit_time"].count();

  if (dict) {
    py::dict stats;

    // core.cc is only tracking read time right now; don't output if we
    // have no query submission time
    if (rq_time == 0) {
      return std::move(stats);
    }

    for (auto &stat : counters) {
      stats[py::str(stat.first)] = stat.second.count();
    }

    return std::move(stats);
  } else {
    std::ostringstream os;

    // core.cc is only tracking read time right now; don't output if we
    // have no query submission time
    if (rq_time == 0) {
      return py::str(os.str());
    }

    os << std::endl;
    os << "==== Python Stats ====" << std::endl << std::endl;

    for (auto &stat : counters) {
      os << "  " << stat.first << " : " << stat.second.count() << std::endl;
    }

    return py::str(os.str());
  }
}

py::str as_built_dump() {
  tiledb_string_t *s;
  int rc = tiledb_as_built_dump(&s);
  if (rc != TILEDB_OK) {
    TPY_ERROR_LOC("Could not dump as built.");
  }
  const char *data_ptr;
  py::size_t length;

  tiledb_string_view(s, &data_ptr, &length);
  py::str res(data_ptr, length);
  tiledb_string_free(&s);

  return res;
}

auto walk_callback = [](const char *path_ptr, tiledb_object_t obj,
                        void *pyfunc) {
  std::string my_path(path_ptr);
  std::string my_objtype;
  if (obj == TILEDB_GROUP) {
    my_objtype = "group";
  } else if (obj == TILEDB_ARRAY) {
    my_objtype = "array";
  } else {
    return 0;
  }
  try {
    py::function func = py::cast<py::function>((PyObject *)pyfunc);
    func(my_path, my_objtype);
  } catch (py::stop_iteration) {
    return 0;
  }
  return 1;
};

void init_core(py::module &m) {
  init_query_condition(m);

  auto pq =
      py::class_<PyQuery>(m, "PyQuery")
          .def(py::init<const Context &, py::object, py::iterable, py::iterable,
                        py::object, py::object>())
          .def("add_label_buffer", &PyQuery::add_label_buffer)
          .def("buffer_dtype", &PyQuery::buffer_dtype)
          .def("results", &PyQuery::results)
          .def("set_subarray", &PyQuery::set_subarray)
          .def("set_cond", &PyQuery::set_cond)
#if defined(TILEDB_SERIALIZATION)
          .def("set_serialized_query", &PyQuery::set_serialized_query)
#endif
          .def("submit", &PyQuery::submit)
          .def("unpack_buffer", &PyQuery::unpack_buffer)
          .def("estimated_result_sizes", &PyQuery::estimated_result_sizes)
          .def("get_stats", &PyQuery::get_stats)
          .def("_allocate_buffers", &PyQuery::allocate_buffers)
          .def("_get_buffers", &PyQuery::get_buffers)
          .def("_buffer_to_pa", &PyQuery::buffer_to_pa)
          .def("_buffers_to_pa_table", &PyQuery::buffers_to_pa_table)
          .def("_test_array", &PyQuery::_test_array)
          .def("_test_err",
               [](py::object self, std::string s) { throw TileDBPyError(s); })
          .def_readwrite("_preload_metadata", &PyQuery::preload_metadata_)
          .def_readwrite("_return_incomplete", &PyQuery::return_incomplete_)
          // properties
          .def_property_readonly("is_incomplete", &PyQuery::is_incomplete)
          .def_property_readonly("_test_init_buffer_bytes",
                                 &PyQuery::_test_init_buffer_bytes)
          .def_property_readonly("_test_alloc_max_bytes",
                                 &PyQuery::_test_alloc_max_bytes)
          .def_readonly("retries", &PyQuery::retries_);

  py::class_<PyAgg>(m, "PyAgg")
      .def(py::init<const Context &, py::object, py::object, py::dict>(),
           "ctx"_a, "py_array"_a, "py_layout"_a, "attr_to_aggs_input"_a)
      .def("set_subarray", &PyAgg::set_subarray)
      .def("set_cond", &PyAgg::set_cond)
      .def("get_aggregate", &PyAgg::get_aggregate);

  py::class_<PAPair>(m, "PAPair")
      .def(py::init())
      .def("get_array", &PAPair::get_array)
      .def("get_schema", &PAPair::get_schema);

  m.def("array_to_buffer", &convert_np);

  m.def("init_stats", []() {
    Stats::enable();
    init_stats();
  });
  m.def("disable_stats", []() {
    Stats::disable();
    disable_stats();
  });
  m.def("stats_enabled", &stats_enabled);
  m.def("reset_stats", []() {
    Stats::reset();
    init_stats();
  });
  m.def("stats_raw_dump_str", []() {
    std::string out;
    Stats::raw_dump(&out);
    return out;
  });
  m.def("stats_dump_str", []() {
    std::string out;
    Stats::dump(&out);
    return out;
  });
  m.def("python_internal_stats", &python_internal_stats,
        py::arg("dict") = false);
  m.def("increment_stat", &increment_stat);
  m.def("get_stats", &get_stats);
  m.def("use_stats", &use_stats);
  m.def("datatype_size", &tiledb_datatype_size);
  m.def("as_built_dump", &as_built_dump);
  m.def("object_type",
        [](const std::string &uri, const Context &ctx) -> py::object {
          tiledb_object_t res;
          ctx.handle_error(
              tiledb_object_type(ctx.ptr().get(), uri.c_str(), &res));
          if (res == TILEDB_ARRAY) {
            return py::str("array");
          } else if (res == TILEDB_GROUP) {
            return py::str("group");
          }
          return py::none();
        });
  m.def("ls",
        [](const std::string &path, py::function func, const Context &ctx) {
          ctx.handle_error(tiledb_object_ls(ctx.ptr().get(), path.c_str(),
                                            walk_callback, (void *)func.ptr()));
        });
  m.def("walk", [](const std::string path, py::function func,
                   const std::string order, const Context &ctx) {
    tiledb_walk_order_t walk_order;
    if (order == "postorder") {
      walk_order = TILEDB_POSTORDER;
    } else if (order == "preorder") {
      walk_order = TILEDB_PREORDER;
    } else {
      throw TileDBError("unknown walk order " + order);
    }
    ctx.handle_error(tiledb_object_walk(ctx.ptr().get(), path.c_str(),
                                        walk_order, walk_callback,
                                        (void *)func.ptr()));
  });
  m.def("remove", &Object::remove);
  m.def("move", &Object::move);

  /*
   We need to make sure C++ TileDBError is translated to a correctly-typed py
   error. Note that using py::exception(..., "TileDBError") creates a new
   exception in the *readquery* module, so we must import to reference.
*/
  static auto tiledb_py_error =
      (py::object)py::module::import("tiledb").attr("TileDBError");

  py::register_exception_translator([](std::exception_ptr p) {
    try {
      if (p)
        std::rethrow_exception(p);
    } catch (const TileDBPyError &e) {
      PyErr_SetString(tiledb_py_error.ptr(), e.what());
    } catch (const tiledb::TileDBError &e) {
      PyErr_SetString(tiledb_py_error.ptr(), e.what());
    } catch (py::builtin_exception &e) {
      // just forward the error
      throw;
      //} catch (std::runtime_error &e) {
      //  std::cout << "unexpected runtime_error: " << e.what() << std::endl;
    }
  });
};
}; // namespace tiledbpy