import { CommonKeyword } from "../../components/commonKeyword";
import { lmt } from '../../Helpers/readI18NProp';
import { logger } from "../../Logger/logger";
import { DewLoader } from "../dewLoader";
// import { Wait } from "../dewWait";
import { DewElement } from "../element";
const { I } = inject();

/**
 * Calendar works
 */
export class LegacyDatePicker {
  /**
   * To select today's date
   *
   * ```js
   *
   * DatePicker.selectToday("//input[@aria-label='date']")
   * ```
   *
   * @param {String} locator located by CSS|XPath|strict locator.
   *
  */
  static async selectToday(locator: string) {
    const currentDate = new Date();
    const day = await currentDate.getDate();
    const month = await currentDate.getMonth() + 1;
    const year = await currentDate.getFullYear();
    try {
      logger.info(`Today date is : ${month}/${day}/${year}`);
      await this.selectDate(locator, `${month}/${day}/${year}`);
    } catch (err) {
      await I.say(`Kindly check the ${month}/${day}/${year} date is not disabled and it is a valid date`, `cyan`);
      logger.info(`Issue while performing operation in DDCC: Unable to select today date ` + locator);
      throw err;
    }
  }

  /**
   * To select provided date
   *
   * ```js
   *
   * DatePicker.selectInNextMonth("//input[@aria-label='date']","15")
   * ```
   *
   * @param {String} locator located by CSS|XPath|strict locator.
   * @param {int} daytoSelect
  */
  static async selectInNextMonth(locator: string, daytoSelect: string = `15`) {
    try {
      let monthtoSelect; let yeartoSelect;
      await CommonKeyword.clickElement(locator);
      const currentDate = new Date();
      const month = await currentDate.getMonth() + 1;
      const year = await currentDate.getFullYear();

      if (month == 12) {
        monthtoSelect = 1;
        yeartoSelect = await year + 1;
      } else {
        monthtoSelect = await month + 1;
        yeartoSelect = await year;
      }
      logger.info(`Date to be selected is : ${monthtoSelect}/${daytoSelect}/${yeartoSelect}`);
      await this.selectDate(locator, `${monthtoSelect}/${daytoSelect}/${yeartoSelect}`);
    } catch (err) {
      await I.say(`Kindly check the ${daytoSelect} day is not disabled and it is a valid date`, `cyan`);
      logger.info(`Issue while performing operation in DDCC: Error on performing select in Next Month ` + locator);
      throw err;
    }
  }
  /** It wll select a provided day in a current month
   *
   * @param {*} locator
   * @param {*} daytoSelect
   *
   * DatePicker.selectDate("//input[@aria-label='date']","25")
   */
  static async selectDayinCurrentMonth(locator: string, daytoSelect: string) {
    try {
      await CommonKeyword.clickElement(locator);
      const currentDate = new Date();
      const month = await currentDate.getMonth() + 1;
      const year = await currentDate.getFullYear();
      logger.info(`Date to be selected is: ${month}/${daytoSelect}/${year}`);
      await this.selectDate(locator, `${month}/${daytoSelect}/${year}`);
    } catch (err) {
      await I.say(`Kindly check the ${daytoSelect} day is not disabled and it is a valid date`, `cyan`);
      logger.info(`Issue while performing operation in DDCC: Error on performing select Day in current month ` + locator);
      throw err;
    }

    /* await CommonKeyword.clickElement(`.//span[contains(@class, 'd-picker-body')]//button/div[text()='${daytoSelect}']`);
       await CommonKeyword.pressKey(`Escape`); */
  }

