#pragma once

#include <memory>

#include <twist/stdlike/mutex.hpp>

namespace solutions {

template <typename T>
class Guarded : std::enable_shared_from_this<Guarded<T>> {
  template<typename> struct Ptr;

 public:
  Ptr<Guarded> operator->() {
    return Ptr<Guarded>(std::enable_shared_from_this<Guarded<T>>::shared_from_this(), mutex_);
  }

  T* GetObjectPtr() {
    return &object_;
  }

 private:
  template <typename S>
  struct Ptr {
    Ptr(std::shared_ptr<S> ptr, twist::stdlike::mutex& mutex) : ptr_(ptr), mutex_(mutex) {
      mutex_.lock();
    }

    ~Ptr() {
      mutex_.unlock();
    }

    auto operator->() {
      //return ptr_.lock()->GetObjectPtr();
      return ptr_->GetObjectPtr();
    }

    std::shared_ptr<S> ptr_;
    twist::stdlike::mutex& mutex_;
  };

  T object_;
  twist::stdlike::mutex mutex_;
};

}  // namespace solutions