{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

A 'GI.Gio.Objects.SocketService.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 'GI.Gio.Objects.SocketService.SocketService'::@/incoming/@
signal is emitted.

A 'GI.Gio.Objects.SocketService.SocketService' is a subclass of 'GI.Gio.Objects.SocketListener.SocketListener' and you need
to add the addresses you want to accept connections on with the
'GI.Gio.Objects.SocketListener.SocketListener' APIs.

There are two options for implementing a network service based on
'GI.Gio.Objects.SocketService.SocketService'. The first is to create the service using
'GI.Gio.Objects.SocketService.socketServiceNew' and to connect to the 'GI.Gio.Objects.SocketService.SocketService'::@/incoming/@
signal. The second is to subclass 'GI.Gio.Objects.SocketService.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 'GI.Gio.Objects.ThreadedSocketService.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.
-}

module GI.Gio.Objects.SocketService
    ( 

-- * Exported types
    SocketService(..)                       ,
    IsSocketService                         ,
    toSocketService                         ,
    noSocketService                         ,


 -- * Methods
-- ** isActive #method:isActive#
    SocketServiceIsActiveMethodInfo         ,
    socketServiceIsActive                   ,


-- ** new #method:new#
    socketServiceNew                        ,


-- ** start #method:start#
    SocketServiceStartMethodInfo            ,
    socketServiceStart                      ,


-- ** stop #method:stop#
    SocketServiceStopMethodInfo             ,
    socketServiceStop                       ,




 -- * Properties
-- ** active #attr:active#
    SocketServiceActivePropertyInfo         ,
    constructSocketServiceActive            ,
    getSocketServiceActive                  ,
    setSocketServiceActive                  ,
    socketServiceActive                     ,




 -- * Signals
-- ** incoming #signal:incoming#
    C_SocketServiceIncomingCallback         ,
    SocketServiceIncomingCallback           ,
    SocketServiceIncomingSignalInfo         ,
    afterSocketServiceIncoming              ,
    genClosure_SocketServiceIncoming        ,
    mk_SocketServiceIncomingCallback        ,
    noSocketServiceIncomingCallback         ,
    onSocketServiceIncoming                 ,
    wrap_SocketServiceIncomingCallback      ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketConnection as Gio.SocketConnection
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketListener as Gio.SocketListener

newtype SocketService = SocketService (ManagedPtr SocketService)
foreign import ccall "g_socket_service_get_type"
    c_g_socket_service_get_type :: IO GType

instance GObject SocketService where
    gobjectType _ = c_g_socket_service_get_type
    

class GObject o => IsSocketService o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError SocketService a) =>
    IsSocketService a
#endif
instance IsSocketService SocketService
instance Gio.SocketListener.IsSocketListener SocketService
instance GObject.Object.IsObject SocketService

toSocketService :: IsSocketService o => o -> IO SocketService
toSocketService = unsafeCastTo SocketService

noSocketService :: Maybe SocketService
noSocketService = Nothing

