/*
 * Created by hangangqiang on 2020.11.10.
 */

#include "data.h"
#include <utility>
#include <cstring>
#include "common/log.h"
size_t MetaData::GetLengthFromBuffer(const char *buffer) {
  if (buffer == nullptr) {
    return 0;
  }
  auto length_buf = reinterpret_cast<const size_t *>(buffer);
  auto length = length_buf[0];
  return length;
}

size_t MetaData::GetLengthFromBuffer(const char *buffer, size_t buffer_size) {
  if (buffer == nullptr) {
    return 0;
  }
  auto length_buf = reinterpret_cast<const size_t *>(buffer);
  auto length = length_buf[0];
  if (length != buffer_size) {
    LOGE("Length of buffer error");
    return 0;
  }
  return length;
}

TYPE MetaData::GetTypeFromBuffer(const char *buffer, size_t buffer_size) {
  if (buffer == nullptr) {
    return kUnknow;
  }
  auto length_buf = reinterpret_cast<const size_t *>(buffer);
  auto length = length_buf[0];
  if (length != buffer_size) {
    LOGE("Length of buffer error");
    return kUnknow;
  }
  length_buf++;
  auto type_buf = reinterpret_cast<const int *>(length_buf);
  if (*type_buf <= kTypeMax && *type_buf >= kTypeMin) {
    return TYPE(*type_buf);
  } else {
    return kUnknow;
  }
}

char *MetaData::InitBuffer(TYPE type, size_t data_length) {
  if (data_length == 0) {
    LOGE("Length should large than 0, %zu", data_length);
    return nullptr;
  }
  size_t buffer_length = head_length_ + data_length;
  auto buffer = new char[buffer_length];
  memset(buffer, 0, buffer_length);
  auto length_buf = reinterpret_cast<size_t *>(buffer);
  *length_buf = buffer_length;
  auto type_buf = reinterpret_cast<int *>(length_buf + 1);
  *type_buf = int(type);
  return buffer;
}

// data_buffer: value(int, 4-byte)
char *IntMetaData::Serialize(size_t *buffer_size) const {
  auto buffer = InitBuffer(kInt, sizeof(int));
  auto data_buf = reinterpret_cast<int *>(buffer + head_length_);
  *data_buf = this->value_;
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *IntMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  if (buffer_size != head_length_ + sizeof(int)) {
    LOGE("Length of intMetaData buffer should be %zu : %zu", (head_length_ + sizeof(int)), buffer_size);
    return nullptr;
  }
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kInt) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto data_buffer = reinterpret_cast<const int *>(buffer + head_length_);
  auto int_meta_data = new IntMetaData(*data_buffer);
  return int_meta_data;
}

char *BoolMetaData::Serialize(size_t *buffer_size) const {
  auto buffer = InitBuffer(kBool, sizeof(bool));
  auto data_buf = reinterpret_cast<bool *>(buffer + head_length_);
  *data_buf = this->value_;
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *BoolMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  if (buffer_size != head_length_ + sizeof(bool)) {
    LOGE("Length of boolMetaData buffer should be %zu : %zu", (head_length_ + sizeof(int)), buffer_size);
    return nullptr;
  }
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kBool) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto data_buffer = reinterpret_cast<const bool *>(buffer + head_length_);
  auto bool_meta_data = new BoolMetaData(*data_buffer);
  return bool_meta_data;
}

// data_buffer: vec_size(size_t 8-byte) value(int, 1-byte)
char *CharVecMetaData::Serialize(size_t *buffer_size) const {
  auto buffer = InitBuffer(kCharVec, sizeof(size_t) + sizeof(char) * this->value_.size());
  auto vec_size_buf = reinterpret_cast<size_t *>(buffer + head_length_);
  *vec_size_buf = this->value_.size();
  auto value_buf = reinterpret_cast<char *>(vec_size_buf + 1);
  std::copy(this->value_.begin(), this->value_.end(), value_buf);
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *CharVecMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kCharVec) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto vec_size_buf = reinterpret_cast<const size_t *>(buffer + head_length_);
  std::vector<char> value;
  value.resize(*vec_size_buf);
  auto value_buf = reinterpret_cast<const char *>(vec_size_buf + 1);
  std::copy(value_buf, value_buf + (*vec_size_buf), value.begin());
  auto int_vec_meta_data = new CharVecMetaData(value);
  return int_vec_meta_data;
}

