// 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/types"
)

// Provides an interface for converting data from one type
// to another type. The conversion can be stateful
// and may fail at any place.
type ConverterIface struct {
	_ structs.HostLayout

	GIface uintptr

	xConvert uintptr

	xReset uintptr
}

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

// OverrideConvert sets the "convert" callback function.
// Converts data.
func (x *ConverterIface) OverrideConvert(cb func(Converter, []byte, uint, []byte, uint, ConverterFlags, *uint, *uint) ConverterResult) {
	if cb == nil {
		x.xConvert = 0
	} else {
		x.xConvert = purego.NewCallback(func(ConverterVarp uintptr, InbufVarp []byte, InbufSizeVarp uint, OutbufVarp []byte, OutbufSizeVarp uint, FlagsVarp ConverterFlags, BytesReadVarp *uint, BytesWrittenVarp *uint) ConverterResult {
			return cb(&ConverterBase{Ptr: ConverterVarp}, InbufVarp, InbufSizeVarp, OutbufVarp, OutbufSizeVarp, FlagsVarp, BytesReadVarp, BytesWrittenVarp)
		})
	}
}

// GetConvert gets the "convert" callback function.
// Converts data.
func (x *ConverterIface) GetConvert() func(Converter, []byte, uint, []byte, uint, ConverterFlags, *uint, *uint) ConverterResult {
	if x.xConvert == 0 {
		return nil
	}
	var rawCallback func(ConverterVarp uintptr, InbufVarp []byte, InbufSizeVarp uint, OutbufVarp []byte, OutbufSizeVarp uint, FlagsVarp ConverterFlags, BytesReadVarp *uint, BytesWrittenVarp *uint) ConverterResult
	purego.RegisterFunc(&rawCallback, x.xConvert)
	return func(ConverterVar Converter, InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar *uint, BytesWrittenVar *uint) ConverterResult {
		return rawCallback(ConverterVar.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar)
	}
}

// OverrideReset sets the "reset" callback function.
// Reverts the internal state of the converter to its initial state.
func (x *ConverterIface) OverrideReset(cb func(Converter)) {
	if cb == nil {
		x.xReset = 0
	} else {
		x.xReset = purego.NewCallback(func(ConverterVarp uintptr) {
			cb(&ConverterBase{Ptr: ConverterVarp})
		})
	}
}

// GetReset gets the "reset" callback function.
// Reverts the internal state of the converter to its initial state.
func (x *ConverterIface) GetReset() func(Converter) {
	if x.xReset == 0 {
		return nil
	}
	var rawCallback func(ConverterVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xReset)
	return func(ConverterVar Converter) {
		rawCallback(ConverterVar.GoPointer())
	}
}

// `GConverter` is an interface for streaming conversions.
//
// `GConverter` is implemented by objects that convert
// binary data in various ways. The conversion can be
// stateful and may fail at any place.
//
// Some example conversions are: character set conversion,
// compression, decompression and regular expression
// replace.
type Converter interface {
	GoPointer() uintptr
	SetGoPointer(uintptr)
	Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar *uint, BytesWrittenVar *uint) (ConverterResult, error)
	ConvertBytes(BytesVar *glib.Bytes) (*glib.Bytes, error)
	Reset()
}

var xConverterGLibType func() types.GType

func ConverterGLibType() types.GType {
	return xConverterGLibType()
}

type ConverterBase struct {
	Ptr uintptr
}

func (x *ConverterBase) GoPointer() uintptr {
	if x == nil {
		return 0
	}
	return x.Ptr
}

func (x *ConverterBase) SetGoPointer(ptr uintptr) {
	x.Ptr = ptr
}

