"""Controller for Asus AXE11000 access point."""

import time
from acts import logger
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import Select

MOBLY_CONTROLLER_CONFIG_NAME = "AsusAXE11000AP"
ACTS_CONTROLLER_REFERENCE_NAME = "access_points"

# Access point UI parameters
USERNAME = "login_username"
PASSWORD = "login_passwd"
SIGN_IN_ID = "button"
APPLY_BUTTON = "apply_btn"
APPLY_BUTTON_ID = "applyButton"
WIRELESS_SETTINGS = "Advanced_Wireless_Content_menu"
GENERAL_TAB = "Advanced_Wireless_Content_tab"
PROFESSIONAL_TAB = "Advanced_WAdvanced_Content_tab"
HE_MODE_ID = "he_mode_field"
WL_UNIT = "wl_unit"
WL_11AX = "wl_11ax"
WL_RADIO = "wl_radio"
WL_CLOSED = "wl_closed"
RADIO = "radio"
BAND_2G_CHANNEL = "band0_channel"
BAND_5G_CHANNEL = "band1_channel"
BAND_6G_CHANNEL = "band2_channel"
BAND_2G_AUTH = "band0_auth_mode_x"
BAND_5G_AUTH = "band1_auth_mode_x"
BAND_6G_AUTH = "band2_auth_mode_x"
BAND_2G_SSID = "band0_ssid"
BAND_5G_SSID = "band1_ssid"
BAND_6G_SSID = "band2_ssid"
BAND_2G_PSK = "band0_wpa_psk"
BAND_5G_PSK = "band1_wpa_psk"
BAND_6G_PSK = "band2_wpa_psk"
BAND_2G_RAD_IP = "band0_radius_ipaddr"
BAND_5G_RAD_IP = "band1_radius_ipaddr"
BAND_2G_RAD_PORT = "band0_radius_port"
BAND_5G_RAD_PORT = "band1_radius_port"
BAND_2G_RAD_KEY = "band0_radius_key"
BAND_5G_RAD_KEY = "band1_radius_key"
SMART_CONNECT = "smartcon_enable_field"
BROWSER_WAIT_SHORT_TIMEOUT = 6
BROWSER_WAIT_TIMEOUT = 15
BROWSER_WAIT_LONG_TIMEOUT = 90
BROWSER_WAIT_VERY_LONG_TIMEOUT = 180

# Access point supported modes, channels
VALID_BANDS = ["2g", "5g", "6g"]
WL_BAND_VALUE = {"2g": "0", "5g": "1", "6g": "2"}
CHANNELS_2G = {
    0: "0",
    1: "1",
    2: "2",
    3: "3",
    4: "4",
    5: "5",
    6: "6",
    7: "7",
    8: "8",
    9: "9",
    10: "10",
    11: "11"
}
CHANNELS_5G = {
    0: "0",
    36: "36/160",
    40: "40/160",
    44: "44/160",
    48: "48/160",
    52: "52/160",
    56: "56/160",
    60: "60/160",
    64: "64/160",
    100: "100/160",
    104: "104/160",
    108: "108/160",
    112: "112/160",
    116: "116/160",
    120: "120/160",
    124: "124/160",
    128: "128/160",
    132: "132/80",
    136: "136/80",
    140: "140/80",
    144: "144/80",
    149: "149/80",
    153: "153/80",
    157: "157/80",
    161: "161/80",
    165: "165"
}
CHANNELS_6G = {
    0: "0",
    37: "6g37/160",
    53: "6g53/160",
    69: "6g69/160",
    85: "6g85/160",
    101: "6g101/160",
    117: "6g117/160",
    133: "6g133/160",
    149: "6g149/160",
    165: "6g165/160",
    181: "6g181/160",
    197: "6g197/160",
    213: "6g213/160"
}


def create(configs):
  """Creates ap controllers from a json config."""
  return [AsusAXE11000AP(c) for c in configs]


def destroy(aps):
  """Destroys a list of ap controllers."""
  for ap in aps:
    ap.reset_to_default_ap_settings()
    ap.driver.quit()


