#pragma once

#include <functional>
#include <vector>
#include <string>
#include <iostream>


namespace ddkit {
namespace utils {
namespace callback {

template<class Actor, typename... Args>
class Wrapper;

class Base {

public:
    virtual ~Base(){}

    template<class Actor, typename... Args>
    void tryToInvoke(void (Actor::*func)(Args...), Args&&... args) {
        auto cb = dynamic_cast<Wrapper<Actor, Args...>*>(this);
        if(cb && cb->isFunction(func)){
            cb->invoke(args...);
        }
    }
};

template<class Actor, typename... Args>
class Wrapper : public Base {

public:
    using ActorType = Actor;
    using CallbackType = std::function<void(Args...)>;
    using ActorFunctionType = void (Actor::*)(Args...);

    Wrapper() = delete;
    virtual ~Wrapper(){}
    
    Wrapper(ActorFunctionType func, CallbackType cb)
        : m_actorFunction(func)
        , m_callback(cb)
    {
    }

    bool isFunction(ActorFunctionType func){
        return m_actorFunction == func;
    }

    void invoke(Args... args){
        m_callback(args...);
    }

private:
    friend class Base;

    ActorFunctionType m_actorFunction;
    CallbackType m_callback;
};

template<class Actor, typename... Args>
Wrapper<Actor, Args...>* Callback(void (Actor::*pm)(Args...), std::function<void(Args...)> cb){
    return new Wrapper<Actor, Args...>(pm, cb);
}

template<class Actor, typename... Args, typename Fn>
Wrapper<Actor, Args...>* Callback(void (Actor::*pm)(Args...), const Fn& callback){
    return new Wrapper<Actor, Args...>(pm,  std::function<void(Args...)>(callback));
}

} // callback
} // utils
    namespace callback = ddkit::utils::callback;
} // ddkit