// Matrix Construct
//
// Copyright (C) Matrix Construct Developers, Authors & Contributors
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.

#pragma once
#define HAVE_IRCD_JS_ROOT_H

namespace ircd  {
namespace js    {

template<class T>
using handle = typename T::handle;

// This conversion is missing in the jsapi. Is this object not gc rooted? Can it not have a handle?
template<class T>
JS::Handle<T>
operator&(const JS::Heap<T> &h)
{
	return JS::Handle<T>::fromMarkedLocation(h.address());
}

// This conversion is missing in the jsapi. Is this object not gc rooted? Can it not have a handle?
template<class T>
JS::MutableHandle<T>
operator&(JS::Heap<T> &h)
{
	const auto ptr(const_cast<T *>(h.address()));
	return JS::MutableHandle<T>::fromMarkedLocation(ptr);
}

// This conversion is missing in the jsapi. Is this object not gc rooted? Can it not have a handle?
template<class T>
JS::Handle<T>
operator&(const JS::TenuredHeap<T> &h)
{
	return JS::Handle<T>::fromMarkedLocation(h.address());
}

// This conversion is missing in the jsapi. Is this object not gc rooted? Can it not have a handle?
template<class T>
JS::MutableHandle<T>
operator&(JS::TenuredHeap<T> &h)
{
	const auto ptr(const_cast<T *>(h.address()));
	return JS::MutableHandle<T>::fromMarkedLocation(ptr);
}

template<class T>
struct root
:JS::Heap<T>
{
	using value_type = T;
	using base_type = JS::Heap<T>;
	using handle = JS::Handle<T>;
	using handle_mutable = JS::MutableHandle<T>;
	using type = root<value_type>;

	operator handle() const
	{
		const auto ptr(this->address());
		return JS::Handle<T>::fromMarkedLocation(ptr);
	}

	operator handle_mutable()
	{
		const auto ptr(this->address());
		return JS::MutableHandle<T>::fromMarkedLocation(ptr);
	}

  private:
	tracing::list::iterator tracing_it;

	tracing::list::iterator add(base_type *const &ptr)
	{
		return cx->tracing.heap.emplace(end(cx->tracing.heap), tracing::thing { ptr, js::type<T>() });
	}

	void del(const tracing::list::iterator &tracing_it)
	{
		if(tracing_it != end(cx->tracing.heap))
		{
			const void *ptr = tracing_it->ptr;
			cx->tracing.heap.erase(tracing_it);
		}
	}

  public:
	root(const handle &h)
	:base_type{h.get()}
	,tracing_it{add(this)}
	{
	}

	root(const handle_mutable &h)
	:base_type{h.get()}
	,tracing_it{add(this)}
	{
	}

	explicit root(const T &t)
	:base_type{t}
	,tracing_it{add(this)}
	{
	}

	root()
	:base_type{}
	,tracing_it{add(this)}
	{
	}

	root(root &&other) noexcept
	:base_type{other.get()}
	,tracing_it{std::move(other.tracing_it)}
	{
		other.tracing_it = end(cx->tracing.heap);
		tracing_it->ptr = static_cast<base_type *>(this);
	}

	root(const root &other)
	:base_type{other.get()}
	,tracing_it{add(this)}
	{
	}

	root &operator=(root &&other) noexcept
	{
		base_type::operator=(std::move(other.get()));
		return *this;
	}

	root &operator=(const root &other)
	{
		base_type::operator=(other.get());
		return *this;
	}

	~root() noexcept
	{
		del(tracing_it);
	}
};

} // namespace js
} // namespace ircd