/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Boost Software License - Version 1.0 - August 17th, 2003
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 *
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 **********************************************************************/

#pragma once

#include <tuple>
#include <type_traits>

namespace LeechCraft
{
namespace Util
{
	namespace detail
	{
		struct ReturnsVoid;

		template<typename T>
		using VoidSafe = std::conditional_t<
				std::is_same<T, void> {}, // C++17
				ReturnsVoid,
				T
			>;

		template<typename R, typename... Args>
		std::tuple<VoidSafe<R>, Args...> TypeGetter (R (*) (Args...));

		template<typename F>
		auto TypeGetter (F&& f) -> decltype (TypeGetter (+f));

		template<typename C, typename R, typename... Args>
		std::tuple<VoidSafe<R>, Args...> TypeGetter (R (C::*) (Args...) const);

		template<typename C, typename R, typename... Args>
		std::tuple<VoidSafe<R>, Args...> TypeGetter (R (C::*) (Args...));

		template<typename C>
		decltype (TypeGetter (&C::operator ())) TypeGetter (const C& c);

		template<typename F>
		using RetTypeRaw_t = std::tuple_element_t<0, decltype (TypeGetter (*static_cast<F*> (nullptr)))>;
	}

	template<typename F, size_t Idx>
	using ArgType_t = std::tuple_element_t<Idx + 1, decltype (detail::TypeGetter (*static_cast<F*> (nullptr)))>;

	template<typename F>
	using RetType_t = std::conditional_t<
			std::is_same_v<detail::RetTypeRaw_t<F>, detail::ReturnsVoid>,
			void,
			detail::RetTypeRaw_t<F>
		>;

	namespace detail
	{
		template<typename>
		struct DecomposeMemberPtr;

		template<typename R, typename C>
		struct DecomposeMemberPtr<R (C::*)>
		{
			using Value_t = R;
			using StructType_t = C;
		};
	}

	template<auto Ptr>
	using MemberPtrType_t = typename detail::DecomposeMemberPtr<decltype (Ptr)>::Value_t;

	template<auto Ptr>
	using MemberPtrStruct_t = typename detail::DecomposeMemberPtr<decltype (Ptr)>::StructType_t;
}
}
