def check_logged_out():
    if browser.browser() is not None:
        browser.quit()
        browser.ensure_browser_open()
        login.logout()
    yield
    if browser.browser() is not None:
        browser.quit()
        browser.ensure_browser_open()
        login.logout()

def generated_request(provider, provider_data, provisioning, template_name, vm_name):
    """Creates a provision request, that is not automatically approved, and returns the search data.

    After finishing the test, request should be automatically deleted.

    Slightly modified code from :py:module:`cfme.tests.infrastructure.test_provisioning`
    """
    first_name = fauxfactory.gen_alphanumeric()
    last_name = fauxfactory.gen_alphanumeric()
    notes = fauxfactory.gen_alphanumeric()
    e_mail = "{}@{}.test".format(first_name, last_name)
    host, datastore = map(provisioning.get, ('host', 'datastore'))
    pytest.sel.force_navigate('infrastructure_provision_vms', context={
        'provider': provider,
        'template_name': template_name,
    })

    provisioning_data = {
        'email': e_mail,
        'first_name': first_name,
        'last_name': last_name,
        'notes': notes,
        'vm_name': vm_name,
        'host_name': {'name': [host]},
        'datastore_name': {'name': [datastore]},
        'num_vms': "10",    # so it won't get auto-approved
    }

    # Same thing, different names. :\
    if provider_data["type"] == 'rhevm':
        provisioning_data['provision_type'] = 'Native Clone'
    elif provider_data["type"] == 'virtualcenter':
        provisioning_data['provision_type'] = 'VMware'

    try:
        provisioning_data['vlan'] = provisioning['vlan']
    except KeyError:
        # provisioning['vlan'] is required for rhevm provisioning
        if provider_data["type"] == 'rhevm':
            raise pytest.fail('rhevm requires a vlan value in provisioning info')

    provisioning_form.fill(provisioning_data)
    pytest.sel.click(provisioning_form.submit_button)
    flash.assert_no_errors()
    request_cells = {
        "Description": "Provision from [{}] to [{}###]".format(template_name, vm_name),
    }
    yield request_cells

    browser().get(store.base_url)
    login_admin()

    requests.delete_request(request_cells)
    flash.assert_no_errors()

def really_logout():
    """A convenience function logging out

    This function simply ensures that we are logged out and that a new browser is loaded
    ready for use.
    """
    try:
        current_appliance.server.logout()
    except AttributeError:
        try:
            browser().quit()
        except AttributeError:
            ensure_browser_open()

def generated_request(provider, provider_data, provisioning, template_name, vm_name):
    """Creates a provision request, that is not automatically approved, and returns the search data.

    After finishing the test, request should be automatically deleted.

    Slightly modified code from :py:module:`cfme.tests.infrastructure.test_provisioning`
    """
    first_name = fauxfactory.gen_alphanumeric()
    last_name = fauxfactory.gen_alphanumeric()
    notes = fauxfactory.gen_alphanumeric()
    e_mail = "{}@{}.test".format(first_name, last_name)
    host, datastore = map(provisioning.get, ("host", "datastore"))
    vm = Vm(name=vm_name, provider=provider, template_name=template_name)
    navigate_to(vm, "ProvisionVM")

    provisioning_data = {
        "email": e_mail,
        "first_name": first_name,
        "last_name": last_name,
        "notes": notes,
        "vm_name": vm_name,
        "host_name": {"name": [host]},
        "datastore_name": {"name": [datastore]},
        "num_vms": "10",  # so it won't get auto-approved
    }

    # Same thing, different names. :\
    if provider_data["type"] == "rhevm":
        provisioning_data["provision_type"] = "Native Clone"
    elif provider_data["type"] == "virtualcenter":
        provisioning_data["provision_type"] = "VMware"

    try:
        provisioning_data["vlan"] = provisioning["vlan"]
    except KeyError:
        # provisioning['vlan'] is required for rhevm provisioning
        if provider_data["type"] == "rhevm":
            raise pytest.fail("rhevm requires a vlan value in provisioning info")

    fill(provisioning_form, provisioning_data, action=provisioning_form.submit_button)
    flash.assert_no_errors()
    request_cells = {"Description": "Provision from [{}] to [{}###]".format(template_name, vm_name)}
    yield request_cells

    browser().get(store.base_url)
    login_admin()

    requests.delete_request(request_cells)
    flash.assert_no_errors()

