#include <functional>
#include <numeric>
#include <iostream>

#include <vulkan/vulkan_core.h>
VkInstance foo;

template <typename T>
struct fn_traits : public fn_traits<decltype(&std::remove_reference_t<T>::operator())> {};

template <typename Ret, typename... Args>
struct fn_traits<Ret(*)(Args...)> : public fn_traits<Ret(Args...)> {};

template <typename Ret, typename... Args>
struct fn_traits<Ret(&)(Args...)> : public fn_traits<Ret(Args...)> {};

template <typename C, typename Ret, typename... Args>
struct fn_traits<Ret(C::*)(Args...)> : public fn_traits<Ret(Args...)> {};

template <typename Ret, typename... Args>
struct fn_traits<Ret(Args...)>
{
	using return_t = Ret;

	template <std::size_t N>
	using argn_t = std::tuple_element_t<N, std::tuple<Args...>>;
};

struct _ct {} _c;
struct _dt {} _d;

template <typename Needle, typename... Ts>
struct pack_type_index
{
	template <std::size_t... Indices>
	static constexpr std::size_t value(std::index_sequence<Indices...>) {
		auto l = {std::is_same_v<Needle, Ts> * Indices...};
		return std::accumulate(l.begin(), l.end(), 0);
	}

	static constexpr std::size_t value() {
		return value(std::index_sequence_for<Ts...>{});
	}
};

template <typename T, typename OutType, bool = std::is_same_v<T, _ct>, bool = std::is_same_v<T, _dt>>
struct ResolveArg;

// _c
template <typename T, typename OutType>
struct ResolveArg<T, OutType, true, false>
{
	static constexpr auto Resolve(T& o, uint32_t *c, OutType *d) {
		return c;
	}
};

// _d
template <typename T, typename OutType>
struct ResolveArg<T, OutType, false, true>
{
	static constexpr auto Resolve(T& o, uint32_t *c, OutType *d) {
		return d;
	}
};

// passthrough
template <typename T, typename OutType>
struct ResolveArg<T, OutType, false, false>
{
	static constexpr auto Resolve(T& o, uint32_t *c, OutType *d) {
		return o;
	}
};

template <typename F, typename OutType, typename TTuple, std::size_t... TypeIndices>
VkResult invoke_helper(uint32_t *c, OutType *d, F &f, TTuple &tt, std::index_sequence<TypeIndices...>)
{
	return std::invoke(f, ResolveArg<std::tuple_element_t<TypeIndices, TTuple>, OutType>::Resolve(std::get<TypeIndices>(tt), c, d)...);
}


template <typename F, typename... Types>
struct VkEnumFnWrapper {
	using IdxSeq = std::index_sequence_for<Types...>;
	using KOutType = fn_traits<F>::template argn_t<pack_type_index<_dt, std::decay_t<Types>...>::value()>;
	using OutType = std::remove_pointer_t<KOutType>;
	using TypeTuple = std::tuple<std::decay_t<Types>...>;
	using FnType = std::decay_t<F>;

	FnType fn;
	TypeTuple tt;

public:
	explicit VkEnumFnWrapper(F &&f, Types&&... t)
	{
		tt = std::forward_as_tuple(t...);
		fn = f;
	}
	
	VkResult operator()(uint32_t *c, OutType *d)
	{
		return invoke_helper(c, d, fn, tt, IdxSeq{});
	}
	
	VkResult Cheese(uint32_t *c, OutType *d)
	{
		return VK_SUCCESS;
	}
};

template <typename F, typename... Types>
VkEnumFnWrapper<F, Types...> wrap(F &&f, Types&&... t)
{
	return VkEnumFnWrapper<F, Types...>(std::forward<F>(f), std::forward<Types>(t)...);
}

template <typename F>
auto UtilVkEnumerate(F &&f)
{
	using OutType = std::remove_pointer_t<typename fn_traits<F>::template argn_t<1>>;
	uint32_t c;
	if(f(&c, nullptr) != VK_SUCCESS)
		throw std::runtime_error{""};

	std::vector<OutType> Result(c);
	if(f(&c, Result.data()) != VK_SUCCESS)
		throw std::runtime_error{""};

	return Result;
}

int main()
{
	//auto l = wrap(vkEnumeratePhysicalDevices, foo, _c, _d);
	auto l = UtilVkEnumerate(wrap(vkEnumerateInstanceExtensionProperties, nullptr, _c, _d));
	
	for(const auto &p : l) {
		std::cout << p.extensionName << std::endl;
	}
	 
	return 0;
}