import 'codeceptjs';
import { CommonKeyword } from './commonKeyword';
import { TextField } from './textfield';
import { GenerateRandom } from './generateRandom';
import { DewFileUpload } from './dewFileUpload';
import { Wait } from './dewWait';
import { DewElement } from './element';
import { logger } from '../Logger/logger';
import { DewButton } from './dewButton';

import { SoftAssert } from './SoftAssertion';
let tableFlexiField: any = [];
let tableFlexiFieldValues: any = [];
const assert = require(`soft-assert`);

/**
 * FlexiformTable Class
 */
export class FlexiformTable extends Helper {
  /**
* The method is used to fill table flexi fields
*
*
* ```js
* await FlexiformTable.fillItemTableFields()
* ```
*/
  static async fillItemTableFields() {
    const browser = await this.prototype.helpers[`WebDriver`].browser;
    await browser.saveScreenshot(`./output/FFScreenshot.png`);
    tableFlexiField = [];
    tableFlexiFieldValues = [];
    const headerNames = await DewElement.getListOfElements(`//dew-flexiform//form[contains(@class,'dynamic-form')]//dew-table//div[@class='float-left fixed-columns']//table/thead/tr/th[not(@hidden)]//div[@class='flex-container']/div`);
    const tagTableArray = await DewElement.getListOfElements(`(//dew-flexiform//form[contains(@class,'dynamic-form')]//dew-table//div[@class='float-left fixed-columns']//table/tbody/tr)/td[not(@hidden)]/*`);
    for (let i = 0; i < headerNames.length; i++) {
      await CommonKeyword.scrollIntoView(`(//dew-flexiform//form[contains(@class,'dynamic-form')]//dew-table//div[@class='float-left fixed-columns']//table/thead/tr/th[not(@hidden)]//div[@class='flex-container']/div)[${i + 1}]`);
      const label = await DewElement.grabTextFrom(`(//dew-flexiform//form[contains(@class,'dynamic-form')]//dew-table//div[@class='float-left fixed-columns']//table/thead/tr/th[not(@hidden)]//div[@class='flex-container']/div)[${i + 1}]`);
      const tag = await tagTableArray[i].getTagName();
      tableFlexiField.push({ "label": label, "index": i + 1, "tagName": tag });
      const tableSectionElements = await `(//dew-flexiform//form[contains(@class,'dynamic-form')]//dew-table//div[@class='float-left fixed-columns']//table/tbody/tr/td[not(@hidden)])[${i + 1}]/${tag}`;
      if (await DewElement.getNumberOfElementsPresentInDom(tableSectionElements) > 0) {
        await flexifill(tag, tableSectionElements, tableFlexiField[i].index);
      }
    }
  }

