#include "matador/object/object_generator.hpp"

#include "matador/object/repository.hpp"

#include <algorithm>

namespace matador::object {
object_generator::object_generator(const repository& repo, const std::shared_ptr<object>& object)
: repo_(repo)
, object_(object) {}

std::shared_ptr<object> object_generator::acquire_object(repository &repo, const std::type_index &ti, const std::string& name) {
    if (repo.has_object_for_type(ti)) {
        auto obj = repo.object_for_type(ti);
        repo.remove_object_for_type(ti);
        obj->update_name(name);
        return obj;
    }

    return repo.provide_object_in_advance(ti, std::make_shared<object>(name));
}

void object_generator::on_revision(const char* id, uint64_t& rev) {
  on_attribute(id, rev);
}

void object_generator::create_pk_constraint(const std::string& name) const {
    const auto pk_attr = find_attribute_by_name(name);
    if (pk_attr == std::end(object_->attributes_)) {
      return;
    }
    restriction pk_constraint(*pk_attr);
    pk_constraint.options_ |= utils::constraints::PrimaryKey;
    pk_constraint.owner_ = object_;
    object_->constraints_.emplace_back(std::move(pk_constraint));
}

void object_generator::create_unique_constraint(const std::string& name) const {
    const auto pk_attr = find_attribute_by_name(name);
    if (pk_attr == std::end(object_->attributes_)) {
        return;
    }
    restriction pk_constraint(*pk_attr);
    pk_constraint.options_ |= utils::constraints::Unique;
    pk_constraint.owner_ = object_;
}

std::list<attribute>::iterator object_generator::find_attribute_by_name(const std::string& name) const {
    return std::find_if(std::begin(object_->attributes_), std::end(object_->attributes_), [&name](const attribute& elem) {
      return elem.name() == name;
    });
}

void object_generator::prepare_primary_key(attribute& ref, utils::identifier &&pk) const {
    object_->pk_attribute_ = &ref;
    object_->pk_identifier_ = std::move(pk);
}
}