#include "matador/object/basic_object_info.hpp"

#include "matador/object/schema_node.hpp"

#include <algorithm>

namespace matador::object {
basic_object_info::basic_object_info(std::shared_ptr<schema_node> node,
                                     const std::type_index type_index,
                                     utils::identifier &&pk,
                                     std::shared_ptr<attribute_definition> &&pk_column,
                                     object_definition &&definition)
: node_(std::move(node))
, type_index_(type_index)
, definition_(std::move(definition))
, identifier_(std::move(pk))
, pk_column_(std::move(pk_column)) {
}

basic_object_info::basic_object_info(std::shared_ptr<schema_node> node,
                                     const std::type_index type_index,
                                     utils::identifier &&pk,
                                     std::shared_ptr<attribute_definition> &&pk_column)
: node_(std::move(node))
, type_index_(type_index)
, identifier_(std::move(pk))
, pk_column_(std::move(pk_column)) {
}

std::type_index basic_object_info::type_index() const {
  return type_index_;
}

std::string basic_object_info::name() const {
  return node_->name();
}

const object_definition &basic_object_info::definition() const {
  return definition_;
}

std::shared_ptr<attribute_definition> basic_object_info::reference_column() const {
  return pk_column_;
}

void basic_object_info::register_relation_endpoint(const std::type_index &tindex, const relation_endpoint &endpoint) {
  relation_endpoints_.insert(std::make_pair(tindex, endpoint));
}

void basic_object_info::unregister_relation_endpoint(const std::type_index &tindex) {
  relation_endpoints_.erase(tindex);
}

basic_object_info::const_endpoint_iterator
basic_object_info::find_relation_endpoint(const std::type_index &tindex) const {
  return relation_endpoints_.find(tindex);
}

basic_object_info::endpoint_iterator basic_object_info::find_relation_endpoint(const std::type_index &tindex) {
  return relation_endpoints_.find(tindex);
}

basic_object_info::const_endpoint_iterator basic_object_info::find_relation_endpoint(const std::string &field) const {
  return std::find_if(relation_endpoints_.begin(), relation_endpoints_.end(), [&field](const t_endpoint_map::value_type &value) {
    return value.second.field_name() == field;
  });
}

basic_object_info::endpoint_iterator basic_object_info::find_relation_endpoint(const std::string &field) {
  return std::find_if(relation_endpoints_.begin(), relation_endpoints_.end(), [&field](const t_endpoint_map::value_type &value) {
    return value.second.field_name() == field;
  });
}

basic_object_info::endpoint_iterator basic_object_info::endpoint_begin() {
  return relation_endpoints_.begin();
}

basic_object_info::const_endpoint_iterator basic_object_info::endpoint_begin() const {
  return relation_endpoints_.begin();
}

basic_object_info::endpoint_iterator basic_object_info::endpoint_end() {
  return relation_endpoints_.end();
}

basic_object_info::const_endpoint_iterator basic_object_info::endpoint_end() const {
  return relation_endpoints_.end();
}

std::size_t basic_object_info::endpoints_size() const {
  return relation_endpoints_.size();
}

bool basic_object_info::endpoints_empty() const {
  return relation_endpoints_.empty();
}
} // namespace matador::object