import { SubscriptionToken } from './SubscriptionToken';
import { ThreadOption } from './UIThread';

/**
 * CompositePresentationEvent class.
 *
 * @export
 * @class CompositePresentationEvent
 * @template T
 * @wType Microsoft.Practices.Prism.Events.CompositePresentationEvent`1
 */
export class CompositePresentationEvent<T> {
  private subscribers: SubscriptionToken[] = [];

  /**
   *  Subscribe to this event
   *
   * @param {(payload: T) => void} handler
   * @param {unknown} parent
   * @memberof CompositePresentationEvent
   * @wMethod Subscribe
   * @wIgnore
   */
  public subscribe(handler: (payload: T) => void, parent: unknown);
  public subscribe(
    handler: (payload: T) => void,
    parent: unknown,
    keepHandlerRef: boolean
  );
  public subscribe(
    handler: (payload: T) => void,
    parent: unknown,
    threadOption: ThreadOption
  );
  public subscribe(
    handler: (payload: T) => void,
    parent: unknown,
    threadOption: ThreadOption,
    keepHandlerRef: boolean,
    filter?: (arg: T) => boolean
  );
  public subscribe(
    handler: (payload: T) => void,
    parent: unknown,
    restArg1?: unknown,
    restArg2?: unknown,
    filter?: (a: any) => boolean
  ): SubscriptionToken {
    const executeInSeparateThead =
      typeof restArg1 === 'number'
        ? restArg1 === ThreadOption.UIThread
        : typeof restArg2 === 'number'
        ? restArg2 === ThreadOption.UIThread
        : false;
    const subscriber = new SubscriptionToken(
      handler,
      parent,
      executeInSeparateThead,
      filter
    );
    this.subscribers.push(subscriber);
    return subscriber;
  }

  /**
   * Unsubscribe to the event
   *
   * @param {SubscriptionToken} token
   * @memberof CompositePresentationEvent
   * @wMethod Unsubscribe
   * @wIgnore
   */
  public unsubscribe(token: SubscriptionToken): void;
  public unsubscribe(handler: (payload: T) => void, parent: unknown): void;
  public unsubscribe(arg0: any, arg1?: any): void {
    let handler: (payload: unknown) => void = null;
    let parent: unknown = null;
    if (arg0 instanceof SubscriptionToken) {
      handler = arg0.handler;
      parent = arg0.parent;
    } else {
      handler = arg0;
      parent = arg1;
    }

    const index = this.subscribers.findIndex((x) => {
      return x.handler === handler && x.parent === parent;
    });

    if (index !== -1) {
      this.subscribers.splice(index, 1);
    } else {
      console.warn('Trying to unsubscribe a non subscribed handler.');
      console.warn(handler);
      console.warn(parent);
    }
  }

  /**
   * Trigger the event
   *
   * @param {T} payload
   * @memberof CompositePresentationEvent
   * @wMethod Publish
   */
  public publish(payload: T) {
    this.subscribers.slice().forEach((subscriber) => {
      subscriber.execute(payload);
    });
  }
}