import { describe, expect, test } from "@jest/globals";
// import { EventEmitter } from "write_your_lib.ts";


class EventEmitter {
  private callbacks: Record<string, Function[]> = {};

  promise(eventName: string): Promise<any> {
    return new Promise((resolve) => {
      this.once(eventName, resolve);
    });;
  }

  once(eventName: string, callback: Function) {
    const cb = function (this: EventEmitter) {
      this.removeEventListener(eventName, cb);
      callback.apply(this, arguments);
    };
    this.addEventListener(eventName, cb);
  }

  addEventListener(eventName: string, callback: Function) {
    let cbs = this.callbacks[eventName];
    if (!cbs) {
      cbs = this.callbacks[eventName] = [];
    }
    if (!cbs.includes(callback)) {
      cbs.push(callback);
    }
  }

  trigger(eventName: string, payload?: any) {
    const cbs = this.callbacks[eventName];
    if (!cbs) {
      return;
    }
    cbs.forEach(cb => {
      cb.call(this, payload);
    })
  }

  removeEventListener(eventName: string, callback: Function) {
    const cbs = this.callbacks[eventName];
    if (!cbs) {
      return;
    }
    const index = cbs.indexOf(callback);
    if (index != -1) {
      cbs.splice(index, 1);
    }
  }
}

describe("Event emitter", () => {
  const emitter = new EventEmitter();
  const callback = jest.fn();

  test("adds a listener", () => {
    emitter.addEventListener("click", callback);
    expect(callback.mock.calls.length).toBe(0);
  });

  test("emits an event", () => {
    let sentEvent = {
      x: 123,
      y: 42
    };

    emitter.trigger("click", sentEvent);

    expect(callback.mock.calls.length).toBe(1);

    expect(callback.mock.calls[0][0]).toBe(sentEvent);

    emitter.trigger("mousemove");
    expect(callback.mock.calls.length).toBe(1);

  });

  test("removes the listener", () => {
    emitter.trigger("click");
    expect(callback.mock.calls.length).toBe(2);

    emitter.removeEventListener("click", callback);
    emitter.trigger("click");
    expect(callback.mock.calls.length).toBe(2);
  });

  test("handles handlers", () => {
    let cb = jest.fn();
    emitter.addEventListener("handler", cb);
    emitter.addEventListener("handler", cb);

    emitter.trigger("handler");
    expect(cb.mock.calls.length).toBe(1);

    emitter.removeEventListener("handler", cb);//no need to remove the handler twice

    emitter.trigger("handler");
    expect(cb.mock.calls.length).toBe(1);
  });

  test("supports once", () => {
    let cb = jest.fn();
    emitter.once("onlyOnce", cb);

    emitter.trigger("onlyOnce");
    emitter.trigger("onlyOnce");

    expect(cb.mock.calls.length).toBe(1);
  });

  test("promises", async () => {
    let cb = jest.fn();
    let p = emitter.promise("promise").then(cb);
    emitter.trigger("promise", "call");

    await p;
    expect(cb.mock.calls.length).toBe(1);
    expect(cb.mock.calls[0][0]).toBe("call");
  });

  test("removes only the needed handler", async () => {
    let cb1 = jest.fn();
    let cb2 = jest.fn();
    emitter.addEventListener("click", cb1);
    emitter.addEventListener("click", cb2);

    emitter.trigger("click");
    expect(cb1.mock.calls.length).toBe(1);
    expect(cb2.mock.calls.length).toBe(1);

    emitter.removeEventListener("click", cb2);

    emitter.trigger("click");
    expect(cb1.mock.calls.length).toBe(2);
    expect(cb2.mock.calls.length).toBe(1);
  });
});