def javascript_alert(url, js_msg, abort_on):
    """Display a javascript alert."""
    log.js.debug("alert: {}".format(js_msg))
    if config.val.content.javascript.modal_dialog:
        raise CallSuper

    if not config.val.content.javascript.alert:
        return

    msg = 'From <b>{}</b>:<br/>{}'.format(html.escape(url.toDisplayString()),
                                          html.escape(js_msg))
    message.ask('Javascript alert', msg, mode=usertypes.PromptMode.alert,
                abort_on=abort_on)

def javascript_alert(url, js_msg, abort_on):
    """Display a javascript alert."""
    log.js.debug("alert: {}".format(js_msg))
    if config.get('ui', 'modal-js-dialog'):
        raise CallSuper

    if config.get('content', 'ignore-javascript-alert'):
        return

    msg = 'From <b>{}</b>:<br/>{}'.format(html.escape(url.toDisplayString()),
                                          html.escape(js_msg))
    message.ask('Javascript alert', msg, mode=usertypes.PromptMode.alert,
                abort_on=abort_on)

    def javaScriptAlert(self, frame, js_msg):
        """Override javaScriptAlert to use the statusbar."""
        log.js.debug("alert: {}".format(js_msg))
        if config.get('ui', 'modal-js-dialog'):
            return super().javaScriptAlert(frame, js_msg)

        if (self._is_shutting_down or
                config.get('content', 'ignore-javascript-alert')):
            return

        msg = 'From <b>{}</b>:<br/>{}'.format(
            html.escape(self.mainFrame().url().toDisplayString()),
            html.escape(js_msg))
        message.ask('Javascript alert', msg, mode=usertypes.PromptMode.alert,
                    abort_on=[self.loadStarted, self.shutting_down])

