import 'codeceptjs';
const { I } = inject();
import { CommonKeyword } from './commonKeyword';
import { DewFileUpload } from './dewFileUpload';
import { DewElement } from './element';
import { TextField } from './textfield';
import { GenerateRandom } from './generateRandom';
import { logger } from '../Logger/logger';
import { DewLoader } from './dewLoader';
import { Wait } from './dewWait';
import { ReadLocators } from "../readLocators";
const locators: any = ReadLocators.readJson();

/**
 * Flexiform for eProc Class
 */
export class EForms {
  /**
      * The method is used to fill flexiform fields without using getInstance API call
      *
      * ```js
      * await eForms.eformWithoutAPI()
      * ```
      */
  static async eformWithoutAPI() {
    try {
      await DewLoader.waitForSpinner();
      const locator = locators.eFormWithoutAPIXpath;
      const elements = await DewElement.getNumberOfElementsPresentInDom(locator);
      console.log(`Total number of eform elements are : ${elements}`);

      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormFileTypeXpath)) {
        const element = locator + locators.eFormFileTypeXpath;
        await fileUpload(element);
      }
      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormPlaceHolderXpath)) {
        const element = locator + locators.eFormPlaceHolderXpath;
        await fillText(element);
      }
      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormTextAreaXpath)) {
        const element = locator + locators.eFormTextAreaXpath;
        await fillTextArea(element);
      }
      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormFillNumericXpath)) {
        const element = locator + locators.eFormFillNumericXpath;
        await fillNumeric(element);
      }
      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormURLXpath)) {
        const element = locator + locators.eFormURLXpath;
        await fillURL(element);
      }
      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormDatePickerXpath)) {
        const element = locator + locators.eFormDatePickerXpath;
        await fillDate(element);
      }
      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormDropdownTriggerXpath)) {
        const element = locator + locators.eFormDropdownTriggerXpath;
        await fillDropDown(element);
      }
      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormCheckboxXpath)) {
        const element = locator + locators.eFormCheckboxXpath;
        await selectCheckbox(element);
      }
      if (await DewElement.getNumberOfElementsPresentInDom(locator + locators.eFormRadioXpath)) {
        const element = locator + locators.eFormRadioXpath;
        await selectRadio(element);
      }
    } catch (err) {
      throw err;
    }
  }
}
module.exports = new EForms();
module.exports.EForms = EForms; // for inheritance

/**
    * The method is used to select checkbox type field
    * @param {any} locatorParam
    */
async function selectCheckbox(locatorParam: any) {
  let element: string;
  if (Array.isArray(locatorParam)) {
    element = locatorParam[0];
  } else {
    element = locatorParam;
  }
  try {
    const noOfElements = await DewElement.getNumberOfElementsPresentInDom(element);
    for (let iterator = 1; iterator <= noOfElements; iterator++) {
      await CommonKeyword.scrollIntoView(`(` + element + `)` + `[${iterator}]`);
      await I.click(`(` + element + `)` + `[${iterator}]`);
      const checkboxLocator = await DewElement.getNumberOfElementsPresentInDom(`(` + `(` + element + `)` + `[${iterator}]` + `//input[not(contains(@class, 'hideInput'))])`);
      const rnd = await GenerateRandom.generateRandomNumber(checkboxLocator);
      await CommonKeyword.scrollIntoView(`(` + `(` + element + `)` + `[${iterator}]` + `//input[not(contains(@class, 'hideInput'))])[${rnd + 1}]`);
      await I.click(`(` + `(` + element + `)` + `[${iterator}]` + `//input[not(contains(@class, 'hideInput'))])[${rnd + 1}]`);
    }
  } catch (err) {
    logger.info(`Error in selecting checkbox`);
  }
}

/**
      * The method is used to select Radio button type field
      * @param {any} locatorParam
      */
async function selectRadio(locatorParam: any) {
  let element: string;
  if (Array.isArray(locatorParam)) {
    element = locatorParam[0];
  } else {
    element = locatorParam;
  }
  try {
    const noOfElements = await DewElement.getNumberOfElementsPresentInDom(element);
    for (let iterator = 1; iterator <= noOfElements; iterator++) {
      await CommonKeyword.scrollIntoView(`(` + element + `)` + `[${iterator}]`);
      await I.click(`(` + element + `)` + `[${iterator}]`);
      const radioLocator = await DewElement.getNumberOfElementsPresentInDom(`(` + `(` + element + `)` + `[${iterator}]` + `/div/label)`);
      const rnd = await GenerateRandom.generateRandomNumber(radioLocator);
      await CommonKeyword.scrollIntoView(`(` + `(` + element + `)` + `[${iterator}]` + `/div/label)[${rnd + 1}]`);
      await I.click(`(` + `(` + element + `)` + `[${iterator}]` + `/div/label)[${rnd + 1}]`);
    }
  } catch (err) {
    logger.info(`Error in selecting radio`);
  }
}

/**
     * The method is used to select Date and time
     * @param {any} dateTimeLocatorParam
     */
