#ifndef QUERY_HAS_MANY_TO_MANY_RELATION_HPP
#define QUERY_HAS_MANY_TO_MANY_RELATION_HPP

#include "matador/object/object_ptr.hpp"

#include "matador/utils/access.hpp"
#include "matador/utils/foreign_attributes.hpp"

namespace matador::object {

template < class LocalType, class ForeignType >
class many_to_many_relation {
public:
    many_to_many_relation() = default;
    many_to_many_relation(std::string local_name, std::string remote_name)
    : local_name_(std::move(local_name))
    , remote_name_(std::move(remote_name)) {}

    template<class Operator>
    void process(Operator &op) {
        namespace field = matador::access;
        field::belongs_to(op, local_name_.c_str(), local_, utils::CascadeNoneFetchLazy);
        field::belongs_to(op, remote_name_.c_str(), remote_, utils::CascadeNoneFetchLazy);
    }

    object_ptr<LocalType> local() const { return local_; }
    object_ptr<LocalType> remote() const { return remote_; }

private:
    std::string local_name_;
    std::string remote_name_;
    object_ptr<LocalType> local_;
    object_ptr<ForeignType> remote_;
};

template < class LocalType, class Type >
class many_to_relation {
public:
    many_to_relation() = default;
    many_to_relation(std::string local_name, std::string remote_name)
    : local_name_(std::move(local_name))
    , type_name_(std::move(remote_name)) {}

    template<class Operator>
    void process(Operator &op) {
        namespace field = matador::access;
        field::belongs_to(op, local_name_.c_str(), local_, utils::CascadeNoneFetchLazy);
        field::attribute(op, type_name_.c_str(), value_);
    }

    object_ptr<LocalType> local() const { return local_; }
    Type value() const { return value_; }

private:
    std::string local_name_;
    std::string type_name_;
    object_ptr<LocalType> local_;
    Type value_;
};

}
#endif //QUERY_HAS_MANY_TO_MANY_RELATION_HPP