def javascript_alert(url, js_msg, abort_on, *, escape_msg=True):
    """Display a javascript alert."""
    log.js.debug("alert: {}".format(js_msg))
    if config.val.content.javascript.modal_dialog:
        raise CallSuper

    if not config.val.content.javascript.alert:
        return

    js_msg = html.escape(js_msg) if escape_msg else js_msg
    msg = 'From <b>{}</b>:<br/>{}'.format(html.escape(url.toDisplayString()),
                                          js_msg)
    urlstr = url.toString(QUrl.RemovePassword | QUrl.FullyEncoded)
    message.ask('Javascript alert', msg, mode=usertypes.PromptMode.alert,
                abort_on=abort_on, url=urlstr)

 def closeEvent(self, e):
     """Override closeEvent to display a confirmation if needed."""
     confirm_quit = config.get("ui", "confirm-quit")
     tab_count = self.tabbed_browser.count()
     download_manager = objreg.get("download-manager", scope="window", window=self.win_id)
     download_count = download_manager.rowCount()
     quit_texts = []
     # Close if set to never ask for confirmation
     if "never" in confirm_quit:
         pass
     # Ask if multiple-tabs are open
     if "multiple-tabs" in confirm_quit and tab_count > 1:
         quit_texts.append("{} {} open.".format(tab_count, "tab is" if tab_count == 1 else "tabs are"))
     # Ask if multiple downloads running
     if "downloads" in confirm_quit and download_count > 0:
         quit_texts.append("{} {} running.".format(tab_count, "download is" if tab_count == 1 else "downloads are"))
     # Process all quit messages that user must confirm
     if quit_texts or "always" in confirm_quit:
         text = "\n".join(["Really quit?"] + quit_texts)
         confirmed = message.ask(self.win_id, text, usertypes.PromptMode.yesno, default=True)
         # Stop asking if the user cancels
         if not confirmed:
             log.destroy.debug("Cancelling closing of window {}".format(self.win_id))
             e.ignore()
             return
     e.accept()
     objreg.get("session-manager").save_last_window_session()
     self._save_geometry()
     log.destroy.debug("Closing window {}".format(self.win_id))
     self.tabbed_browser.shutdown()

    def on_ssl_errors(self, reply, errors):
        """Decide if SSL errors should be ignored or not.

        This slot is called on SSL/TLS errors by the self.sslErrors signal.

        Args:
            reply: The QNetworkReply that is encountering the errors.
            errors: A list of errors.
        """
        ssl_strict = config.get('network', 'ssl-strict')
        if ssl_strict == 'ask':
            err_string = '\n'.join('- ' + err.errorString() for err in errors)
            answer = message.ask(
                self._win_id,
                'SSL errors - continue?\n{}'.format(err_string),
                mode=usertypes.PromptMode.yesno)
            if answer:
                reply.ignoreSslErrors()
        elif ssl_strict:
            pass
        else:
            for err in errors:
                # FIXME we might want to use warn here (non-fatal error)
                # https://github.com/The-Compiler/qutebrowser/issues/114
                message.error(self._win_id,
                              'SSL error: {}'.format(err.errorString()))
            reply.ignoreSslErrors()

 def _on_proxy_authentication_required(self, url, authenticator,
                                       proxy_host):
     """Called when a proxy needs authentication."""
     msg = "<b>{}</b> requires a username and password.".format(
         html_utils.escape(proxy_host))
     answer = message.ask(
         title="Proxy authentication required", text=msg,
         mode=usertypes.PromptMode.user_pwd,
         abort_on=[self.shutting_down, self.load_started])
     if answer is not None:
         authenticator.setUser(answer.user)
         authenticator.setPassword(answer.password)
     else:
         try:
             # pylint: disable=no-member, useless-suppression
             sip.assign(authenticator, QAuthenticator())
             # pylint: enable=no-member, useless-suppression
         except AttributeError:
             url_string = url.toDisplayString()
             error_page = jinja.render(
                 'error.html',
                 title="Error loading page: {}".format(url_string),
                 url=url_string, error="Proxy authentication required",
                 icon='')
             self.set_html(error_page)

 def closeEvent(self, e):
     """Override closeEvent to display a confirmation if needed."""
     if crashsignal.is_crashing:
         e.accept()
         return
     confirm_quit = config.get('ui', 'confirm-quit')
     tab_count = self.tabbed_browser.count()
     download_manager = objreg.get('download-manager', scope='window',
                                   window=self.win_id)
     download_count = download_manager.running_downloads()
     quit_texts = []
     # Ask if multiple-tabs are open
     if 'multiple-tabs' in confirm_quit and tab_count > 1:
         quit_texts.append("{} {} open.".format(
             tab_count, "tab is" if tab_count == 1 else "tabs are"))
     # Ask if multiple downloads running
     if 'downloads' in confirm_quit and download_count > 0:
         quit_texts.append("{} {} running.".format(
             tab_count,
             "download is" if tab_count == 1 else "downloads are"))
     # Process all quit messages that user must confirm
     if quit_texts or 'always' in confirm_quit:
         text = '\n'.join(['Really quit?'] + quit_texts)
         confirmed = message.ask(self.win_id, text,
                                 usertypes.PromptMode.yesno,
                                 default=True)
         # Stop asking if the user cancels
         if not confirmed:
             log.destroy.debug("Cancelling closing of window {}".format(
                 self.win_id))
             e.ignore()
             return
     e.accept()
     self._do_close()

 def shouldInterruptJavaScript(self):
     """Override shouldInterruptJavaScript to use the statusbar."""
     answer = message.ask("Interrupt long-running javascript?",
                          usertypes.PromptMode.yesno)
     if answer is None:
         answer = True
     return answer

 def javaScriptPrompt(self, _frame, msg, default):
     """Override javaScriptPrompt to use the statusbar."""
     answer = message.ask(self._win_id, "js: {}".format(msg),
                          usertypes.PromptMode.text, default)
     if answer is None:
         return (False, "")
     else:
         return (True, answer)