def move_to_element(loc, **kwargs):
    """
    Moves to an element.

    Args:
        loc: A locator, expects either a string, WebElement, tuple.
    Returns: Returns the element it was moved to to enable chaining.
    """
    brand = "//div[@id='page_header_div']//div[contains(@class, 'brand')]"
    wait_for_ajax()
    el = element(loc, **kwargs)
    move_to = ActionChains(browser()).move_to_element(el)
    try:
        move_to.perform()
    except MoveTargetOutOfBoundsException:
        # ff workaround
        execute_script("arguments[0].scrollIntoView();", el)
        if elements(brand) and not is_displayed(brand):
            # If it does it badly that it moves whole page, this moves it back
            try:
                execute_script("arguments[0].scrollIntoView();", element(brand))
            except MoveTargetOutOfBoundsException:
                pass
        try:
            move_to.perform()
        except MoveTargetOutOfBoundsException:  # This has become desperate now.
            raise exceptions.CannotScrollException(
                "Despite all the workarounds, scrolling to `{}` was unsuccessful.".format(loc))
    return el

def needs_firefox():
    """ Fixture which skips the test if not run under firefox.

    I recommend putting it in the first place.
    """
    if browser.browser().name != "firefox":
        pytest.skip(msg="This test needs firefox to run")

def click(loc, wait_ajax=True, no_custom_handler=False):
    """
    Clicks on an element.

    If the element implements `_custom_click_handler` the control will be given to it. Then the
    handler decides what to do (eg. do not click under some circumstances).

    Args:
        loc: A locator, expects either a string, WebElement, tuple or an object implementing
            `_custom_click_handler` method.
        wait_ajax: Whether to wait for ajax call to finish. Default True but sometimes it's
            handy to not do that. (some toolbar clicks)
        no_custom_handler: To prevent recursion, the custom handler sets this to True.
    """
    if hasattr(loc, "_custom_click_handler") and not no_custom_handler:
        # Object can implement own modification of click behaviour
        return loc._custom_click_handler()

    # Move mouse cursor to element
    move_to_element(loc)
    # and then click on current mouse position
    ActionChains(browser()).click().perform()
    # -> using this approach, we don't check if we clicked a specific element
    if wait_ajax:
        wait_for_ajax()

def move_to_element(loc, **kwargs):
    """
    Moves to an element.

    Args:
        loc: A locator, expects either a string, WebElement, tuple.
    Returns: It passes `loc` through to make it possible to use in case we want to immediately use
        the element that it is being moved to.
    """
    brand = "//div[@id='page_header_div']//div[contains(@class, 'brand')]"
    wait_for_ajax()
    el = element(loc, **kwargs)
    move_to = ActionChains(browser()).move_to_element(el)
    try:
        move_to.perform()
    except MoveTargetOutOfBoundsException:
        # ff workaround
        execute_script("arguments[0].scrollIntoView();", el)
        if elements(brand) and not is_displayed(brand):
            # If it does it badly that it moves whole page, this moves it back
            try:
                execute_script("arguments[0].scrollIntoView();", element(brand))
            except MoveTargetOutOfBoundsException:
                pass
        move_to.perform()
    return el

def current_url():
    """
    Returns the current_url of the page

    Returns: A url.
    """
    return browser().current_url

    def get_logging_url(self):

        def report_kibana_failure():
            raise RuntimeError("Kibana not found in the window title or content")

        browser_instance = browser()

        all_windows_before = browser_instance.window_handles
        appliance_window = browser_instance.current_window_handle

        self.monitor.item_select('External Logging')

        all_windows_after = browser_instance.window_handles

        new_windows = set(all_windows_after) - set(all_windows_before)

        if not new_windows:
            raise RuntimeError("No logging window was open!")

        logging_window = new_windows.pop()
        browser_instance.switch_to_window(logging_window)

        logging_url = browser_instance.current_url

        wait_for(lambda: "kibana" in
                         browser_instance.title.lower() + " " +
                         browser_instance.page_source.lower(),
                 fail_func=report_kibana_failure, num_sec=60, delay=5)

        browser_instance.close()
        browser_instance.switch_to_window(appliance_window)

        return logging_url

def move_to_element(loc):
    """
    Moves to an element.

    Args:
        loc: A locator, expects either a string, WebElement, tuple.
    """
    ActionChains(browser()).move_to_element(element(loc)).perform()

def get(url):
    """
    Changes page to the spceified URL

    Args:
        url: URL to navigate to.
    """
    return browser().get(url)

def _t(t, root=None):
    """Assume tuple is a 2-item tuple like (By.ID, 'myid').

    Handles the case when root= locator resolves to multiple elements. In that case all of them
    are processed and all results are put in the same list."""
    result = []
    for root_element in (elements(root) if root is not None else [browser()]):
        result += root_element.find_elements(*t)
    return result

def drag_and_drop(source_element, dest_element):
    """Drag and Drop element.

    Args:
        loc: A locator, expects either a string, WebElement, tuple.
        wait_ajax: Whether to wait for ajax call to finish. Default True but sometimes it's
            handy to not do that. (some toolbar clicks)
    """
    ActionChains(browser()).drag_and_drop(dest_element, source_element).perform()