  /**
* The method is used to verify table flexi fields
*
*
* ```js
* await FlexiformTable.verifyFlexiFields()
* ```
*/
  static async verifyFlexiFields() {
    for (let i = 0; i < tableFlexiField.length; i++) {
      const tagName = tableFlexiField[i].tagName; const index = tableFlexiField[i].index; const text = tableFlexiFieldValues[i].text;
      await CommonKeyword.scrollIntoView(`//dew-flexiform//form[contains(@class,'dynamic-form')]//div/dew-row/dew-col/` + tagName);
      const flexiElement = `((//dew-flexiform//form[contains(@class,'dynamic-form')]//dew-table//div//table/tbody/tr)/td[not(@hidden)])`;

      switch (tagName) {
      case `flexiform-datetime`:

        try {
          await CommonKeyword.scrollIntoView(flexiElement + `[${index}]/flexiform-datetime//span`);
          const value = await DewElement.grabTextFrom(flexiElement + `[${index}]/flexiform-datetime//span`);
          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `Not matched- flexiform-datetime, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in date-time`);
        }
        break;

      case `dew-text`:
        try {
          await CommonKeyword.scrollIntoView(flexiElement + `[${index}]//dew-text//input`);
          const value = await DewElement.grabTextFrom(flexiElement + `[${index}]//dew-text//input`);
          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `Not matched-dew-text, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in text field`);
        }
        break;

      case `dew-textarea`:
        try {
          await CommonKeyword.scrollIntoView(flexiElement + `[${index}]/dew-textarea//span`);
          const value = await DewElement.grabTextFrom(flexiElement + `[${index}]/dew-textarea//span`);
          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `Not matched-dew-textarea, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in textarea`);
        }
        break;
      case `dew-numeric`:
        try {
          await CommonKeyword.scrollIntoView(`(` + flexiElement + `[${index}]/dew-numeric//span)[1]`);
          const value = await DewElement.grabTextFrom(`(` + flexiElement + `[${index}]/dew-numeric//span)[1]`);
          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `Not matched-dew-numeric, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in numeric field`);
        }
        break;

      case `ffdew-dropdown`:
        try {
          await CommonKeyword.scrollIntoView(flexiElement + `[${index}]/ffdew-dropdown//span`);
          const value = await DewElement.grabTextFrom(flexiElement + `[${index}]/ffdew-dropdown//span`);
          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `ffdew-dropdown Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in dropdown-ffdew-dropdown`);
        }
        break;

      case `dew-multi-select`:
        try {
          await CommonKeyword.scrollIntoView(flexiElement + `[${index}]//dew-multi-select//span`);
          const value = await DewElement.grabTextFrom(flexiElement + `[${index}]//dew-multi-select//span`);
          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `dew-multi-select Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in multi-select-dew-multi-select`);
        }
        break;

      case `dew-autocomplete`:
        try {
          await CommonKeyword.scrollIntoView(flexiElement + `[${index}]//dew-autocomplete//span`);
          const value = await DewElement.grabTextFrom(flexiElement + `[${index}]//dew-autocomplete//span`);
          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `dew-autocomplete Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in auto complete-dew-autocomplete`);
        }
        break;

      case `dew-fileupload`:
        try {
          await CommonKeyword.scrollIntoView(flexiElement + `[${index}]/dew-fileupload//a//span[contains(@class,'icon')]`);
          await CommonKeyword.clickElement(flexiElement + `[${index}]/dew-fileupload//a//span[contains(@class,'icon')]`);

          const locator = await DewElement.getListOfElements(flexiElement + `[${index}]/dew-fileupload//dew-modal//dew-modal-body//p[@title='FFScreenshot.png']`);
          await DewButton.click(`Done`);
          SoftAssert.softTrue(locator.length > 0, `Not matched-dew-fileupload`);
        } catch (err) {
          logger.info(`Error in file upload`);
        }
        break;

      default:
        throw new Error(`Error in DDCC`);
      }
    }
    assert.softAssertAll();
  }

  /**
* The method is used to verify table flexi fields in edit mode
*
*
* ```js
* await FlexiformTable.verifyFlexiFieldsinEditMode()
* ```
*/
  static async verifyFlexiFieldsinEditMode() {
    for (let i = 0; i < tableFlexiField.length; i++) {
      const tagName = tableFlexiField[i].tagName; const index = tableFlexiField[i].index; const text = tableFlexiFieldValues[i].text;
      await CommonKeyword.scrollIntoView(`//dew-flexiform//form[contains(@class,'dynamic-form')]//div/dew-row/dew-col/` + tagName);
      const flexiElement = `((//dew-flexiform//form[contains(@class,'dynamic-form')]//dew-table//div[@class='float-left fixed-columns']//table/tbody/tr)/td[not(@hidden)])`;
      switch (tagName) {
      case `flexiform-datetime`:
        try {
          const value = await DewElement.grabAttributeFrom(flexiElement + `[${index}]//flexiform-datetime//input`, `value`);
          console.log(`Value-----`, value.toString());
          SoftAssert.softTrue(text.includes(value.toString()), ` flexiform-datetime Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in date-time`);
        }
        break;

      case `dew-text`:
        try {
          const value = await DewElement.grabAttributeFrom(flexiElement + `[${index}]//dew-text//dew-input/input`, `value`);

          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), ` dew-text Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in text field`);
        }
        break;

      case `dew-textarea`:
        try {
          const value = await DewElement.grabAttributeFrom(flexiElement + `[${index}]//dew-textarea//dew-input/textarea`, `value`);
          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `dew-textarea Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in textarea`);
        }
        break;
      case `dew-numeric`:
        try {
          const value = await DewElement.grabAttributeFrom(flexiElement + `[${index}]//dew-numeric//input`, `value`);

          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `dew-numeric Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in numeric field`);
        }
        break;

      case `ffdew-dropdown`:
        try {
          const value = await DewElement.grabAttributeFrom(flexiElement + `[${index}]//dew-flexiform-autocomplete//input`, `value`);

          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `ffdew-dropdown Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in dropdown`);
        }
        break;

      case `dew-multi-select`:
        try {
          const value = await DewElement.grabAttributeFrom(flexiElement + `[${index}]//dew-multi-select//dew-flexiform-multi-select/dew-row/dew-badge-group/span`, `value`);
          console.log(`Value-----` + value);
          SoftAssert.softTrue(value.includes(text), `dew-multi-select Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in multi-select`);
        }
        break;

      case `dew-autocomplete`:
        try {
          const value = await DewElement.grabAttributeFrom(flexiElement + `[${index}]//dew-autocomplete//dew-flexiform-autocomplete//input`, `value`);

          console.log(`Value-----`, value);
          SoftAssert.softTrue(text.includes(value), `dew-autocomplete Not matched, Expected:${text} Actual:${value}`);
        } catch (err) {
          logger.info(`Error in auto complete`);
        }
        break;

      case `dew-fileupload`:
        try {
          const fileUploadLoc = flexiElement + `[${index}]//dew-fileupload//span`;
          await CommonKeyword.scrollIntoView(fileUploadLoc);
          await CommonKeyword.clickElement(fileUploadLoc);
          const locator = await DewElement.getListOfElements(`//dew-file-upload/following-sibling::dew-row//dew-col//p[@title='FFScreenshot.png']`);
          await DewButton.click(`Done`);

          SoftAssert.softTrue(locator.length > 0, `dew-fileupload Not matched`);
        } catch (err) {
          logger.info(`Error in file upload`);
        }
        break;

      default:
        throw new Error(`Error in DDCC`);
      }
    }
    assert.softAssertAll();
  }
}

