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

use crate::SocketConnection;
use crate::SocketListener;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::ToValue;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// A [`SocketService`][crate::SocketService] is an object that represents a service that
    /// is provided to the network or over local sockets. When a new
    /// connection is made to the service the `signal::SocketService::incoming`
    /// signal is emitted.
    ///
    /// A [`SocketService`][crate::SocketService] is a subclass of [`SocketListener`][crate::SocketListener] and you need
    /// to add the addresses you want to accept connections on with the
    /// [`SocketListener`][crate::SocketListener] APIs.
    ///
    /// There are two options for implementing a network service based on
    /// [`SocketService`][crate::SocketService]. The first is to create the service using
    /// [`new()`][Self::new()] and to connect to the `signal::SocketService::incoming`
    /// signal. The second is to subclass [`SocketService`][crate::SocketService] and override the
    /// default signal handler implementation.
    ///
    /// In either case, the handler must immediately return, or else it
    /// will block additional incoming connections from being serviced.
    /// If you are interested in writing connection handlers that contain
    /// blocking code then see [`ThreadedSocketService`][crate::ThreadedSocketService].
    ///
    /// The socket service runs on the main loop of the
    /// [thread-default context][g-main-context-push-thread-default-context]
    /// of the thread it is created in, and is not
    /// threadsafe in general. However, the calls to start and stop the
    /// service are thread-safe so these can be used from threads that
    /// handle incoming clients.
    ///
    /// # Implements
    ///
    /// [`SocketServiceExt`][trait@crate::prelude::SocketServiceExt], [`SocketListenerExt`][trait@crate::prelude::SocketListenerExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GSocketService")]
    pub struct SocketService(Object<ffi::GSocketService, ffi::GSocketServiceClass>) @extends SocketListener;

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

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

    /// Creates a new [`SocketService`][crate::SocketService] with no sockets to listen for.
    /// New listeners can be added with e.g. [`SocketListenerExt::add_address()`][crate::prelude::SocketListenerExt::add_address()]
    /// or [`SocketListenerExt::add_inet_port()`][crate::prelude::SocketListenerExt::add_inet_port()].
    ///
    /// New services are created active, there is no need to call
    /// [`SocketServiceExt::start()`][crate::prelude::SocketServiceExt::start()], unless [`SocketServiceExt::stop()`][crate::prelude::SocketServiceExt::stop()] has been
    /// called before.
    ///
    /// # Returns
    ///
    /// a new [`SocketService`][crate::SocketService].
    #[doc(alias = "g_socket_service_new")]
    pub fn new() -> SocketService {
        unsafe { from_glib_full(ffi::g_socket_service_new()) }
    }
}

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

/// Trait containing all [`struct@SocketService`] methods.
///
/// # Implementors
///
/// [`SocketService`][struct@crate::SocketService], [`ThreadedSocketService`][struct@crate::ThreadedSocketService]
pub trait SocketServiceExt: 'static {
    /// Check whether the service is active or not. An active
    /// service will accept new clients that connect, while
    /// a non-active service will let connecting clients queue
    /// up until the service is started.
    ///
    /// # Returns
    ///
    /// [`true`] if the service is active, [`false`] otherwise
    #[doc(alias = "g_socket_service_is_active")]
    fn is_active(&self) -> bool;

    /// Restarts the service, i.e. start accepting connections
    /// from the added sockets when the mainloop runs. This only needs
    /// to be called after the service has been stopped from
    /// [`stop()`][Self::stop()].
    ///
    /// This call is thread-safe, so it may be called from a thread
    /// handling an incoming client request.
    #[doc(alias = "g_socket_service_start")]
    fn start(&self);

    /// Stops the service, i.e. stops accepting connections
    /// from the added sockets when the mainloop runs.
    ///
    /// This call is thread-safe, so it may be called from a thread
    /// handling an incoming client request.
    ///
    /// Note that this only stops accepting new connections; it does not
    /// close the listening sockets, and you can call
    /// [`start()`][Self::start()] again later to begin listening again. To
    /// close the listening sockets, call [`SocketListenerExt::close()`][crate::prelude::SocketListenerExt::close()]. (This
    /// will happen automatically when the [`SocketService`][crate::SocketService] is finalized.)
    ///
    /// This must be called before calling [`SocketListenerExt::close()`][crate::prelude::SocketListenerExt::close()] as
    /// the socket service will start accepting connections immediately
    /// when a new socket is added.
    #[doc(alias = "g_socket_service_stop")]
    fn stop(&self);

    /// Whether the service is currently accepting connections.
    fn set_active(&self, active: bool);

    /// The ::incoming signal is emitted when a new incoming connection
    /// to `service` needs to be handled. The handler must initiate the
    /// handling of `connection`, but may not block; in essence,
    /// asynchronous operations must be used.
    ///
    /// `connection` will be unreffed once the signal handler returns,
    /// so you need to ref it yourself if you are planning to use it.
    /// ## `connection`
    /// a new [`SocketConnection`][crate::SocketConnection] object
    /// ## `source_object`
    /// the source_object passed to
    ///  [`SocketListenerExt::add_address()`][crate::prelude::SocketListenerExt::add_address()]
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being called
    #[doc(alias = "incoming")]
    fn connect_incoming<F: Fn(&Self, &SocketConnection, Option<&glib::Object>) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "active")]
    fn connect_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<SocketService>> SocketServiceExt for O {
    fn is_active(&self) -> bool {
        unsafe {
            from_glib(ffi::g_socket_service_is_active(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn start(&self) {
        unsafe {
            ffi::g_socket_service_start(self.as_ref().to_glib_none().0);
        }
    }

    fn stop(&self) {
        unsafe {
            ffi::g_socket_service_stop(self.as_ref().to_glib_none().0);
        }
    }

    fn set_active(&self, active: bool) {
        glib::ObjectExt::set_property(self.as_ref(), "active", &active)
    }

    fn connect_incoming<
        F: Fn(&Self, &SocketConnection, Option<&glib::Object>) -> bool + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn incoming_trampoline<
            P: IsA<SocketService>,
            F: Fn(&P, &SocketConnection, Option<&glib::Object>) -> bool + 'static,
        >(
            this: *mut ffi::GSocketService,
            connection: *mut ffi::GSocketConnection,
            source_object: *mut glib::gobject_ffi::GObject,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                SocketService::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(connection),
                Option::<glib::Object>::from_glib_borrow(source_object)
                    .as_ref()
                    .as_ref(),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"incoming\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    incoming_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_active_trampoline<
            P: IsA<SocketService>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GSocketService,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SocketService::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::active\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_active_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for SocketService {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("SocketService")
    }
}