  /**
 * To select date
 *
 * ```js
 *
 * DatePicker.selectDate("//input[@aria-label='date']","01/25/2020")
 * ```
 *
 * @param {String} locator located by CSS|XPath|strict locator.
 * @param {String} date in MM/DD/YYYY date format
*/
  static async selectDate(locator: string, date: string) {
    try {
      const dateObj = new Date(Date.parse(date));
      const month = dateObj.toLocaleString(`default`, { month: `long` }); // months from 1-12
      const day = dateObj.getDate();
      const year = dateObj.getFullYear();

      await CommonKeyword.clickElement(locator);
      // await Wait.waitForDefaultTimeout(5);
      await CommonKeyword.scrollIntoView(`.d-picker-header`, `{ behavior: \`auto\`, block: \`center\`, inline: \`center\` }`);

      await selectYear(year);
      await selectMonth(month.toString());
      await selectDay(day);
      await DewLoader.waitForSpinner();
      await verifyDateTime(locator, date);
    } catch (err) {
      await I.say(`Kindly check the ${date} date is not disabled and it is a valid date`, `cyan`);
      logger.info(`Issue while performing operation in DDCC: Unable to select date ` + locator);
      throw err;
    }
  }

  /**
  * To select date and time
  *
  * ```js
  *
  * DatePicker.selectDateAndTime("//input[@aria-label='date']","02/20/2020","12:50")
  * ```
  *
  * @param {String} locator located by CSS|XPath|strict locator.
  * @param {String} date In MM/DD/YYYY date format
  * @param {String} time In 24 hours format hh/mm
 */
  static async selectDateAndTime(locator: string, date: string, time: string) {
    try {
      const dateObj = new Date(Date.parse(date));
      const month: string = dateObj.toLocaleString(`default`, { month: `long` }); // months from 1-12
      const day: number = dateObj.getDate();
      const year: number = dateObj.getFullYear();

      await CommonKeyword.scrollIntoView(locator, { behavior: `auto`, block: `center`, inline: `center` });
      await CommonKeyword.clickElement(locator);
      await selectYear(year);
      await selectMonth(month.toString());
      await selectDay(day);

      await selectTime(time);
      await CommonKeyword.pressKey(`Escape`);
      await DewLoader.waitForSpinner();
      await verifyDateTime(locator, date, time);
    } catch (err) {
      await I.say(`Kindly check the ${date}, ${time} is not disabled and it is a valid date and time`, `cyan`);
      logger.info(`Issue while performing operation in DDCC: unable to select date time ` + locator);
      throw err;
    }
  }
}

/**
 * Select Year from calender
 *
 * @param {string} year
 */
async function selectYear(year: number) {
  try {
    await CommonKeyword.scrollIntoView(`//div[contains(@class,'d-picker-header')]//button[contains(@aria-label,'previousMonth')]`, { behavior: `auto`, block: `center`, inline: `center` });
    await CommonKeyword.clickElement(`//div[contains(@class,'d-picker-header')]//div[@class[normalize-space()='text-center pointer']]`);
    await CommonKeyword.clickElement(`//div[contains(@class,'d-picker-header')]//div[@class[normalize-space()='text-center pointer']]`);
    await CommonKeyword.clickElement(`//div[contains(@class,'cdk-overlay-pane')]//span[contains(@class, 'd-picker-body')]//button[text()[normalize-space()='${year}']]`);
    await DewElement.verifyIfISeeText(year.toString());
  } catch (err) {
    throw err;
  }
}

/**
 * Select Month from calender
 *
 * @param {string} month
 */