// data_buffer: vec_size(size_t 8-byte) value(int, 4-byte)
char *IntVecMetaData::Serialize(size_t *buffer_size) const {
  auto buffer = InitBuffer(kIntVec, sizeof(size_t) + sizeof(int) * this->value_.size());
  auto vec_size_buf = reinterpret_cast<size_t *>(buffer + head_length_);
  *vec_size_buf = this->value_.size();
  auto value_buf = reinterpret_cast<int *>(vec_size_buf + 1);
  std::copy(this->value_.begin(), this->value_.end(), value_buf);
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *IntVecMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kIntVec) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto vec_size_buf = reinterpret_cast<const size_t *>(buffer + head_length_);
  std::vector<int> value;
  value.resize(*vec_size_buf);
  auto value_buf = reinterpret_cast<const int *>(vec_size_buf + 1);
  std::copy(value_buf, value_buf + (*vec_size_buf), value.begin());
  auto int_vec_meta_data = new IntVecMetaData(value);
  return int_vec_meta_data;
}

// data_buffer: out_vec_size(size_t 8-byte) in_vec_sizes(size_t 8-byte) value(char, 4-byte)
char *CharVecVecMetaData::Serialize(size_t *buffer_size) const {
  size_t data_length = sizeof(size_t) + sizeof(size_t) * this->value_.size();
  for (auto &int_vec : value_) {
    data_length += sizeof(int) * int_vec.size();
  }
  auto buffer = InitBuffer(kCharVecVec, data_length);
  auto out_vec_size_buf = reinterpret_cast<size_t *>(buffer + head_length_);
  *out_vec_size_buf = this->value_.size();
  auto in_vec_size_buf = out_vec_size_buf + 1;
  for (auto &int_vec : value_) {
    *(in_vec_size_buf++) = int_vec.size();
  }
  auto value_buf = reinterpret_cast<char *>(in_vec_size_buf);
  for (auto &int_vec : value_) {
    std::copy(int_vec.begin(), int_vec.end(), value_buf);
    value_buf += int_vec.size();
  }
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *CharVecVecMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kCharVecVec) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto out_vec_size_buf = reinterpret_cast<const size_t *>(buffer + head_length_);
  std::vector<std::vector<char>> value;
  value.reserve(*out_vec_size_buf);
  auto in_vec_size_buf = reinterpret_cast<const size_t *>(out_vec_size_buf + 1);
  for (size_t i = 0; i < *out_vec_size_buf; i++) {
    std::vector<char> int_vec;
    int_vec.resize(*in_vec_size_buf++);
    value.emplace_back(int_vec);
  }
  auto value_buf = reinterpret_cast<const char *>(in_vec_size_buf);
  for (auto &char_vec : value) {
    std::copy(value_buf, value_buf + char_vec.size(), char_vec.begin());
    value_buf += char_vec.size();
  }
  auto char_vec_vec_meta_data = new CharVecVecMetaData(value);
  return char_vec_vec_meta_data;
}

// data_buffer: out_vec_size(size_t 8-byte) in_vec_sizes(size_t 8-byte) value(int, 4-byte)
char *IntVecVecMetaData::Serialize(size_t *buffer_size) const {
  size_t data_length = sizeof(size_t) + sizeof(size_t) * this->value_.size();
  for (auto &int_vec : value_) {
    data_length += sizeof(int) * int_vec.size();
  }
  auto buffer = InitBuffer(kIntVecVec, data_length);
  auto out_vec_size_buf = reinterpret_cast<size_t *>(buffer + head_length_);
  *out_vec_size_buf = this->value_.size();
  auto in_vec_size_buf = out_vec_size_buf + 1;
  for (auto &int_vec : value_) {
    *(in_vec_size_buf++) = int_vec.size();
  }
  auto value_buf = reinterpret_cast<int *>(in_vec_size_buf);
  for (auto &int_vec : value_) {
    std::copy(int_vec.begin(), int_vec.end(), value_buf);
    value_buf += int_vec.size();
  }
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *IntVecVecMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kIntVecVec) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto out_vec_size_buf = reinterpret_cast<const size_t *>(buffer + head_length_);
  std::vector<std::vector<int>> value;
  value.reserve(*out_vec_size_buf);
  auto in_vec_size_buf = reinterpret_cast<const size_t *>(out_vec_size_buf + 1);
  for (size_t i = 0; i < *out_vec_size_buf; i++) {
    std::vector<int> int_vec;
    int_vec.resize(*in_vec_size_buf++);
    value.emplace_back(int_vec);
  }
  auto value_buf = reinterpret_cast<const int *>(in_vec_size_buf);
  for (auto &int_vec : value) {
    std::copy(value_buf, value_buf + int_vec.size(), int_vec.begin());
    value_buf += int_vec.size();
  }
  auto int_vec_vec_meta_data = new IntVecVecMetaData(value);
  return int_vec_vec_meta_data;
}

