#ifndef FUNCTION_HPP_INCLUDED
#define FUNCTION_HPP_INCLUDED

/*
    function is a buffed duplicate of std::function, but can have arbitrary amounts of  signatures

        function<void (int), double (char*, float&)> f;  // wow!

    Differences:

        Doesn't have "target access" whatever that means, mainly because I didn't find a use
        for that my entire life using std::function.

        Doesn't support allocator stuff, they're deprecated in C++17 anyways.

    Note:

        When the function is invoked, overload resolution is performed

            function<void (char), void (double)> f = [](auto x){cout << sizeof(x) << endl;};
            f('c');  // prints 1
            f(4.2);  // prints sizeof(double), likely 8

        It is thus valid to construct a function with an object that doesn't have the exact
        signature as specified as long as there is an implicit conversion from the specified
        signature to the object's operator()

            function<void (int), void (double)> f = [](int i){cout << i << endl;};
            f(42.5);  // prints 42, due to double to int conversion
            f(420);   // prints 420

        Remember the return types can vary

            function<int* (), pair<int, int> (int), double (char, char)> f = something;
            int* p = f();
            auto [x, y] = f(4200);
            double d = f('4', '2');

*/

#include<utility>
#include<type_traits>
#include<memory>
#include<functional>
//#include<util/func_traits.h>

namespace detail
{
    struct dummy {};

    template<typename...>
    struct erasure_base
    {
        void operator()(dummy) {};
    };

    template<typename Ret, typename... Args, typename... Fns>
    struct erasure_base<Ret (Args...), Fns...> : erasure_base<Fns...>
    {
        virtual Ret operator()(Args&&...) = 0;
        using erasure_base<Fns...>::operator();
    };

    template<typename...>
    struct erasure;

    // Base is the common erasure_base, only the base case of erasure contains the callable object
    template<typename Base, typename Callable, typename Ret, typename... Args>
    struct erasure<Base, Callable, Ret (Args...)> : Base
    {
        template<typename C>
        erasure(C&& callable) : callable{std::forward<C>(callable)} {}
        Ret operator()(Args&&... args) override
        {
            return Ret(callable(std::forward<Args>(args)...));
        }
        std::decay_t<Callable> callable;
    };

    // Next is the erasure type that contains the next signature
    template<typename Base, typename Callable, typename Ret, typename... Args, typename... Fns>
    struct erasure<Base, Callable, Ret (Args...), Fns...> : erasure<Base, Callable, Fns...>
    {
        using Next = erasure<Base, Callable, Fns...>;

        template<typename C>
        erasure(C&& callable) : Next{std::forward<C>(callable)} {}
        Ret operator()(Args&&... args) override
        {
            return Ret(Next::callable(std::forward<Args>(args)...));
        }
    };
}

template<typename... Fns>
class function
{
    using erasure_base = detail::erasure_base<Fns...>;
    template<typename Callable>
    using erasure = detail::erasure<erasure_base, Callable, Fns...>;
    using nullptr_t = decltype(nullptr);

public:
    function() = default;
    function(nullptr_t) {}
    function(const function&) = delete;
    function(function&&) = default;

    template<typename Callable>
    function(Callable&& callable) : ptr{new erasure<Callable>(std::forward<Callable>(callable))} {}

    function& operator=(const function&) = delete;
    function& operator=(function&&) = default;

    ~function() = default;

    template<typename... Args>
    decltype(auto) operator()(Args&&... args)
    {
        if(!ptr)
            throw std::bad_function_call{};
        return ptr->operator()(std::forward<Args>(args)...);
    }

    void swap(function& other) {swap(ptr, other.ptr);}
    friend void swap(function& x, function& y) noexcept {x.swap(y);}
    operator bool() const noexcept {return ptr;}

    friend bool operator==(nullptr_t, const function& f) noexcept {return !f;}
    friend bool operator==(const function& f, nullptr_t) noexcept {return !f;}
    friend bool operator!=(nullptr_t, const function& f) noexcept {return f;}
    friend bool operator!=(const function& f, nullptr_t) noexcept {return f;}

private:
    std::unique_ptr<erasure_base> ptr;
};


// deduction guide, not core

//template<typename Callable>
//function(Callable&&) -> function<typename func_traits<Callable>::signature>;






#endif // FUNCTION_HPP_INCLUDED