/*
 * Created by hangangqiang on 2020.11.10.
 */

#ifndef LEETCODE_DATA_H
#define LEETCODE_DATA_H

#include <map>
#include <utility>
#include <vector>

enum TYPE {
  kTypeMin = 0,
  kUnknow = kTypeMin,
  kInt,
  kBool,
  kFloat,
  kDouble,
  kString,
  kCharVec,
  kIntVec,
  kFloatVec,
  kDoubleVec,
  kStringVec,
  kStringVecVec,
  kCharVecVec,
  kIntVecVec,
  kHybridization,
  kTypeMax = kHybridization
};

// length(size_t, 8-byte) type(int, 4-byte) data_buffer(char, n-byte)
class MetaData {
 public:
  explicit MetaData(TYPE type) : type_(type) {}
  virtual ~MetaData() = default;
  virtual char *Serialize(size_t *buffer_size) const = 0;

  static size_t GetLengthFromBuffer(const char *buffer);
  static size_t GetLengthFromBuffer(const char *buffer, size_t buffer_size);
  static TYPE GetTypeFromBuffer(const char *buffer, size_t buffer_size);
  static char *InitBuffer(TYPE type, size_t data_length);

  TYPE type_ = kInt;
  const static size_t head_length_ = sizeof(size_t) + sizeof(int);
};

// data_buffer: value(int, 4-byte)
class IntMetaData : public MetaData {
 public:
  explicit IntMetaData(int int_value) : MetaData(kInt), value_(int_value){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  int GetValue() const { return this->value_; }

 private:
  int value_;
};

// data_buffer: value(int, 4-byte)
class BoolMetaData : public MetaData {
 public:
  explicit BoolMetaData(bool bool_value) : MetaData(kBool), value_(bool_value){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  bool GetValue() const { return this->value_; }

 private:
  bool value_;
};

class CharVecMetaData : public MetaData {
 public:
  explicit CharVecMetaData(std::vector<char> char_vec) : MetaData(kCharVec), value_(std::move(char_vec)){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  const std::vector<char> &GetValue() const { return this->value_; }

 private:
  std::vector<char> value_;
};

class CharVecVecMetaData : public MetaData {
 public:
  explicit CharVecVecMetaData(std::vector<std::vector<char>> char_vec)
      : MetaData(kCharVecVec), value_(std::move(char_vec)){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  const std::vector<std::vector<char>> &GetValue() const { return this->value_; }

 private:
  std::vector<std::vector<char>> value_;
};

// data_buffer: vec_size(size_t 8-byte) value(int, 4-byte)
class IntVecMetaData : public MetaData {
 public:
  explicit IntVecMetaData(std::vector<int> int_vec) : MetaData(kIntVec), value_(std::move(int_vec)){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  const std::vector<int> &GetValue() const { return this->value_; }

 private:
  std::vector<int> value_;
};

class IntVecVecMetaData : public MetaData {
 public:
  explicit IntVecVecMetaData(std::vector<std::vector<int>> int_vec_vec)
      : MetaData(kIntVecVec), value_(std::move(int_vec_vec)){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  const std::vector<std::vector<int>> &GetValue() const { return this->value_; }

 private:
  std::vector<std::vector<int>> value_;
};

class StringMetaData : public MetaData {
 public:
  explicit StringMetaData(std::string value = "") : MetaData(kString), value_(std::move(value)){};
  explicit StringMetaData(const char *value) : MetaData(kString), value_(value){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  std::string GetValue() const { return this->value_; }
  StringMetaData &operator<<(const std::string &line) {
    this->value_ += line + "\n";
    return *this;
  }

 private:
  std::string value_;
};

class StringVecVecMetaData : public MetaData {
 public:
  explicit StringVecVecMetaData(std::vector<std::vector<std::string>> string_vec_vec)
      : MetaData(kStringVecVec), value_(std::move(string_vec_vec)){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  const std::vector<std::vector<std::string>> &GetValue() const { return this->value_; }

 private:
  std::vector<std::vector<std::string>> value_;
};

class StringVecMetaData : public MetaData {
 public:
  explicit StringVecMetaData(std::vector<std::string> value) : MetaData(kStringVec), value_(std::move(value)){};
  char *Serialize(size_t *buffer_size) const override;
  static MetaData *Deserialize(const char *buffer, size_t buffer_size);
  std::vector<std::string> GetValue() const { return this->value_; }

 private:
  std::vector<std::string> value_;
};

// todo:
// StringVecVec can reuse logical of StringVec, and StringVec and reuse logical of String
// IntVecVec can reuse logical of IntVec, and StringVec and reuse logical of Int
// ...
class Data {
 public:
  Data();
  explicit Data(const MetaData &meta_datas);
  explicit Data(const std::vector<MetaData *> &meta_datas);
  virtual ~Data();
  MetaData *GetNextMetaData();
  bool GetNextInt(int *result);
  bool GetNextBool(bool *result);
  bool GetNextCharVec(std::vector<char> *result);
  bool GetNextIntVec(std::vector<int> *result);
  bool GetNextCharVecVec(std::vector<std::vector<char>> *result);
  bool GetNextIntVecVec(std::vector<std::vector<int>> *result);
  bool GetNextString(std::string *result);
  bool GetNextStringVec(std::vector<std::string> *result);
  bool GetNextStringVecVec(std::vector<std::vector<std::string>> *result);
  void ResetCurse();
  bool operator==(const Data &other);

 private:
  char *buffer_ = nullptr;
  size_t buffer_size_ = 0;
  const char *cur_buffer_ = nullptr;
  // type of buffer and buffer_size
  std::vector<std::pair<TYPE, size_t>> format_;
  size_t curse_ = 0;
};

#endif  // LEETCODE_DATA_H