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

use crate::Message;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// The abstract base class for handling authentication.
    ///
    /// Specific HTTP Authentication mechanisms are implemented by its subclasses,
    /// but applications never need to be aware of the specific subclasses being
    /// used.
    ///
    /// #SoupAuth objects store the authentication data associated with a given bit
    /// of web space. They are created automatically by [`Session`][crate::Session].
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `authority`
    ///  The authority (host:port) being authenticated to.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `is-authenticated`
    ///  Whether or not the auth has been authenticated.
    ///
    /// Readable
    ///
    ///
    /// #### `is-cancelled`
    ///  Whether or not the auth has been cancelled.
    ///
    /// Readable
    ///
    ///
    /// #### `is-for-proxy`
    ///  Whether or not the auth is for a proxy server.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `realm`
    ///  The authentication realm.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `scheme-name`
    ///  The authentication scheme name.
    ///
    /// Readable
    ///
    /// # Implements
    ///
    /// [`AuthExt`][trait@crate::prelude::AuthExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "SoupAuth")]
    pub struct Auth(Object<ffi::SoupAuth, ffi::SoupAuthClass>);

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

impl Auth {
    pub const NONE: Option<&'static Auth> = None;

    /// Creates a new #SoupAuth of type @type_ with the information from
    /// @msg and @auth_header.
    ///
    /// This is called by [`Session`][crate::Session]; you will normally not create auths
    /// yourself.
    /// ## `type_`
    /// the type of auth to create (a subtype of #SoupAuth)
    /// ## `msg`
    /// the #SoupMessage the auth is being created for
    /// ## `auth_header`
    /// the WWW-Authenticate/Proxy-Authenticate header
    ///
    /// # Returns
    ///
    /// the new #SoupAuth, or [`None`] if it could
    ///   not be created
    #[doc(alias = "soup_auth_new")]
    pub fn new(type_: glib::types::Type, msg: &Message, auth_header: &str) -> Option<Auth> {
        skip_assert_initialized!();
        unsafe {
            from_glib_full(ffi::soup_auth_new(
                type_.into_glib(),
                msg.to_glib_none().0,
                auth_header.to_glib_none().0,
            ))
        }
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Auth>> Sealed for T {}
}

/// Trait containing all [`struct@Auth`] methods.
///
/// # Implementors
///
/// [`AuthBasic`][struct@crate::AuthBasic], [`AuthDigest`][struct@crate::AuthDigest], [`AuthNTLM`][struct@crate::AuthNTLM], [`AuthNegotiate`][struct@crate::AuthNegotiate], [`Auth`][struct@crate::Auth]
pub trait AuthExt: IsA<Auth> + sealed::Sealed + 'static {
    /// Call this on an auth to authenticate it.
    ///
    /// Normally this will cause the auth's message to be requeued with the new
    /// authentication info.
    /// ## `username`
    /// the username provided by the user or client
    /// ## `password`
    /// the password provided by the user or client
    #[doc(alias = "soup_auth_authenticate")]
    fn authenticate(&self, username: &str, password: &str) {
        unsafe {
            ffi::soup_auth_authenticate(
                self.as_ref().to_glib_none().0,
                username.to_glib_none().0,
                password.to_glib_none().0,
            );
        }
    }

