import fs from 'fs';
import path from 'path';

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

import { GetMonthlyUtilityDataRequestHandler } from './get-monthly-utilitty-data-request-handler';
import { GetServiceAccountsRequestHandler } from './get-service-accounts-request-handler';
import { RequestHandler } from './request-handler';

const workFlowConfigFilePath = path.join(
  'src',
  'services',
  'workflow',
  'srp',
  'workflow.json',
);
const srpWorkflowJson = JSON.parse(
  fs.readFileSync(workFlowConfigFilePath).toString(),
);

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

export class SRPRequestHandler implements RequestHandler {
  password: string;
  username: string;
  requestHandler: LooseObject;
  requestHandlerFlow: LooseObject = new Map();

  constructor() {
    this.requestHandlerFlow.set(
      mockWorkflowJSON.userDetailsUrlSRP,
      new GetServiceAccountsRequestHandler(),
    );
    this.requestHandlerFlow.set(
      mockWorkflowJSON.getAccountHistoryUrlSRP,
      new GetMonthlyUtilityDataRequestHandler(),
    );
  }

  async type(
    selector: string,
    text: string,
    options?: {
      delay: number;
    },
  ) {
    if (selector === srpWorkflowJson.login.usernameSelector) {
      this.username = text;
    }

    if (selector === srpWorkflowJson.login.passwordSelector) {
      this.password = text;
    }
    return Promise.resolve();
  }

  async waitForResponse(
    urlOrPredicate:
      | string
      | ((res: BrowserInterface.HTTPResponse) => boolean | Promise<boolean>),
    options?: {
      timeout?: number;
    },
  ) {
    try {
      if (
        (this.username !== 'user_good' || this.password !== 'pass_good') &&
        (this.username !== 'Naval' || this.password !== 'Gurukant')
      ) {
        const data = {
          error_description: srpWorkflowJson.login.invalidMessage,
        };
        return Promise.resolve(data);
      }

      if (
        typeof urlOrPredicate === 'string' &&
        urlOrPredicate.startsWith(
          srpWorkflowJson.getServiceAccounts.userAccountsDetailUrl,
        ) &&
        this.username === 'Naval' &&
        this.password === 'Gurukant'
      ) {
        const data = { error: 'Failed to extract data' };
        return Promise.resolve(data);
      }

      if (
        urlOrPredicate ===
        srpWorkflowJson.getServiceAccounts.userAccountsDetailUrl
      ) {
        const data = {
          billAccountList: [
            {
              customerKey: '447458894',
              account: '278949124',
              serviceAddress: {
                streetAddress: '3005 Cranberry Hwy Rt 6 28',
                cityName: 'Wareham',
                state: 'MA',
                zipCode: '25381',
              },
            },
            {
              customerKey: '001381273',
              account: '278949124',
              serviceAddress: {
                streetAddress: '100 Charlton Road',
                cityName: 'Sturbridge',
                state: 'MA',
                zipCode: '15661',
              },
            },
          ],
        };
        return Promise.resolve(data);
      }

      if (
        typeof urlOrPredicate === 'string' &&
        urlOrPredicate.startsWith(
          srpWorkflowJson.getServiceAccounts.userDetailsUrl,
        )
      ) {
        this.requestHandler = this.requestHandlerFlow.get(
          mockWorkflowJSON.userDetailsUrlSRP,
        );

        const data = this.requestHandler.waitForResponse(
          urlOrPredicate,
          options,
        );

        return Promise.resolve(data);
      }

      if (
        typeof urlOrPredicate === 'string' &&
        urlOrPredicate.startsWith(
          srpWorkflowJson.getMonthlyUtilityData.getAccountHistoryUrl,
        )
      ) {
        this.requestHandler = this.requestHandlerFlow.get(
          mockWorkflowJSON.getAccountHistoryUrlSRP,
        );

        const data = this.requestHandler.waitForResponse(
          urlOrPredicate,
          options,
        );

        return Promise.resolve(data);
      }
      return Promise.resolve({});
    } catch (err) {
      return Promise.reject(err);
    }
  }
}