// data_buffer: string_len(size_t 8-byte) value(char, 1-byte)
char *StringMetaData::Serialize(size_t *buffer_size) const {
  auto buffer = InitBuffer(kString, sizeof(size_t) + sizeof(char) * this->value_.size());
  auto string_size_buf = reinterpret_cast<size_t *>(buffer + head_length_);
  *string_size_buf = this->value_.size();
  auto value_buf = reinterpret_cast<char *>(string_size_buf + 1);
  std::copy(this->value_.begin(), this->value_.end(), value_buf);
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *StringMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kString) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto string_size_buf = reinterpret_cast<const size_t *>(buffer + head_length_);
  std::string value;
  value.resize(*string_size_buf);
  auto value_buf = reinterpret_cast<const char *>(string_size_buf + 1);
  std::copy(value_buf, value_buf + (*string_size_buf), value.begin());
  auto int_vec_meta_data = new StringMetaData(value);
  return int_vec_meta_data;
}

// data_buffer: vec_size(size_t 8-byte) string_len(size_t 8-byte) value(char, 1-byte)
char *StringVecMetaData::Serialize(size_t *buffer_size) const {
  size_t data_length = sizeof(size_t) + sizeof(size_t) * this->value_.size();
  for (auto &string : value_) {
    data_length += sizeof(int) * string.size();
  }
  auto buffer = InitBuffer(kStringVec, data_length);
  auto vec_size_buf = reinterpret_cast<size_t *>(buffer + head_length_);
  *vec_size_buf = this->value_.size();
  auto string_len_buf = vec_size_buf + 1;
  for (auto &string : value_) {
    *(string_len_buf++) = string.size();
  }
  auto value_buf = reinterpret_cast<char *>(string_len_buf);
  for (auto &string : value_) {
    std::copy(string.begin(), string.end(), value_buf);
    value_buf += string.size();
  }
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *StringVecMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kStringVec) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto vec_size_buf = reinterpret_cast<const size_t *>(buffer + head_length_);
  std::vector<std::string> value;
  value.reserve(*vec_size_buf);
  auto string_len_buf = reinterpret_cast<const size_t *>(vec_size_buf + 1);
  for (size_t i = 0; i < *vec_size_buf; i++) {
    std::string s;
    s.resize(*string_len_buf++);
    value.emplace_back(s);
  }
  auto value_buf = reinterpret_cast<const char *>(string_len_buf);
  for (auto &s : value) {
    std::copy(value_buf, value_buf + s.size(), s.begin());
    value_buf += s.size();
  }
  auto string_vec_meta_data = new StringVecMetaData(value);
  return string_vec_meta_data;
}

// data_buffer: out_vec_size(size_t 8-byte) in_vec_sizes(size_t 8-byte) string_len(size_t 8-byte) value(char, 1-byte)
char *StringVecVecMetaData::Serialize(size_t *buffer_size) const {
  size_t data_length = sizeof(size_t);
  size_t out_vec_size = value_.size();
  data_length += out_vec_size * sizeof(size_t);
  for (auto &stringvec : value_) {
    size_t int_vec_size = stringvec.size();
    data_length += int_vec_size * sizeof(size_t);
    for (auto &string : stringvec) {
      data_length += sizeof(int) * string.size();
    }
  }
  auto buffer = InitBuffer(kStringVecVec, data_length);
  auto buf = reinterpret_cast<size_t *>(buffer + head_length_);
  *buf++ = out_vec_size;
  for (auto &stringvec : value_) {
    *buf++ = stringvec.size();
    for (auto &string : stringvec) {
      *buf++ = string.size();
      auto char_buf = reinterpret_cast<char *>(buf);
      std::copy(string.begin(), string.end(), char_buf);
      buf = reinterpret_cast<size_t *>(char_buf + string.size());
    }
  }
  *buffer_size = GetLengthFromBuffer(buffer);
  return buffer;
}

