#include "matador/object/restriction.hpp"

#include "matador/object/attribute.hpp"
#include "matador/object/object.hpp"

namespace matador::object {
restriction::restriction(std::string name)
: name_(std::move(name)) {}

std::string restriction::name() const {
  return prefix() + name_;
}

const class attribute* restriction::attribute() const {
  if (std::holds_alternative<class attribute*>(attr_)) {
    return std::get<class attribute*>(attr_);
  }

  return nullptr;
}

std::string restriction::column_name() const {
    if (std::holds_alternative<class attribute*>(attr_)) {
        return std::get<class attribute*>(attr_)->name();
    }
    if (std::holds_alternative<std::string>(attr_)) {
        return std::get<std::string>(attr_);
    }

    return "";
}

std::shared_ptr<object> restriction::owner() const {
  return owner_;
}

bool restriction::is_primary_key_constraint() const {
  return utils::is_constraint_set(options_, utils::constraints::PrimaryKey);
}

bool restriction::is_foreign_key_constraint() const {
  return utils::is_constraint_set(options_, utils::constraints::ForeignKey);
}

bool restriction::is_unique_constraint() const {
  return utils::is_constraint_set(options_, utils::constraints::Unique);
}

const std::string& restriction::ref_table_name() const {
  return reference_->name();
}

const std::string& restriction::ref_column_name() const {
  return reference_->primary_key_attribute()->name();
}

std::ostream & operator<<(std::ostream &os, const class restriction &c) {
  os << "constraint " << c.name() << " for column " << c.column_name();
  return os;
}

std::string restriction::prefix() const {
    if (utils::is_constraint_set(options_, utils::constraints::PrimaryKey)) {
        return "PK_";
    }
    if (utils::is_constraint_set(options_, utils::constraints::ForeignKey)) {
        return "FK_";
    }
    if (utils::is_constraint_set(options_, utils::constraints::Unique)) {
        return "UK_";
    }
    return "";
}

// constraint_builder & constraint_builder::constraint(std::string name) {
//   constraint_name = std::move(name);
//   return *this;
// }
//
// constraint_builder & constraint_builder::primary_key(std::string name) {
//   column_name = std::move(name);
//   options_ |= utils::constraints::PrimaryKey;
//   return *this;
// }
//
// constraint_builder & constraint_builder::foreign_key(std::string name) {
//   column_name = std::move(name);
//   options_ |= utils::constraints::ForeignKey;
//   return *this;
// }
//
// constraint_builder & constraint_builder::references(std::string table, std::string column) {
//   ref_table_name = std::move(table);
//   ref_column_name = std::move(column);
//
//   return *this;
// }
//
// constraint_builder::operator class restriction() const {
//   class restriction c;
//   c.name_ = constraint_name;
//   c.attr_ = column_name;
//   c.options_ = options_;
//   c.ref_column_name_ = ref_column_name;
//   c.ref_table_name_ = ref_table_name;
//   return c;
// }
//
// constraint_builder constraint(std::string name) {
//   constraint_builder builder;
//   return builder.constraint(std::move(name));
// }
}