// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from webkit-gir-files
// DO NOT EDIT

use crate::{ffi, AuthenticationScheme, Credential, SecurityOrigin};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Represents an authentication request.
    ///
    /// Whenever a client attempts to load a page protected by HTTP
    /// authentication, credentials will need to be provided to authorize access.
    /// To allow the client to decide how it wishes to handle authentication,
    /// WebKit will fire a #WebKitWebView::authenticate signal with a
    /// WebKitAuthenticationRequest object to provide client side
    /// authentication support. Credentials are exposed through the
    /// #WebKitCredential object.
    ///
    /// In case the client application does not wish
    /// to handle this signal WebKit will provide a default handler. To handle
    /// authentication asynchronously, simply increase the reference count of the
    /// WebKitAuthenticationRequest object.
    ///
    /// ## Signals
    ///
    ///
    /// #### `authenticated`
    ///  This signal is emitted when the user authentication request succeeded.
    /// Applications handling their own credential storage should connect to
    /// this signal to save the credentials.
    ///
    ///
    ///
    ///
    /// #### `cancelled`
    ///  This signal is emitted when the user authentication request is
    /// cancelled. It allows the application to dismiss its authentication
    /// dialog in case of page load failure for example.
    ///
    ///
    #[doc(alias = "WebKitAuthenticationRequest")]
    pub struct AuthenticationRequest(Object<ffi::WebKitAuthenticationRequest, ffi::WebKitAuthenticationRequestClass>);

    match fn {
        type_ => || ffi::webkit_authentication_request_get_type(),
    }
}

impl AuthenticationRequest {
    /// Authenticate the #WebKitAuthenticationRequest.
    ///
    /// Authenticate the #WebKitAuthenticationRequest using the #WebKitCredential
    /// supplied. To continue without credentials, pass [`None`] as @credential.
    /// ## `credential`
    /// A #WebKitCredential, or [`None`]
    #[doc(alias = "webkit_authentication_request_authenticate")]
    pub fn authenticate(&self, credential: Option<&Credential>) {
        unsafe {
            ffi::webkit_authentication_request_authenticate(
                self.to_glib_none().0,
                mut_override(credential.to_glib_none().0),
            );
        }
    }

