#include <cstring>

#include <new>

#include "marisa-swig.h"

namespace marisa_swig {

void Key::str(const char **ptr_out, size_t *length_out) const {

  *ptr_out = key_.ptr();

  *length_out = key_.length();

}

size_t Key::id() const {

  return key_.id();

}

float Key::weight() const {

  return key_.weight();

}

void Query::str(const char **ptr_out, size_t *length_out) const {

  *ptr_out = query_.ptr();

  *length_out = query_.length();

}

size_t Query::id() const {

  return query_.id();

}

Keyset::Keyset() : keyset_(new (std::nothrow) marisa::Keyset) {

  MARISA_THROW_IF(keyset_ == NULL, ::MARISA_MEMORY_ERROR);

}

Keyset::~Keyset() {

  delete keyset_;

}

void Keyset::push_back(const marisa::Key &key) {

  keyset_->push_back(key);

}

void Keyset::push_back(const char *ptr, size_t length, float weight) {

  keyset_->push_back(ptr, length, weight);

}

const Key &Keyset::key(size_t i) const {

  return reinterpret_cast<const Key &>((*keyset_)[i]);

}

void Keyset::key_str(size_t i,

    const char **ptr_out, size_t *length_out) const {

  *ptr_out = (*keyset_)[i].ptr();

  *length_out = (*keyset_)[i].length();

}

size_t Keyset::key_id(size_t i) const {

  return (*keyset_)[i].id();

}

size_t Keyset::num_keys() const {

  return keyset_->num_keys();

}

bool Keyset::empty() const {

  return keyset_->empty();

}

size_t Keyset::size() const {

  return keyset_->size();

}

size_t Keyset::total_length() const {

  return keyset_->total_length();

}

void Keyset::reset() {

  keyset_->reset();

}

void Keyset::clear() {

  keyset_->clear();

}

Agent::Agent()

    : agent_(new (std::nothrow) marisa::Agent), buf_(NULL), buf_size_(0) {

  MARISA_THROW_IF(agent_ == NULL, ::MARISA_MEMORY_ERROR);

}

Agent::~Agent() {

  delete agent_;

  delete [] buf_;

}

void Agent::set_query(const char *ptr, size_t length) {

  if (length > buf_size_) {

    size_t new_buf_size = (buf_size_ != 0) ? buf_size_ : 1;

    if (length >= (MARISA_SIZE_MAX / 2)) {

      new_buf_size = MARISA_SIZE_MAX;

    } else {

      while (new_buf_size < length) {

        new_buf_size *= 2;

      }

    }

    char *new_buf = new (std::nothrow) char[new_buf_size];

    MARISA_THROW_IF(new_buf == NULL, MARISA_MEMORY_ERROR);

    delete [] buf_;

    buf_ = new_buf;

    buf_size_ = new_buf_size;

  }

  std::memcpy(buf_, ptr, length);

  agent_->set_query(buf_, length);

}

void Agent::set_query(size_t id) {

  agent_->set_query(id);

}

const Key &Agent::key() const {

  return reinterpret_cast<const Key &>(agent_->key());

}

const Query &Agent::query() const {

  return reinterpret_cast<const Query &>(agent_->query());

}

void Agent::key_str(const char **ptr_out, size_t *length_out) const {

  *ptr_out = agent_->key().ptr();

  *length_out = agent_->key().length();

}

size_t Agent::key_id() const {

  return agent_->key().id();

}

void Agent::query_str(const char **ptr_out, size_t *length_out) const {

  *ptr_out = agent_->query().ptr();

  *length_out = agent_->query().length();

}

size_t Agent::query_id() const {

  return agent_->query().id();

}

Trie::Trie() : trie_(new (std::nothrow) marisa::Trie) {

  MARISA_THROW_IF(trie_ == NULL, ::MARISA_MEMORY_ERROR);

}

Trie::~Trie() {

  delete trie_;

}

void Trie::build(Keyset &keyset, int config_flags) {

  trie_->build(*keyset.keyset_, config_flags);

}

void Trie::mmap(const char *filename) {

  trie_->mmap(filename);

}

void Trie::load(const char *filename) {

  trie_->load(filename);

}

void Trie::save(const char *filename) const {

  trie_->save(filename);

}

bool Trie::lookup(Agent &agent) const {

  return trie_->lookup(*agent.agent_);

}

void Trie::reverse_lookup(Agent &agent) const {

  trie_->reverse_lookup(*agent.agent_);

}

bool Trie::common_prefix_search(Agent &agent) const {

  return trie_->common_prefix_search(*agent.agent_);

}

bool Trie::predictive_search(Agent &agent) const {

  return trie_->predictive_search(*agent.agent_);

}

size_t Trie::lookup(const char *ptr, size_t length) const {

  marisa::Agent agent;

  agent.set_query(ptr, length);

  if (!trie_->lookup(agent)) {

    return MARISA_INVALID_KEY_ID;

  }

  return agent.key().id();

}

void Trie::reverse_lookup(size_t id,

    const char **ptr_out_to_be_deleted, size_t *length_out) const {

  marisa::Agent agent;

  agent.set_query(id);

  trie_->reverse_lookup(agent);

  char * const buf = new (std::nothrow) char[agent.key().length()];

  MARISA_THROW_IF(buf == NULL, MARISA_MEMORY_ERROR);

  std::memcpy(buf, agent.key().ptr(), agent.key().length());

  *ptr_out_to_be_deleted = buf;

  *length_out = agent.key().length();

}

size_t Trie::num_tries() const {

  return trie_->num_tries();

}

size_t Trie::num_keys() const {

  return trie_->num_keys();

}

size_t Trie::num_nodes() const {

  return trie_->num_nodes();

}

TailMode Trie::tail_mode() const {

  if (trie_->tail_mode() == ::MARISA_TEXT_TAIL) {

    return TEXT_TAIL;

  } else {

    return BINARY_TAIL;

  }

}

NodeOrder Trie::node_order() const {

  if (trie_->node_order() == ::MARISA_LABEL_ORDER) {

    return LABEL_ORDER;

  } else {

    return WEIGHT_ORDER;

  }

}

bool Trie::empty() const {

  return trie_->empty();

}

size_t Trie::size() const {

  return trie_->size();

}

size_t Trie::total_size() const {

  return trie_->total_size();

}

size_t Trie::io_size() const {

  return trie_->io_size();

}

void Trie::clear() {

  trie_->clear();

}

}  // namespace marisa_swig