    /// Tests if @self is able to authenticate by providing credentials to the
    /// [`authenticate()`][Self::authenticate()].
    ///
    /// # Returns
    ///
    /// [`true`] if @self is able to accept credentials.
    #[doc(alias = "soup_auth_can_authenticate")]
    fn can_authenticate(&self) -> bool {
        unsafe {
            from_glib(ffi::soup_auth_can_authenticate(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Call this on an auth to cancel it.
    ///
    /// You need to cancel an auth to complete an asynchronous authenticate operation
    /// when no credentials are provided ([`authenticate()`][Self::authenticate()] is not called).
    /// The #SoupAuth will be cancelled on dispose if it hans't been authenticated.
    #[doc(alias = "soup_auth_cancel")]
    fn cancel(&self) {
        unsafe {
            ffi::soup_auth_cancel(self.as_ref().to_glib_none().0);
        }
    }

    //#[doc(alias = "soup_auth_free_protection_space")]
    //fn free_protection_space(&self, space: /*Unimplemented*/&[&Basic: Pointer]) {
    //    unsafe { TODO: call ffi:soup_auth_free_protection_space() }
    //}

    /// Returns the authority (host:port) that @self is associated with.
    ///
    /// # Returns
    ///
    /// the authority
    #[doc(alias = "soup_auth_get_authority")]
    #[doc(alias = "get_authority")]
    fn authority(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::soup_auth_get_authority(self.as_ref().to_glib_none().0)) }
    }

    /// Generates an appropriate "Authorization" header for @msg.
    ///
    /// (The session will only call this if [`is_authenticated()`][Self::is_authenticated()] returned
    /// [`true`].)
    /// ## `msg`
    /// the #SoupMessage to be authorized
    ///
    /// # Returns
    ///
    /// the "Authorization" header, which must be freed.
    #[doc(alias = "soup_auth_get_authorization")]
    #[doc(alias = "get_authorization")]
    fn authorization(&self, msg: &Message) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::soup_auth_get_authorization(
                self.as_ref().to_glib_none().0,
                msg.to_glib_none().0,
            ))
        }
    }

    /// Gets an opaque identifier for @self.
    ///
    /// The identifier can be used as a hash key or the like. #SoupAuth objects from
    /// the same server with the same identifier refer to the same authentication
    /// domain (eg, the URLs associated with them take the same usernames and
    /// passwords).
    ///
    /// # Returns
    ///
    /// the identifier
    #[doc(alias = "soup_auth_get_info")]
    #[doc(alias = "get_info")]
    fn info(&self) -> Option<glib::GString> {
        unsafe { from_glib_full(ffi::soup_auth_get_info(self.as_ref().to_glib_none().0)) }
    }

    /// Returns a list of paths on the server which @self extends over.
    ///
    /// (All subdirectories of these paths are also assumed to be part
    /// of @self's protection space, unless otherwise discovered not to
    /// be.)
    /// ## `source_uri`
    /// the URI of the request that @self was generated in
    ///   response to.
    ///
    /// # Returns
    ///
    /// the list of
    ///   paths, which can be freed with `Auth::free_protection_space()`.
    #[doc(alias = "soup_auth_get_protection_space")]
    #[doc(alias = "get_protection_space")]
    fn protection_space(&self, source_uri: &glib::Uri) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::soup_auth_get_protection_space(
                self.as_ref().to_glib_none().0,
                source_uri.to_glib_none().0,
            ))
        }
    }

    /// Returns @self's realm.
    ///
    /// This is an identifier that distinguishes separate authentication spaces on a
    /// given server, and may be some string that is meaningful to the user.
    /// (Although it is probably not localized.)
    ///
    /// # Returns
    ///
    /// the realm name
    #[doc(alias = "soup_auth_get_realm")]
    #[doc(alias = "get_realm")]
    fn realm(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::soup_auth_get_realm(self.as_ref().to_glib_none().0)) }
    }

    /// soup_auth_get_scheme_name: (attributes org.gtk.Method.get_property=scheme-name)
    /// Returns @self's scheme name. (Eg, "Basic", "Digest", or "NTLM")
    ///
    /// # Returns
    ///
    /// the scheme name
    #[doc(alias = "soup_auth_get_scheme_name")]
    #[doc(alias = "get_scheme_name")]
    fn scheme_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::soup_auth_get_scheme_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Tests if @self has been given a username and password.
    ///
    /// # Returns
    ///
    /// [`true`] if @self has been given a username and password
    #[doc(alias = "soup_auth_is_authenticated")]
    fn is_authenticated(&self) -> bool {
        unsafe {
            from_glib(ffi::soup_auth_is_authenticated(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Tests if @self has been cancelled
    ///
    /// # Returns
    ///
    /// [`true`] if @self has been cancelled
    #[doc(alias = "soup_auth_is_cancelled")]
    fn is_cancelled(&self) -> bool {
        unsafe { from_glib(ffi::soup_auth_is_cancelled(self.as_ref().to_glib_none().0)) }
    }

    /// Tests whether or not @self is associated with a proxy server rather
    /// than an "origin" server.
    ///
    /// # Returns
    ///
    /// [`true`] or [`false`]
    #[doc(alias = "soup_auth_is_for_proxy")]
    fn is_for_proxy(&self) -> bool {
        unsafe { from_glib(ffi::soup_auth_is_for_proxy(self.as_ref().to_glib_none().0)) }
    }

    /// Tests if @self is ready to make a request for @msg with.
    ///
    /// For most auths, this is equivalent to [`is_authenticated()`][Self::is_authenticated()], but for
    /// some auth types (eg, NTLM), the auth may be sendable (eg, as an
    /// authentication request) even before it is authenticated.
    /// ## `msg`
    /// a #SoupMessage
    ///
    /// # Returns
    ///
    /// [`true`] if @self is ready to make a request with.
    #[doc(alias = "soup_auth_is_ready")]
    fn is_ready(&self, msg: &Message) -> bool {
        unsafe {
            from_glib(ffi::soup_auth_is_ready(
                self.as_ref().to_glib_none().0,
                msg.to_glib_none().0,
            ))
        }
    }

    /// Updates @self with the information from @msg and @auth_header,
    /// possibly un-authenticating it.
    ///
    /// As with [`Auth::new()`][crate::Auth::new()], this is normally only used by [`Session`][crate::Session].
    /// ## `msg`
    /// the #SoupMessage @self is being updated for
    /// ## `auth_header`
    /// the WWW-Authenticate/Proxy-Authenticate header
    ///
    /// # Returns
    ///
    /// [`true`] if @self is still a valid (but potentially
    ///   unauthenticated) #SoupAuth. [`false`] if something about @auth_params
    ///   could not be parsed or incorporated into @self at all.
    #[doc(alias = "soup_auth_update")]
    fn update(&self, msg: &Message, auth_header: &str) -> bool {
        unsafe {
            from_glib(ffi::soup_auth_update(
                self.as_ref().to_glib_none().0,
                msg.to_glib_none().0,
                auth_header.to_glib_none().0,
            ))
        }
    }

    /// The authority (host:port) being authenticated to.
    fn set_authority(&self, authority: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "authority", authority)
    }

    /// Whether or not the auth is for a proxy server.
    #[doc(alias = "is-for-proxy")]
    fn set_is_for_proxy(&self, is_for_proxy: bool) {
        ObjectExt::set_property(self.as_ref(), "is-for-proxy", is_for_proxy)
    }

    /// The authentication realm.
    fn set_realm(&self, realm: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "realm", realm)
    }

    #[doc(alias = "authority")]
    fn connect_authority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_authority_trampoline<P: IsA<Auth>, F: Fn(&P) + 'static>(
            this: *mut ffi::SoupAuth,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Auth::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::authority\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_authority_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-authenticated")]
    fn connect_is_authenticated_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_authenticated_trampoline<
            P: IsA<Auth>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::SoupAuth,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Auth::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::is-authenticated\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_is_authenticated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-cancelled")]
    fn connect_is_cancelled_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_cancelled_trampoline<P: IsA<Auth>, F: Fn(&P) + 'static>(
            this: *mut ffi::SoupAuth,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Auth::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::is-cancelled\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_is_cancelled_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-for-proxy")]
    fn connect_is_for_proxy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_for_proxy_trampoline<P: IsA<Auth>, F: Fn(&P) + 'static>(
            this: *mut ffi::SoupAuth,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Auth::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::is-for-proxy\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_is_for_proxy_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "realm")]
    fn connect_realm_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_realm_trampoline<P: IsA<Auth>, F: Fn(&P) + 'static>(
            this: *mut ffi::SoupAuth,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Auth::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::realm\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_realm_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "scheme-name")]
    fn connect_scheme_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_scheme_name_trampoline<P: IsA<Auth>, F: Fn(&P) + 'static>(
            this: *mut ffi::SoupAuth,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Auth::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::scheme-name\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_scheme_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Auth>> AuthExt for O {}