async function fillDate(dateTimeLocatorParam: any) {
  let dateTimeLocator: string;
  if (Array.isArray(dateTimeLocatorParam)) {
    dateTimeLocator = dateTimeLocatorParam[0];
  } else {
    dateTimeLocator = dateTimeLocatorParam;
  }
  try {
    const noOfElements = await DewElement.getNumberOfElementsPresentInDom(dateTimeLocator);
    for (let iterator = 1; iterator <= noOfElements; iterator++) {
      console.log(`(` + dateTimeLocator + `)` + `[${iterator}]`);
      await CommonKeyword.scrollIntoView(`(` + dateTimeLocator + `)` + `[${iterator}]`);
      await I.click(`(` + dateTimeLocator + `)` + `[${iterator}]`);
      await I.click(locators.eFormCurrentDateXpath);
    }
  } catch (err) {
    logger.info(`Error in date-time`);
  }
}
/**
     * The method is used to select dropdown and multi-select type of field
     * @param {any} autoCompleteLocatorParam
     */
async function fillDropDown(autoCompleteLocatorParam: any) {
  let autoCompleteLocator: string;
  if (Array.isArray(autoCompleteLocatorParam)) {
    autoCompleteLocator = autoCompleteLocatorParam[0];
  } else {
    autoCompleteLocator = autoCompleteLocatorParam;
  }
  try {
    const noOfElements = await DewElement.getNumberOfElementsPresentInDom(autoCompleteLocator);
    for (let iterator = 1; iterator <= noOfElements; iterator++) {
      await CommonKeyword.scrollIntoView(`(` + autoCompleteLocator + `)` + `[${iterator}]`);
      await I.click(`(` + autoCompleteLocator + `)` + `[${iterator}]`);
      const locator = locators.eFormFillDropDownXpath;
      await Wait.waitUntilVisibilityOfElement(locator);
      const autoCompleteElements = await DewElement.grabNumberOfVisibleElements(locator);
      const rnd = await GenerateRandom.generateRandomNumber(autoCompleteElements);
      await CommonKeyword.click(`(//div[contains(@class,'dropdown-item')])[${rnd + 1}]`);
    }
  } catch (err) {
    logger.info(`Error in auto complete`);
  }
}
/**
     * The method is used to enter random URL
     *@param {any} elementParam
      */
async function fillURL(elementParam: any) {
  let element: string;
  if (Array.isArray(elementParam)) {
    element = elementParam[0];
  } else {
    element = elementParam;
  }
  try {
    const noOfElements = await DewElement.getNumberOfElementsPresentInDom(element);
    for (let iterator = 1; iterator <= noOfElements; iterator++) {
      await CommonKeyword.scrollIntoView(`(` + element + `)` + `[${iterator}]`);
      await TextField.enterTextUsingLocator(`(` + element + `)` + `[${iterator}]`, `https://` + await GenerateRandom.generateRandomString(8) + `.com`);
    }
  } catch (err) {
    logger.info(`Error in URL type field`);
  }
}
/**
     * The method is use to fill Numeeric type field
     * @param {any} elementParam
     */
async function fillNumeric(elementParam: any) {
  let element: string;
  if (Array.isArray(elementParam)) {
    element = elementParam[0];
  } else {
    element = elementParam;
  }
  try {
    const noOfElements = await DewElement.getNumberOfElementsPresentInDom(element);
    for (let iterator = 1; iterator <= noOfElements; iterator++) {
      await CommonKeyword.scrollIntoView(`(` + element + `)` + `[${iterator}]`);
      await TextField.enterTextUsingLocator(`(` + element + `)` + `[${iterator}]`, await GenerateRandom.generateRandomNumber(8));
    }
  } catch (err) {
    logger.info(`Error in Numeric type field`);
  }
}
/**
     * The method is use to fill textarea type field
     * @param {any} elementParam
     */
async function fillTextArea(elementParam: any) {
  let element: string;
  if (Array.isArray(elementParam)) {
    element = elementParam[0];
  } else {
    element = elementParam;
  }
  try {
    const noOfElements = await DewElement.getNumberOfElementsPresentInDom(element);
    for (let iterator = 1; iterator <= noOfElements; iterator++) {
      await CommonKeyword.scrollIntoView(`(` + element + `)` + `[${iterator}]`);
      await TextField.enterTextUsingLocator(`(` + element + `)` + `[${iterator}]`, await GenerateRandom.generateRandomString(8));
    }
  } catch (err) {
    logger.info(`Error in textarea type field`);
  }
}

/**
     * The method is use to upload a file
     *@param {any} elementParam
      */
async function fileUpload(elementParam: any) {
  let element: string;
  if (Array.isArray(elementParam)) {
    element = elementParam[0];
  } else {
    element = elementParam;
  }
  const noOfElements = await DewElement.getNumberOfElementsPresentInDom(element);

  for (let iterator = 1; iterator <= noOfElements; iterator++) {
    await CommonKeyword.scrollIntoView(`(` + element + `)` + `[${iterator}]`);
    await DewFileUpload.uploadFileUsingLocator(`(` + element + `)` + `[${iterator}]`, `resources//Sprint.xlsx`);
  }
}
/**
     * The method is use to fill Text type field
     *@param {any} elementParam
      */
async function fillText(elementParam: any) {
  let element: string;
  if (Array.isArray(elementParam)) {
    element = elementParam[0];
  } else {
    element = elementParam;
  }
  try {
    const noOfElements = await DewElement.getNumberOfElementsPresentInDom(element);
    for (let iterator = 1; iterator <= noOfElements; iterator++) {
      await CommonKeyword.scrollIntoView(`(` + element + `)` + `[${iterator}]`);
      await TextField.enterTextUsingLocator(`(` + element + `)` + `[${iterator}]`, await GenerateRandom.generateRandomString(8));
    }
  } catch (err) {
    logger.info(`Error in text field`);
  }
}