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

glib::wrapper! {
    /// Defines how to handle cookies in a #WebKitWebContext.
    ///
    /// The WebKitCookieManager defines how to set up and handle cookies.
    /// You can get it from a #WebKitWebsiteDataManager with
    /// webkit_website_data_manager_get_cookie_manager(), and use it to set where to
    /// store cookies with webkit_cookie_manager_set_persistent_storage(),
    /// or to set the acceptance policy, with webkit_cookie_manager_get_accept_policy().
    ///
    /// ## Signals
    ///
    ///
    /// #### `changed`
    ///  This signal is emitted when cookies are added, removed or modified.
    ///
    ///
    #[doc(alias = "WebKitCookieManager")]
    pub struct CookieManager(Object<ffi::WebKitCookieManager, ffi::WebKitCookieManagerClass>);

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

impl CookieManager {
    /// Asynchronously add a #SoupCookie to the underlying storage.
    ///
    /// When the operation is finished, @callback will be called. You can then call
    /// webkit_cookie_manager_add_cookie_finish() to get the result of the operation.
    /// ## `cookie`
    /// the #SoupCookie to be added
    /// ## `cancellable`
    /// a #GCancellable or [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is satisfied
    #[doc(alias = "webkit_cookie_manager_add_cookie")]
    pub fn add_cookie<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cookie: &soup::Cookie,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn add_cookie_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let _ = ffi::webkit_cookie_manager_add_cookie_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = add_cookie_trampoline::<P>;
        unsafe {
            ffi::webkit_cookie_manager_add_cookie(
                self.to_glib_none().0,
                mut_override(cookie.to_glib_none().0),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn add_cookie_future(
        &self,
        cookie: &soup::Cookie,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let cookie = cookie.clone();
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.add_cookie(&cookie, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Asynchronously delete a #SoupCookie from the current session.
    ///
    /// When the operation is finished, @callback will be called. You can then call
    /// webkit_cookie_manager_delete_cookie_finish() to get the result of the operation.
    /// ## `cookie`
    /// the #SoupCookie to be deleted
    /// ## `cancellable`
    /// a #GCancellable or [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is satisfied
    #[doc(alias = "webkit_cookie_manager_delete_cookie")]
    pub fn delete_cookie<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cookie: &soup::Cookie,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn delete_cookie_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let _ = ffi::webkit_cookie_manager_delete_cookie_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = delete_cookie_trampoline::<P>;
        unsafe {
            ffi::webkit_cookie_manager_delete_cookie(
                self.to_glib_none().0,
                mut_override(cookie.to_glib_none().0),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn delete_cookie_future(
        &self,
        cookie: &soup::Cookie,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let cookie = cookie.clone();
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.delete_cookie(&cookie, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Asynchronously get the cookie acceptance policy of @self.
    ///
    /// Note that when policy was set to [`CookieAcceptPolicy::NoThirdParty`][crate::CookieAcceptPolicy::NoThirdParty] and
    /// ITP is enabled, this will return [`CookieAcceptPolicy::Always`][crate::CookieAcceptPolicy::Always].
    /// See also webkit_website_data_manager_set_itp_enabled().
    ///
    /// When the operation is finished, @callback will be called. You can then call
    /// webkit_cookie_manager_get_accept_policy_finish() to get the result of the operation.
    /// ## `cancellable`
    /// a #GCancellable or [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is satisfied
    #[doc(alias = "webkit_cookie_manager_get_accept_policy")]
    #[doc(alias = "get_accept_policy")]
    pub fn accept_policy<P: FnOnce(Result<CookieAcceptPolicy, glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn accept_policy_trampoline<
            P: FnOnce(Result<CookieAcceptPolicy, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret = ffi::webkit_cookie_manager_get_accept_policy_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(from_glib(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = accept_policy_trampoline::<P>;
        unsafe {
            ffi::webkit_cookie_manager_get_accept_policy(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn accept_policy_future(
        &self,
    ) -> Pin<
        Box_<dyn std::future::Future<Output = Result<CookieAcceptPolicy, glib::Error>> + 'static>,
    > {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.accept_policy(Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Asynchronously get a list of #SoupCookie from @self.
    ///
    /// When the operation is finished, @callback will be called. You can then call
    /// webkit_cookie_manager_get_all_cookies_finish() to get the result of the operation.
    /// ## `cancellable`
    /// a #GCancellable or [`None`] to ignore
    /// ## `callback`
    /// (closure user_data): a #GAsyncReadyCallback to call when the request is satisfied
    #[cfg(feature = "v2_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_42")))]
    #[doc(alias = "webkit_cookie_manager_get_all_cookies")]
    #[doc(alias = "get_all_cookies")]
    pub fn all_cookies<P: FnOnce(Result<Vec<soup::Cookie>, glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn all_cookies_trampoline<
            P: FnOnce(Result<Vec<soup::Cookie>, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret = ffi::webkit_cookie_manager_get_all_cookies_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = all_cookies_trampoline::<P>;
        unsafe {
            ffi::webkit_cookie_manager_get_all_cookies(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v2_42")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_42")))]
    pub fn all_cookies_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<soup::Cookie>, glib::Error>> + 'static>>
    {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.all_cookies(Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Asynchronously get a list of #SoupCookie from @self.
    ///
    /// Asynchronously get a list of #SoupCookie from @self associated with @uri, which
    /// must be either an HTTP or an HTTPS URL.
    ///
    /// When the operation is finished, @callback will be called. You can then call
    /// webkit_cookie_manager_get_cookies_finish() to get the result of the operation.
    /// ## `uri`
    /// the URI associated to the cookies to be retrieved
    /// ## `cancellable`
    /// a #GCancellable or [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is satisfied
    #[doc(alias = "webkit_cookie_manager_get_cookies")]
    #[doc(alias = "get_cookies")]
    pub fn cookies<P: FnOnce(Result<Vec<soup::Cookie>, glib::Error>) + 'static>(
        &self,
        uri: &str,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn cookies_trampoline<
            P: FnOnce(Result<Vec<soup::Cookie>, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret = ffi::webkit_cookie_manager_get_cookies_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = cookies_trampoline::<P>;
        unsafe {
            ffi::webkit_cookie_manager_get_cookies(
                self.to_glib_none().0,
                uri.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn cookies_future(
        &self,
        uri: &str,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<soup::Cookie>, glib::Error>> + 'static>>
    {
        let uri = String::from(uri);
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.cookies(&uri, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Set the cookie acceptance policy of @self as @policy.
    ///
    /// Note that ITP has its own way to handle third-party cookies, so when it's enabled,
    /// and @policy is set to [`CookieAcceptPolicy::NoThirdParty`][crate::CookieAcceptPolicy::NoThirdParty], [`CookieAcceptPolicy::Always`][crate::CookieAcceptPolicy::Always]
    /// will be used instead. Once disabled, the policy will be set back to [`CookieAcceptPolicy::NoThirdParty`][crate::CookieAcceptPolicy::NoThirdParty].
    /// See also webkit_website_data_manager_set_itp_enabled().
    /// ## `policy`
    /// a #WebKitCookieAcceptPolicy
    #[doc(alias = "webkit_cookie_manager_set_accept_policy")]
    pub fn set_accept_policy(&self, policy: CookieAcceptPolicy) {
        unsafe {
            ffi::webkit_cookie_manager_set_accept_policy(self.to_glib_none().0, policy.into_glib());
        }
    }

    /// Set non-session cookies.
    ///
    /// Set the @filename where non-session cookies are stored persistently using
    /// @storage as the format to read/write the cookies.
    /// Cookies are initially read from @filename to create an initial set of cookies.
    /// Then, non-session cookies will be written to @filename when the WebKitCookieManager::changed
    /// signal is emitted.
    /// By default, @self doesn't store the cookies persistently, so you need to call this
    /// method to keep cookies saved across sessions.
    ///
    /// This method should never be called on a #WebKitCookieManager associated to an ephemeral #WebKitWebsiteDataManager.
    /// ## `filename`
    /// the filename to read to/write from
    /// ## `storage`
    /// a #WebKitCookiePersistentStorage
    #[doc(alias = "webkit_cookie_manager_set_persistent_storage")]
    pub fn set_persistent_storage(&self, filename: &str, storage: CookiePersistentStorage) {
        unsafe {
            ffi::webkit_cookie_manager_set_persistent_storage(
                self.to_glib_none().0,
                filename.to_glib_none().0,
                storage.into_glib(),
            );
        }
    }

    /// This signal is emitted when cookies are added, removed or modified.
    #[doc(alias = "changed")]
    pub fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn changed_trampoline<F: Fn(&CookieManager) + 'static>(
            this: *mut ffi::WebKitCookieManager,
            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"changed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    changed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}