import '../string/replaceAll.js';

/**
 *
 * 一个简单的事件触发器
 *
 */

type FlexEventWatchType = "on" | "once" | "off" | "offAll" | 'emit' | 'execute' | 'wait-begin' | 'wait-end' | 'wait-timeout';
type FlexEventWatchParams<Message = any> = {
    type: FlexEventWatchType;
    event: string;
    listener?: {
        id: string;
        fn?: string | Function;
        count?: number;
    };
    message?: Message;
    retain?: boolean;
    async?: boolean;
};
interface FlexEventOptions<Message = any> {
    context?: any;
    ignoreError?: boolean;
    wildcard?: boolean;
    delimiter?: string;
    onWatch?: (params: FlexEventWatchParams<Message>) => void;
}
interface SubscribeOptions {
    id?: string;
    objectify?: boolean;
    count?: number;
}
interface FlexEventListener<Message = any> {
    (message: Message): void;
}
type ForEachEventListenerCallback<Message, Events> = ({ event, listenerId, listener, count, eventListeners }: {
    event: Events;
    listenerId: string;
    listener: FlexEventListener<Message>;
    count: number;
    eventListeners: FlexEventListenerRegistry<Message>;
}) => boolean | void;
interface FlexEventSubscriber {
    off(): void;
}
type FlexEventListenerRegistry<M> = Map<string, [FlexEventListener<M>, number]>;
type FlexListenerRegistry<M, E> = Map<E, FlexEventListenerRegistry<M>>;
/**
 * Event: 指定一个通用事件类型
 *
 *
 */
declare class FlexEvent<Message = any, Events extends string = string, Options extends Record<string, any> = Record<string, any>> {
    private _listeners;
    private _options;
    private _lastMessage;
    static listenerSeqId: number;
    constructor(options?: FlexEventOptions<Message>);
    get options(): Required<FlexEventOptions<any> & Options>;
    get delimiter(): (FlexEventOptions<any> & Options)["delimiter"];
    get context(): (FlexEventOptions<any> & Options)["context"];
    get listeners(): FlexListenerRegistry<Message, Events>;
    get retainedMessages(): Record<string, any>;
    /**
     * 检测事件是否匹配
     *
     * isEventMatched("a/*","x")      false
     * isEventMatched("a/*","a/b")    true
     * isEventMatched("a/**","a/b")   true
     * isEventMatched("a/ * /*","a/x/x")   true
     * isEventMatched("a/** /c","a/b/x/x/c")   true
     * isEventMatched("a/** /c/** /d","a/b/x/x/c/x/x/x/d")   true
     *
     * 事件中的**代表所有层级
     * *代表一个事件名称
     *
     * @param pattern
     * @param event
     */
    private isEventMatched;
    /**
     *
     * 用来监视事件的订阅情况,用于调试时使用
     *
     * onWatch((type)=>{})
     *
     * type: on,emit,off,once
     *
     * @returns
     */
    private _onWatch;
    /**
     * 订阅事件并返回一个事件订阅ID
     *
     * 如果options.objectify = true,则返回一个侦听器对象
     * 可以在后续进行退订
     * on(event,callback)
     * on("a/*",callback)     1个*代表匹配一个事件名称
     * on("a/**",callback)    2个*代表所有层级
     *
     * @param event
     * @param callback
     * @param options
     * @returns
     */
    on(event: Events, callback: FlexEventListener<Message>, options?: SubscribeOptions): FlexEventSubscriber | string;
    /**
     * 全部信息都监听 一般用于测试
     * @param callback
    */
    onAny(callback: FlexEventListener<any>, options?: SubscribeOptions): string | FlexEventSubscriber;
    /**
     * 如果事件已经有最近触发时保留的数据，则立即触发事件将最近的数据传递给侦听器
     * @param event
     */
    private emitRetainEvent;
    /**
     * 只订阅一次事件
     * @param event
     * @param callback
     * @param options
     * @returns
     */
    once(event: Events, callback: FlexEventListener<Message>, options?: SubscribeOptions): string | FlexEventSubscriber;
    /**
     * 遍历所有侦听器
     *   {"<事件名称>":{<listenerId>:[Callback,<侦听次数>]}}
     * @param callback  ={}
     */
    private forEachListeners;
    /**
     * 遍历符合event事件的侦听器
     *
     * forEachEventListeners(event,callback)
     *
     * @param event         事件名称
     * @param callback
     * @returns
     */
    private forEachEventListeners;
    /**
     * 当调用forEachListeners时，用来根据event名称从侦听器中匹配出对应的侦听器
     *
     * @param event
     */
    private getMatchedListeners;
    /**
     * 注销订阅
     *
     * - 通过listenerId进行退订
     * - 直接指定一个callback并且callback严格相等
     * - 具备同一样原型链的callback的均退订
     *
     *  let listenerId = emitter.on(event,callback)
     *
     *  emitter.off(listenerId)              // 精确退订指定的订阅，需要自行保存订阅Id
     *  emitter.off(callback)                // 所有callback均会退订
     *  emitter.off(event,callback)          // 退订指定事件的callback均会退订
     *
     * @param event
     * @param callback
     * @returns
     */
    off(listener: FlexEventListener<Message>): void;
    off(listenerId: string): void;
    off(event: Events, listener: FlexEventListener<Message>): void;
    /**
     * 等待某个事件触发后返回
     *
     * 当等待多个事件时，
     *
     * 可以指定侦听模式
     *
     * - Or模式：默认即只要侦听到一个事件就返回
     * - And模式：即需要同时侦听到所有事件才返回。当侦听的事件是由逗号分隔的多个事件时，即为And模式
     *
     * @param event  一个或多个事件名称
     */
    waitFor(event: Events | Events[], timeout?: number): Promise<any[]>;
    clear(): void;
    offAll(event?: Events): void;
    /**
     * 返回指定事件的的所有侦听器函数
     * @param event
     * @returns
     */
    getListeners(event: Events): [FlexEventListener<Message>, string, number][];
    /**
     * 执行侦听器函数
     *
     * @param listenerId  侦听器ID
     * @param listeners   事件侦听器列表
     * @param message
     * @returns
     */
    private executeListener;
    private executeListeners;
    /**
     * 触发事件
     *
     * emit("a/b/c")
     *
     * @param event
     * @param message
     */
    emit(event: Events, message?: Message, retain?: boolean): any[];
    /**
     * 异步触发事件
     * @param this
     * @param event
     * @param message
     * @returns
     */
    emitAsync(event: Events, message?: Message, retain?: boolean): Promise<any[]>;
}

export { FlexEvent, type FlexEventListener, type FlexEventListenerRegistry, type FlexEventOptions, type FlexEventSubscriber, type FlexEventWatchParams, type FlexEventWatchType, type FlexListenerRegistry, type ForEachEventListenerCallback, type SubscribeOptions };