#ifndef OBJECT_PTR_HPP
#define OBJECT_PTR_HPP

#include "matador/utils/identifier.hpp"

#include "matador/object/primary_key_resolver.hpp"

#include <memory>

namespace matador::object {
template <typename Type>
class object_ptr {
public:
  object_ptr() = default;
  explicit object_ptr(Type *obj)
  : ptr_(obj)
  , pk_(primary_key_resolver::resolve_object(*obj).pk) {}
  explicit object_ptr(std::shared_ptr<Type> obj) : ptr_(obj) {}
  object_ptr(const object_ptr &other) : ptr_(other.ptr_) {}
  object_ptr(object_ptr &&other) noexcept : ptr_(std::move(other.ptr_)) {}
  object_ptr &operator=(const object_ptr &other) = default;
  object_ptr &operator=(object_ptr &&other) = default;

  using value_type = Type;
  Type* operator->() { return ptr_.get(); }
  Type& operator*() const { return *ptr_; }

  [[nodiscard]] bool empty() const { return ptr_ == nullptr; }
  void reset(Type *obj) {
    ptr_.reset(obj);
    pk_ = primary_key_resolver::resolve_object(*obj).pk;
  }

  Type* get() { return ptr_.get(); }
  const Type* get() const { return ptr_.get(); }
  operator bool() { return valid(); }
  bool valid() { return ptr_ != nullptr; }

  [[nodiscard]] const utils::identifier& primary_key() const { return pk_; }
  void primary_key(const utils::identifier &pk) { pk_ = pk; }
private:
    std::shared_ptr<Type> ptr_{};
    utils::identifier pk_;
};

}

#endif //OBJECT_PTR_HPP