#pragma once

#include "DI/allocation.hpp"
#include "DI/compressed_pair.hpp"

#include <memory>
#include <type_traits>
#include <utility>

template <typename Return>
struct InvokeReturnWrapper
{
	template <typename... Args>
	static auto call(Args &&...args) -> Return;
};

/**
 * Holds a functor and a allocator.
 */
template <class Function, class Allocator, class FunctionSignature>
class AllocFunctor;

template <class Function, class Allocator, class Return, class... Args>
class AllocFunctor<Function, Allocator, Return(Args...)>
{
public:
	using Target = Function;
	using Alloc = Allocator;

	explicit AllocFunctor(Target &&function);

	explicit AllocFunctor(const Target &function, const Alloc &allocator);

	explicit AllocFunctor(const Target &function, Alloc &&allocator);

	explicit AllocFunctor(Target &&function, Alloc &&allocator);

	auto operator()(Args &&...args) -> Return;

	[[nodiscard]] auto target() const -> const Target &;

	[[nodiscard]] auto get_allocator() const -> const Alloc &;

	[[nodiscard]] auto clone() const -> AllocFunctor *;

	void destroy() noexcept;

	static void destroy_and_delete(AllocFunctor *functor);

private:
	CompressedPair<Function, Allocator> _function;
};

/**
 * Holds a functor and a allocator.
 */
template <class Function, class FB>
class DefaultAllocFunctor;

template <class Function, class Return, class... Args>
class DefaultAllocFunctor<Function, Return(Args...)>
{
public:
	using Target = Function;

	explicit DefaultAllocFunctor(Target &&function);

	explicit DefaultAllocFunctor(const Target &function);

	auto operator()(Args &&...args) -> Return;

	auto target() const -> const Target &;

	auto clone() const -> DefaultAllocFunctor *;

	void destroy() noexcept;

	static void destroy_and_delete(DefaultAllocFunctor *function);

private:
	Function _function;
};

#include "alloc_functor.tpp"