#pragma once
#include <functional>

template<typename ...T> class Callback;

template<typename ...T>
class CallbackOwner {
    std::vector<std::function<void(T...)>> CallbackTargets;

    public:
    void Invoke(T... args) const {
        for(std::function<void(T...)>& target : CallbackTargets)
            target(args...);
    }

    Callback<T...> GetCallback() {
        return Callback<T...>(CallbackTargets);
    }
};

template<typename ...T>
class Callback {
    private:
    std::vector<std::function<void(T...)>>& CallbackTargets;

    public:
    void Register(const std::function<void(T...)>& target) {
        CallbackTargets.push_back(target);
    }

    void Unregister(const std::function<void(T...)>& target) {
        for(int i =0; i < CallbackTargets.size(); i++) {
            if(CallbackTargets[i].template target<void*>() == target.template target<void*>()) {
                CallbackTargets.erase(CallbackTargets.begin() + i);
                return;
            }
        }
        // Todo: Throw error for unregistering inexisting target
    }

    Callback(std::vector<std::function<void(T...)>>& CallbackTargets) : CallbackTargets(CallbackTargets) {

    }

    Callback& operator+=(const std::function<void(T...)>& target) {
        Register(target);
        return *this;
    }

    Callback& operator-=(const std::function<void(T...)>& target) {
        Unregister(target);
        return *this;
    }
};