#include "godot_variant.h"

#include <cstdint>
#include <stdexcept>

bool GodotVariant::operator<(const GodotVariant& rhs) const {
  if (value.index() != rhs.value.index()) {
    return value.index() < rhs.value.index();
  }

  if (const int32_t* pval = std::get_if<int32_t>(&value)) {
    return *pval < std::get<int32_t>(rhs.value);
  } else if (const std::string* pval = std::get_if<std::string>(&value)) {
    return *pval < std::get<std::string>(rhs.value);
  } else if (const std::map<GodotVariant, GodotVariant>* pval =
                 std::get_if<std::map<GodotVariant, GodotVariant>>(&value)) {
    return *pval < std::get<std::map<GodotVariant, GodotVariant>>(rhs.value);
  } else if (const std::vector<GodotVariant>* pval =
                 std::get_if<std::vector<GodotVariant>>(&value)) {
    return *pval < std::get<std::vector<GodotVariant>>(rhs.value);
  }

  throw std::invalid_argument("Incomparable variants.");
}

void GodotVariant::Serialize(std::basic_ostream<char>& output) const {
  if (const int32_t* pval = std::get_if<int32_t>(&value)) {
    uint32_t typebits = 2;
    output.write(reinterpret_cast<char*>(&typebits), 4);
    output.write(reinterpret_cast<const char*>(pval), 4);
  } else if (const std::string* pval = std::get_if<std::string>(&value)) {
    uint32_t typebits = 4;
    output.write(reinterpret_cast<char*>(&typebits), 4);

    uint32_t lengthbits = pval->length();
    output.write(reinterpret_cast<char*>(&lengthbits), 4);

    output.write(pval->data(), pval->length());

    if (pval->length() % 4 != 0) {
      int padding = 4 - (pval->length() % 4);
      for (int i = 0; i < padding; i++) {
        output.put(0);
      }
    }
  } else if (const std::map<GodotVariant, GodotVariant>* pval =
                 std::get_if<std::map<GodotVariant, GodotVariant>>(&value)) {
    uint32_t typebits = 18;
    output.write(reinterpret_cast<char*>(&typebits), 4);

    uint32_t lengthbits = pval->size() & 0x7fffffff;
    output.write(reinterpret_cast<char*>(&lengthbits), 4);

    for (const auto& mapping : *pval) {
      mapping.first.Serialize(output);
      mapping.second.Serialize(output);
    }
  } else if (const std::vector<GodotVariant>* pval =
                 std::get_if<std::vector<GodotVariant>>(&value)) {
    uint32_t typebits = 19;
    output.write(reinterpret_cast<char*>(&typebits), 4);

    uint32_t lengthbits = pval->size() & 0x7fffffff;
    output.write(reinterpret_cast<char*>(&lengthbits), 4);

    for (const auto& entry : *pval) {
      entry.Serialize(output);
    }
  }
}