//go:build wasm

package main

import "fmt"

//go:wasmexport SuperFunction
func SuperFunction(x, y int32) int32 {
	return x + y
} // OK

func main() {

}

package main

import (
	"context"
	_ "embed"
	"fmt"
	"log"
	"os"
	"unsafe"

	"github.com/bytecodealliance/wasmtime-go"
)

func memoryLimit(megabytes uint32) uint32 {
	const wazeroPageSize = 64
	kilobytes := megabytes * 1024
	return kilobytes / wazeroPageSize
}

//go:embed out.wasm
var wasmModule []byte

func main() {
	// Almost all operations in wasmtime require a contextual `store`
	// argument to share, so create that first
	engine := wasmtime.NewEngine()
	//store.SetWasi()

	// Once we have our binary `wasm` we can compile that into a `*Module`
	// which represents compiled JIT code.
	module, err := wasmtime.NewModule(engine, wasmModule)
	if err != nil {
		log.Fatal(err)
	}

	// Create a linker with WASI functions defined within it
	linker := wasmtime.NewLinker(engine)
	err = linker.DefineWasi()
	if err != nil {
		log.Fatal(err)
	}

	// Configure WASI imports to write stdout into a file, and then create
	// a `Store` using this wasi configuration.
	wasiConfig := wasmtime.NewWasiConfig()
	store := wasmtime.NewStore(engine)
	store.SetWasi(wasiConfig)
	instance, err := linker.Instantiate(store, module)
	if err != nil {
		log.Fatal(err)
	}

	// After we've instantiated we can lookup our `run` function and call
	// it.
	run := instance.GetFunc(store, "SuperFunction")
	_, err = run.Call(store, 96, 55)
	if err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"context"
	_ "embed"
	"fmt"
	"log"
	"os"
	"unsafe"

	"github.com/tetratelabs/wazero"
	"github.com/tetratelabs/wazero/api"
	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
)

func main() {
	ctx := context.Background()
	runtime := wazero.NewRuntimeWithConfig(
		ctx,
		wazero.
			NewRuntimeConfig().
			WithCoreFeatures(api.CoreFeaturesV2).
			WithMemoryLimitPages(memoryLimit(256)),
	)
	_, err := wasi_snapshot_preview1.Instantiate(ctx, runtime)
	if err != nil {
		panic(err)
	}

	builder := runtime.NewHostModuleBuilder("env")
	wasi_snapshot_preview1.NewFunctionExporter().ExportFunctions(builder)
	_, err = builder.Instantiate(ctx)
	if err != nil {
		panic(err)
	}

	compiledModule, err := runtime.CompileModule(ctx, wasmModule)
	if err != nil {
		panic(fmt.Errorf("can't compile WASM module: %w", err))
	}

	mod, err := runtime.InstantiateModule(
		ctx,
		compiledModule,
		wazero.
			NewModuleConfig().
			WithStdout(os.Stdout).
			WithStderr(os.Stderr),
	)
	if err != nil {
		panic(fmt.Errorf("can't instantiate module: %w", err))
	}

	funcName := "SuperFunction"
	targetFunc := mod.ExportedFunction(funcName)
	if targetFunc == nil {
		panic(fmt.Errorf("target function not found: %s", funcName))
	}

	mod.Memory().Grow(2)
	res, err := targetFunc.Call(ctx, 96, 55)
	//res, err := targetFunc.Call(ctx)
	fmt.Println(res, err)

	fmt.Println(targetFunc.Definition().DebugName())
	fmt.Println(targetFunc.Definition().Name())
	fmt.Println(targetFunc.Definition().ParamTypes())
	fmt.Println(targetFunc.Definition().ParamNames())

}