// Package gio was automatically generated by github.com/bnema/puregotk DO NOT EDIT
package gio

import (
	"structs"
	"unsafe"

	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/glib"
	"github.com/bnema/puregotk/v4/gobject"
	"github.com/bnema/puregotk/v4/gobject/types"
)

type ThreadedSocketServiceClass struct {
	_ structs.HostLayout

	ParentClass SocketServiceClass

	xRun uintptr

	xGReserved1 uintptr

	xGReserved2 uintptr

	xGReserved3 uintptr

	xGReserved4 uintptr

	xGReserved5 uintptr
}

func (x *ThreadedSocketServiceClass) GoPointer() uintptr {
	return uintptr(unsafe.Pointer(x))
}

// OverrideRun sets the "run" callback function.
func (x *ThreadedSocketServiceClass) OverrideRun(cb func(*ThreadedSocketService, *SocketConnection, *gobject.Object) bool) {
	if cb == nil {
		x.xRun = 0
	} else {
		x.xRun = purego.NewCallback(func(ServiceVarp uintptr, ConnectionVarp uintptr, SourceObjectVarp uintptr) bool {
			return cb(ThreadedSocketServiceNewFromInternalPtr(ServiceVarp), SocketConnectionNewFromInternalPtr(ConnectionVarp), gobject.ObjectNewFromInternalPtr(SourceObjectVarp))
		})
	}
}

// GetRun gets the "run" callback function.
func (x *ThreadedSocketServiceClass) GetRun() func(*ThreadedSocketService, *SocketConnection, *gobject.Object) bool {
	if x.xRun == 0 {
		return nil
	}
	var rawCallback func(ServiceVarp uintptr, ConnectionVarp uintptr, SourceObjectVarp uintptr) bool
	purego.RegisterFunc(&rawCallback, x.xRun)
	return func(ServiceVar *ThreadedSocketService, ConnectionVar *SocketConnection, SourceObjectVar *gobject.Object) bool {
		return rawCallback(ServiceVar.GoPointer(), ConnectionVar.GoPointer(), SourceObjectVar.GoPointer())
	}
}

