import { EventEmitter2 } from "eventemitter2";

export interface IEventPublisherArgs {
  subscribers: EventSubscriber[];
}

export class EventPublisher {
  private emitter: EventEmitter2;

  constructor(args: IEventPublisherArgs) {
    this.emitter = new EventEmitter2({ wildcard: true, delimiter: "." });

    const bus: IEventBus = {
      subscribe: (id, cb) => {
        this.emitter.on(id, cb);
      }
    };

    for (const subscriber of args.subscribers) {
      subscriber.attach(bus);
    }
  }

  publish(event: PublishEvent) {
    this.emitter.emit(event.id, event);
  }
}

export class PublishEvent {
  constructor(public id: string) {}
}

export type SubscribeListenerFunction = (event: PublishEvent) => void;

export type SubscribeFunction = (
  id: string,
  cb: SubscribeListenerFunction
) => void;

export interface IEventBus {
  subscribe: SubscribeFunction;
}

export abstract class EventSubscriber {
  abstract attach(bus: IEventBus): void;
}

import { Container } from "typedi";

export class IntegrationConnectedEvent extends PublishEvent {
  constructor(public payload: any) {
    super("integration.connected");
  }
}

export class IntegrationSubscriber extends EventSubscriber {
  attach(bus: IEventBus) {
    bus.subscribe(
      "integration.connected",
      this.onIntegrationConnectedEvent
    );
  }

  async onIntegrationConnectedEvent(event: PublishEvent) {
    if (event instanceof IntegrationConnectedEvent) {
      console.log(event.payload);
    }
  }
}

Container.set("publisher", new EventPublisher({ subscribers: [new IntegrationSubscriber()] }));

const publisher = Container.get("publisher");

publisher.publish(new IntegrationConnectedEvent("Hello World!"));

// Console output: Hello World!