#pragma once

#include <type_traits>  // std::enable_if, std::is_constructible, etc
#include <functional>   // std::invoke
#include "tl/functional.h"
#include "tl/vector_map.h"
#include "tl/unordered_map.h"
#include "tl/hash_and_combine.h"
#include "tl/memory_buffer.h"
#include "tl/detail/internal_assert.h"
#include "tl/atomic.h"
#include <mutex>
#include "compact_signal.h"

namespace tl
{

namespace detail
{

struct signal_mt_thread_policy
{
	using mutex_t = std::mutex;
	using connection_id_counter_t = tl::atomic<uint32_t>;
	using data_ptr_t = tl::atomic<uint64_t*>;
};

}

using signal_system_mt = signal_system<detail::signal_mt_thread_policy>;
using connection_mt = signal_system_mt::scoped_connection;

template <typename Signature>
class signal_mt;

template<typename R, typename...Args>
class signal_mt<R(Args...)>
{
public:
	signal_mt() noexcept = default;
	signal_mt(const signal_mt&) noexcept = delete;
	signal_mt(signal_mt&&) noexcept = delete;
	~signal_mt() noexcept
	{
		disconnect_all_slots();
	}

	signal_mt& operator=(const signal_mt<R(Args...)>&) = delete;
	signal_mt& operator=(signal_mt<R(Args...)>&&) = delete;

	connection_mt connect(tl::function<void(Args...)> delegate) noexcept
	{
		return signal_system_mt::add((intptr_t)this, 0, std::move(delegate));
	}

	void invoke(Args... args) const noexcept
	{
		signal_system_mt::invoke((intptr_t)this, 0, std::forward<Args>(args)...);
	}

	void disconnect_all_slots() const noexcept
	{
		signal_system_mt::remove_all((intptr_t)this);
	}

	bool has_slots() const
	{
		return signal_system_mt::get_slot_count((intptr_t)this, 0) > 0;
	}
};

}