package main

/*
// Generated by rust2go. Please DO NOT edit this C part manually.

#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

typedef struct ListRef {
  const void *ptr;
  uintptr_t len;
} ListRef;

typedef struct StringRef {
  const uint8_t *ptr;
  uintptr_t len;
} StringRef;

typedef struct MigrateConfigRef {
  struct StringRef driver;
  struct StringRef dsn;
} MigrateConfigRef;

typedef struct MigrateOutcomeRef {
  uint32_t version;
  bool dirty;
  struct StringRef error;
} MigrateOutcomeRef;
*/
import "C"
import (
	"runtime"
	"unsafe"

	"github.com/ihciah/rust2go/asmcall"
)

var MigrateServiceImpl MigrateService

type MigrateService interface {
	up(cfg MigrateConfig) MigrateOutcome
	version(cfg MigrateConfig) MigrateOutcome
}

//export CMigrateService_up
func CMigrateService_up(cfg C.MigrateConfigRef, slot *C.void, cb *C.void) {
	_new_cfg := newMigrateConfig(cfg)
	resp := MigrateServiceImpl.up(_new_cfg)
	resp_ref, buffer := cvt_ref(cntMigrateOutcome, refMigrateOutcome)(&resp)
	asmcall.CallFuncG0P2(unsafe.Pointer(cb), unsafe.Pointer(&resp_ref), unsafe.Pointer(slot))
	runtime.KeepAlive(resp_ref)
	runtime.KeepAlive(resp)
	runtime.KeepAlive(buffer)
}

//export CMigrateService_version
func CMigrateService_version(cfg C.MigrateConfigRef, slot *C.void, cb *C.void) {
	_new_cfg := newMigrateConfig(cfg)
	resp := MigrateServiceImpl.version(_new_cfg)
	resp_ref, buffer := cvt_ref(cntMigrateOutcome, refMigrateOutcome)(&resp)
	asmcall.CallFuncG0P2(unsafe.Pointer(cb), unsafe.Pointer(&resp_ref), unsafe.Pointer(slot))
	runtime.KeepAlive(resp_ref)
	runtime.KeepAlive(resp)
	runtime.KeepAlive(buffer)
}

func newString(s_ref C.StringRef) string {
	return unsafe.String((*byte)(unsafe.Pointer(s_ref.ptr)), s_ref.len)
}
func refString(s *string, _ *[]byte) C.StringRef {
	return C.StringRef{
		ptr: (*C.uint8_t)(unsafe.StringData(*s)),
		len: C.uintptr_t(len(*s)),
	}
}

func ownString(s_ref C.StringRef) string {
	return string(unsafe.Slice((*byte)(unsafe.Pointer(s_ref.ptr)), int(s_ref.len)))
}
func cntString(_ *string, _ *uint) [0]C.StringRef { return [0]C.StringRef{} }
func new_list_mapper[T1, T2 any](f func(T1) T2) func(C.ListRef) []T2 {
	return func(x C.ListRef) []T2 {
		input := unsafe.Slice((*T1)(unsafe.Pointer(x.ptr)), x.len)
		output := make([]T2, len(input))
		for i, v := range input {
			output[i] = f(v)
		}
		return output
	}
}
func new_list_mapper_primitive[T1, T2 any](_ func(T1) T2) func(C.ListRef) []T2 {
	return func(x C.ListRef) []T2 {
		return unsafe.Slice((*T2)(unsafe.Pointer(x.ptr)), x.len)
	}
}

// only handle non-primitive type T
func cnt_list_mapper[T, R any](f func(s *T, cnt *uint) [0]R) func(s *[]T, cnt *uint) [0]C.ListRef {
	return func(s *[]T, cnt *uint) [0]C.ListRef {
		for _, v := range *s {
			f(&v, cnt)
		}
		*cnt += uint(len(*s)) * size_of[R]()
		return [0]C.ListRef{}
	}
}

// only handle primitive type T
func cnt_list_mapper_primitive[T, R any](_ func(s *T, cnt *uint) [0]R) func(s *[]T, cnt *uint) [0]C.ListRef {
	return func(s *[]T, cnt *uint) [0]C.ListRef { return [0]C.ListRef{} }
}

