import fs from 'fs';
import {
  EventEmitter,
  KeyInput,
  PageEventObject,
  Protocol,
  WaitForOptions,
  SerializableOrJSHandle,
} from 'puppeteer';
import path from 'path';

import { BrowserInterface, LooseObject } from '../../../src/typings';

import { MockResponse } from './mock-response';
import { SRPRequestHandler } from './srp-request-handler';
import { GetServiceAccountsRequestHandler } from './get-service-accounts-request-handler';

const mockWorkflowPath = path.join(
  'test',
  'mocks',
  'mock-utility-data',
  'mock-workflow-url.json',
);
const mockWorkflowJSON = JSON.parse(
  fs.readFileSync(mockWorkflowPath).toString(),
);

export class MockPage implements BrowserInterface.Page {
  requestHandler: LooseObject;
  requestHandlerFlow: LooseObject = new Map();
  constructor() {
    this.requestHandlerFlow.set(
      mockWorkflowJSON.loginUrlSRP,
      new SRPRequestHandler(),
    );
    this.requestHandlerFlow.set(
      mockWorkflowJSON.billDetailsDetailUrl,
      new GetServiceAccountsRequestHandler(),
    );
  }

  keyboard: BrowserInterface.Keyboard = {
    press: async (key: KeyInput) => {
      return Promise.resolve();
    },
  };

  async goto(
    url: string,
    options?: WaitForOptions & {
      referer?: string;
    },
  ) {
    const requestHandler = this.requestHandlerFactory(url);
    if (!requestHandler) {
      return;
    }
    this.requestHandler = this.requestHandlerFactory(url);

    const mockResponse: BrowserInterface.HTTPResponse = new MockResponse();
    return Promise.resolve(mockResponse);
  }

  async type(selector: string, text: string) {
    this.requestHandler.type(selector, text);
    return Promise.resolve();
  }

  async waitForResponse(
    urlOrPredicate:
      | string
      | ((res: BrowserInterface.HTTPResponse) => boolean | Promise<boolean>),
    options?: {
      timeout?: number;
    },
  ) {
    const data = this.requestHandler.waitForResponse(urlOrPredicate, options);
    const mockResponse = new MockResponse();
    mockResponse.data = data;
    return mockResponse;
  }

  async waitForSelector(
    selector: string,
    options?: {
      visible?: boolean;
      hidden?: boolean;
      timeout?: number;
    },
  ) {
    return Promise.resolve(null);
  }

  requestHandlerFactory(url: string) {
    return this.requestHandlerFlow.get(url);
  }

  setDefaultTimeout(timeout: number) {
    return Promise.resolve();
  }

  async setRequestInterception(value: Boolean) {
    return Promise.resolve();
  }

  on<K extends keyof PageEventObject>(
    eventName: K,
    handler: (event: PageEventObject[K]) => void,
  ): EventEmitter {
    return;
  }

  async setCookie(...cookies: Protocol.Network.CookieParam[]): Promise<void> {
    return Promise.resolve();
  }

  cookies() {
    const data = [{ name: 'mock-cookie', value: 'mock-value' }];
    return Promise.resolve(data);
  }

  async $eval<ReturnType>(
    selector: string,
    pageFunction: (
      element: Element,
      ...args: unknown[]
    ) => ReturnType | Promise<ReturnType>,
    ...args: SerializableOrJSHandle[]
  ) {
    const data = this.requestHandler.$eval(selector, pageFunction);
    return Promise.resolve(data);
  }
}