#pragma once

#include <array>

#include <cstddef>

#include <cstdint>

#include <cstring>

#include <limits>

#include <memory>

#include <numeric>

#include <string>

#include <string_view>

#include <vector>

#include "arrow/array/array_base.h"

#include "arrow/array/array_binary.h"

#include "arrow/array/builder_base.h"

#include "arrow/array/data.h"

#include "arrow/buffer.h"

#include "arrow/buffer_builder.h"

#include "arrow/status.h"

#include "arrow/type.h"

#include "arrow/util/macros.h"

#include "arrow/util/visibility.h"

namespace arrow {

template <typename TYPE>

class BaseBinaryBuilder : public ArrayBuilder {

};

class ARROW_EXPORT BinaryBuilder : public BaseBinaryBuilder<BinaryType> {

public:

using BaseBinaryBuilder::BaseBinaryBuilder;

/// \cond FALSE

using ArrayBuilder::Finish;

/// \endcond

Status Finish(std::shared_ptr<BinaryArray>* out) { return FinishTyped(out); }

std::shared_ptr<DataType> type() const override { return binary(); }

};

class ARROW_EXPORT StringBuilder : public BinaryBuilder {

public:

using BinaryBuilder::BinaryBuilder;

/// \cond FALSE

using ArrayBuilder::Finish;

/// \endcond

Status Finish(std::shared_ptr<StringArray>* out) { return FinishTyped(out); }

std::shared_ptr<DataType> type() const override { return utf8(); }

};

class ARROW_EXPORT LargeBinaryBuilder : public BaseBinaryBuilder<LargeBinaryType> {

public:

using BaseBinaryBuilder::BaseBinaryBuilder;

/// \cond FALSE

using ArrayBuilder::Finish;

/// \endcond

Status Finish(std::shared_ptr<LargeBinaryArray>* out) { return FinishTyped(out); }

std::shared_ptr<DataType> type() const override { return large_binary(); }

};

class ARROW_EXPORT LargeStringBuilder : public LargeBinaryBuilder {

public:

using LargeBinaryBuilder::LargeBinaryBuilder;

/// \cond FALSE

using ArrayBuilder::Finish;

/// \endcond

Status Finish(std::shared_ptr<LargeStringArray>* out) { return FinishTyped(out); }

std::shared_ptr<DataType> type() const override { return large_utf8(); }

};

class ARROW_EXPORT FixedSizeBinaryBuilder : public ArrayBuilder {

public:

using TypeClass = FixedSizeBinaryType;

explicit FixedSizeBinaryBuilder(const std::shared_ptr<DataType>& type,

MemoryPool* pool = default_memory_pool(),

int64_t alignment = kDefaultBufferAlignment);

Status Append(const uint8_t* value) {

}

Status Append(const char* value) {

return Append(reinterpret_cast<const uint8_t*>(value));

}

Status Append(std::string_view view) {

}

Status Append(const std::string& s) {

}

Status Append(const Buffer& s) {

}

Status Append(const std::shared_ptr<Buffer>& s) { return Append(*s); }

template <size_t NBYTES>

Status Append(const std::array<uint8_t, NBYTES>& value) {

}

Status AppendValues(const uint8_t* data, int64_t length,

const uint8_t* valid_bytes = NULLPTR);

Status AppendValues(const uint8_t* data, int64_t length, const uint8_t* validity,

int64_t bitmap_offset);

Status AppendNull() final;

Status AppendNulls(int64_t length) final;

Status AppendEmptyValue() final;

Status AppendEmptyValues(int64_t length) final;

Status AppendArraySlice(const ArraySpan& array, int64_t offset,

}

void UnsafeAppend(const uint8_t* value) {

}

void UnsafeAppend(const char* value) {

UnsafeAppend(reinterpret_cast<const uint8_t*>(value));

}

void UnsafeAppend(std::string_view value) {

}

void UnsafeAppend(const Buffer& s) { UnsafeAppend(std::string_view(s)); }

void UnsafeAppend(const std::shared_ptr<Buffer>& s) { UnsafeAppend(*s); }

void UnsafeAppendNull() {

UnsafeAppendToBitmap(false);

byte_builder_.UnsafeAppend(/*num_copies=*/byte_width_, 0);

}

Status ValidateOverflow(int64_t new_bytes) const {

}

/// \brief Ensures there is enough allocated capacity to append the indicated

/// number of bytes to the value data buffer without additional allocations

Status ReserveData(int64_t elements) {

ARROW_RETURN_NOT_OK(ValidateOverflow(elements));

return byte_builder_.Reserve(elements);

}

void Reset() override;

Status Resize(int64_t capacity) override;

Status FinishInternal(std::shared_ptr<ArrayData>* out) override;

/// \cond FALSE

using ArrayBuilder::Finish;

/// \endcond

Status Finish(std::shared_ptr<FixedSizeBinaryArray>* out) { return FinishTyped(out); }

/// \return size of values buffer so far

int64_t value_data_length() const { return byte_builder_.length(); }

int32_t byte_width() const { return byte_width_; }

/// Temporary access to a value.

///

/// This pointer becomes invalid on the next modifying operation.

const uint8_t* GetValue(int64_t i) const;

/// Temporary access to a value.

///

/// This view becomes invalid on the next modifying operation.

std::string_view GetView(int64_t i) const;

static constexpr int64_t memory_limit() {

return std::numeric_limits<int64_t>::max() - 1;

}

std::shared_ptr<DataType> type() const override {

return fixed_size_binary(byte_width_);

}

protected:

int32_t byte_width_;

BufferBuilder byte_builder_;

/// Temporary access to a value.

///

/// This pointer becomes invalid on the next modifying operation.

uint8_t* GetMutableValue(int64_t i) {

uint8_t* data_ptr = byte_builder_.mutable_data();

return data_ptr + i * byte_width_;

}

void CheckValueSize(int64_t size);

};

namespace internal {

class ARROW_EXPORT ChunkedBinaryBuilder {

public:

explicit ChunkedBinaryBuilder(int32_t max_chunk_value_length,

MemoryPool* pool = default_memory_pool());

ChunkedBinaryBuilder(int32_t max_chunk_value_length, int32_t max_chunk_length,

MemoryPool* pool = default_memory_pool());

virtual ~ChunkedBinaryBuilder() = default;

Status Append(const uint8_t* value, int32_t length) {

}

Status Append(std::string_view value) {

return Append(reinterpret_cast<const uint8_t*>(value.data()),

static_cast<int32_t>(value.size()));

}

Status AppendNull() {

}

Status Reserve(int64_t values);

virtual Status Finish(ArrayVector* out);

protected:

Status NextChunk();

// maximum total character data size per chunk

int64_t max_chunk_value_length_;

// maximum elements allowed per chunk

int64_t max_chunk_length_ = kListMaximumElements;

// when Reserve() would cause builder_ to exceed its max_chunk_length_,

// add to extra_capacity_ instead and wait to reserve until the next chunk

int64_t extra_capacity_ = 0;

std::unique_ptr<BinaryBuilder> builder_;

std::vector<std::shared_ptr<Array>> chunks_;

};

class ARROW_EXPORT ChunkedStringBuilder : public ChunkedBinaryBuilder {

public:

using ChunkedBinaryBuilder::ChunkedBinaryBuilder;

Status Finish(ArrayVector* out) override;

};

} // namespace internal

} // namespace arrow