class AsusAXE11000AP(object):
  """Asus AXE11000 AccessPoint controller.

  Controller class for Asus AXE11000 6GHz AP. This class provides methods to
  configure the AP with different settings required for 11ax and 6GHz testing.
  The controller uses chrome webdriver to communicate with the AP.

  The controller object is initiated in the test class. The ACTS test runner
  calls this controller using the 'AsusAXE11000AP' keyword in the ACTS config
  file. The AP is reset to default settings and this is handled during the
  test teardown.

  Attributes:
    ip: IP address to reach the AP.
    port: Port numnber to reach the AP.
    protocol: Protcol to reach the AP (http/https).
    username: Username to login to the AP.
    password: Password to login to the AP.
    config_page: web url to login to the AP.
    ap_settings: AP settings configured at any given point.
    default_ap_settings: Default AP settings before running the tests.
    driver: chrome webdriver object to update the settings.
  """

  def __init__(self, config):
    """Initialize AP.

    Creates a chrome webdriver object based on the router parameters.
    The webdriver will login to the router and goes to the wireless settings
    page. This object will be used to change the router settings required for
    the test cases. Required parameters are <ip_address>, <port>, <protocol>,
    <admin_username> and <admin_password>.

    Url: <procotol>://<ip_address>:<port>/Main_Login.asp
    Login: <admin_username>/<admin_password>

    Args:
      config: dict, dictionary of router parameters required for webdriver.
    """
    self.ip = config["ip_address"]
    self.port = config["port"]
    self.protocol = config["protocol"]
    self.username = config["admin_username"]
    self.password = config["admin_password"]
    lambda_msg = lambda msg: "[AsusAXE11000AP|%s] %s" % (self.ip, msg)
    self.log = logger.create_logger(lambda_msg)
    self.ap_settings = {"2g": {}, "5g": {}, "6g": {},}
    self.config_page = (
        "{protocol}://{ip_address}:{port}/Main_Login.asp").format(
            protocol=self.protocol, ip_address=self.ip, port=self.port)
    self.chrome_options = Options()
    self.chrome_options.add_argument("--headless")
    self.chrome_options.add_argument("--no-sandbox")
    self.driver = webdriver.Chrome(options=self.chrome_options)
    self.driver.implicitly_wait(BROWSER_WAIT_TIMEOUT*2)
    self.driver.get(self.config_page)
    self.driver.find_element_by_name(USERNAME).send_keys(self.username)
    self.driver.find_element_by_name(PASSWORD).send_keys(self.password)
    self.driver.find_element_by_id(SIGN_IN_ID).click()
    self._wait_for_web_element(self.driver.find_element_by_id,
                               WIRELESS_SETTINGS)
    self.driver.find_element_by_id(WIRELESS_SETTINGS).click()
    self._wait_for_web_element(self.driver.find_element_by_id, SMART_CONNECT)
    self._update_ap_settings()
    self.default_ap_settings = self.ap_settings.copy()

  ### Helper methods ###

  def _wait_for_web_element(self,
                            find_element,
                            element,
                            attribute=None,
                            value=None):
    """Verifies click actions/selections work.

    Args:
      find_element: func(), webdriver method to call
      element: str, web element to look for. Ex: id, class, name
      attribute: str, attribute to get from a webelement
      value: str, verify attribute is set to the correct value

    Raises:
      ValueError: An error occurred if expected attribute not found.
    """
    curr_time = time.time()
    while time.time() < curr_time + BROWSER_WAIT_TIMEOUT*4:
      time.sleep(2)
      try:
        x = find_element(element)
        if attribute and str(value) not in x.get_attribute(attribute):
          raise ValueError("Attribute is not set to the right value")
        return
      except NoSuchElementException:
        pass
    raise ValueError("Failed to find web element: %s" % element)

  def _update_ap_settings_2g_band(self):
    """Read settings configured on 2g band.

    Parameters Updated:
      security type: open, wpa2-psk, wpa3-sae or wpa2-ent.
      ssid: SSID of the wifi network.
      password: password of the wifi network (if psk or sae network).
      radius server ip: Radius server IP addr (if ent network).
      radius server port: Radius server Port number (if ent network).
      radius server secret: Radius server secret (if ent network).
      channel: 2G band channel.
    """
    dict_2g = {}
    dict_2g["security"] = self.driver.find_element_by_name(
        BAND_2G_AUTH).get_attribute("value")
    dict_2g["SSID"] = self.driver.find_element_by_name(
        BAND_2G_SSID).get_attribute("value")
    if dict_2g["security"] == "psk2" or dict_2g["security"] == "sae":
      dict_2g["password"] = self.driver.find_element_by_name(
          BAND_2G_PSK).get_attribute("value")
    elif dict_2g["security"] == "wpa2":
      dict_2g["radius_ip_addr"] = self.driver.find_element_by_name(
          BAND_2G_RAD_IP).get_attribute("value")
      dict_2g["radius_port"] = self.driver.find_element_by_name(
          BAND_2G_RAD_PORT).get_attribute("value")
      dict_2g["radius_secret"] = self.driver.find_element_by_name(
          BAND_2G_RAD_KEY).get_attribute("value")
    channel_field = self._get_webdriver_elements_for_channels("2g")
    ch_val = self.driver.find_element_by_name(channel_field).get_attribute(
        "value")
    channel = 0
    for key, val in CHANNELS_2G.items():
      if val == ch_val:
        channel = key
        break
    self.ap_settings["2g"] = dict_2g.copy()
    self.ap_settings["2g"]["channel"] = channel

  def _update_ap_settings_5g_band(self):
    """Read settings configured on 5g band.

    Parameters Updated:
      security type: open, wpa2-psk, wpa3-sae or wpa2-ent.
      ssid: SSID of the wifi network.
      password: password of the wifi network (if psk or sae network).
      radius server ip: Radius server IP addr (if ent network).
      radius server port: Radius server Port number (if ent network).
      radius server secret: Radius server secret (if ent network).
      channel: 5G band channel.
    """
    dict_5g = {}
    dict_5g["security"] = self.driver.find_element_by_name(
        BAND_5G_AUTH).get_attribute("value")
    dict_5g["SSID"] = self.driver.find_element_by_name(
        BAND_5G_SSID).get_attribute("value")
    if dict_5g["security"] == "psk2" or dict_5g["security"] == "sae":
      dict_5g["password"] = self.driver.find_element_by_name(
          BAND_5G_PSK).get_attribute("value")
    elif dict_5g["security"] == "wpa2":
      dict_5g["radius_ip_addr"] = self.driver.find_element_by_name(
          BAND_5G_RAD_IP).get_attribute("value")
      dict_5g["radius_port"] = self.driver.find_element_by_name(
          BAND_5G_RAD_PORT).get_attribute("value")
      dict_5g["radius_secret"] = self.driver.find_element_by_name(
          BAND_5G_RAD_KEY).get_attribute("value")
    channel_field = self._get_webdriver_elements_for_channels("5g")
    ch_val = self.driver.find_element_by_name(channel_field).get_attribute(
        "value")
    channel = 0
    for key, val in CHANNELS_5G.items():
      if val == ch_val:
        channel = key
        break
    self.ap_settings["5g"] = dict_5g.copy()
    self.ap_settings["5g"]["channel"] = channel

  def _update_ap_settings_6g_band(self):
    """Read settings configured on 6g band.

    Parameters Updated:
      security type: wpa3-owe, wpa3-sae.
      ssid: SSID of the wifi network.
      password: password of the wifi network (if sae network).
      channel: 6G band channel.
    """
    dict_6g = {}
    dict_6g["security"] = self.driver.find_element_by_name(
        BAND_6G_AUTH).get_attribute("value")
    dict_6g["SSID"] = self.driver.find_element_by_name(
        BAND_6G_SSID).get_attribute("value")
    if dict_6g["security"] == "sae":
      dict_6g["password"] = self.driver.find_element_by_name(
          BAND_6G_PSK).get_attribute("value")
    channel_field = self._get_webdriver_elements_for_channels("6g")
    ch_val = self.driver.find_element_by_name(channel_field).get_attribute(
        "value")
    channel = 0
    for key, val in CHANNELS_6G.items():
      if val == ch_val:
        channel = key
        break
    self.ap_settings["6g"] = dict_6g.copy()
    self.ap_settings["6g"]["channel"] = channel

  def _update_ap_settings(self):
    """Read AP settings of 2G, 5G and 6G bands.

    This method reads the wifi network currently configured on any particular
    band. The settings are updated to self.ap_settings object.
    """
    self.driver.refresh()
    self._update_ap_settings_2g_band()
    self._update_ap_settings_5g_band()
    self._update_ap_settings_6g_band()

  def _get_webdriver_elements_for_channels(self, band):
    """Return webdriver elements for the band to configure channel.

    Args:
      band: str, Wifi band to configure. Ex: 2g, 5g, 6g.

    Returns:
      channel field for the specific band.
    """
    channel_field = BAND_2G_CHANNEL
    if band == "5g":
      channel_field = BAND_5G_CHANNEL
    elif band == "6g":
      channel_field = BAND_6G_CHANNEL
    return channel_field

  def _set_channel(self, band, channel):
    """Configure channel on a specific band.

    Args:
      band: str, Wifi band to check. Ex: 2g, 5g, 6g.
      channel: int, Channel to set.

    Raises:
      ValueError: An error occurred due to invalid band or configuration.
    """
    band = band.lower()
    if band not in VALID_BANDS:
      raise ValueError("Band %s is not valid" % band)
    if (band == "2g" and channel not in CHANNELS_2G) or (
        band == "5g" and
        channel not in CHANNELS_5G) or (band == "6g" and
                                        channel not in CHANNELS_6G):
      raise ValueError("Channel %s is not supported in band %s" %
                       (channel, band))
    channel_field = self._get_webdriver_elements_for_channels(band)
    channels_val_dict = CHANNELS_6G
    if band == "2g":
      channels_val_dict = CHANNELS_2G
    elif band == "5g":
      channels_val_dict = CHANNELS_5G
    channel = channels_val_dict[channel]

    # Set channel
    if self.driver.find_element_by_name(channel_field).get_attribute(
        "value") != channel:
      css_selector = "select[name=%s]" % channel_field
      Select(self.driver.find_element_by_css_selector(
          css_selector)).select_by_value(channel)
      time.sleep(BROWSER_WAIT_SHORT_TIMEOUT)

  def _configure_personal_network(self, band, auth, ssid=None, password=None):
    """Configure wpa3 sae/wpa2 psk network on a specific band.

    Args:
      band: str, Wifi band to check. Ex: 2g, 5g, 6g.
      auth: str, WPA2 PSK or WPA3 SAE security.
      ssid: str, ssid of the wifi network.
      password: str, password of the wifi network.

    Raises:
      ValueError: An error occurred due to invalid band or configuration.
    """
    band = band.lower()
    if band not in VALID_BANDS:
      raise ValueError("Band %s is not valid" % band)
    if band == "6g" and auth == "psk2":
      raise ValueError("AP doesn't support WPA2 PSK on 6g band.")
    (auth_field, ssid_field,
     psk_field) = self._get_webdriver_elements_for_personal_auth(band)

    # configure personal network
    css_selector = "select[name=%s]" % auth_field
    Select(self.driver.find_element_by_css_selector(
        css_selector)).select_by_value(auth)
    time.sleep(BROWSER_WAIT_SHORT_TIMEOUT)
    if ssid:
      self.driver.find_element_by_name(ssid_field).clear()
      self.driver.find_element_by_name(ssid_field).send_keys(ssid)
    if password:
      self.driver.find_element_by_name(psk_field).clear()
      self.driver.find_element_by_name(psk_field).send_keys(password)

  def _configure_open_owe_network(self, band, auth, ssid=None):
    """Configure wpa3 owe/open network on a specific band.

    Args:
      band: str, Wifi band to check. Ex: 2g, 5g, 6g.
      auth: str, WPA2 PSK or WPA3 SAE security.
      ssid: str, ssid of the wifi network.

    Raises:
      ValueError: An error occurred due to invalid band or configuration.
    """
    band = band.lower()
    if band not in VALID_BANDS:
      raise ValueError("Band %s is not valid" % band)
    if band == "6g" and auth == "open":
      raise ValueError("AP doesn't support open network on 6g band.")
    if (band == "2g" or band == "5g") and auth == "owe":
      raise ValueError("AP doesn't support OWE on 2g and 5g bands.")
    (auth_field, ssid_field,
     _) = self._get_webdriver_elements_for_personal_auth(band)

    # Configure wifi network
    css_selector = "select[name=%s]" % auth_field
    Select(self.driver.find_element_by_css_selector(
        css_selector)).select_by_value(auth)
    time.sleep(BROWSER_WAIT_SHORT_TIMEOUT)
    if ssid:
      self.driver.find_element_by_name(ssid_field).clear()
      self.driver.find_element_by_name(ssid_field).send_keys(ssid)

  def _configure_wpa2_ent_network(self, band, radius_ip, radius_port,
                                  radius_secret, ssid=None):
    """Configure wpa2 ent network on a specific band.

    Args:
      band: str, Wifi band to check. Ex: 2g, 5g.
      radius_ip: str, radius server ip addr.
      radius_port: str, radius server port number.
      radius_secret: str, radius server secret.
      ssid: str, ssid of the wifi network.

    Raises:
      ValueError: An error occurred due to invalid band or configuration.
    """
    band = band.lower()
    if band not in VALID_BANDS:
      raise ValueError("Band %s is not valid" % band)
    if band == "6g":
      raise ValueError("6GHz doesn't support enterprise network on this AP.")
    (auth_field, ssid_field,
     _) = self._get_webdriver_elements_for_personal_auth(band)
    (rad_ip_field, rad_port_field,
     rad_key_field) = self._get_webdriver_elements_for_ent_auth(band)

    # Set enterprise network
    css_selector = "select[name=%s]" % auth_field
    Select(self.driver.find_element_by_css_selector(
        css_selector)).select_by_value("wpa2")
    time.sleep(BROWSER_WAIT_SHORT_TIMEOUT)
    if ssid:
      self.driver.find_element_by_name(ssid_field).clear()
      self.driver.find_element_by_name(ssid_field).send_keys(ssid)
    self.driver.find_element_by_name(rad_ip_field).clear()
    self.driver.find_element_by_name(rad_ip_field).send_keys(radius_ip)
    self.driver.find_element_by_name(rad_port_field).clear()
    self.driver.find_element_by_name(rad_port_field).send_keys(radius_port)
    self.driver.find_element_by_name(rad_key_field).clear()
    self.driver.find_element_by_name(rad_key_field).send_keys(radius_secret)

  def _get_webdriver_elements_for_personal_auth(self, band):
    """Return webdriver elements for the band to configure personal auth.

    Args:
      band: str, Wifi band to configure. Ex: 2g, 5g, 6g.

    Returns:
      tuple of auth, ssid, psk field for the band.
    """
    auth_field = BAND_2G_AUTH
    ssid_field = BAND_2G_SSID
    psk_field = BAND_2G_PSK
    if band == "5g":
      auth_field = BAND_5G_AUTH
      ssid_field = BAND_5G_SSID
      psk_field = BAND_5G_PSK
    elif band == "6g":
      auth_field = BAND_6G_AUTH
      ssid_field = BAND_6G_SSID
      psk_field = BAND_6G_PSK
    return (auth_field, ssid_field, psk_field)

  def _get_webdriver_elements_for_ent_auth(self, band):
    """Return webdriver elements for the band to configure ent auth.

    Args:
      band: str, Wifi band to configure. Ex: 2g, 5g, 6g.

    Returns:
      tuple of radius server IP, port, secret for the band.
    """
    rad_ip_field = BAND_2G_RAD_IP
    rad_port_field = BAND_2G_RAD_PORT
    rad_key_field = BAND_2G_RAD_KEY
    if band == "5g":
      rad_ip_field = BAND_5G_RAD_IP
      rad_port_field = BAND_5G_RAD_PORT
      rad_key_field = BAND_5G_RAD_KEY
    return (rad_ip_field, rad_port_field, rad_key_field)

  ### Methods to configure AP ###

  def set_channel_and_apply(self, band, channel):
    """Set channel for specific band.

    Args:
      band: str, Wifi band to check. Ex: 2g, 5g, 6g.
      channel: int, Channel to set.
    """
    # Go back to General tab in advanced settings
    self.driver.find_element_by_id(GENERAL_TAB).click()
    self._wait_for_web_element(self.driver.find_element_by_id, SMART_CONNECT)

    channel_field = self._get_webdriver_elements_for_channels(band)
    self._set_channel(band, channel)
    self.driver.find_element_by_id(APPLY_BUTTON_ID).click()
    time.sleep(BROWSER_WAIT_LONG_TIMEOUT)
    self._wait_for_web_element(self.driver.find_element_by_name,
                               channel_field, "value", channel)
    self._update_ap_settings()

  def get_configured_channel(self, band):
    """Get the channel configured on specific band.

    Args:
      band: str, Wifi band to check. Ex: eg, 5g, 6g.

    Returns:
      Channel configured on the band.

    Raises:
      ValueError: An error occurred due to invalid band.
    """
    band = band.lower()
    if band not in VALID_BANDS:
      raise ValueError("Band %s is not valid" % band)
    return self.ap_settings[band]["channel"]

  def configure_ap(self, network_dict):
    """Configure AP with settings for different bands.

    Args:
      network_dict: dict, dictionary that holds configuration for each band.
    """
    # Go back to General tab in advanced settings
    self.driver.refresh()
    self.driver.find_element_by_id(GENERAL_TAB).click()
    self._wait_for_web_element(self.driver.find_element_by_id, SMART_CONNECT)

    # configure wireless settings
    self.log.info("Network dictionary: %s" % network_dict)
    for band in network_dict:
      security = network_dict[band]["security"]
      ssid = network_dict[band]["SSID"] if "SSID" in network_dict[
          band] else None
      password = network_dict[band]["password"] if "password" in network_dict[
          band] else None
      if security == "open" or security == "owe":
        self._configure_open_owe_network(band, security, ssid)
      elif security == "psk2" or security == "sae":
        self._configure_personal_network(band, security, ssid, password)
      elif network_dict[band]["security"] == "wpa2":
        self._configure_wpa2_ent_network(
            band,
            network_dict[band]["radius_server_ip"],
            network_dict[band]["radius_server_port"],
            network_dict[band]["radius_server_secret"],
            ssid)

    for band in network_dict:
      if "channel" in network_dict[band]:
        self._set_channel(band, network_dict[band]["channel"])
    self.driver.find_element_by_id(APPLY_BUTTON_ID).click()
    time.sleep(BROWSER_WAIT_LONG_TIMEOUT)

    # update ap settings
    self._update_ap_settings()

    # configure hidden or 11ax mode
    for band in network_dict:
      apply_settings = False
      if "hidden" in network_dict[band]:
        res = self._configure_hidden_network(band, network_dict[band]["hidden"])
        apply_settings = apply_settings or res
      if "11ax" in network_dict[band]:
        res = self._configure_11ax_mode(band, network_dict[band]["11ax"])
        apply_settings = apply_settings or res
      if apply_settings:
        self.driver.find_element_by_id(APPLY_BUTTON).click()
        time.sleep(BROWSER_WAIT_VERY_LONG_TIMEOUT)

  def get_wifi_network(self, band):
    """Get wifi network configured on the AP for the specific band.

    Args:
      band: str, Wifi band to check. Ex: 2g, 5g, 6g.

    Returns:
      Wifi network as a dictionary.

    Raises:
      ValueError: An error occurred due to invalid band.
    """
    band = band.lower()
    if band not in VALID_BANDS:
      raise ValueError("Band %s is not valid" % band)
    wifi_network = {}
    wifi_network["SSID"] = self.ap_settings[band]["SSID"]
    if "password" in self.ap_settings[band]:
      wifi_network["password"] = self.ap_settings[band]["password"]
    security = self.ap_settings[band]["security"]
    if security == "sae" or security == "owe":
      wifi_network["security"] = security
    return wifi_network

  def _configure_hidden_network(self, band, val):
    """Configure hidden network for a specific band.

    Args:
      band: str, Wifi band to configure hidden network.
      val: str, String value to configure.

    Returns:
      True if settings applied, False if not.

    Raises:
      ValueError: An error occurred due to invalid band.
    """
    band = band.lower()
    if band not in VALID_BANDS:
      raise ValueError("Band %s is not valid" % band)

    # Go to Professional tab in advanced settings
    self.driver.find_element_by_id(PROFESSIONAL_TAB).click()
    self._wait_for_web_element(self.driver.find_element_by_id, HE_MODE_ID)

    # Select the requested band from the drop down menu
    css_selector = "select[name=%s]" % WL_UNIT
    Select(
        self.driver.find_element_by_css_selector(css_selector)).select_by_value(
            WL_BAND_VALUE[band])  # (TODO: gmoturu@) find if selection worked
    time.sleep(BROWSER_WAIT_SHORT_TIMEOUT)

    # Configure hidden network
    state = True if val == "1" else False
    return_result = False
    if self.driver.find_element_by_name(WL_CLOSED).is_selected() != state:
      css_selector = "input[name='%s'][value='%s']" % (WL_CLOSED, val)
      self.driver.find_element_by_css_selector(css_selector).click()
      time.sleep(BROWSER_WAIT_SHORT_TIMEOUT)
      return_result = True

    return return_result

  def configure_hidden_network_and_apply(self, band, state=True):
    """Configure hidden network for a specific band.

    Args:
      band: str, Wifi band to configure hidden network.
      state: bool, Set the wifi network as hidden if True, False if not.
    """
    val = "1" if state else "0"
    if self._configure_hidden_network(band, val):
      self.driver.find_element_by_id(APPLY_BUTTON).click()
      time.sleep(BROWSER_WAIT_VERY_LONG_TIMEOUT)
      if self.driver.find_element_by_name(WL_CLOSED).is_selected() != state:
        raise ValueError("Failed to configure hidden network on band: %s" % band)

      # Go back to General tab in advanced settings
      self.driver.find_element_by_id(GENERAL_TAB).click()
      self._wait_for_web_element(self.driver.find_element_by_id, SMART_CONNECT)

  def _configure_11ax_mode(self, band, val):
    """Configure 11ax mode on a specific band.

    Args:
      band: str, Wifi band to check. Ex: 2g, 5g, 6g.
      val: str, String value to configure.

    Returns:
      True if settings are applied, False if not.

    Raises:
      ValueError: An error occurred due to invalid band.
    """
    band = band.lower()
    if band not in VALID_BANDS:
      raise ValueError("Band %s is not valid" % band)

    # Go to Professional tab in advanced settings
    self.driver.find_element_by_id(PROFESSIONAL_TAB).click()
    self._wait_for_web_element(self.driver.find_element_by_id, HE_MODE_ID)

    # Select the requested band from the drop down menu
    css_selector = "select[name=%s]" % WL_UNIT
    Select(
        self.driver.find_element_by_css_selector(css_selector)).select_by_value(
            WL_BAND_VALUE[band])  # (TODO: gmoturu@) find if selection worked
    time.sleep(BROWSER_WAIT_SHORT_TIMEOUT)

    # Configure 11ax
    return_result = False
    if self.driver.find_element_by_name(WL_11AX).get_attribute(
        "value") != val:
      css_selector = "select[name=%s]" % WL_11AX
      Select(self.driver.find_element_by_css_selector(
          css_selector)).select_by_value(val)
      time.sleep(BROWSER_WAIT_SHORT_TIMEOUT)
      return_result = True

    return return_result

  def configure_11ax_mode_and_apply(self, band, state=True):
    """Configure 11ax mode on a specific band.

    Args:
      band: str, Wifi band to check. Ex: 2g, 5g, 6g.
      state: bool, Enable 11ax if True, disable if False
    """
    val = "1" if state else "0"
    if self._configure_11ax_mode(band, val):
      self.driver.find_element_by_id(APPLY_BUTTON).click()
      time.sleep(BROWSER_WAIT_VERY_LONG_TIMEOUT)
      self._wait_for_web_element(self.driver.find_element_by_name, WL_11AX,
                                 "value", val)

      # Go back to General tab in advanced settings
      self.driver.find_element_by_id(GENERAL_TAB).click()
      self._wait_for_web_element(self.driver.find_element_by_id, SMART_CONNECT)

  def reset_to_default_ap_settings(self):
    """Reset AP to the default settings."""
    if self.default_ap_settings != self.ap_settings:
      self.configure_ap(self.default_ap_settings)