MetaData *StringVecVecMetaData::Deserialize(const char *buffer, size_t buffer_size) {
  auto length = GetLengthFromBuffer(buffer, buffer_size);
  if (length == 0) {
    LOGE("Deserialize buffer failed, buffer_size error");
    return nullptr;
  }
  auto type = GetTypeFromBuffer(buffer, buffer_size);
  if (type != kStringVecVec) {
    LOGE("Deserialize buffer failed, type error: %d", type);
    return nullptr;
  }
  auto buf = reinterpret_cast<const size_t *>(buffer + head_length_);
  std::vector<std::vector<std::string>> value;
  value.resize(*buf++);  // out_vec_size -> N std::vector<std::string>
  for (size_t i = 0; i < value.size(); i++) {
    value[i].resize(*buf++);  // in_vec_size -> N std::string
    for (size_t j = 0; j < value[i].size(); j++) {
      value[i][j].resize(*buf++);
      auto *char_buf = reinterpret_cast<const char *>(buf);
      std::copy(char_buf, char_buf + value[i][j].size(), value[i][j].begin());
      buf = reinterpret_cast<const size_t *>(char_buf + value[i][j].size());
    }
  }
  auto string_vec_vec_meta_data = new StringVecVecMetaData(value);
  return string_vec_vec_meta_data;
}

Data::Data() = default;

Data::Data(const MetaData &meta_data) {
  size_t buffer_size = 0;
  buffer_ = meta_data.Serialize(&buffer_size);
  buffer_size_ += buffer_size;
  cur_buffer_ = buffer_;
  format_.emplace_back(std::make_pair(meta_data.type_, buffer_size));
}

Data::Data(const std::vector<MetaData *> &meta_datas) {
  for (auto *meta_data : meta_datas) {
    if (meta_data == nullptr) {
      return;
    }
    size_t buffer_size = 0;
    buffer_size_ += buffer_size;
    auto tmp_buffer = meta_data->Serialize(&buffer_size);
    auto old_buffer = buffer_;
    buffer_ = new char[buffer_size_ + buffer_size];
    if (buffer_size_ > 0) {
      memcpy(buffer_, old_buffer, buffer_size_);
    }
    memcpy(buffer_ + buffer_size_, tmp_buffer, buffer_size);
    delete[] (tmp_buffer);
    delete[] (old_buffer);
    buffer_size_ += buffer_size;
    format_.emplace_back(std::make_pair(meta_data->type_, buffer_size));
  }
  cur_buffer_ = buffer_;
}