    /// Determine whether this #WebKitAuthenticationRequest should allow the storage of credentials.
    ///
    /// Determine whether the authentication method associated with this
    /// #WebKitAuthenticationRequest should allow the storage of credentials.
    /// This will return [`false`] if WebKit doesn't support credential storing,
    /// if private browsing is enabled, or if persistent credential storage has been
    /// disabled in #WebKitWebsiteDataManager, unless credentials saving has been
    /// explicitly enabled with webkit_authentication_request_set_can_save_credentials().
    ///
    /// # Returns
    ///
    /// [`true`] if WebKit can store credentials or [`false`] otherwise.
    #[doc(alias = "webkit_authentication_request_can_save_credentials")]
    pub fn can_save_credentials(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_authentication_request_can_save_credentials(
                self.to_glib_none().0,
            ))
        }
    }

    /// Cancel the authentication challenge.
    ///
    /// This will also cancel the page loading and result in a
    /// #WebKitWebView::load-failed signal with a #WebKitNetworkError of type [`NetworkError::Cancelled`][crate::NetworkError::Cancelled] being emitted.
    #[doc(alias = "webkit_authentication_request_cancel")]
    pub fn cancel(&self) {
        unsafe {
            ffi::webkit_authentication_request_cancel(self.to_glib_none().0);
        }
    }

    /// Get the #GTlsPasswordFlags of the [`AuthenticationScheme::ClientCertificatePinRequested`][crate::AuthenticationScheme::ClientCertificatePinRequested] authentication challenge.
    ///
    /// # Returns
    ///
    /// a #GTlsPasswordFlags
    #[doc(alias = "webkit_authentication_request_get_certificate_pin_flags")]
    #[doc(alias = "get_certificate_pin_flags")]
    pub fn certificate_pin_flags(&self) -> gio::TlsPasswordFlags {
        unsafe {
            from_glib(
                ffi::webkit_authentication_request_get_certificate_pin_flags(self.to_glib_none().0),
            )
        }
    }

    /// Get the host that this authentication challenge is applicable to.
    ///
    /// # Returns
    ///
    /// The host of @self.
    #[doc(alias = "webkit_authentication_request_get_host")]
    #[doc(alias = "get_host")]
    pub fn host(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_authentication_request_get_host(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the port that this authentication challenge is applicable to.
    ///
    /// # Returns
    ///
    /// The port of @self.
    #[doc(alias = "webkit_authentication_request_get_port")]
    #[doc(alias = "get_port")]
    pub fn port(&self) -> u32 {
        unsafe { ffi::webkit_authentication_request_get_port(self.to_glib_none().0) }
    }

    /// Get the #WebKitCredential of the proposed authentication challenge.
    ///
    /// Get the #WebKitCredential of the proposed authentication challenge that was
    /// stored from a previous session. The client can use this directly for
    /// authentication or construct their own #WebKitCredential.
    ///
    /// # Returns
    ///
    /// A #WebKitCredential encapsulating credential details
    /// or [`None`] if there is no stored credential.
    #[doc(alias = "webkit_authentication_request_get_proposed_credential")]
    #[doc(alias = "get_proposed_credential")]
    pub fn proposed_credential(&self) -> Option<Credential> {
        unsafe {
            from_glib_full(ffi::webkit_authentication_request_get_proposed_credential(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the realm that this authentication challenge is applicable to.
    ///
    /// # Returns
    ///
    /// The realm of @self.
    #[doc(alias = "webkit_authentication_request_get_realm")]
    #[doc(alias = "get_realm")]
    pub fn realm(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_authentication_request_get_realm(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the authentication scheme of the authentication challenge.
    ///
    /// # Returns
    ///
    /// The #WebKitAuthenticationScheme of @self.
    #[doc(alias = "webkit_authentication_request_get_scheme")]
    #[doc(alias = "get_scheme")]
    pub fn scheme(&self) -> AuthenticationScheme {
        unsafe {
            from_glib(ffi::webkit_authentication_request_get_scheme(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the #WebKitSecurityOrigin that this authentication challenge is applicable to.
    ///
    /// # Returns
    ///
    /// a newly created #WebKitSecurityOrigin.
    #[doc(alias = "webkit_authentication_request_get_security_origin")]
    #[doc(alias = "get_security_origin")]
    pub fn security_origin(&self) -> Option<SecurityOrigin> {
        unsafe {
            from_glib_full(ffi::webkit_authentication_request_get_security_origin(
                self.to_glib_none().0,
            ))
        }
    }

    /// Determine whether the authentication challenge is associated with a proxy server.
    ///
    /// Determine whether the authentication challenge is associated with a proxy server rather than an "origin" server.
    ///
    /// # Returns
    ///
    /// [`true`] if authentication is for a proxy or [`false`] otherwise.
    #[doc(alias = "webkit_authentication_request_is_for_proxy")]
    pub fn is_for_proxy(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_authentication_request_is_for_proxy(
                self.to_glib_none().0,
            ))
        }
    }

    /// Determine whether this this is a first attempt or a retry for this authentication challenge.
    ///
    /// # Returns
    ///
    /// [`true`] if authentication attempt is a retry or [`false`] otherwise.
    #[doc(alias = "webkit_authentication_request_is_retry")]
    pub fn is_retry(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_authentication_request_is_retry(
                self.to_glib_none().0,
            ))
        }
    }

    /// Set whether the authentication method associated with @self
    /// should allow the storage of credentials.
    ///
    /// Set whether the authentication method associated with @self
    /// should allow the storage of credentials.
    /// This should be used by applications handling their own credentials
    /// storage to indicate that it should be supported even when internal
    /// credential storage is disabled or unsupported.
    /// Note that storing of credentials will not be allowed on ephemeral
    /// sessions in any case.
    /// ## `enabled`
    /// value to set
    #[doc(alias = "webkit_authentication_request_set_can_save_credentials")]
    pub fn set_can_save_credentials(&self, enabled: bool) {
        unsafe {
            ffi::webkit_authentication_request_set_can_save_credentials(
                self.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the #WebKitCredential of the proposed authentication challenge.
    ///
    /// Set the #WebKitCredential of the proposed authentication challenge that was
    /// stored from a previous session. This should only be used by applications handling
    /// their own credential storage. (When using the default WebKit credential storage,
    /// webkit_authentication_request_get_proposed_credential() already contains previously-stored
    /// credentials.)
    /// Passing a [`None`] @credential will clear the proposed credential.
    /// ## `credential`
    /// a #WebKitCredential, or [`None`]
    #[doc(alias = "webkit_authentication_request_set_proposed_credential")]
    pub fn set_proposed_credential(&self, credential: &mut Credential) {
        unsafe {
            ffi::webkit_authentication_request_set_proposed_credential(
                self.to_glib_none().0,
                credential.to_glib_none_mut().0,
            );
        }
    }

    /// This signal is emitted when the user authentication request succeeded.
    /// Applications handling their own credential storage should connect to
    /// this signal to save the credentials.
    /// ## `credential`
    /// the #WebKitCredential accepted
    #[doc(alias = "authenticated")]
    pub fn connect_authenticated<F: Fn(&Self, &Credential) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn authenticated_trampoline<
            F: Fn(&AuthenticationRequest, &Credential) + 'static,
        >(
            this: *mut ffi::WebKitAuthenticationRequest,
            credential: *mut ffi::WebKitCredential,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(credential))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"authenticated\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    authenticated_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the user authentication request is
    /// cancelled. It allows the application to dismiss its authentication
    /// dialog in case of page load failure for example.
    #[doc(alias = "cancelled")]
    pub fn connect_cancelled<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn cancelled_trampoline<F: Fn(&AuthenticationRequest) + 'static>(
            this: *mut ffi::WebKitAuthenticationRequest,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"cancelled\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    cancelled_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}