def javascript_confirm(url, js_msg, abort_on):
    """Display a javascript confirm prompt."""
    log.js.debug("confirm: {}".format(js_msg))
    if config.get('ui', 'modal-js-dialog'):
        raise CallSuper

    msg = 'From <b>{}</b>:<br/>{}'.format(html.escape(url.toDisplayString()),
                                          html.escape(js_msg))
    ans = message.ask('Javascript confirm', msg,
                      mode=usertypes.PromptMode.yesno,
                      abort_on=abort_on)
    return bool(ans)

    def _javascript_prompt(self, _frame, msg, default):
        """Override javaScriptPrompt to use the statusbar.

        We use this approach and override the method conditionally in __init__
        because overriding javaScriptPrompt was broken in 5.3.0.

        http://www.riverbankcomputing.com/pipermail/pyqt/2014-June/034385.html
        """
        answer = message.ask("js: {}".format(msg), usertypes.PromptMode.text,
                             default)
        if answer is None:
            return (False, "")
        else:
            return (True, answer)

def ignore_certificate_errors(url, errors, abort_on):
    """Display a certificate error question.

    Args:
        url: The URL the errors happened in
        errors: A list of QSslErrors or QWebEngineCertificateErrors

    Return:
        True if the error should be ignored, False otherwise.
    """
    ssl_strict = config.val.content.ssl_strict
    log.webview.debug("Certificate errors {!r}, strict {}".format(
        errors, ssl_strict))

    for error in errors:
        assert error.is_overridable(), repr(error)

    if ssl_strict == 'ask':
        err_template = jinja.environment.from_string("""
            Errors while loading <b>{{url.toDisplayString()}}</b>:<br/>
            <ul>
            {% for err in errors %}
                <li>{{err}}</li>
            {% endfor %}
            </ul>
        """.strip())
        msg = err_template.render(url=url, errors=errors)

        urlstr = url.toString(QUrl.RemovePassword | QUrl.FullyEncoded)
        ignore = message.ask(title="Certificate errors - continue?", text=msg,
                             mode=usertypes.PromptMode.yesno, default=False,
                             abort_on=abort_on, url=urlstr)
        if ignore is None:
            # prompt aborted
            ignore = False
        return ignore
    elif ssl_strict is False:
        log.webview.debug("ssl_strict is False, only warning about errors")
        for err in errors:
            # FIXME we might want to use warn here (non-fatal error)
            # https://github.com/qutebrowser/qutebrowser/issues/114
            message.error('Certificate error: {}'.format(err))
        return True
    elif ssl_strict is True:
        return False
    else:
        raise ValueError("Invalid ssl_strict value {!r}".format(ssl_strict))
    raise utils.Unreachable

def authentication_required(url, authenticator, abort_on):
    """Ask a prompt for an authentication question."""
    realm = authenticator.realm()
    if realm:
        msg = '<b>{}</b> says:<br/>{}'.format(
            html.escape(url.toDisplayString()), html.escape(realm))
    else:
        msg = '<b>{}</b> needs authentication'.format(
            html.escape(url.toDisplayString()))
    answer = message.ask(title="Authentication required", text=msg,
                         mode=usertypes.PromptMode.user_pwd,
                         abort_on=abort_on)
    if answer is not None:
        authenticator.setUser(answer.user)
        authenticator.setPassword(answer.password)
    return answer

    def javaScriptConfirm(self, frame, js_msg):
        """Override javaScriptConfirm to use the statusbar."""
        log.js.debug("confirm: {}".format(js_msg))
        if config.get('ui', 'modal-js-dialog'):
            return super().javaScriptConfirm(frame, js_msg)

        if self._is_shutting_down:
            return False

        msg = 'From <b>{}</b>:<br/>{}'.format(
            html.escape(self.mainFrame().url().toDisplayString()),
            html.escape(js_msg))
        ans = message.ask('Javascript confirm', msg,
                          mode=usertypes.PromptMode.yesno,
                          abort_on=[self.loadStarted, self.shutting_down])
        return bool(ans)