// only handle non-primitive type T
func ref_list_mapper[T, R any](f func(s *T, buffer *[]byte) R) func(s *[]T, buffer *[]byte) C.ListRef {
	return func(s *[]T, buffer *[]byte) C.ListRef {
		if len(*buffer) == 0 {
			return C.ListRef{
				ptr: unsafe.Pointer(nil),
				len: C.uintptr_t(len(*s)),
			}
		}
		ret := C.ListRef{
			ptr: unsafe.Pointer(&(*buffer)[0]),
			len: C.uintptr_t(len(*s)),
		}
		children_bytes := int(size_of[R]()) * len(*s)
		children := (*buffer)[:children_bytes]
		*buffer = (*buffer)[children_bytes:]
		for _, v := range *s {
			child := f(&v, buffer)
			len := unsafe.Sizeof(child)
			copy(children, unsafe.Slice((*byte)(unsafe.Pointer(&child)), len))
			children = children[len:]
		}
		return ret
	}
}

// only handle primitive type T
func ref_list_mapper_primitive[T, R any](_ func(s *T, buffer *[]byte) R) func(s *[]T, buffer *[]byte) C.ListRef {
	return func(s *[]T, buffer *[]byte) C.ListRef {
		if len(*s) == 0 {
			return C.ListRef{
				ptr: unsafe.Pointer(nil),
				len: C.uintptr_t(0),
			}
		}
		return C.ListRef{
			ptr: unsafe.Pointer(&(*s)[0]),
			len: C.uintptr_t(len(*s)),
		}
	}
}
func size_of[T any]() uint {
	var t T
	return uint(unsafe.Sizeof(t))
}
func cvt_ref[R, CR any](cnt_f func(s *R, cnt *uint) [0]CR, ref_f func(p *R, buffer *[]byte) CR) func(p *R) (CR, []byte) {
	return func(p *R) (CR, []byte) {
		var cnt uint
		cnt_f(p, &cnt)
		buffer := make([]byte, cnt)
		return ref_f(p, &buffer), buffer
	}
}
func cvt_ref_cap[R, CR any](cnt_f func(s *R, cnt *uint) [0]CR, ref_f func(p *R, buffer *[]byte) CR, add_cap uint) func(p *R) (CR, []byte) {
	return func(p *R) (CR, []byte) {
		var cnt uint
		cnt_f(p, &cnt)
		buffer := make([]byte, cnt, cnt+add_cap)
		return ref_f(p, &buffer), buffer
	}
}

func newC_uint8_t(n C.uint8_t) uint8    { return uint8(n) }
func newC_uint16_t(n C.uint16_t) uint16 { return uint16(n) }
func newC_uint32_t(n C.uint32_t) uint32 { return uint32(n) }
func newC_uint64_t(n C.uint64_t) uint64 { return uint64(n) }
func newC_int8_t(n C.int8_t) int8       { return int8(n) }
func newC_int16_t(n C.int16_t) int16    { return int16(n) }
func newC_int32_t(n C.int32_t) int32    { return int32(n) }
func newC_int64_t(n C.int64_t) int64    { return int64(n) }
func newC_bool(n C.bool) bool           { return bool(n) }
func newC_uintptr_t(n C.uintptr_t) uint { return uint(n) }
func newC_intptr_t(n C.intptr_t) int    { return int(n) }
func newC_float(n C.float) float32      { return float32(n) }
func newC_double(n C.double) float64    { return float64(n) }

func cntC_uint8_t(_ *uint8, _ *uint) [0]C.uint8_t    { return [0]C.uint8_t{} }
func cntC_uint16_t(_ *uint16, _ *uint) [0]C.uint16_t { return [0]C.uint16_t{} }
func cntC_uint32_t(_ *uint32, _ *uint) [0]C.uint32_t { return [0]C.uint32_t{} }
func cntC_uint64_t(_ *uint64, _ *uint) [0]C.uint64_t { return [0]C.uint64_t{} }
func cntC_int8_t(_ *int8, _ *uint) [0]C.int8_t       { return [0]C.int8_t{} }
func cntC_int16_t(_ *int16, _ *uint) [0]C.int16_t    { return [0]C.int16_t{} }
func cntC_int32_t(_ *int32, _ *uint) [0]C.int32_t    { return [0]C.int32_t{} }
func cntC_int64_t(_ *int64, _ *uint) [0]C.int64_t    { return [0]C.int64_t{} }
func cntC_bool(_ *bool, _ *uint) [0]C.bool           { return [0]C.bool{} }
func cntC_uintptr_t(_ *uint, _ *uint) [0]C.uintptr_t { return [0]C.uintptr_t{} }
func cntC_intptr_t(_ *int, _ *uint) [0]C.intptr_t    { return [0]C.intptr_t{} }
func cntC_float(_ *float32, _ *uint) [0]C.float      { return [0]C.float{} }
func cntC_double(_ *float64, _ *uint) [0]C.double    { return [0]C.double{} }

