// Trivial test organ: echoes input back with a prefix.
// Built with: GOOS=wasip1 GOARCH=wasm go build -buildmode=c-shared -o trivial.wasm .
package main

import "unsafe"

// Memory pool: a simple bump allocator for guest-side allocations.
// This avoids Go GC issues in WASM by using a fixed buffer.
var pool [1 << 20]byte // 1MB
var poolOffset uint32

//go:wasmexport alloc
func alloc(size uint32) uint32 {
	if poolOffset+size > uint32(len(pool)) {
		// Reset if exhausted (simple strategy for short-lived calls).
		poolOffset = 0
	}
	ptr := poolOffset
	poolOffset += size
	return uint32(uintptr(unsafe.Pointer(&pool[ptr])))
}

//go:wasmexport dealloc
func dealloc(ptr uint32, size uint32) {
	// No-op with bump allocator. Memory is reclaimed on pool reset.
}

//go:wasmexport organ_type
func organ_type() uint32 {
	s := "enzyme"
	ptr := alloc(uint32(len(s)))
	copy(pool[ptr-uint32(uintptr(unsafe.Pointer(&pool[0]))):], s)
	return ptr
}

//go:wasmexport organ_version
func organ_version() uint64 {
	return 1
}

//go:wasmexport process
func process(inputPtr uint32, inputLen uint32) uint64 {
	// Read input from our pool by computing offset.
	base := uint32(uintptr(unsafe.Pointer(&pool[0])))
	offset := inputPtr - base

	if offset+inputLen > uint32(len(pool)) {
		// Out of bounds — return empty.
		return 0
	}

	input := pool[offset : offset+inputLen]

	if len(input) == 0 {
		return 0
	}

	opcode := input[0]
	data := input[1:]

	var result []byte

	switch opcode {
	case 0x01: // CanDigest: return 0x01 if input contains "package "
		result = []byte{0x00}
		for i := 0; i+8 <= len(data); i++ {
			if string(data[i:i+8]) == "package " {
				result = []byte{0x01}
				break
			}
		}

	case 0x02: // Digest: return the input prefixed with "digested:"
		prefix := []byte("digested:")
		result = make([]byte, len(prefix)+len(data))
		copy(result, prefix)
		copy(result[len(prefix):], data)

	default:
		result = []byte("unknown opcode")
	}

	// Write result to pool.
	outPtr := alloc(uint32(len(result)))
	outOffset := outPtr - base
	copy(pool[outOffset:], result)

	// Pack pointer and length into uint64.
	return uint64(outPtr)<<32 | uint64(len(result))
}

func main() {}