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

Represents a git remote callbacks.
-}

module GI.Ggit.Objects.RemoteCallbacks
    ( 

-- * Exported types
    RemoteCallbacks(..)                     ,
    IsRemoteCallbacks                       ,
    toRemoteCallbacks                       ,
    noRemoteCallbacks                       ,


 -- * Signals
-- ** completion #signal:completion#
    C_RemoteCallbacksCompletionCallback     ,
    RemoteCallbacksCompletionCallback       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    RemoteCallbacksCompletionSignalInfo     ,
#endif
    afterRemoteCallbacksCompletion          ,
    genClosure_RemoteCallbacksCompletion    ,
    mk_RemoteCallbacksCompletionCallback    ,
    noRemoteCallbacksCompletionCallback     ,
    onRemoteCallbacksCompletion             ,
    wrap_RemoteCallbacksCompletionCallback  ,


-- ** progress #signal:progress#
    C_RemoteCallbacksProgressCallback       ,
    RemoteCallbacksProgressCallback         ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    RemoteCallbacksProgressSignalInfo       ,
#endif
    afterRemoteCallbacksProgress            ,
    genClosure_RemoteCallbacksProgress      ,
    mk_RemoteCallbacksProgressCallback      ,
    noRemoteCallbacksProgressCallback       ,
    onRemoteCallbacksProgress               ,
    wrap_RemoteCallbacksProgressCallback    ,


-- ** transferProgress #signal:transferProgress#
    C_RemoteCallbacksTransferProgressCallback,
    RemoteCallbacksTransferProgressCallback ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    RemoteCallbacksTransferProgressSignalInfo,
#endif
    afterRemoteCallbacksTransferProgress    ,
    genClosure_RemoteCallbacksTransferProgress,
    mk_RemoteCallbacksTransferProgressCallback,
    noRemoteCallbacksTransferProgressCallback,
    onRemoteCallbacksTransferProgress       ,
    wrap_RemoteCallbacksTransferProgressCallback,


-- ** updateTips #signal:updateTips#
    C_RemoteCallbacksUpdateTipsCallback     ,
    RemoteCallbacksUpdateTipsCallback       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    RemoteCallbacksUpdateTipsSignalInfo     ,
#endif
    afterRemoteCallbacksUpdateTips          ,
    genClosure_RemoteCallbacksUpdateTips    ,
    mk_RemoteCallbacksUpdateTipsCallback    ,
    noRemoteCallbacksUpdateTipsCallback     ,
    onRemoteCallbacksUpdateTips             ,
    wrap_RemoteCallbacksUpdateTipsCallback  ,




    ) 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.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.TransferProgress as Ggit.TransferProgress

newtype RemoteCallbacks = RemoteCallbacks (ManagedPtr RemoteCallbacks)
foreign import ccall "ggit_remote_callbacks_get_type"
    c_ggit_remote_callbacks_get_type :: IO GType

instance GObject RemoteCallbacks where
    gobjectType _ = c_ggit_remote_callbacks_get_type
    

class GObject o => IsRemoteCallbacks o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError RemoteCallbacks a) =>
    IsRemoteCallbacks a
#endif
instance IsRemoteCallbacks RemoteCallbacks
instance GObject.Object.IsObject RemoteCallbacks

toRemoteCallbacks :: (MonadIO m, IsRemoteCallbacks o) => o -> m RemoteCallbacks
toRemoteCallbacks = liftIO . unsafeCastTo RemoteCallbacks

noRemoteCallbacks :: Maybe RemoteCallbacks
noRemoteCallbacks = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveRemoteCallbacksMethod (t :: Symbol) (o :: *) :: * where
    ResolveRemoteCallbacksMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveRemoteCallbacksMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveRemoteCallbacksMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveRemoteCallbacksMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveRemoteCallbacksMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveRemoteCallbacksMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveRemoteCallbacksMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveRemoteCallbacksMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveRemoteCallbacksMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveRemoteCallbacksMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveRemoteCallbacksMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveRemoteCallbacksMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveRemoteCallbacksMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveRemoteCallbacksMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveRemoteCallbacksMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveRemoteCallbacksMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveRemoteCallbacksMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveRemoteCallbacksMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveRemoteCallbacksMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveRemoteCallbacksMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveRemoteCallbacksMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveRemoteCallbacksMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveRemoteCallbacksMethod l o = O.MethodResolutionFailed l o

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

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

#endif

-- signal RemoteCallbacks::completion
type RemoteCallbacksCompletionCallback =
    Ggit.Enums.RemoteCompletionType ->
    IO ()

