import { ipcMain, IpcMainInvokeEvent, IpcMainEvent } from "electron";

export class IpcHandler<InputParam, ReturnType> implements IIpcHandler<InputParam, ReturnType> {

  readonly channel: string;

  readonly _handlerCallback: IpcHandlerCallback<InputParam, ReturnType>;

  constructor(options: {
      channel: string;
      handlerCallback: IpcHandlerCallback<InputParam, ReturnType>;
  }) {
    this.channel = options.channel;
    this._handlerCallback = options.handlerCallback;
  }

  handle() {
      this.remove();
      ipcMain.handle(this.channel, this._onInvoke);
  }

  remove() {
      ipcMain.removeHandler(this.channel);
  }

  private _onInvoke = (_e: IpcMainInvokeEvent, payload?: string | null): Promise<Error | ReturnType> => {

      return new Promise(async (resolve, reject) => {

          console.log(`[IPC] Handle:${this.channel}`);

          try {

              const params = payload ? JSON.parse(payload) : null;

              const res = await this._handlerCallback(params);

              resolve(res as unknown as ReturnType);

          } catch(e) {
              console.log(`[IPC] Error:${this.channel}`);
              reject(e);
          }
      });
  }

}


export class IpcListener<InputParam> implements IIpcListener<InputParam> {

  readonly channel: string;

  readonly _listenerCallback: IpcListenerCallback<InputParam>;

  constructor(options: {
      channel: string;
      listenerCallback: IpcListenerCallback<InputParam>;
  }) {
    this.channel = options.channel;
    this._listenerCallback = options.listenerCallback;
  }

  listen() {
      this.remove();
      ipcMain.on(this.channel, this._onPost);
  }

  remove() {
      ipcMain.removeAllListeners(this.channel);
  }

  private _onPost = (_e: IpcMainEvent, payload: InputParam): void => {

      console.log(`[IPC] Post: ${this.channel}`);
      this._listenerCallback(payload);
  }

}