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

glib::wrapper! {
    /// Debug logging support
    ///
    /// #SoupLogger watches a [`Session`][crate::Session] and logs the HTTP traffic that
    /// it generates, for debugging purposes. Many applications use an
    /// environment variable to determine whether or not to use
    /// #SoupLogger, and to determine the amount of debugging output.
    ///
    /// To use #SoupLogger, first create a logger with [`new()`][Self::new()], optionally
    /// configure it with [`set_request_filter()`][Self::set_request_filter()],
    /// [`set_response_filter()`][Self::set_response_filter()], and [`set_printer()`][Self::set_printer()], and
    /// then attach it to a session (or multiple sessions) with
    /// [`SessionExt::add_feature()`][crate::prelude::SessionExt::add_feature()].
    ///
    /// By default, the debugging output is sent to `stdout`, and looks something
    /// like:
    ///
    /// ```text
    /// > POST /unauth HTTP/1.1
    /// > Soup-Debug-Timestamp: 1200171744
    /// > Soup-Debug: SoupSession 1 (0x612190), SoupMessage 1 (0x617000), GSocket 1 (0x612220)
    /// > Host: localhost
    /// > Content-Type: text/plain
    /// > Connection: close
    ///
    /// < HTTP/1.1 201 Created
    /// < Soup-Debug-Timestamp: 1200171744
    /// < Soup-Debug: SoupMessage 1 (0x617000)
    /// < Date: Sun, 12 Jan 2008 21:02:24 GMT
    /// < Content-Length: 0
    /// ```
    ///
    /// The `Soup-Debug-Timestamp` line gives the time (as a `time_t`) when the
    /// request was sent, or the response fully received.
    ///
    /// The `Soup-Debug` line gives further debugging information about the
    /// [`Session`][crate::Session], [`Message`][crate::Message], and [`gio::Socket`][crate::gio::Socket] involved; the hex
    /// numbers are the addresses of the objects in question (which may be useful if
    /// you are running in a debugger). The decimal IDs are simply counters that
    /// uniquely identify objects across the lifetime of the #SoupLogger. In
    /// particular, this can be used to identify when multiple messages are sent
    /// across the same connection.
    ///
    /// Currently, the request half of the message is logged just before
    /// the first byte of the request gets written to the network (from the
    /// [`starting`][struct@crate::Message#starting] signal).
    ///
    /// The response is logged just after the last byte of the response body is read
    /// from the network (from the [`got-body`][struct@crate::Message#got-body] or
    /// [`got-informational`][struct@crate::Message#got-informational] signal), which means that the
    /// [`got-headers`][struct@crate::Message#got-headers] signal, and anything triggered off it (such as
    /// #SoupMessage::authenticate) will be emitted *before* the response headers are
    /// actually logged.
    ///
    /// If the response doesn't happen to trigger the [`got-body`][struct@crate::Message#got-body] nor
    /// [`got-informational`][struct@crate::Message#got-informational] signals due to, for example, a
    /// cancellation before receiving the last byte of the response body, the
    /// response will still be logged on the event of the [`finished`][struct@crate::Message#finished]
    /// signal.
    ///
    /// ## Properties
    ///
    ///
    /// #### `level`
    ///  The level of logging output.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `max-body-size`
    ///  If [`level`][struct@crate::Logger#level] is [`LoggerLogLevel::Body`][crate::LoggerLogLevel::Body], this gives
    /// the maximum number of bytes of the body that will be logged.
    /// (-1 means "no limit".)
    ///
    /// Readable | Writeable | Construct
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`SessionFeatureExt`][trait@crate::prelude::SessionFeatureExt]
    #[doc(alias = "SoupLogger")]
    pub struct Logger(Object<ffi::SoupLogger, ffi::SoupLoggerClass>) @implements SessionFeature;

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