// This is the main operation used when converting data. It is to be called
// multiple times in a loop, and each time it will do some work, i.e.
// producing some output (in @outbuf) or consuming some input (from @inbuf) or
// both. If its not possible to do any work an error is returned.
//
// Note that a single call may not consume all input (or any input at all).
// Also a call may produce output even if given no input, due to state stored
// in the converter producing output.
//
// If any data was either produced or consumed, and then an error happens, then
// only the successful conversion is reported and the error is returned on the
// next call.
//
// A full conversion loop involves calling this method repeatedly, each time
// giving it new input and space output space. When there is no more input
// data after the data in @inbuf, the flag %G_CONVERTER_INPUT_AT_END must be set.
// The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
// each time until all data is consumed and all output is produced, then
// %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
// may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
// in a decompression converter where the end of data is detectable from the
// data (and there might even be other data after the end of the compressed data).
//
// When some data has successfully been converted @bytes_read and is set to
// the number of bytes read from @inbuf, and @bytes_written is set to indicate
// how many bytes was written to @outbuf. If there are more data to output
// or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
// %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
// then %G_CONVERTER_FINISHED is returned.
//
// On error %G_CONVERTER_ERROR is returned and @error is set accordingly.
// Some errors need special handling:
//
// %G_IO_ERROR_NO_SPACE is returned if there is not enough space
// to write the resulting converted data, the application should
// call the function again with a larger @outbuf to continue.
//
// %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
// input to fully determine what the conversion should produce,
// and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
// example with an incomplete multibyte sequence when converting text,
// or when a regexp matches up to the end of the input (and may match
// further input). It may also happen when @inbuf_size is zero and
// there is no more data to produce.
//
// When this happens the application should read more input and then
// call the function again. If further input shows that there is no
// more data call the function again with the same data but with
// the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
// to finish as e.g. in the regexp match case (or, to fail again with
// %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
// input is actually partial).
//
// After g_converter_convert() has returned %G_CONVERTER_FINISHED the
// converter object is in an invalid state where its not allowed
// to call g_converter_convert() anymore. At this time you can only
// free the object or call g_converter_reset() to reset it to the
// initial state.
//
// If the flag %G_CONVERTER_FLUSH is set then conversion is modified
// to try to write out all internal state to the output. The application
// has to call the function multiple times with the flag set, and when
// the available input has been consumed and all internal state has
// been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
// really at the end) is returned instead of %G_CONVERTER_CONVERTED.
// This is somewhat similar to what happens at the end of the input stream,
// but done in the middle of the data.
//
// This has different meanings for different conversions. For instance
// in a compression converter it would mean that we flush all the
// compression state into output such that if you uncompress the
// compressed data you get back all the input data. Doing this may
// make the final file larger due to padding though. Another example
// is a regexp conversion, where if you at the end of the flushed data
// have a match, but there is also a potential longer match. In the
// non-flushed case we would ask for more input, but when flushing we
// treat this as the end of input and do the match.
//
// Flushing is not always possible (like if a charset converter flushes
// at a partial multibyte sequence). Converters are supposed to try
// to produce as much output as possible and then return an error
// (typically %G_IO_ERROR_PARTIAL_INPUT).
func (x *ConverterBase) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar *uint, BytesWrittenVar *uint) (ConverterResult, error) {
	var cerr *glib.Error

	cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

// Applies @converter to the data in @bytes.
func (x *ConverterBase) ConvertBytes(BytesVar *glib.Bytes) (*glib.Bytes, error) {
	var cerr *glib.Error

	cret := XGConverterConvertBytes(x.GoPointer(), BytesVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

// Resets all internal state in the converter, making it behave
// as if it was just created. If the converter has any internal
// state that would produce output then that output is lost.
func (x *ConverterBase) Reset() {

	XGConverterReset(x.GoPointer())

}

var XGConverterConvert func(uintptr, []byte, uint, []byte, uint, ConverterFlags, *uint, *uint, **glib.Error) ConverterResult
var XGConverterConvertBytes func(uintptr, *glib.Bytes, **glib.Error) *glib.Bytes
var XGConverterReset func(uintptr)

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(&xConverterGLibType, libs, "g_converter_get_type")

	core.PuregoSafeRegister(&XGConverterConvert, libs, "g_converter_convert")
	core.PuregoSafeRegister(&XGConverterConvertBytes, libs, "g_converter_convert_bytes")
	core.PuregoSafeRegister(&XGConverterReset, libs, "g_converter_reset")

}