package main

import (
	"encoding/json"
	"fmt"
	zrfu "git.swzry.com/zry/zry-rust-ffi-utils/go-zrfu"
	"io"
)

type TestCBORStruct struct {
	A string                 `cbor:"a"`
	B int64                  `cbor:"b"`
	C map[string]string      `cbor:"c"`
	D map[string]interface{} `cbor:"d"`
}

func main() {
	lib, err := zrfu.LoadDyLib("zrfu_test_rust.dll")
	if err != nil {
		fmt.Println("failed init dll: ", err)
		return
	}
	lib.SetDebugMode(true)
	bv1, err := zrfu.NewBytesVec(lib)
	defer bv1.Close()
	if err != nil {
		fmt.Println("failed new BytesVec: ", err)
		return
	}
	fmt.Println("Write 'neko: '...")
	n, err := bv1.Write([]byte("neko: "))
	if err != nil {
		fmt.Println("failed write to BytesVec: ", err)
		return
	}
	fmt.Println(n, "byte(s) written into BytesVec.")
	l, err := bv1.Len()
	if err != nil {
		fmt.Println("failed get length of BytesVec: ", err)
		return
	}
	fmt.Println("Now length=", l, " byte(s).")
	fmt.Println("Write 'nya~'...")
	n, err = bv1.Write([]byte("nya~"))
	if err != nil {
		fmt.Println("failed write to BytesVec: ", err)
		return
	}
	fmt.Println(n, "byte(s) written into BytesVec.")
	l, err = bv1.Len()
	if err != nil {
		fmt.Println("failed get length of BytesVec: ", err)
		return
	}
	fmt.Println("Now length=", l, " byte(s).")
	rdat, err := io.ReadAll(bv1)
	if err != nil {
		fmt.Println("failed read from BytesVec: ", err)
		return
	}
	fmt.Println("Read from BytesVec: ", string(rdat))

	fmt.Println("======== Call Func Test ========")
	caller, err := zrfu.NewZRFUCaller(lib)
	if err != nil {
		fmt.Println("failed init ZRFUCaller: ", err)
		return
	}

	fmt.Println("---- TestFuncAR ----")
	argar := &TestCBORStruct{
		A: "hello, TestFuncAR",
		B: 114514,
		C: map[string]string{
			"nya":   "meow~",
			"hello": "world",
		},
		D: map[string]interface{}{
			"test":   1919.810,
			"satori": 5,
		},
	}
	var retar TestCBORStruct
	err = caller.CallAR("TestFuncAR", argar, &retar)
	if err != nil {
		fmt.Println("failed call proc: ", err)
		return
	}
	fmt.Println(" ---- TestFuncAR Result ----")
	JsonPrintUtil(retar)

	fmt.Println("---- TestFuncA ----")
	arga := &TestCBORStruct{
		A: "hello, TestFuncA",
		B: 1919810,
		C: map[string]string{
			"nya":   "cat",
			"hello": "gensokyo",
		},
		D: map[string]interface{}{
			"test":   114.514,
			"satori": 5,
		},
	}
	err = caller.CallA("TestFuncA", arga)
	if err != nil {
		fmt.Println("failed call proc: ", err)
		return
	}

	fmt.Println("---- TestFuncR ----")
	var retr TestCBORStruct
	err = caller.CallR("TestFuncR", &retr)
	if err != nil {
		fmt.Println("failed call proc: ", err)
		return
	}
	fmt.Println(" ---- TestFuncR Result ----")
	JsonPrintUtil(retar)

	fmt.Println("---- TestFuncN ----")
	err = caller.CallN("TestFuncN")
	if err != nil {
		fmt.Println("failed call proc: ", err)
		return
	}
}

func JsonPrintUtil(v interface{}) {
	jd, err := json.MarshalIndent(v, "\t", "  ")
	if err != nil {
		fmt.Println("Failed encode json for debug: ", err)
		return
	}
	fmt.Println(string(jd))
}