#include "matador/object/object_definition.hpp"

namespace matador::object {
object_definition::object_definition(std::initializer_list<object::attribute_definition> columns)
: columns_(columns)
{
  init();
}

object_definition::object_definition(const std::vector<object::attribute_definition> &columns)
: columns_(columns)
{
  init();
}

object_definition::object_definition(const object_definition &x)
: columns_(x.columns_)
, pk_index_(x.pk_index_)
{
  for (auto& col : columns_) {
    add_to_map(col, col.index());
  }
}

object_definition &object_definition::operator=(const object_definition &x)
{
  if (&x == this) {
    return *this;
  }

  columns_ = x.columns_;
  columns_by_name_.clear();
  pk_index_ = x.pk_index_;
  for (auto& col : columns_) {
    add_to_map(col, col.index());
  }
  return *this;
}

bool object_definition::has_primary_key() const
{
    return pk_index_ > -1;
}

std::optional<object::attribute_definition> object_definition::primary_key() const
{
  if (!has_primary_key()) {
    return std::nullopt;
  }

  return columns_[pk_index_];
}

void object_definition::append(attribute_definition col)
{
  auto &ref = columns_.emplace_back(std::move(col));
  add_to_map(ref, columns_.size()-1);
}

const std::vector<object::attribute_definition> &object_definition::columns() const
{
  return columns_;
}

const attribute_definition &object_definition::at(const std::string &name) const
{
  return columns_by_name_.at(name).first;
}

const attribute_definition &object_definition::at( const size_t index) const
{
  return columns_.at(index);
}

object_definition::iterator object_definition::find(const std::string &column_name)
{
  auto it = columns_by_name_.find(column_name);
  return it != columns_by_name_.end() ? columns_.begin() + it->second.second : columns_.end();
}

object_definition::const_iterator object_definition::find(const std::string &column_name) const {
  auto it = columns_by_name_.find(column_name);
  return it != columns_by_name_.end() ? columns_.begin() + it->second.second : columns_.end();
}

object_definition::iterator object_definition::begin()
{
  return columns_.begin();
}

object_definition::const_iterator object_definition::begin() const
{
  return columns_.begin();
}

object_definition::const_iterator object_definition::cbegin() const
{
  return columns_.cbegin();
}

object_definition::iterator object_definition::end()
{
  return columns_.end();
}

object_definition::const_iterator object_definition::end() const
{
  return columns_.end();
}

object_definition::const_iterator object_definition::cend() const
{
  return columns_.cend();
}

size_t object_definition::size() const
{
  return columns_.size();
}

bool object_definition::empty() const
{
  return columns_.empty();
}

void object_definition::clear()
{
  columns_.clear();
  columns_by_name_.clear();
}

void object_definition::init()
{
  size_t index{0};
  for(auto &col : columns_) {
    add_to_map(col, index++);
  }
}

void object_definition::add_to_map(attribute_definition &col, size_t index)
{
  columns_by_name_.emplace(col.name(), column_index_pair {std::ref(col), index});
  if (is_constraint_set(col.attributes().options(), utils::constraints::PRIMARY_KEY)) {
    pk_index_ = static_cast<int>(index);
  }
}

}