// 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::{HSTSPolicy, SessionFeature};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Automatic HTTP Strict Transport Security enforcing for [`Session`][crate::Session].
    ///
    /// A #SoupHSTSEnforcer stores HSTS policies and enforces them when
    /// required. #SoupHSTSEnforcer implements [`SessionFeature`][crate::SessionFeature], so you
    /// can add an HSTS enforcer to a session with
    /// [`SessionExt::add_feature()`][crate::prelude::SessionExt::add_feature()] or [`SessionExt::add_feature_by_type()`][crate::prelude::SessionExt::add_feature_by_type()].
    ///
    /// #SoupHSTSEnforcer keeps track of all the HTTPS destinations that,
    /// when connected to, return the Strict-Transport-Security header with
    /// valid values. #SoupHSTSEnforcer will forget those destinations
    /// upon expiry or when the server requests it.
    ///
    /// When the [`Session`][crate::Session] the #SoupHSTSEnforcer is attached to queues or
    /// restarts a message, the #SoupHSTSEnforcer will rewrite the URI to HTTPS if
    /// the destination is a known HSTS host and is contacted over an insecure
    /// transport protocol (HTTP). Users of #SoupHSTSEnforcer are advised to listen
    /// to changes in the [`uri`][struct@crate::Message#uri] property in order to be aware of
    /// changes in the message URI.
    ///
    /// Note that #SoupHSTSEnforcer does not support any form of long-term
    /// HSTS policy persistence. See [`HSTSEnforcerDB`][crate::HSTSEnforcerDB] for a persistent
    /// enforcer.
    ///
    /// ## Signals
    ///
    ///
    /// #### `changed`
    ///  Emitted when @hsts_enforcer changes.
    ///
    /// If a policy has been added,
    /// @new_policy will contain the newly-added policy and
    /// @old_policy will be [`None`]. If a policy has been deleted,
    /// @old_policy will contain the to-be-deleted policy and
    /// @new_policy will be [`None`]. If a policy has been changed,
    /// @old_policy will contain its old value, and @new_policy its
    /// new value.
    ///
    /// Note that you shouldn't modify the policies from a callback to
    /// this signal.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`HSTSEnforcerExt`][trait@crate::prelude::HSTSEnforcerExt], [`trait@glib::ObjectExt`], [`SessionFeatureExt`][trait@crate::prelude::SessionFeatureExt]
    #[doc(alias = "SoupHSTSEnforcer")]
    pub struct HSTSEnforcer(Object<ffi::SoupHSTSEnforcer, ffi::SoupHSTSEnforcerClass>) @implements SessionFeature;

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

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

    /// Creates a new #SoupHSTSEnforcer.
    ///
    /// The base #SoupHSTSEnforcer class does not support persistent storage of HSTS
    /// policies, see [`HSTSEnforcerDB`][crate::HSTSEnforcerDB] for that.
    ///
    /// # Returns
    ///
    /// a new #SoupHSTSEnforcer
    #[doc(alias = "soup_hsts_enforcer_new")]
    pub fn new() -> HSTSEnforcer {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::soup_hsts_enforcer_new()) }
    }
}

impl Default for HSTSEnforcer {
    fn default() -> Self {
        Self::new()
    }
}

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

