import {Awaitable, Rehydratable} from '../util'
import {Instantiable, StaticClass} from '../di'

/**
 * A closure that should be executed with the given event is fired.
 */
export type EventSubscriber<T extends Dispatchable> = (event: T) => Awaitable<void>

/**
 * An object used to track event subscriptions internally.
 */
export interface EventSubscriberEntry<T extends Dispatchable> {
    /** Globally unique ID of this subscription. */
    id: string

    /** The event class subscribed to. */
    event: StaticClass<T, Instantiable<T>>

    /** The closure to execute when the event is fired. */
    subscriber: EventSubscriber<T>
}

/**
 * An object returned upon subscription, used to unsubscribe.
 */
export interface EventSubscription {
    /**
     * Unsubscribe the associated listener from the event bus.
     */
    unsubscribe(): Awaitable<void>
}

/**
 * An instance of something that can be fired on an event bus.
 */
export interface Dispatchable extends Rehydratable {
    shouldQueue?: boolean
}

/**
 * An event-driven bus that manages subscribers and dispatched items.
 */
export interface Bus {
    subscribe<T extends Dispatchable>(eventClass: StaticClass<T, Instantiable<T>>, subscriber: EventSubscriber<T>): Awaitable<EventSubscription>
    unsubscribe<T extends Dispatchable>(subscriber: EventSubscriber<T>): Awaitable<void>
    dispatch(event: Dispatchable): Awaitable<void>
}