impl Logger {
    /// Creates a new #SoupLogger with the given debug level.
    ///
    /// If you need finer control over what message parts are and aren't
    /// logged, use [`set_request_filter()`][Self::set_request_filter()] and
    /// [`set_response_filter()`][Self::set_response_filter()].
    /// ## `level`
    /// the debug level
    ///
    /// # Returns
    ///
    /// a new #SoupLogger
    #[doc(alias = "soup_logger_new")]
    pub fn new(level: LoggerLogLevel) -> Logger {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::soup_logger_new(level.into_glib())) }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`Logger`] objects.
    ///
    /// This method returns an instance of [`LoggerBuilder`](crate::builders::LoggerBuilder) which can be used to create [`Logger`] objects.
    pub fn builder() -> LoggerBuilder {
        LoggerBuilder::new()
    }

    /// Get the maximum body size for @self.
    ///
    /// # Returns
    ///
    /// the maximum body size, or -1 if unlimited
    #[doc(alias = "soup_logger_get_max_body_size")]
    #[doc(alias = "get_max_body_size")]
    pub fn max_body_size(&self) -> i32 {
        unsafe { ffi::soup_logger_get_max_body_size(self.to_glib_none().0) }
    }

    /// Sets the maximum body size for @self (-1 means no limit).
    /// ## `max_body_size`
    /// the maximum body size to log
    #[doc(alias = "soup_logger_set_max_body_size")]
    pub fn set_max_body_size(&self, max_body_size: i32) {
        unsafe {
            ffi::soup_logger_set_max_body_size(self.to_glib_none().0, max_body_size);
        }
    }

    /// Sets up a filter to determine the log level for a given request.
    ///
    /// For each HTTP request @self will invoke @request_filter to
    /// determine how much (if any) of that request to log. (If you do not
    /// set a request filter, @self will just always log requests at the
    /// level passed to [`new()`][Self::new()].)
    /// ## `request_filter`
    /// the callback for request debugging
    /// ## `filter_data`
    /// data to pass to the callback
    #[doc(alias = "soup_logger_set_request_filter")]
    pub fn set_request_filter<P: Fn(&Logger, &Message) -> LoggerLogLevel + 'static>(
        &self,
        request_filter: P,
    ) {
        let request_filter_data: Box_<P> = Box_::new(request_filter);
        unsafe extern "C" fn request_filter_func<
            P: Fn(&Logger, &Message) -> LoggerLogLevel + 'static,
        >(
            logger: *mut ffi::SoupLogger,
            msg: *mut ffi::SoupMessage,
            user_data: glib::ffi::gpointer,
        ) -> ffi::SoupLoggerLogLevel {
            let logger = from_glib_borrow(logger);
            let msg = from_glib_borrow(msg);
            let callback = &*(user_data as *mut P);
            (*callback)(&logger, &msg).into_glib()
        }
        let request_filter = Some(request_filter_func::<P> as _);
        unsafe extern "C" fn destroy_func<P: Fn(&Logger, &Message) -> LoggerLogLevel + 'static>(
            data: glib::ffi::gpointer,
        ) {
            let _callback = Box_::from_raw(data as *mut P);
        }
        let destroy_call3 = Some(destroy_func::<P> as _);
        let super_callback0: Box_<P> = request_filter_data;
        unsafe {
            ffi::soup_logger_set_request_filter(
                self.to_glib_none().0,
                request_filter,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// Sets up a filter to determine the log level for a given response.
    ///
    /// For each HTTP response @self will invoke @response_filter to
    /// determine how much (if any) of that response to log. (If you do not
    /// set a response filter, @self will just always log responses at
    /// the level passed to [`new()`][Self::new()].)
    /// ## `response_filter`
    /// the callback for response debugging
    /// ## `filter_data`
    /// data to pass to the callback
    #[doc(alias = "soup_logger_set_response_filter")]
    pub fn set_response_filter<P: Fn(&Logger, &Message) -> LoggerLogLevel + 'static>(
        &self,
        response_filter: P,
    ) {
        let response_filter_data: Box_<P> = Box_::new(response_filter);
        unsafe extern "C" fn response_filter_func<
            P: Fn(&Logger, &Message) -> LoggerLogLevel + 'static,
        >(
            logger: *mut ffi::SoupLogger,
            msg: *mut ffi::SoupMessage,
            user_data: glib::ffi::gpointer,
        ) -> ffi::SoupLoggerLogLevel {
            let logger = from_glib_borrow(logger);
            let msg = from_glib_borrow(msg);
            let callback = &*(user_data as *mut P);
            (*callback)(&logger, &msg).into_glib()
        }
        let response_filter = Some(response_filter_func::<P> as _);
        unsafe extern "C" fn destroy_func<P: Fn(&Logger, &Message) -> LoggerLogLevel + 'static>(
            data: glib::ffi::gpointer,
        ) {
            let _callback = Box_::from_raw(data as *mut P);
        }
        let destroy_call3 = Some(destroy_func::<P> as _);
        let super_callback0: Box_<P> = response_filter_data;
        unsafe {
            ffi::soup_logger_set_response_filter(
                self.to_glib_none().0,
                response_filter,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// The level of logging output.
    pub fn level(&self) -> LoggerLogLevel {
        ObjectExt::property(self, "level")
    }

    /// The level of logging output.
    pub fn set_level(&self, level: LoggerLogLevel) {
        ObjectExt::set_property(self, "level", level)
    }

    #[doc(alias = "level")]
    pub fn connect_level_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_level_trampoline<F: Fn(&Logger) + 'static>(
            this: *mut ffi::SoupLogger,
            _param_spec: glib::ffi::gpointer,
            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"notify::level\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_level_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "max-body-size")]
    pub fn connect_max_body_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_max_body_size_trampoline<F: Fn(&Logger) + 'static>(
            this: *mut ffi::SoupLogger,
            _param_spec: glib::ffi::gpointer,
            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"notify::max-body-size\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_max_body_size_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl Default for Logger {
    fn default() -> Self {
        glib::object::Object::new::<Self>()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Logger`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct LoggerBuilder {
    builder: glib::object::ObjectBuilder<'static, Logger>,
}

impl LoggerBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The level of logging output.
    pub fn level(self, level: LoggerLogLevel) -> Self {
        Self {
            builder: self.builder.property("level", level),
        }
    }

    /// If [`level`][struct@crate::Logger#level] is [`LoggerLogLevel::Body`][crate::LoggerLogLevel::Body], this gives
    /// the maximum number of bytes of the body that will be logged.
    /// (-1 means "no limit".)
    pub fn max_body_size(self, max_body_size: i32) -> Self {
        Self {
            builder: self.builder.property("max-body-size", max_body_size),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Logger`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Logger {
        self.builder.build()
    }
}