/// Trait containing all [`struct@HSTSEnforcer`] methods.
///
/// # Implementors
///
/// [`HSTSEnforcerDB`][struct@crate::HSTSEnforcerDB], [`HSTSEnforcer`][struct@crate::HSTSEnforcer]
pub trait HSTSEnforcerExt: IsA<HSTSEnforcer> + sealed::Sealed + 'static {
    /// Gets a list of domains for which there are policies in @enforcer.
    /// ## `session_policies`
    /// whether to include session policies
    ///
    /// # Returns
    ///
    /// a newly allocated
    ///   list of domains. Use [`glib::List::free_full()`][crate::glib::List::free_full()] and `free()` to free the
    ///   list.
    #[doc(alias = "soup_hsts_enforcer_get_domains")]
    #[doc(alias = "get_domains")]
    fn domains(&self, session_policies: bool) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::soup_hsts_enforcer_get_domains(
                self.as_ref().to_glib_none().0,
                session_policies.into_glib(),
            ))
        }
    }

    /// Gets a list with the policies in @enforcer.
    /// ## `session_policies`
    /// whether to include session policies
    ///
    /// # Returns
    ///
    /// a newly
    ///   allocated list of policies. Use [`glib::List::free_full()`][crate::glib::List::free_full()] and
    ///   `HSTSPolicy::free()` to free the list.
    #[doc(alias = "soup_hsts_enforcer_get_policies")]
    #[doc(alias = "get_policies")]
    fn policies(&self, session_policies: bool) -> Vec<HSTSPolicy> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::soup_hsts_enforcer_get_policies(
                self.as_ref().to_glib_none().0,
                session_policies.into_glib(),
            ))
        }
    }

    /// Gets whether @self has a currently valid policy for @domain.
    /// ## `domain`
    /// a domain.
    ///
    /// # Returns
    ///
    /// [`true`] if access to @domain should happen over HTTPS, false
    ///   otherwise.
    #[doc(alias = "soup_hsts_enforcer_has_valid_policy")]
    fn has_valid_policy(&self, domain: &str) -> bool {
        unsafe {
            from_glib(ffi::soup_hsts_enforcer_has_valid_policy(
                self.as_ref().to_glib_none().0,
                domain.to_glib_none().0,
            ))
        }
    }

    /// Gets whether @self stores policies persistenly.
    ///
    /// # Returns
    ///
    /// [`true`] if @self storage is persistent or [`false`] otherwise.
    #[doc(alias = "soup_hsts_enforcer_is_persistent")]
    fn is_persistent(&self) -> bool {
        unsafe {
            from_glib(ffi::soup_hsts_enforcer_is_persistent(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets @policy to @self.
    ///
    /// If @policy is expired, any existing HSTS policy for its host will be removed
    /// instead. If a policy existed for this host, it will be replaced. Otherwise,
    /// the new policy will be inserted. If the policy is a session policy, that is,
    /// one created with `HSTSPolicy::new_session_policy()`, the policy will not
    /// expire and will be enforced during the lifetime of @self's
    /// [`Session`][crate::Session].
    /// ## `policy`
    /// the policy of the HSTS host
    #[doc(alias = "soup_hsts_enforcer_set_policy")]
    fn set_policy(&self, policy: &mut HSTSPolicy) {
        unsafe {
            ffi::soup_hsts_enforcer_set_policy(
                self.as_ref().to_glib_none().0,
                policy.to_glib_none_mut().0,
            );
        }
    }

    /// Sets a session policy for @domain.
    ///
    /// A session policy is a policy that is permanent to the lifetime of
    /// @self's [`Session`][crate::Session] and doesn't expire.
    /// ## `domain`
    /// policy domain or hostname
    /// ## `include_subdomains`
    /// [`true`] if the policy applies on sub domains
    #[doc(alias = "soup_hsts_enforcer_set_session_policy")]
    fn set_session_policy(&self, domain: &str, include_subdomains: bool) {
        unsafe {
            ffi::soup_hsts_enforcer_set_session_policy(
                self.as_ref().to_glib_none().0,
                domain.to_glib_none().0,
                include_subdomains.into_glib(),
            );
        }
    }

    /// Emitted when @hsts_enforcer changes.
    ///
    /// If a policy has been added,
    /// @new_policy will contain the newly-added policy and
    /// @old_policy will be [`None`]. If a policy has been deleted,
    /// @old_policy will contain the to-be-deleted policy and
    /// @new_policy will be [`None`]. If a policy has been changed,
    /// @old_policy will contain its old value, and @new_policy its
    /// new value.
    ///
    /// Note that you shouldn't modify the policies from a callback to
    /// this signal.
    /// ## `old_policy`
    /// the old #SoupHSTSPolicy value
    /// ## `new_policy`
    /// the new #SoupHSTSPolicy value
    #[doc(alias = "changed")]
    fn connect_changed<F: Fn(&Self, &HSTSPolicy, &HSTSPolicy) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn changed_trampoline<
            P: IsA<HSTSEnforcer>,
            F: Fn(&P, &HSTSPolicy, &HSTSPolicy) + 'static,
        >(
            this: *mut ffi::SoupHSTSEnforcer,
            old_policy: *mut ffi::SoupHSTSPolicy,
            new_policy: *mut ffi::SoupHSTSPolicy,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                HSTSEnforcer::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(old_policy),
                &from_glib_borrow(new_policy),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<HSTSEnforcer>> HSTSEnforcerExt for O {}