def feature_permission(url, option, msg, yes_action, no_action, abort_on,
                       blocking=False):
    """Handle a feature permission request.

    Args:
        url: The URL the request was done for.
        option: An option name to check.
        msg: A string like "show notifications"
        yes_action: A callable to call if the request was approved
        no_action: A callable to call if the request was denied
        abort_on: A list of signals which interrupt the question.
        blocking: If True, ask a blocking question.

    Return:
        The Question object if a question was asked (and blocking=False),
        None otherwise.
    """
    config_val = config.instance.get(option, url=url)
    if config_val == 'ask':
        if url.isValid():
            urlstr = url.toString(QUrl.RemovePassword | QUrl.FullyEncoded)
            text = "Allow the website at <b>{}</b> to {}?".format(
                html.escape(url.toDisplayString()), msg)
        else:
            urlstr = None
            text = "Allow the website to {}?".format(msg)

        if blocking:
            answer = message.ask(abort_on=abort_on, title='Permission request',
                                 text=text, url=urlstr,
                                 mode=usertypes.PromptMode.yesno)
            if answer:
                yes_action()
            else:
                no_action()
            return None
        else:
            return message.confirm_async(
                yes_action=yes_action, no_action=no_action,
                cancel_action=no_action, abort_on=abort_on,
                title='Permission request', text=text, url=urlstr)
    elif config_val:
        yes_action()
        return None
    else:
        no_action()
        return None

 def javaScriptPrompt(self, _frame, js_msg, default):
     """Override javaScriptPrompt to use the statusbar."""
     if (self._is_shutting_down or
             config.get('content', 'ignore-javascript-prompt')):
         return (False, "")
     msg = '<b>{}</b> asks:<br/>{}'.format(
         html.escape(self.mainFrame().url().toDisplayString()),
         html.escape(js_msg))
     answer = message.ask('Javascript prompt', msg,
                          mode=usertypes.PromptMode.text,
                          default=default,
                          abort_on=[self.loadStarted,
                                    self.shutting_down])
     if answer is None:
         return (False, "")
     else:
         return (True, answer)

 def closeEvent(self, e):
     """Override closeEvent to display a confirmation if needed."""
     confirm_quit = config.get('ui', 'confirm-quit')
     count = self._tabbed_browser.count()
     if confirm_quit == 'never':
         e.accept()
     elif confirm_quit == 'multiple-tabs' and count <= 1:
         e.accept()
     else:
         text = "Close {} {}?".format(
             count, "tab" if count == 1 else "tabs")
         confirmed = message.ask(text, usertypes.PromptMode.yesno,
                                 default=True)
         if confirmed:
             e.accept()
         else:
             e.ignore()

def javascript_prompt(url, js_msg, default, abort_on):
    """Display a javascript prompt."""
    log.js.debug("prompt: {}".format(js_msg))
    if config.get('ui', 'modal-js-dialog'):
        raise CallSuper
    if config.get('content', 'ignore-javascript-prompt'):
        return (False, "")

    msg = '<b>{}</b> asks:<br/>{}'.format(html.escape(url.toDisplayString()),
                                          html.escape(js_msg))
    answer = message.ask('Javascript prompt', msg,
                         mode=usertypes.PromptMode.text,
                         default=default,
                         abort_on=abort_on)

    if answer is None:
        return (False, "")
    else:
        return (True, answer)

 def on_proxy_authentication_required(self, proxy, authenticator):
     """Called when a proxy needs authentication."""
     proxy_id = ProxyId(proxy.type(), proxy.hostName(), proxy.port())
     if proxy_id in _proxy_auth_cache:
         user, password = _proxy_auth_cache[proxy_id]
         authenticator.setUser(user)
         authenticator.setPassword(password)
     else:
         msg = '<b>{}</b> says:<br/>{}'.format(
             html.escape(proxy.hostName()),
             html.escape(authenticator.realm()))
         abort_on = self._get_abort_signals()
         answer = message.ask(
             title="Proxy authentication required", text=msg,
             mode=usertypes.PromptMode.user_pwd, abort_on=abort_on)
         if answer is not None:
             authenticator.setUser(answer.user)
             authenticator.setPassword(answer.password)
             _proxy_auth_cache[proxy_id] = answer