import { DbClient } from '@contour/db-client/lib/dbClient';

import { NodeProfile } from '../../../../@types/nodeProfile';
import envConfig from '../../../../env/env-config';
import { getNodeProfile, getUserEmail } from '../../../../env/nodeProfile';
import { API } from '../../../../util/API';
import { getTimestampInPlainString } from '../../../../util/dateUtil';
import { HTTP_METHOD } from '../../../../util/httpMethod';
import { makeRequest } from '../../../../util/httpRequestUtil';
import { makeAuthenticatedRequest } from '../../../../util/loginUtil';
import scenarioContext from '../../../../util/scenarioContext';
import { splitCamelCase } from '../../../../util/stringUtil';

export async function createUserInDefaultNode(partyRole: string, role: string) {
  const nodeName = envConfig.defaultParty[partyRole];
  const nodeProfile: NodeProfile = getNodeProfile(nodeName);
  const userName = 'autoTest' + getTimestampInPlainString();
  const password = envConfig.constants.defaultPassword;
  const emailAddress = getUserEmail(userName, nodeName);

  const roles = splitCamelCase(role);
  const roleIDs = await getRoleIDs(nodeName, roles);
  const userUUID = await submitNewUserRequest(nodeName, emailAddress, roleIDs);
  await approveNewUserRequest(nodeName, userUUID);
  const onboardingToken = await getOnboardingTokenFromDB(nodeProfile, userUUID);
  await onboardUser(nodeProfile.baseUrl, userName, password, onboardingToken);

  scenarioContext().userDtl.email = emailAddress;
  scenarioContext().userDtl.password = password;
  scenarioContext().userDtl.userName = userName;
}

async function getRoleIDs(nodeName: string, roles: string[]): Promise<string[]> {
  const roleIDs: string[] = [];
  const roleList = await makeAuthenticatedRequest(nodeName, 'admin1', API.GET_ROLE_LIST, HTTP_METHOD.GET);
  roles.forEach((role) => {
    roleIDs.push(roleList.find((x: { name: string }) => x.name === role).id);
  });

  logger.debug(`Role ID's retrieved successfully for the roles ${roles.join(', ')}`);
  return roleIDs;
}
async function submitNewUserRequest(nodeName: string, emailAddress: string, roleIDs: string[]): Promise<string> {
  const response = await makeAuthenticatedRequest(
    nodeName,
    'admin1',
    API.CREATE_USER,
    HTTP_METHOD.POST,
    `{
      "email": "${emailAddress}",
      "roles": ${JSON.stringify(roleIDs)}
    }`
  );
  if (response.id == undefined) {
    throw new Error(`New user request API failed withr response ${response}`);
  }

  logger.debug(`New user request for ${emailAddress} is SUBMITTED successfully with UUID ${response.id}`);
  return response.id;
}

async function approveNewUserRequest(nodeName: string, userUUID: string): Promise<void> {
  await makeAuthenticatedRequest(nodeName, 'admin2', API.APPROVE_USER.replace('#uuid#', userUUID), HTTP_METHOD.PUT);
  logger.debug(`New user request for UUID ${userUUID} is APPROVED successfully`);
}

async function getOnboardingTokenFromDB(nodeProfile: NodeProfile, userUUID: string): Promise<string> {
  const query = `select onboarding_token from users where id='${userUUID}';`;
  const dbConfig = nodeProfile.dbConfig;
  const dbClient = new DbClient(dbConfig);
  const response = await dbClient.runQuery(query);
  logger.debug(`Onboarding token is retrieved from DB successfully for UUID ${userUUID}`);
  return response[0]['onboarding_token'];
}

async function onboardUser(
  baseURL: string,
  displayName: string,
  password: string,
  onboardingToken: string
): Promise<void> {
  const reqBody = JSON.parse(`{"displayName": "${displayName}", "password": "${password}"}`);
  await makeRequest(
    baseURL + API.VERSION + API.SETUP_USER.replace('#token#', onboardingToken),
    HTTP_METHOD.POST,
    JSON.stringify(reqBody),
    { 'Content-Type': 'application/json' }
  );
  logger.debug(`User with displayname ${displayName} is setup successfully with onboarding token ${onboardingToken}`);
}