const { I } = inject();

import { logger } from "../Logger/logger";
import { Wait } from "./dewWait";
import { z } from "./z";

/**
 * Sort column class
 */
export class Tab {
  /**
     * Switch to tab specified by the tabIndex number
     *
     * ```js
     * Tab.switchToTab(2)
     *```
     *
     * @param {number} tabIndex Tab index to switchto
     */
  static async switchToTab(tabIndex: number) {
    try {
      logger.info(`Current tab:`, await z.grabTitle());
      logger.info(`Switching to tab with index:`, tabIndex);
      await z.switchToNextTab(tabIndex);
      logger.info(`Switched to tab:`, await z.grabTitle());
    } catch (error) {
      logger.log(`Issue while performing operation in DDCC: Error while swiching to tab`);
      throw error;
    }
  }

  /**
   * Method id used to open a new tab
   */
  static async openNewTab() {
    await z.openNewTab();
  }

  /**
   * Method is used to switch to next tab
   */
  static async switchToNextTab() {
    await z.switchToNextTab();
  }

  /**
     * Close the current active tab
     *
     * ```js
     * Tab.closeCurrentTab();
     *```
     */
  static async closeCurrentTab() {
    try {
      logger.info(`Current tab:`, await z.grabTitle());
      await z.closeCurrentTab();
      logger.info(`Closed tab:`);
    } catch (error) {
      logger.log(`Issue while performing operation in DDCC: Error while closing current tab`);
      throw error;
    }
  }

  /**
     * Close All inactive tab
     *
     * ```js
     * Tab.closeCurrentTab();
     *```
     */
  static async closeInactiveTab() {
    try {
      logger.info(`Current tab:`, await z.grabTitle());
      z.closeOtherTabs();
      logger.info(`Closed All inactive tab:`);
    } catch (error) {
      logger.log(`Issue while performing operation in DDCC: Error while closing inactive tab`);
      throw error;
    }
  }

  /**
    * Switch to main tab
    *
    * ```js
    * Tab.switchToMainTab()
    *```
    *
    */
  static async switchToMainTab() {
    try {
      logger.info(` Current tab:`, await z.grabTitle());

      const numberofOpenTabs = await z.grabNumberOfOpenTabs();
      logger.info(`Number of open tabs:`, numberofOpenTabs);
      let i = 0;
      for (i = 1; i < numberofOpenTabs; i++) {
        try {
          await z.switchToPreviousTab();
        } catch (err) {
          logger.info(`Already on main Tab`);
          break;
        }
      }

      logger.info(`Switched to Main Tab:`, await z.grabTitle());
    } catch (error) {
      logger.log(`Issue while performing operation in DDCC: Error while switching to main tab`);
      throw error;
    }
  }

  /**
     * Switch to specific tab from main tab
     *
     * ```js
     * Tab.switchFromMainTabUsingTitle("Google")
     *```
     * @param{String} tabTitle
     *
     */
  static async switchFromMainTabUsingTitle(tabTitle: string) {
    try {
      logger.info(`Current tab:`, await z.grabTitle());
      /*  await this.switchToMainTab();
         z.wait(5); */
      await Wait.waitForDefaultTimeout(3);
      const numberofOpenTabs = await z.grabNumberOfOpenTabs();
      logger.info(`Number of open tabs:`, numberofOpenTabs);
      let i = 0;
      for (i = 1; i < numberofOpenTabs; i++) {
        const currentTabTitle = await z.grabTitle();
        if (currentTabTitle == tabTitle) {
          logger.info(`Switched To Required Tab :`, currentTabTitle);
          break;
        } else if (i == numberofOpenTabs) {
          logger.info(`No Such Tab Present`);
        } else {
          z.switchToNextTab();
        }
      }
    } catch (error) {
      logger.log(`Issue while performing operation in DDCC: Error while switching tab using title`);
      throw error;
    }
  }

  /**
     * Grab number of open tabs. Returns Promise <number > number of open tabs
     *
     * ```js
     * Tab.grabNumberOfOpenTabs();
     *```
     */
  static async grabNumberOfOpenTabs() {
    try {
      const tabs = await z.grabNumberOfOpenTabs();
      return tabs;
    } catch (error) {
      logger.log(`Issue while performing operation in DDCC: Error while grabbing open tabs`);
      throw error;
    }
  }

  // /**
  //  * Switch to main tab
  //  *
  //  * ```js
  //  * Tab.switchToMainTab(2)
  //  *```
  //  *
  //  */

  // async switchFromSubTabUsingTitle(tabTitle) {

  /*     logger.info("Issue while performing operation in DDCC: Current tab:", await z.grabTitle());
         await this.switchToMainTab();
         z.wait(5);
         let numberofOpenTabs = await z.grabNumberOfOpenTabs();
         logger.info("Issue while performing operation in DDCC: Number of open tabs:", numberofOpenTabs);
         let i;
         for (i =1; i < numberofOpenTabs; i++) { */

  /*         let currentTabTitle = await z.grabTitle();
             if (currentTabTitle == tabTitle) {
                 logger.info("Issue while performing operation in DDCC: Switched To Required Tab :", currentTabTitle);
                 break;
             }else if (i == numberofOpenTabs) {
                 logger.info("Issue while performing operation in DDCC: No Such Tab Present");
             } else {
                 z.switchToNextTab();
             }
         }
     } */
}