func refC_uint8_t(p *uint8, _ *[]byte) C.uint8_t    { return C.uint8_t(*p) }
func refC_uint16_t(p *uint16, _ *[]byte) C.uint16_t { return C.uint16_t(*p) }
func refC_uint32_t(p *uint32, _ *[]byte) C.uint32_t { return C.uint32_t(*p) }
func refC_uint64_t(p *uint64, _ *[]byte) C.uint64_t { return C.uint64_t(*p) }
func refC_int8_t(p *int8, _ *[]byte) C.int8_t       { return C.int8_t(*p) }
func refC_int16_t(p *int16, _ *[]byte) C.int16_t    { return C.int16_t(*p) }
func refC_int32_t(p *int32, _ *[]byte) C.int32_t    { return C.int32_t(*p) }
func refC_int64_t(p *int64, _ *[]byte) C.int64_t    { return C.int64_t(*p) }
func refC_bool(p *bool, _ *[]byte) C.bool           { return C.bool(*p) }
func refC_uintptr_t(p *uint, _ *[]byte) C.uintptr_t { return C.uintptr_t(*p) }
func refC_intptr_t(p *int, _ *[]byte) C.intptr_t    { return C.intptr_t(*p) }
func refC_float(p *float32, _ *[]byte) C.float      { return C.float(*p) }
func refC_double(p *float64, _ *[]byte) C.double    { return C.double(*p) }

type MigrateConfig struct {
	driver string
	dsn    string
}

func newMigrateConfig(p C.MigrateConfigRef) MigrateConfig {
	return MigrateConfig{
		driver: newString(p.driver),
		dsn:    newString(p.dsn),
	}
}
func ownMigrateConfig(p C.MigrateConfigRef) MigrateConfig {
	return MigrateConfig{
		driver: ownString(p.driver),
		dsn:    ownString(p.dsn),
	}
}
func cntMigrateConfig(s *MigrateConfig, cnt *uint) [0]C.MigrateConfigRef {
	_ = s
	_ = cnt
	return [0]C.MigrateConfigRef{}
}
func refMigrateConfig(p *MigrateConfig, buffer *[]byte) C.MigrateConfigRef {
	return C.MigrateConfigRef{
		driver: refString(&p.driver, buffer),
		dsn:    refString(&p.dsn, buffer),
	}
}

type MigrateOutcome struct {
	version uint32
	dirty   bool
	error   string
}

func newMigrateOutcome(p C.MigrateOutcomeRef) MigrateOutcome {
	return MigrateOutcome{
		version: newC_uint32_t(p.version),
		dirty:   newC_bool(p.dirty),
		error:   newString(p.error),
	}
}
func ownMigrateOutcome(p C.MigrateOutcomeRef) MigrateOutcome {
	return MigrateOutcome{
		version: newC_uint32_t(p.version),
		dirty:   newC_bool(p.dirty),
		error:   ownString(p.error),
	}
}
func cntMigrateOutcome(s *MigrateOutcome, cnt *uint) [0]C.MigrateOutcomeRef {
	_ = s
	_ = cnt
	return [0]C.MigrateOutcomeRef{}
}
func refMigrateOutcome(p *MigrateOutcome, buffer *[]byte) C.MigrateOutcomeRef {
	return C.MigrateOutcomeRef{
		version: refC_uint32_t(&p.version, buffer),
		dirty:   refC_bool(&p.dirty, buffer),
		error:   refString(&p.error, buffer),
	}
}
func main() {}