async function selectMonth(month: string) {
  try {
    let monthTobeSelected = null;
    let monthTobeViewed!: string;

    if (month == `January`) {
      monthTobeSelected = `Jan`;
      monthTobeViewed = `JAN`;
    }
    if (month == `February`) {
      monthTobeSelected = `Feb`;
      monthTobeViewed = `FEB`;
    }
    if (month == `March`) {
      monthTobeSelected = `Mar`;
      monthTobeViewed = `MAR`;
    }
    if (month == `April`) {
      monthTobeSelected = `Apr`;
      monthTobeViewed = `APR`;
    }
    if (month == `May`) {
      monthTobeSelected = `May`;
      monthTobeViewed = `MAY`;
    }
    if (month == `June`) {
      monthTobeSelected = `Jun`;
      monthTobeViewed = `JUN`;
    }
    if (month == `July`) {
      monthTobeSelected = `Jul`;
      monthTobeViewed = `JUL`;
    }
    if (month == `August`) {
      monthTobeSelected = `Aug`;
      monthTobeViewed = `AUG`;
    }
    if (month == `September`) {
      monthTobeSelected = `Sep`;
      monthTobeViewed = `SEP`;
    }
    if (month == `October`) {
      monthTobeSelected = `Oct`;
      monthTobeViewed = `OCT`;
    }
    if (month == `November`) {
      monthTobeSelected = `Nov`;
      monthTobeViewed = `NOV`;
    }
    if (month == `December`) {
      monthTobeSelected = `Dec`;
      monthTobeViewed = `DEC`;
    }

    await CommonKeyword.clickElement(`.//span[contains(@class,'d-picker-body')]//button[text()[normalize-space()='${monthTobeSelected}']] | .//span[contains(@class,'d-picker-body')]//button[text()[normalize-space()='${month}']]`);
    await DewElement.verifyIfISeeText(monthTobeViewed);
  } catch (err) {
    throw err;
  }
}

/**
 * Select Day from calender
 *
 * @param {string} day
 */
async function selectDay(day: number) {
  try {
    await DewElement.verifyIfISeeElement(`.d-picker-header`);
    // await CommonKeyword.clickElement(`(.//span[contains(@class, 'd-picker-body')]//button[not(@disabled)]/div[text()='${day}'])`);

    const numberofdaypresent = await DewElement.grabNumberOfVisibleElements(`(//button/div[text()='${day}'])`);
    // await Wait.waitForDefaultTimeout(5);
    /*  const numberofInRangeDay = await DewElement.grabNumberOfVisibleElements(`(//button[not(@disabled)]/div[contains(@class,'inRange') and text()='${day}'])`);
       await Wait.waitForDefaultTimeout(2); */

    if (day <= 20 || await Number(numberofdaypresent) == 1) {
      const isElementDisabled = await DewElement.grabAttributeFrom(`(//div[text()='${day}']/parent::button)[1]`, `disabled`);
      logger.info(`Element disabled: ${isElementDisabled}`);
      if (Boolean(isElementDisabled) != true || isElementDisabled.toString() != `true`) {
        await CommonKeyword.clickElement(`(//button/div[text()='${day}'])[1]`, `//div[contains(@class,'d-picker')]`);
      } else {
        // await I.say(`Kindly check the ${day} day is not disabled and it is a valid day`, `cyan`);
        await I.say(`The Disabled attribute for the day ${day} is true. Element disabled: ${isElementDisabled}`, `cyan`);
        throw new Error(`The Disabled attribute for the day ${day} is true.`);
      }
    } else {
      const isElementDisabled = await DewElement.grabAttributeFrom(`(//div[text()='${day}']/parent::button)[2]`, `disabled`);
      logger.info(`Element disbaled: ${isElementDisabled}`);
      if (Boolean(isElementDisabled) != true || isElementDisabled.toString() != `true`) {
        await CommonKeyword.clickElement(`(//button/div[text()='${day}'])[2]`, `//div[contains(@class,'d-picker')]`);
      } else {
        // await I.say(`Kindly check the ${day} day is not disabled and it is a valid day`, `cyan`);
        await I.say(`The Disabled attribute for the day ${day} is true. Element disabled: ${isElementDisabled}`, `cyan`);
        throw new Error(`The Disabled attribute for the day ${day} is true.`);
      }
    }

    if (await DewElement.checkIfElementVisible(`//button[contains(@class,'calendarDoneBtn')] | //button[text()[normalize-space()='${await lmt.getLabel(`Done`)}']]`)) {
      await CommonKeyword.clickElement(`//button[contains(@class,'calendarDoneBtn')] | //button[text()[normalize-space()='${await lmt.getLabel(`Done`)}']]`);
    } else {
      await CommonKeyword.pressKey(`Escape`);
    }
    /*  await CommonKeyword.clickElement(`//button[text()[normalize-space()='${await lmt.getLabel(`Done`)}']]`);
       await Wait.waitForDefaultTimeout(2); */
  } catch (err) {
    await I.say(`Kindly check the ${day} day is not disabled and it is a valid day`, `cyan`);
    throw err;
  }
}