def navigate_accordions(accordions, page_name, ui_bench_pg_limit, ui_worker_pid, prod_tail,
        soft_assert):
    pages = []
    for acc_tree in accordions:
        pages.extend(analyze_page_stat(perf_click(ui_worker_pid, prod_tail, True, accordion.click,
            acc_tree), soft_assert))

        logger.info('Starting to read tree: {}'.format(acc_tree))
        tree_contents, sel_time = perf_bench_read_tree(accordion.tree(acc_tree))
        logger.info('{} tree read in {}ms'.format(acc_tree, sel_time))

        pages.extend(analyze_page_stat(perf_click(ui_worker_pid, prod_tail, False, None),
            soft_assert))

        nav_limit = 0
        count = -1
        if accordions[acc_tree] in ui_bench_pg_limit:
            nav_limit = ui_bench_pg_limit[accordions[acc_tree]]
            count = 0

        paths = []
        generate_tree_paths(tree_contents, [], paths)
        logger.info('Found {} tree paths'.format(len(paths)))
        for path in paths:
            logger.info('Navigating to: {}, {}'.format(acc_tree, path[-1]))
            try:
                pages.extend(analyze_page_stat(perf_click(ui_worker_pid, prod_tail, True,
                    accordion.tree(acc_tree).click_path, *path), soft_assert))
                count += 1
                # Navigate out of the page every 4th click
                if (count % 4) == 0:
                    pages.extend(analyze_page_stat(perf_click(ui_worker_pid, prod_tail, False,
                        sel.force_navigate, 'dashboard'), soft_assert))
                    pages.extend(analyze_page_stat(perf_click(ui_worker_pid, prod_tail, False,
                        sel.force_navigate, page_name), soft_assert))
            except CandidateNotFound:
                logger.info('Could not navigate to: '.format(path[-1]))
            except UnexpectedAlertPresentException:
                logger.warning('UnexpectedAlertPresentException - page_name: {}, accordion: {},'
                    ' path: {}'.format(page_name, acc_tree, path[-1]))
                browser().switch_to_alert().dismiss()
            if not nav_limit == 0 and count >= nav_limit:
                break
    return pages

def drag_and_drop_by_offset(source_element, x=0, y=0):
    """Drag and Drop element by offset

    Args:
        source_element: A locator, expects either a string, WebElement, tuple.
        x: Distance in pixels on X axis to move it.
        y: Distance in pixels on Y axis to move it.
    """
    e = move_to_element(source_element)
    ActionChains(browser()).drag_and_drop_by_offset(e, x, y).perform()

def handle_alert(cancel=False, wait=30.0, squash=False):
    """Handles an alert popup.

    Args:
        cancel: Whether or not to cancel the alert.
            Accepts the Alert (False) by default.
        wait: Time to wait for an alert to appear.
            Default 30 seconds, can be set to 0 to disable waiting.
        squash: Whether or not to squash errors during alert handling.
            Default False

    Returns:
        True if the alert was handled, False if exceptions were
        squashed, None if there was no alert.

    No exceptions will be raised if ``squash`` is True.

    Raises:
        utils.wait.TimedOutError: If the alert popup does not appear
        selenium.common.exceptions.NoAlertPresentException: If no alert is present when accepting
            or dismissing the alert.

    """

    # throws timeout exception if not found
    try:
        if wait:
            WebDriverWait(browser(), wait).until(expected_conditions.alert_is_present())
        popup = browser().switch_to_alert()
        answer = 'cancel' if cancel else 'ok'
        logger.info('Handling popup "%s", clicking %s' % (popup.text, answer))
        popup.dismiss() if cancel else popup.accept()
        wait_for_ajax()
        return True
    except NoAlertPresentException:
        return None
    except Exception as e:
        logger.exception(e)
        if squash:
            return False
        else:
            raise

def click(loc, wait_ajax=True):
    """
    Clicks on an element.

    Args:
        loc: A locator, expects either a string, WebElement, tuple.
        wait_ajax: Whether to wait for ajax call to finish. Default True but sometimes it's
            handy to not do that. (some toolbar clicks)
    """
    ActionChains(browser()).move_to_element(element(loc)).click().perform()
    if wait_ajax:
        wait_for_ajax()

def send_keys(loc, text):
    """
    Sends the supplied keys to an element.

    Args:
        loc: A locator, expects either a string, WebElement, tuple.
        text: The text to inject into the element.
    """
    if text is not None:
        el = element(loc)
        ActionChains(browser()).move_to_element(el).send_keys_to_element(el, text).perform()
        wait_for_ajax()

def set_text(loc, text):
    """
    Clears the element and then sends the supplied keys.

    Args:
        loc: A locator, expects either a string, WebElement, tuple.
        text: The text to inject into the element.
    """
    if text is not None:
        el = element(loc)
        ActionChains(browser()).move_to_element(el).perform()
        el.clear()
        el.send_keys(text)