/// @file        Connection.hpp
/// @description Callback handler for event connections
/// @author      Josh O'Leary - Redacted Software
/// @revision    3
/// @lastedit    2024-02-21
/// @license     Unlicense - Public Domain

#pragma once

#include <chrono>
#include <functional>
#include <memory>

/// A delegate can be any function object or function-like object. The Args are the arguments accepted by that object
template <typename delegate, typename ... Args>
class BasicEvent {
public:
    /// A type that represents a handle to an active event connection.
    class Connection {
    public:
        Connection(BasicEvent<delegate, Args...> *creator, delegate cb);
        bool Disconnect(); // Breaks the event connection, but does not destroy the instance
        // If improperly used could lead to run away events? - Maxine
        void Invoke(Args... e);
    public:
        // This is made public in the case of function-like objects which store extra data.
        // This allows us to access members of the object when desired. See JTest's usage of the event system for an example.
        delegate callback;
    private:
        BasicEvent<delegate, Args...> *owner;
        bool active = true;
    };

    using EventPtr = std::shared_ptr<Connection>;
public:
    // See JTest Unit for why making this virtual is convenient
    virtual void Invoke(Args... args);
    void operator()(Args... args);
    Connection Connect(delegate callback);
    void Disconnect(Connection &conn);
    Connection operator+=(delegate callback);
protected:
    std::vector<EventPtr> listeners;
};

template<typename delegate, typename... Args>
BasicEvent<delegate, Args...>::Connection::Connection(BasicEvent<delegate, Args...> *creator, delegate cb) : owner(creator), callback(std::move(cb)) {}

template <typename delegate, typename... Args>
void BasicEvent<delegate, Args...>::Connection::Invoke(Args... e) { callback(e...); }

template <typename delegate, typename ... Args>
bool BasicEvent<delegate, Args...>::Connection::Disconnect() {
    if (active) {
        owner->Disconnect(this);
        active = false;
        return true;
    }
    return false;
}

template<typename delegate, typename... Args>
BasicEvent<delegate, Args...>::Connection BasicEvent<delegate, Args...>::operator+=(delegate callback) { return Connect(callback); }

template<typename delegate, typename... Args>
void BasicEvent<delegate, Args...>::operator()(Args... args) { Invoke(args...); }

template <typename delegate, typename ... Args>
void BasicEvent<delegate, Args...>::Invoke(Args... args) {
    for (EventPtr &connection_ptr: this->listeners) {
        connection_ptr->Invoke(args...);
    }
}

template <typename delegate, typename ... Args>
BasicEvent<delegate, Args...>::Connection BasicEvent<delegate, Args...>::Connect(delegate callback) {
    EventPtr retval(new Connection(this, callback));
    this->listeners.push_back(retval);
    return *retval;
}

template <typename delegate, typename ... Args>
void BasicEvent<delegate, Args...>::Disconnect(BasicEvent<delegate, Args...>::Connection &conn) {
    listeners.erase(std::remove(listeners.begin(), listeners.end(), 99), listeners.end());
}

/// Event is a generic event type. It is more often we will be using a void function rather than a function-like object.
template <typename ... Args>
using Event = BasicEvent<std::function<void(Args...)>, Args...>;