type family ResolveSocketServiceMethod (t :: Symbol) (o :: *) :: * where
    ResolveSocketServiceMethod "accept" o = Gio.SocketListener.SocketListenerAcceptMethodInfo
    ResolveSocketServiceMethod "acceptAsync" o = Gio.SocketListener.SocketListenerAcceptAsyncMethodInfo
    ResolveSocketServiceMethod "acceptFinish" o = Gio.SocketListener.SocketListenerAcceptFinishMethodInfo
    ResolveSocketServiceMethod "acceptSocket" o = Gio.SocketListener.SocketListenerAcceptSocketMethodInfo
    ResolveSocketServiceMethod "acceptSocketAsync" o = Gio.SocketListener.SocketListenerAcceptSocketAsyncMethodInfo
    ResolveSocketServiceMethod "acceptSocketFinish" o = Gio.SocketListener.SocketListenerAcceptSocketFinishMethodInfo
    ResolveSocketServiceMethod "addAddress" o = Gio.SocketListener.SocketListenerAddAddressMethodInfo
    ResolveSocketServiceMethod "addAnyInetPort" o = Gio.SocketListener.SocketListenerAddAnyInetPortMethodInfo
    ResolveSocketServiceMethod "addInetPort" o = Gio.SocketListener.SocketListenerAddInetPortMethodInfo
    ResolveSocketServiceMethod "addSocket" o = Gio.SocketListener.SocketListenerAddSocketMethodInfo
    ResolveSocketServiceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSocketServiceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSocketServiceMethod "close" o = Gio.SocketListener.SocketListenerCloseMethodInfo
    ResolveSocketServiceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSocketServiceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSocketServiceMethod "isActive" o = SocketServiceIsActiveMethodInfo
    ResolveSocketServiceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSocketServiceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSocketServiceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSocketServiceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSocketServiceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSocketServiceMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveSocketServiceMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveSocketServiceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSocketServiceMethod "start" o = SocketServiceStartMethodInfo
    ResolveSocketServiceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSocketServiceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSocketServiceMethod "stop" o = SocketServiceStopMethodInfo
    ResolveSocketServiceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSocketServiceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSocketServiceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSocketServiceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSocketServiceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSocketServiceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSocketServiceMethod "setBacklog" o = Gio.SocketListener.SocketListenerSetBacklogMethodInfo
    ResolveSocketServiceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSocketServiceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSocketServiceMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSocketServiceMethod t SocketService, O.MethodInfo info SocketService p) => O.IsLabelProxy t (SocketService -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveSocketServiceMethod t SocketService, O.MethodInfo info SocketService p) => O.IsLabel t (SocketService -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal SocketService::incoming
type SocketServiceIncomingCallback =
    Gio.SocketConnection.SocketConnection ->
    Maybe GObject.Object.Object ->
    IO Bool

noSocketServiceIncomingCallback :: Maybe SocketServiceIncomingCallback
noSocketServiceIncomingCallback = Nothing

type C_SocketServiceIncomingCallback =
    Ptr () ->                               -- object
    Ptr Gio.SocketConnection.SocketConnection ->
    Ptr GObject.Object.Object ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_SocketServiceIncomingCallback :: C_SocketServiceIncomingCallback -> IO (FunPtr C_SocketServiceIncomingCallback)

genClosure_SocketServiceIncoming :: SocketServiceIncomingCallback -> IO Closure
genClosure_SocketServiceIncoming cb = do
    let cb' = wrap_SocketServiceIncomingCallback cb
    mk_SocketServiceIncomingCallback cb' >>= newCClosure


wrap_SocketServiceIncomingCallback ::
    SocketServiceIncomingCallback ->
    Ptr () ->
    Ptr Gio.SocketConnection.SocketConnection ->
    Ptr GObject.Object.Object ->
    Ptr () ->
    IO CInt
wrap_SocketServiceIncomingCallback _cb _ connection sourceObject _ = do
    connection' <- (newObject Gio.SocketConnection.SocketConnection) connection
    maybeSourceObject <-
        if sourceObject == nullPtr
        then return Nothing
        else do
            sourceObject' <- (newObject GObject.Object.Object) sourceObject
            return $ Just sourceObject'
    result <- _cb  connection' maybeSourceObject
    let result' = (fromIntegral . fromEnum) result
    return result'


onSocketServiceIncoming :: (GObject a, MonadIO m) => a -> SocketServiceIncomingCallback -> m SignalHandlerId
onSocketServiceIncoming obj cb = liftIO $ connectSocketServiceIncoming obj cb SignalConnectBefore
afterSocketServiceIncoming :: (GObject a, MonadIO m) => a -> SocketServiceIncomingCallback -> m SignalHandlerId
afterSocketServiceIncoming obj cb = connectSocketServiceIncoming obj cb SignalConnectAfter

connectSocketServiceIncoming :: (GObject a, MonadIO m) =>
                                a -> SocketServiceIncomingCallback -> SignalConnectMode -> m SignalHandlerId
connectSocketServiceIncoming obj cb after = liftIO $ do
    let cb' = wrap_SocketServiceIncomingCallback cb
    cb'' <- mk_SocketServiceIncomingCallback cb'
    connectSignalFunPtr obj "incoming" cb'' after

-- VVV Prop "active"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

getSocketServiceActive :: (MonadIO m, IsSocketService o) => o -> m Bool
getSocketServiceActive obj = liftIO $ getObjectPropertyBool obj "active"

setSocketServiceActive :: (MonadIO m, IsSocketService o) => o -> Bool -> m ()
setSocketServiceActive obj val = liftIO $ setObjectPropertyBool obj "active" val

constructSocketServiceActive :: (IsSocketService o) => Bool -> IO (GValueConstruct o)
constructSocketServiceActive val = constructObjectPropertyBool "active" val

data SocketServiceActivePropertyInfo
instance AttrInfo SocketServiceActivePropertyInfo where
    type AttrAllowedOps SocketServiceActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint SocketServiceActivePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint SocketServiceActivePropertyInfo = IsSocketService
    type AttrGetType SocketServiceActivePropertyInfo = Bool
    type AttrLabel SocketServiceActivePropertyInfo = "active"
    type AttrOrigin SocketServiceActivePropertyInfo = SocketService
    attrGet _ = getSocketServiceActive
    attrSet _ = setSocketServiceActive
    attrConstruct _ = constructSocketServiceActive
    attrClear _ = undefined

instance O.HasAttributeList SocketService
type instance O.AttributeList SocketService = SocketServiceAttributeList
type SocketServiceAttributeList = ('[ '("active", SocketServiceActivePropertyInfo), '("listenBacklog", Gio.SocketListener.SocketListenerListenBacklogPropertyInfo)] :: [(Symbol, *)])

socketServiceActive :: AttrLabelProxy "active"
socketServiceActive = AttrLabelProxy

data SocketServiceIncomingSignalInfo
instance SignalInfo SocketServiceIncomingSignalInfo where
    type HaskellCallbackType SocketServiceIncomingSignalInfo = SocketServiceIncomingCallback
    connectSignal _ = connectSocketServiceIncoming

type instance O.SignalList SocketService = SocketServiceSignalList
type SocketServiceSignalList = ('[ '("event", Gio.SocketListener.SocketListenerEventSignalInfo), '("incoming", SocketServiceIncomingSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method SocketService::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketService"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_service_new" g_socket_service_new :: 
    IO (Ptr SocketService)

{- |
Creates a new 'GI.Gio.Objects.SocketService.SocketService' with no sockets to listen for.
New listeners can be added with e.g. 'GI.Gio.Objects.SocketListener.socketListenerAddAddress'
or 'GI.Gio.Objects.SocketListener.socketListenerAddInetPort'.

New services are created active, there is no need to call
'GI.Gio.Objects.SocketService.socketServiceStart', unless 'GI.Gio.Objects.SocketService.socketServiceStop' has been
called before.

@since 2.22
-}
socketServiceNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m SocketService
    {- ^ __Returns:__ a new 'GI.Gio.Objects.SocketService.SocketService'. -}
socketServiceNew  = liftIO $ do
    result <- g_socket_service_new
    checkUnexpectedReturnNULL "socketServiceNew" result
    result' <- (wrapObject SocketService) result
    return result'

-- method SocketService::is_active
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "service", argType = TInterface (Name {namespace = "Gio", name = "SocketService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_service_is_active" g_socket_service_is_active :: 
    Ptr SocketService ->                    -- service : TInterface (Name {namespace = "Gio", name = "SocketService"})
    IO CInt

{- |
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.

@since 2.22
-}
socketServiceIsActive ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketService a) =>
    a
    {- ^ /@service@/: a 'GI.Gio.Objects.SocketService.SocketService' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the service is active, 'False' otherwise -}
socketServiceIsActive service = liftIO $ do
    service' <- unsafeManagedPtrCastPtr service
    result <- g_socket_service_is_active service'
    let result' = (/= 0) result
    touchManagedPtr service
    return result'

data SocketServiceIsActiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSocketService a) => O.MethodInfo SocketServiceIsActiveMethodInfo a signature where
    overloadedMethod _ = socketServiceIsActive

-- method SocketService::start
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "service", argType = TInterface (Name {namespace = "Gio", name = "SocketService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_service_start" g_socket_service_start :: 
    Ptr SocketService ->                    -- service : TInterface (Name {namespace = "Gio", name = "SocketService"})
    IO ()

{- |
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
'GI.Gio.Objects.SocketService.socketServiceStop'.

This call is thread-safe, so it may be called from a thread
handling an incoming client request.

@since 2.22
-}
socketServiceStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketService a) =>
    a
    {- ^ /@service@/: a 'GI.Gio.Objects.SocketService.SocketService' -}
    -> m ()
socketServiceStart service = liftIO $ do
    service' <- unsafeManagedPtrCastPtr service
    g_socket_service_start service'
    touchManagedPtr service
    return ()

data SocketServiceStartMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSocketService a) => O.MethodInfo SocketServiceStartMethodInfo a signature where
    overloadedMethod _ = socketServiceStart

-- method SocketService::stop
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "service", argType = TInterface (Name {namespace = "Gio", name = "SocketService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_service_stop" g_socket_service_stop :: 
    Ptr SocketService ->                    -- service : TInterface (Name {namespace = "Gio", name = "SocketService"})
    IO ()

{- |
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
'GI.Gio.Objects.SocketService.socketServiceStart' again later to begin listening again. To
close the listening sockets, call 'GI.Gio.Objects.SocketListener.socketListenerClose'. (This
will happen automatically when the 'GI.Gio.Objects.SocketService.SocketService' is finalized.)

This must be called before calling 'GI.Gio.Objects.SocketListener.socketListenerClose' as
the socket service will start accepting connections immediately
when a new socket is added.

@since 2.22
-}
socketServiceStop ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketService a) =>
    a
    {- ^ /@service@/: a 'GI.Gio.Objects.SocketService.SocketService' -}
    -> m ()
socketServiceStop service = liftIO $ do
    service' <- unsafeManagedPtrCastPtr service
    g_socket_service_stop service'
    touchManagedPtr service
    return ()

data SocketServiceStopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSocketService a) => O.MethodInfo SocketServiceStopMethodInfo a signature where
    overloadedMethod _ = socketServiceStop