noRemoteCallbacksCompletionCallback :: Maybe RemoteCallbacksCompletionCallback
noRemoteCallbacksCompletionCallback = Nothing

type C_RemoteCallbacksCompletionCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_RemoteCallbacksCompletionCallback :: C_RemoteCallbacksCompletionCallback -> IO (FunPtr C_RemoteCallbacksCompletionCallback)

genClosure_RemoteCallbacksCompletion :: RemoteCallbacksCompletionCallback -> IO Closure
genClosure_RemoteCallbacksCompletion cb = do
    let cb' = wrap_RemoteCallbacksCompletionCallback cb
    mk_RemoteCallbacksCompletionCallback cb' >>= newCClosure


wrap_RemoteCallbacksCompletionCallback ::
    RemoteCallbacksCompletionCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_RemoteCallbacksCompletionCallback _cb _ object _ = do
    let object' = (toEnum . fromIntegral) object
    _cb  object'


onRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId
onRemoteCallbacksCompletion obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksCompletionCallback cb
    cb'' <- mk_RemoteCallbacksCompletionCallback cb'
    connectSignalFunPtr obj "completion" cb'' SignalConnectBefore

afterRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId
afterRemoteCallbacksCompletion obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksCompletionCallback cb
    cb'' <- mk_RemoteCallbacksCompletionCallback cb'
    connectSignalFunPtr obj "completion" cb'' SignalConnectAfter


-- signal RemoteCallbacks::progress
type RemoteCallbacksProgressCallback =
    T.Text ->
    IO ()

noRemoteCallbacksProgressCallback :: Maybe RemoteCallbacksProgressCallback
noRemoteCallbacksProgressCallback = Nothing

type C_RemoteCallbacksProgressCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_RemoteCallbacksProgressCallback :: C_RemoteCallbacksProgressCallback -> IO (FunPtr C_RemoteCallbacksProgressCallback)

genClosure_RemoteCallbacksProgress :: RemoteCallbacksProgressCallback -> IO Closure
genClosure_RemoteCallbacksProgress cb = do
    let cb' = wrap_RemoteCallbacksProgressCallback cb
    mk_RemoteCallbacksProgressCallback cb' >>= newCClosure


wrap_RemoteCallbacksProgressCallback ::
    RemoteCallbacksProgressCallback ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO ()
wrap_RemoteCallbacksProgressCallback _cb _ object _ = do
    object' <- cstringToText object
    _cb  object'


onRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId
onRemoteCallbacksProgress obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksProgressCallback cb
    cb'' <- mk_RemoteCallbacksProgressCallback cb'
    connectSignalFunPtr obj "progress" cb'' SignalConnectBefore

afterRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId
afterRemoteCallbacksProgress obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksProgressCallback cb
    cb'' <- mk_RemoteCallbacksProgressCallback cb'
    connectSignalFunPtr obj "progress" cb'' SignalConnectAfter


-- signal RemoteCallbacks::transfer-progress
type RemoteCallbacksTransferProgressCallback =
    Ggit.TransferProgress.TransferProgress ->
    IO ()

noRemoteCallbacksTransferProgressCallback :: Maybe RemoteCallbacksTransferProgressCallback
noRemoteCallbacksTransferProgressCallback = Nothing

type C_RemoteCallbacksTransferProgressCallback =
    Ptr () ->                               -- object
    Ptr Ggit.TransferProgress.TransferProgress ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_RemoteCallbacksTransferProgressCallback :: C_RemoteCallbacksTransferProgressCallback -> IO (FunPtr C_RemoteCallbacksTransferProgressCallback)

genClosure_RemoteCallbacksTransferProgress :: RemoteCallbacksTransferProgressCallback -> IO Closure
genClosure_RemoteCallbacksTransferProgress cb = do
    let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
    mk_RemoteCallbacksTransferProgressCallback cb' >>= newCClosure


wrap_RemoteCallbacksTransferProgressCallback ::
    RemoteCallbacksTransferProgressCallback ->
    Ptr () ->
    Ptr Ggit.TransferProgress.TransferProgress ->
    Ptr () ->
    IO ()
wrap_RemoteCallbacksTransferProgressCallback _cb _ object _ = do
    B.ManagedPtr.withTransient Ggit.TransferProgress.TransferProgress object $ \object' -> do
        _cb  object'


onRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId
onRemoteCallbacksTransferProgress obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
    cb'' <- mk_RemoteCallbacksTransferProgressCallback cb'
    connectSignalFunPtr obj "transfer-progress" cb'' SignalConnectBefore

afterRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId
afterRemoteCallbacksTransferProgress obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
    cb'' <- mk_RemoteCallbacksTransferProgressCallback cb'
    connectSignalFunPtr obj "transfer-progress" cb'' SignalConnectAfter


-- signal RemoteCallbacks::update-tips
type RemoteCallbacksUpdateTipsCallback =
    T.Text ->
    Ggit.OId.OId ->
    Ggit.OId.OId ->
    IO ()

noRemoteCallbacksUpdateTipsCallback :: Maybe RemoteCallbacksUpdateTipsCallback
noRemoteCallbacksUpdateTipsCallback = Nothing

type C_RemoteCallbacksUpdateTipsCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr Ggit.OId.OId ->
    Ptr Ggit.OId.OId ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_RemoteCallbacksUpdateTipsCallback :: C_RemoteCallbacksUpdateTipsCallback -> IO (FunPtr C_RemoteCallbacksUpdateTipsCallback)

genClosure_RemoteCallbacksUpdateTips :: RemoteCallbacksUpdateTipsCallback -> IO Closure
genClosure_RemoteCallbacksUpdateTips cb = do
    let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
    mk_RemoteCallbacksUpdateTipsCallback cb' >>= newCClosure


wrap_RemoteCallbacksUpdateTipsCallback ::
    RemoteCallbacksUpdateTipsCallback ->
    Ptr () ->
    CString ->
    Ptr Ggit.OId.OId ->
    Ptr Ggit.OId.OId ->
    Ptr () ->
    IO ()
wrap_RemoteCallbacksUpdateTipsCallback _cb _ object p0 p1 _ = do
    object' <- cstringToText object
    B.ManagedPtr.withTransient Ggit.OId.OId p0 $ \p0' -> do
        B.ManagedPtr.withTransient Ggit.OId.OId p1 $ \p1' -> do
            _cb  object' p0' p1'


onRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId
onRemoteCallbacksUpdateTips obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
    cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb'
    connectSignalFunPtr obj "update-tips" cb'' SignalConnectBefore

afterRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId
afterRemoteCallbacksUpdateTips obj cb = liftIO $ do
    let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
    cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb'
    connectSignalFunPtr obj "update-tips" cb'' SignalConnectAfter


#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList RemoteCallbacks
type instance O.AttributeList RemoteCallbacks = RemoteCallbacksAttributeList
type RemoteCallbacksAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data RemoteCallbacksCompletionSignalInfo
instance SignalInfo RemoteCallbacksCompletionSignalInfo where
    type HaskellCallbackType RemoteCallbacksCompletionSignalInfo = RemoteCallbacksCompletionCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_RemoteCallbacksCompletionCallback cb
        cb'' <- mk_RemoteCallbacksCompletionCallback cb'
        connectSignalFunPtr obj "completion" cb'' connectMode

data RemoteCallbacksProgressSignalInfo
instance SignalInfo RemoteCallbacksProgressSignalInfo where
    type HaskellCallbackType RemoteCallbacksProgressSignalInfo = RemoteCallbacksProgressCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_RemoteCallbacksProgressCallback cb
        cb'' <- mk_RemoteCallbacksProgressCallback cb'
        connectSignalFunPtr obj "progress" cb'' connectMode

data RemoteCallbacksTransferProgressSignalInfo
instance SignalInfo RemoteCallbacksTransferProgressSignalInfo where
    type HaskellCallbackType RemoteCallbacksTransferProgressSignalInfo = RemoteCallbacksTransferProgressCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_RemoteCallbacksTransferProgressCallback cb
        cb'' <- mk_RemoteCallbacksTransferProgressCallback cb'
        connectSignalFunPtr obj "transfer-progress" cb'' connectMode

data RemoteCallbacksUpdateTipsSignalInfo
instance SignalInfo RemoteCallbacksUpdateTipsSignalInfo where
    type HaskellCallbackType RemoteCallbacksUpdateTipsSignalInfo = RemoteCallbacksUpdateTipsCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_RemoteCallbacksUpdateTipsCallback cb
        cb'' <- mk_RemoteCallbacksUpdateTipsCallback cb'
        connectSignalFunPtr obj "update-tips" cb'' connectMode

type instance O.SignalList RemoteCallbacks = RemoteCallbacksSignalList
type RemoteCallbacksSignalList = ('[ '("completion", RemoteCallbacksCompletionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("progress", RemoteCallbacksProgressSignalInfo), '("transferProgress", RemoteCallbacksTransferProgressSignalInfo), '("updateTips", RemoteCallbacksUpdateTipsSignalInfo)] :: [(Symbol, *)])

#endif