module.exports = new FlexiformTable();
module.exports.FlexiformTable = FlexiformTable; // for inheritance

/**
* To get an array of elements
*
* await getElements(`//dew-file-upload//input[@type='file']`)
* ```
*  @param {String} locator
*/
async function getElements(locator: string) {
  const totalNumberOfElement = await DewElement.getNumberOfElementsPresentInDom(locator);
  let element: any;
  for (let index = 1; index <= totalNumberOfElement; index++) {
    const visibleElement: any = locate(locator);
    if (await DewElement.checkIfElementVisible(visibleElement)) {
      element = visibleElement.value;
      break;
    }
  }
  return element;
}

/**
*
* To fill flexifields
* ```js
* await Flexiform.flexifill("dew-flexi","//dew-flexiform//form[contains(@class,'dynamic-form')]//dew-table//div[@class='float-left fixed-columns']//table/tbody/tr/td[not(@hidden)]/dew-radiofield")
* ```
* @param {string} tagName
* @param {String} flexiLocator
*@param {String} index
*/
async function flexifill(tagName: string, flexiLocator: string, index: any) {
  await CommonKeyword.scrollIntoView(flexiLocator);
  const flexiElement = await getElements(flexiLocator);
  try {
    switch (tagName) {
    case `flexiform-datetime`:
      try {
        const dateTimeLocator = flexiElement + `//dew-datepicker//input`;

        await CommonKeyword.scrollIntoView(dateTimeLocator);
        await CommonKeyword.clickElement(dateTimeLocator);
        await CommonKeyword.clickElement(`.currentDate`);
        if (await DewElement.grabNumberOfVisibleElements(`//div[contains(@class,'month')][text()='Select Time']`) > 0) {
          await CommonKeyword.click(flexiElement + `/../..`);
        }
        const text = await DewElement.grabAttributeFrom(dateTimeLocator, `value`);
        await tableFlexiFieldValues.push({ index: index, text: text });
      } catch (err) {
        logger.info(`Error in date-time`);
      }
      break;

    case `dew-text`:
      try {
        const textLocator = flexiElement + `//dew-input/input`;
        const text = await GenerateRandom.generateRandomString(8);
        await CommonKeyword.scrollIntoView(textLocator);
        await TextField.enterTextUsingLocator(textLocator, text);
        await tableFlexiFieldValues.push({ index: index, text: text });
      } catch (err) {
        logger.info(`Error in text field`);
      }
      break;

    case `dew-textarea`:
      try {
        const textLocator = flexiElement + `//dew-input/textarea`;
        const text = await GenerateRandom.generateRandomString(5);
        await CommonKeyword.scrollIntoView(textLocator);
        await TextField.type(textLocator, text);
        await tableFlexiFieldValues.push({ index: index, text: text });
      } catch (err) {
        logger.info(`Error in textarea`);
      }
      break;
    case `dew-numeric`:
      try {
        const numLocator = flexiElement + `//dew-input-container//input`;
        const num = await (await GenerateRandom.generateRandomNumber(1000)).toString();
        await CommonKeyword.scrollIntoView(numLocator);
        await TextField.type(numLocator, num);
        const value = await DewElement.grabAttributeFrom(numLocator, `value`);
        console.log(`Value-----`, value);
        if (value == ``) {
          await TextField.type(numLocator, num);
        }
        await tableFlexiFieldValues.push({ index: index, text: num });
      } catch (err) {
        logger.info(`Error in numeric field`);
      }
      break;

    case `ffdew-dropdown`:
      try {
        const dropdownLocator = flexiElement + `//dew-flexiform-autocomplete//input`;
        await CommonKeyword.scrollIntoView(dropdownLocator);
        await TextField.enterTextUsingLocator(dropdownLocator, ` `);
        const locator = `//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div | //div[contains(@class,'ff-ac-suggestion-item')]`;
        await Wait.waitUntilVisibilityOfElement(locator);
        const dropdownElements = await DewElement.grabNumberOfVisibleElements(locator);
        const rnd = await GenerateRandom.generateRandomNumber(dropdownElements);
        const text = await DewElement.grabTextFrom(`(//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div)[${rnd + 1}] | (//div[contains(@class,'ff-ac-suggestion-item')])[${rnd + 1}]`);
        await CommonKeyword.clickElement(`(//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div)[${rnd + 1}] | (//div[contains(@class,'ff-ac-suggestion-item')])[${rnd + 1}]`);
        await tableFlexiFieldValues.push({ index: index, text: text });
      } catch (err) {
        logger.info(`Error in dropdown`);
      }
      break;

    case `dew-multi-select`:
      try {
        const multiSelectLocator = flexiElement + `//dew-flexiform-multi-select//input`;
        await CommonKeyword.scrollIntoView(multiSelectLocator);

        await TextField.enterTextUsingLocator(multiSelectLocator, ` `);
        const locator = `//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div | //div[contains(@class,'ff-ac-suggestion-item')]`;
        await Wait.waitUntilVisibilityOfElement(locator);
        const multiSelectElements = await DewElement.grabNumberOfVisibleElements(locator);
        const rnd = await GenerateRandom.generateRandomNumber(multiSelectElements);
        const text = await DewElement.grabTextFrom(`(//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div/p)[${rnd + 1}] | (//div[contains(@class,'ff-ac-suggestion-item')]/p)[${rnd + 1}]`);
        await CommonKeyword.clickElement(`(//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div)[${rnd + 1}] | (//div[contains(@class,'ff-ac-suggestion-item')])[${rnd + 1}]`);

        await tableFlexiFieldValues.push({ index: index, text: text });
      } catch (err) {
        logger.info(`Error in multi-select`);
      }
      break;

    case `dew-autocomplete`:
      try {
        const autoCompleteLocator = flexiElement + `//dew-flexiform-autocomplete//input`;
        await CommonKeyword.scrollIntoView(autoCompleteLocator);
        await TextField.enterTextUsingLocator(autoCompleteLocator, ` `);
        const locator = `//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div | //div[contains(@class,'ff-ac-suggestion-item')]`;
        await Wait.waitUntilVisibilityOfElement(locator);
        const autoCompleteElements = await DewElement.grabNumberOfVisibleElements(locator);
        const rnd = await GenerateRandom.generateRandomNumber(autoCompleteElements);
        const text = await DewElement.grabTextFrom(`(//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div)[${rnd + 1}] | (//div[contains(@class,'ff-ac-suggestion-item')])[${rnd + 1}]`);
        await CommonKeyword.clickElement(`(//div[contains(@class,'autoCompleteListOutsideTable')]//div[contains(@class,'list')]/div)[${rnd + 1}] | (//div[contains(@class,'ff-ac-suggestion-item')])[${rnd + 1}]`);
        await tableFlexiFieldValues.push({ index: index, text: text });
      } catch (err) {
        logger.info(`Error in auto complete`);
      }
      break;

    case `dew-fileupload`:
      try {
        const fileUploadLocator2 = flexiElement + `//a/div`;
        if (await DewElement.getNumberOfElementsPresentInDom(flexiElement + `//a/div`) > 0) {
          await CommonKeyword.scrollIntoView(fileUploadLocator2);
          await CommonKeyword.clickElement(fileUploadLocator2);
          await Wait.waitUntilVisibilityOfElement(`//div[@class='cdk-overlay-container']//div[@class[normalize-space()='modal-content']]`);
          await DewFileUpload.uploadFileUsingLocator(`//div[@class='cdk-overlay-container']//div[@class[normalize-space()='modal-content']]//dew-file-upload//input[@type='file']`, `./output/FFScreenshot.png`);
          await DewButton.click(`Done`);
          await tableFlexiFieldValues.push({ index: index, text: `FFScreenshot.png` });
        }
      } catch (err) {
        logger.info(`Error in file upload`);
      }
      break;

    default:
      throw new Error(`Error in DDCC`);
    }
  } catch (err) {
    throw err;
  }
}