// 标记接口，用于标识实现了消息处理功能的类 TODO 注调了
//interface IHandle {}

// 泛型接口，用于处理特定类型的消息
interface IHandle<TMessage> {//extends IHandle TODO 报错
    // 处理传入的消息
    Handle(message: TMessage): void;
}

// 事件聚合器接口，定义了事件聚合器的基本功能
interface IEventAggregator {
    // 默认的线程调度器，用于消息发布时的线程管理
    PublicationThreadMarshaller: (action: () => void) => void;
    // 订阅消息，将实现了 IHandle<T> 接口的实例添加到事件聚合器中
    Subscribe(instance: any): void;
    // 取消订阅，将指定的实例从事件聚合器中移除
    Unsubscribe(instance: any): void;
    // 使用默认的线程调度器发布消息
    Publish(message: any): void;
    // 使用指定的线程调度器发布消息
    Publish(message: any, marshal: (action: () => void) => void): void;
}

// 事件聚合器的具体实现
class EventAggregator implements IEventAggregator {
    // 存储所有的消息处理程序
    private handlers: Handler[] = [];
    // 默认的线程调度器，直接执行传入的操作
    public static DefaultPublicationThreadMarshaller: (action: () => void) => void = (action) => action();
    // 用于设置默认的线程调度器
    public PublicationThreadMarshaller: (action: () => void) => void;

    constructor() {
        // 初始化 PublicationThreadMarshaller 为默认的线程调度器
        this.PublicationThreadMarshaller = EventAggregator.DefaultPublicationThreadMarshaller;
    }

    // 订阅消息
    public Subscribe(instance: any): void {
        if (this.handlers.some(x => x.Matches(instance))) {
            return;
        }
        // 创建一个新的 Handler 实例并添加到 handlers 列表中
        this.handlers.push(new Handler(instance));
    }

    // 取消订阅
    public Unsubscribe(instance: any): void {
        const found = this.handlers.find(x => x.Matches(instance));
        if (found) {
            // 从 handlers 列表中移除指定的实例
            this.handlers = this.handlers.filter(x => x !== found);
        }
    }

    // 使用默认的线程调度器发布消息 TODO
    public Publish(message: any): void {
        //this.Publish(message, this.PublicationThreadMarshaller);
    }
    //TODO 线程消息发布订阅的模式是否ts中是否有其他的方式能实现
    //使用指定的线程调度器发布消息
    // public Publish(message: any, marshal: (action: () => void) => void): void {
    //     const toNotify = [...this.handlers];
    //     marshal(() => {
    //         const messageType = message.constructor;
    //         const dead = toNotify
    //             .filter(handler => !handler.Handle(messageType, message))
    //             .toArray();
    //         if (dead.length > 0) {
    //             this.handlers = this.handlers.filter(x => !dead.includes(x));
    //         }
    //     });
    // }
}

// 用于存储订阅者的信息和处理方法
class Handler {
    // 存储订阅者的实例
    private reference: WeakRef<any>;
    // 存储订阅者支持处理的消息类型和对应的处理方法
    private supportedHandlers: Map<Function, ((message: any) => void)> = new Map();

    constructor(handler: any) {
        this.reference = new WeakRef(handler);
        const handlerInfo = null;//(IHandle as any).prototype; TODO 这个IHandle
        const interfaces = Object.getPrototypeOf(handler).constructor
            .getInterfaces()
            .filter(x => x.prototype instanceof handlerInfo && x.typeParameters.length > 0);
        // interfaces.forEach((@interface: any) => { TODO注掉了
        //     const type = @interface.typeParameters[0];
        //     const method = @interface.prototype.Handle;
        //     this.supportedHandlers.set(type, method.bind(handler));
        // });
    }

    // 检查 reference 指向的实例是否与指定的实例相同
    public Matches(instance: any): boolean {
        return this.reference.deref() === instance;
    }

    // 处理消息
    public Handle(messageType: Function, message: any): boolean {
        const target = this.reference.deref();
        if (!target) {
            return false;
        }
        for (const [key, value] of this.supportedHandlers) {
            if (key.prototype.isPrototypeOf(message)) {
                value(message);
                return true;
            }
        }
        return true;
    }
}

export { IHandle, IHandle as IHandleGeneric, IEventAggregator, EventAggregator };