MetaData *Data::GetNextMetaData() {
  if (this->curse_ >= this->format_.size()) {
    return nullptr;
  }
  auto format = this->format_.at(this->curse_);
  this->curse_ += 1;
  switch (format.first) {
    case kInt: {
      auto meta_data = IntMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    case kBool: {
      auto meta_data = BoolMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    case kCharVec: {
      auto meta_data = CharVecMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    case kIntVec: {
      auto meta_data = IntVecMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    case kCharVecVec: {
      auto meta_data = CharVecVecMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    case kIntVecVec: {
      auto meta_data = IntVecVecMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    case kString: {
      auto meta_data = StringMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    case kStringVec: {
      auto meta_data = StringVecMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    case kStringVecVec: {
      auto meta_data = StringVecVecMetaData::Deserialize(cur_buffer_, format.second);
      cur_buffer_ += format.second;
      return meta_data;
    }
    default:
      LOGE("Unsupported TYPE: %d", format.first);
      return nullptr;
  }
}

Data::~Data() { delete[] (this->buffer_); }

bool Data::GetNextInt(int *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto int_meta_data = dynamic_cast<IntMetaData *>(this->GetNextMetaData());
  if (int_meta_data == nullptr) {
    LOGE("Next meta data is not a int meta data");
    return false;
  }
  *result = int_meta_data->GetValue();
  delete (int_meta_data);
  return true;
}

bool Data::GetNextBool(bool *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto bool_meta_data = dynamic_cast<BoolMetaData *>(this->GetNextMetaData());
  if (bool_meta_data == nullptr) {
    LOGE("Next meta data is not a bool meta data");
    return false;
  }
  *result = bool_meta_data->GetValue();
  delete (bool_meta_data);
  return true;
}

bool Data::GetNextCharVec(std::vector<char> *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto char_vec_meta_data = dynamic_cast<CharVecMetaData *>(this->GetNextMetaData());
  if (char_vec_meta_data == nullptr) {
    LOGE("Next meta data is not a char vector meta data");
    return false;
  }
  *result = char_vec_meta_data->GetValue();
  delete (char_vec_meta_data);
  return true;
}

bool Data::GetNextIntVec(std::vector<int> *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto int_vec_meta_data = dynamic_cast<IntVecMetaData *>(this->GetNextMetaData());
  if (int_vec_meta_data == nullptr) {
    LOGE("Next meta data is not a int vector meta data");
    return false;
  }
  *result = int_vec_meta_data->GetValue();
  delete (int_vec_meta_data);
  return true;
}

bool Data::GetNextCharVecVec(std::vector<std::vector<char>> *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto char_vec_vec_meta_data = dynamic_cast<CharVecVecMetaData *>(this->GetNextMetaData());
  if (char_vec_vec_meta_data == nullptr) {
    LOGE("Next meta data is not a char vector vector meta data");
    return false;
  }
  *result = char_vec_vec_meta_data->GetValue();
  delete (char_vec_vec_meta_data);
  return true;
}

bool Data::GetNextIntVecVec(std::vector<std::vector<int>> *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto int_vec_vec_meta_data = dynamic_cast<IntVecVecMetaData *>(this->GetNextMetaData());
  if (int_vec_vec_meta_data == nullptr) {
    LOGE("Next meta data is not a int vector vector meta data");
    return false;
  }
  *result = int_vec_vec_meta_data->GetValue();
  delete (int_vec_vec_meta_data);
  return true;
}

bool Data::GetNextString(std::string *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto string_meta_data = dynamic_cast<StringMetaData *>(this->GetNextMetaData());
  if (string_meta_data == nullptr) {
    LOGI("Next meta data is not a string meta data");
    return false;
  }
  *result = string_meta_data->GetValue();
  delete (string_meta_data);
  return true;
}

bool Data::GetNextStringVec(std::vector<std::string> *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto string_vec_meta_data = dynamic_cast<StringVecMetaData *>(this->GetNextMetaData());
  if (string_vec_meta_data == nullptr) {
    LOGE("Next meta data is not a string vector meta data");
    return false;
  }
  *result = string_vec_meta_data->GetValue();
  delete (string_vec_meta_data);
  return true;
}

bool Data::GetNextStringVecVec(std::vector<std::vector<std::string>> *result) {
  CHECK_NULL_RETURN(result, "Input result is nullptr", false);
  auto string_vec_vec_meta_data = dynamic_cast<StringVecVecMetaData *>(this->GetNextMetaData());
  if (string_vec_vec_meta_data == nullptr) {
    LOGE("Next meta data is not a string vector vector meta data");
    return false;
  }
  *result = string_vec_vec_meta_data->GetValue();
  delete (string_vec_vec_meta_data);
  return true;
}

bool Data::operator==(const Data &other) {
  if (this == &other) {
    return true;
  }
  if (this->buffer_size_ != other.buffer_size_) {
    return false;
  }
  if (this->format_ != other.format_) {
    return false;
  }
  for (auto i = 0; i < this->buffer_size_; i++) {
    if (this->buffer_[i] != other.buffer_[i]) {
      return false;
    }
  }
  return true;
}

void Data::ResetCurse() {
  this->curse_ = 0;
  this->cur_buffer_ = buffer_;
}