/**
 * Select Time from calender
 *
 * @param {string} time
 */
async function selectTime(time: string) {
  try {
    await CommonKeyword.clickElement(`//div[text()='Clock Hour']/following-sibling::dew-select[//div[contains(@class,'date-time-picker')]//div[@class='dropdown']]`);
    await CommonKeyword.clickElement(`//div[@title='24 hrs']`);

    const hour = time.split(`:`)[0];
    const minute = time.split(`:`)[1];

    await CommonKeyword.clickElement(`//dew-timepicker//input[@formcontrolname='hour']`);
    // z.scrollIntoView("//div[contains(@class,'dropdown-menu show')]//a[contains(text(),'"+hour+"')]")
    await CommonKeyword.clickElement(`//div[contains(@class,'dropdown-menu show')]//a[contains(text(),'${hour}')]`);

    await CommonKeyword.clickElement(`//dew-timepicker//input[@formcontrolname='minute']`);
    // z.scrollIntoView("//div[contains(@class,'dropdown-menu show')]//a[contains(text(),'"+minute+"')]")
    await CommonKeyword.clickElement(`//div[contains(@class,'dropdown-menu show')]//a[contains(text(),'${minute}')]`);
  } catch (err) {
    throw err;
  }
}

/**
 * The Function is used to verify date and time passed in parameter is matching with actual date and time selected.
 * @param {String} locator located by CSS|XPath|strict locator.
 * @param {String} date In MM/DD/YYYY date format
 * @param {String} time In 24 hours format hh/mm
 */
async function verifyDateTime(locator: string, date: string, time?: string) {
  await DewLoader.waitForSpinner();
  const grabbedDateTime = (await DewElement.grabValueFrom(locator)).toString();
  const grabbedDate = await grabbedDateTime.split(` `)[0];

  // parses the grabbed date in MM/DD/YYYY format
  const grabbedDateObj = new Date(Date.parse(grabbedDate));
  const grabbedDay = String(grabbedDateObj.getDate()).padStart(2, `0`);
  const grabbedMonth = String(grabbedDateObj.getMonth() + 1).padStart(2, `0`); // January is 0!
  const grabbedYear = grabbedDateObj.getFullYear();
  const parsedGrabbedDate = `${grabbedMonth}/${grabbedDay}/${grabbedYear}`;

  // Parses the date passed in parameter in MM/DD/YYYY Format
  const dateObj = new Date(Date.parse(date));
  const day = String(dateObj.getDate()).padStart(2, `0`);
  const month = String(dateObj.getMonth() + 1).padStart(2, `0`); // January is 0!
  const year = dateObj.getFullYear();
  const parsedEnteredDate = `${month}/${day}/${year}`;

  if (await grabbedDate == date || parsedGrabbedDate == parsedEnteredDate) {
    logger.info(`Date passed in parameter ${date} matched with grabbed date ${grabbedDate}`);
    await I.say(`Date passed in parameter ${date} matched with grabbed date ${grabbedDate}`, `cyan`);
    if (time !== undefined) {
      const grabbedTime = await grabbedDateTime.split(` `)[1];
      if (await grabbedTime == time) {
        await I.say(`Time passed in parameter is ${time} matched with grabbed time ${grabbedTime}`, `cyan`);
      } else {
        await I.say(`Time passed in parameter is ${time} not matched with grabbed time ${grabbedTime}`, `cyan`);
      }
    }
  } else {
    await I.say(`Date passed in parameter ${date} not matched with grabbed date ${grabbedDate}`, `cyan`);
  }
}