// OverrideGReserved1 sets the "_g_reserved1" callback function.
func (x *ThreadedSocketServiceClass) OverrideGReserved1(cb func()) {
	if cb == nil {
		x.xGReserved1 = 0
	} else {
		x.xGReserved1 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved1 gets the "_g_reserved1" callback function.
func (x *ThreadedSocketServiceClass) GetGReserved1() func() {
	if x.xGReserved1 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved1)
	return func() {
		rawCallback()
	}
}

// OverrideGReserved2 sets the "_g_reserved2" callback function.
func (x *ThreadedSocketServiceClass) OverrideGReserved2(cb func()) {
	if cb == nil {
		x.xGReserved2 = 0
	} else {
		x.xGReserved2 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved2 gets the "_g_reserved2" callback function.
func (x *ThreadedSocketServiceClass) GetGReserved2() func() {
	if x.xGReserved2 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved2)
	return func() {
		rawCallback()
	}
}

// OverrideGReserved3 sets the "_g_reserved3" callback function.
func (x *ThreadedSocketServiceClass) OverrideGReserved3(cb func()) {
	if cb == nil {
		x.xGReserved3 = 0
	} else {
		x.xGReserved3 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved3 gets the "_g_reserved3" callback function.
func (x *ThreadedSocketServiceClass) GetGReserved3() func() {
	if x.xGReserved3 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved3)
	return func() {
		rawCallback()
	}
}

// OverrideGReserved4 sets the "_g_reserved4" callback function.
func (x *ThreadedSocketServiceClass) OverrideGReserved4(cb func()) {
	if cb == nil {
		x.xGReserved4 = 0
	} else {
		x.xGReserved4 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved4 gets the "_g_reserved4" callback function.
func (x *ThreadedSocketServiceClass) GetGReserved4() func() {
	if x.xGReserved4 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved4)
	return func() {
		rawCallback()
	}
}

// OverrideGReserved5 sets the "_g_reserved5" callback function.
func (x *ThreadedSocketServiceClass) OverrideGReserved5(cb func()) {
	if cb == nil {
		x.xGReserved5 = 0
	} else {
		x.xGReserved5 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved5 gets the "_g_reserved5" callback function.
func (x *ThreadedSocketServiceClass) GetGReserved5() func() {
	if x.xGReserved5 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved5)
	return func() {
		rawCallback()
	}
}

type ThreadedSocketServicePrivate struct {
	_ structs.HostLayout
}

func (x *ThreadedSocketServicePrivate) GoPointer() uintptr {
	return uintptr(unsafe.Pointer(x))
}

// A `GThreadedSocketService` is a simple subclass of [class@Gio.SocketService]
// that handles incoming connections by creating a worker thread and
// dispatching the connection to it by emitting the
// [signal@Gio.ThreadedSocketService::run signal] in the new thread.
//
// The signal handler may perform blocking I/O and need not return
// until the connection is closed.
//
// The service is implemented using a thread pool, so there is a
// limited amount of threads available to serve incoming requests.
// The service automatically stops the [class@Gio.SocketService] from accepting
// new connections when all threads are busy.
//
// As with [class@Gio.SocketService], you may connect to
// [signal@Gio.ThreadedSocketService::run], or subclass and override the default
// handler.
type ThreadedSocketService struct {
	SocketService
}

var xThreadedSocketServiceGLibType func() types.GType

func ThreadedSocketServiceGLibType() types.GType {
	return xThreadedSocketServiceGLibType()
}

func ThreadedSocketServiceNewFromInternalPtr(ptr uintptr) *ThreadedSocketService {
	cls := &ThreadedSocketService{}
	cls.Ptr = ptr
	return cls
}

var xNewThreadedSocketService func(int) uintptr

// Creates a new #GThreadedSocketService with no listeners. Listeners
// must be added with one of the #GSocketListener "add" methods.
func NewThreadedSocketService(MaxThreadsVar int) *ThreadedSocketService {
	var cls *ThreadedSocketService

	cret := xNewThreadedSocketService(MaxThreadsVar)

	if cret == 0 {
		return nil
	}
	cls = &ThreadedSocketService{}
	cls.Ptr = cret
	return cls
}

func (c *ThreadedSocketService) GoPointer() uintptr {
	if c == nil {
		return 0
	}
	return c.Ptr
}

func (c *ThreadedSocketService) SetGoPointer(ptr uintptr) {
	c.Ptr = ptr
}

// SetPropertyMaxThreads sets the "max-threads" property.
// The maximum number of threads handling clients for this service.
func (x *ThreadedSocketService) SetPropertyMaxThreads(value int) {
	var v gobject.Value
	v.Init(gobject.TypeIntVal)
	v.SetInt(value)
	x.SetProperty("max-threads", &v)
}

// GetPropertyMaxThreads gets the "max-threads" property.
// The maximum number of threads handling clients for this service.
func (x *ThreadedSocketService) GetPropertyMaxThreads() int {
	var v gobject.Value
	x.GetProperty("max-threads", &v)
	return v.GetInt()
}

// The ::run signal is emitted in a worker thread in response to an
// incoming connection. This thread is dedicated to handling
// @connection and may perform blocking IO. The signal handler need
// not return until the connection is closed.
func (x *ThreadedSocketService) ConnectRun(cb *func(ThreadedSocketService, uintptr, uintptr) bool) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "run", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, ConnectionVarp uintptr, SourceObjectVarp uintptr) bool {
		fa := ThreadedSocketService{}
		fa.Ptr = clsPtr
		cbFn := *cb

		return cbFn(fa, ConnectionVarp, SourceObjectVarp)

	}
	cbRefPtr := purego.NewCallback(fcb)
	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
	handlerID := gobject.SignalConnect(x.GoPointer(), "run", cbRefPtr)
	glib.SaveHandlerMapping(handlerID, cbPtr)
	return handlerID
}

func init() {
	core.SetPackageName("GIO", "gio-2.0")
	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("GIO") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xThreadedSocketServiceGLibType, libs, "g_threaded_socket_service_get_type")

	core.PuregoSafeRegister(&xNewThreadedSocketService, libs, "g_threaded_socket_service_new")

}