// Copyright (c) 2023 l-m.dev. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module wasm

import encoding.leb128

fn (mut func Function) u32(v u32) {
	func.code << leb128.encode_u32(v)
}

fn (mut func Function) blocktype(typ FuncType) {
	if typ.parameters.len == 0 {
		if typ.results.len == 0 {
			func.code << 0x40 // empty type
			return
		} else if typ.results.len == 1 {
			func.code << u8(typ.results[0]) // encode a single result type
			return
		}
	}

	// encode full type
	tidx := func.mod.new_functype(typ)
	func.code << leb128.encode_i32(tidx)
}

pub type PatchPos = int

// patch_pos returns a `PatchPos` for use with `patch`.
pub fn (func Function) patch_pos() PatchPos {
	return func.code.len
}

// patch "patches" the code generated starting from the last `patch_pos` call in `begin` to `loc`.
//
// ```v
// start := func.patch_pos()
//
// ...
//
// patch_block := func.patch_pos()
// {
//     func.i32_const(10)
//     func.local_set(idx)
// }
// func.patch(start, patch_block) // will patch code to the `start`.
// // func.code[patch_block..]
// ```
pub fn (mut func Function) patch(loc PatchPos, begin PatchPos) {
	if loc == begin {
		return
	}
	assert loc < begin

	v := func.code[begin..].clone()
	func.code.trim(begin)
	func.code.insert(int(loc), v)

	for mut patch in func.patches {
		if patch.pos >= begin {
			patch.pos -= begin - loc
		} else if patch.pos >= loc {
			patch.pos += func.code.len - begin
		}
	}

	func.patches.sort(a.pos < b.pos)

	/*
	lenn := begin
	diff := loc - begin

	for mut patch in func.patches {
		if patch.pos >= begin {
			patch.pos += diff
		}
		if patch.pos <= lenn {
			continue
		}
		delta := patch.pos - lenn
		patch.pos = loc + delta
	}

	func.patches.sort(a.pos < b.pos)*/
}

// new_local creates a function local and returns it's index.
// See `local_get`, `local_set`, `local_tee`.
pub fn (mut func Function) new_local(v ValType) LocalIndex {
	ret := func.locals.len
	func.locals << FunctionLocal{
		typ: v
	}
	return ret
}

// new_local_named creates a function local with a name and returns it's index.
// The `name` is used in debug information, where applicable.
// See `local_get`, `local_set`, `local_tee`.
pub fn (mut func Function) new_local_named(v ValType, name string) LocalIndex {
	ret := func.locals.len
	func.locals << FunctionLocal{
		typ: v
		name: name
	}
	return ret
}

// i32_const places a constant i32 value on the stack.
// WebAssembly instruction: `i32.const`.
pub fn (mut func Function) i32_const(v i32) {
	func.code << 0x41 // i32.const
	func.code << leb128.encode_i32(v)
}

// i64_const places a constant i64 value on the stack.
// WebAssembly instruction: `i64.const`.
pub fn (mut func Function) i64_const(v i64) {
	func.code << 0x42 // i64.const
	func.code << leb128.encode_i64(v)
}

// f32_const places a constant f32 value on the stack.
// WebAssembly instruction: `f32.const`.
pub fn (mut func Function) f32_const(v f32) {
	func.code << 0x43 // f32.const
	push_f32(mut func.code, v)
}

// f64_const places a constant f64 value on the stack.
// WebAssembly instruction: `f64.const`.
pub fn (mut func Function) f64_const(v f64) {
	func.code << 0x44 // f64.const
	push_f64(mut func.code, v)
}

// local_get places the value of the local at the index `local` on the stack.
// WebAssembly instruction: `local.get`.
pub fn (mut func Function) local_get(local LocalIndex) {
	func.code << 0x20 // local.get
	func.u32(u32(local))
}

// local_get sets the local at the index `local` to the value on the stack.
// WebAssembly instruction: `local.set`.
pub fn (mut func Function) local_set(local LocalIndex) {
	func.code << 0x21 // local.set
	func.u32(u32(local))
}

// local_tee sets the local at the index `local` to the value on the stack, then places it's value on the stack.
// WebAssembly instruction: `local.tee`.
pub fn (mut func Function) local_tee(local LocalIndex) {
	func.code << 0x22 // local.tee
	func.u32(u32(local))
}

type GlobalIndices = GlobalImportIndex | GlobalIndex

// global_get places the value of the global at the index `global` on the stack.
// WebAssembly instruction: `global.get`.
pub fn (mut func Function) global_get(global GlobalIndices) {
	func.code << 0x23 // global.get
	match global {
		GlobalIndex {
			func.patches << FunctionGlobalPatch{
				idx: global
				pos: func.code.len
			}
		}
		GlobalImportIndex {
			func.u32(u32(global))
		}
	}
}

// global_set sets the global at the index `global` to the value on the stack.
// WebAssembly instruction: `global.set`.
pub fn (mut func Function) global_set(global GlobalIndices) {
	func.code << 0x24 // global.set
	match global {
		GlobalIndex {
			func.patches << FunctionGlobalPatch{
				idx: global
				pos: func.code.len
			}
		}
		GlobalImportIndex {
			func.u32(u32(global))
		}
	}
}

// drop drops the value on the stack
// WebAssembly instruction: `drop`.
pub fn (mut func Function) drop() {
	func.code << 0x1A
}

// c_select selects one of its first two operands based on an i32 condition.
// WebAssembly instruction: `select`.
pub fn (mut func Function) c_select() {
	func.code << 0x1B
}

// add adds two values on the stack with type `typ`.
// WebAssembly instructions: `i32|i64|f32|f64.add`.
pub fn (mut func Function) add(typ NumType) {
	match typ {
		.i32_t { func.code << 0x6A } // i32.add
		.i64_t { func.code << 0x7C } // i64.add
		.f32_t { func.code << 0x92 } // f32.add
		.f64_t { func.code << 0xA0 } // f64.add
	}
}

// sub subtracts two values on the stack with type `typ`.
// WebAssembly instructions: `i32|i64|f32|f64.sub`.
pub fn (mut func Function) sub(typ NumType) {
	match typ {
		.i32_t { func.code << 0x6B } // i32.sub
		.i64_t { func.code << 0x7D } // i64.sub
		.f32_t { func.code << 0x93 } // f32.sub
		.f64_t { func.code << 0xA1 } // f64.sub
	}
}

// mul multiplies two values on the stack with type `typ`.
// WebAssembly instructions: `i32|i64|f32|f64.mul`.
pub fn (mut func Function) mul(typ NumType) {
	match typ {
		.i32_t { func.code << 0x6C } // i32.mul
		.i64_t { func.code << 0x7E } // i64.mul
		.f32_t { func.code << 0x94 } // f32.mul
		.f64_t { func.code << 0xA2 } // f64.mul
	}
}

// div divides two values on the stack with type `typ`, with respect to `is_signed`.
// WebAssembly instructions: `i32|i64.div_s`, `i32|i64.div_u`, `f32|f64.div`.
pub fn (mut func Function) div(typ NumType, is_signed bool) {
	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x6D // i32.div_s
			} else {
				func.code << 0x6E // i32.div_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x7F // i64.div_s
			} else {
				func.code << 0x80 // i64.div_u
			}
		}
		.f32_t {
			func.code << 0x95 // f32.div
		}
		.f64_t {
			func.code << 0xA3 // f64.div
		}
	}
}

// rem takes the remainder of two values on the stack with type `typ`, with respect to `is_signed`.
// WebAssembly instructions: `i32|i64.rem_s`, `i32|i64.rem_u`.
pub fn (mut func Function) rem(typ NumType, is_signed bool) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x6F // i32.rem_s
			} else {
				func.code << 0x70 // i32.rem_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x81 // i64.rem_s
			} else {
				func.code << 0x82 // i64.rem_u
			}
		}
		else {}
	}
}

// and takes the bitwise and of two values on the stack with type `typ`.
// WebAssembly instruction: `i32|i64.and`.
pub fn (mut func Function) b_and(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x71 } // i32.and
		.i64_t { func.code << 0x83 } // i64.and
		else {}
	}
}

// or takes the bitwise or of two values on the stack with type `typ`.
// WebAssembly instruction: `i32|i64.or`.
pub fn (mut func Function) b_or(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x72 } // i32.or
		.i64_t { func.code << 0x84 } // i64.or
		else {}
	}
}

// xor takes the bitwise xor of two values on the stack with type `typ`.
// WebAssembly instruction: `i32|i64.xor`.
pub fn (mut func Function) b_xor(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x73 } // i32.xor
		.i64_t { func.code << 0x85 } // i64.xor
		else {}
	}
}

// shl performs bitwise left-shift on a value with type `typ`.
// WebAssembly instruction: `i32|i64.shl`.
pub fn (mut func Function) b_shl(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x74 } // i32.shl
		.i64_t { func.code << 0x86 } // i64.shl
		else {}
	}
}

// shr performs bitwise right-shift on a value with type `typ`, with respect to `is_signed`.
// WebAssembly instructions: `i32|i64.shr_s`, `i32|i64.shr_u`.
pub fn (mut func Function) b_shr(typ NumType, is_signed bool) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x75 // i32.shr_s
			} else {
				func.code << 0x76 // i32.shr_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x87 // i64.shr_s
			} else {
				func.code << 0x88 // i64.shr_u
			}
		}
		else {}
	}
}

// clz counts the amount of leading zeros in the numbers binary representation.
// WebAssembly instruction: `i32|i64.clz`.
pub fn (mut func Function) clz(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x67 } // i32.clz
		.i64_t { func.code << 0x79 } // i64.clz
		else {}
	}
}

// ctz counts the amount of trailing zeros in the numbers binary representation.
// WebAssembly instruction: `i32|i64.ctz`.
pub fn (mut func Function) ctz(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x68 } // i32.ctz
		.i64_t { func.code << 0x7A } // i64.ctz
		else {}
	}
}

// popcnt counts the amount of 1s in a numbers binary representation.
// WebAssembly instruction: `i32|i64.popcnt`.
pub fn (mut func Function) popcnt(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x69 } // i32.popcnt
		.i64_t { func.code << 0x7B } // i64.popcnt
		else {}
	}
}

// rotl performs bitwise left-rotate on a value with type `typ`.
// WebAssembly instruction: `i32|i64.rotl`.
pub fn (mut func Function) rotl(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x77 } // i32.rotl
		.i64_t { func.code << 0x89 } // i64.rotl
		else {}
	}
}

// rotr performs bitwise right-rotate on a value with type `typ`.
// WebAssembly instruction: `i32|i64.rotr`.
pub fn (mut func Function) rotr(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x78 } // i32.rotr
		.i64_t { func.code << 0xA8 } // i64.rotr
		else {}
	}
}

// abs gets the absolute value of a float with type `typ`.
// WebAssembly instruction: `f32|f64.abs`.
pub fn (mut func Function) abs(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x8B } // f32.abs
		.f64_t { func.code << 0x99 } // f64.abs
		else {}
	}
}

// neg negates the value of a float with type `typ`.
// WebAssembly instruction: `f32|f64.neg`.
pub fn (mut func Function) neg(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x8C } // f32.neg
		.f64_t { func.code << 0x9A } // f64.neg
		else {}
	}
}

// ceil rounds up the value of a float with type `typ` to the nearest integer.
// WebAssembly instruction: `f32|f64.ceil`.
pub fn (mut func Function) ceil(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x8D } // f32.ceil
		.f64_t { func.code << 0x9B } // f64.ceil
		else {}
	}
}

// floor rounds down the value of a float with type `typ` to the nearest integer.
// WebAssembly instruction: `f32|f64.floor`.
pub fn (mut func Function) floor(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x8E } // f32.floor
		.f64_t { func.code << 0x9C } // f64.floor
		else {}
	}
}

// trunc discards the fractional part of the value of a float with type `typ`.
// WebAssembly instruction: `f32|f64.trunc`.
pub fn (mut func Function) trunc(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x8F } // f32.trunc
		.f64_t { func.code << 0x9D } // f64.trunc
		else {}
	}
}

// nearest rounds the value of a float with type `typ` to the nearest integer.
// WebAssembly instruction: `f32|f64.nearest`.
pub fn (mut func Function) nearest(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x90 } // f32.nearest
		.f64_t { func.code << 0x9E } // f64.nearest
		else {}
	}
}

// sqrt performs the square root on the value of a float with type `typ`.
// WebAssembly instruction: `f32|f64.sqrt`.
pub fn (mut func Function) sqrt(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x91 } // f32.sqrt
		.f64_t { func.code << 0x9F } // f64.sqrt
		else {}
	}
}

// min gets the smaller value of two floats with type `typ`.
// WebAssembly instruction: `f32|f64.min`.
pub fn (mut func Function) min(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x96 } // f32.min
		.f64_t { func.code << 0xA4 } // f64.min
		else {}
	}
}

// max gets the higher value of two floats with type `typ`.
// WebAssembly instruction: `f32|f64.max`.
pub fn (mut func Function) max(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x97 } // f32.max
		.f64_t { func.code << 0xA5 } // f64.max
		else {}
	}
}

// copysign copies the sign bit of one float value to another float, both with type `typ`.
// WebAssembly instruction: `f32|f64.copysign`.
pub fn (mut func Function) copysign(typ NumType) {
	assert typ in [.f32_t, .f64_t]

	match typ {
		.f32_t { func.code << 0x98 } // f32.copysign
		.f64_t { func.code << 0xA6 } // f64.copysign
		else {}
	}
}

// eqz checks if the value with type `typ` is equal to zero, places an i32 boolean value on the stack.
// WebAssembly instruction: `i32|i64.eqz`.
pub fn (mut func Function) eqz(typ NumType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x45 } // i32.eqz
		.i64_t { func.code << 0x50 } // i64.eqz
		else {}
	}
}

// eq checks if two values with type `typ` are equal, places an i32 boolean value on the stack.
// WebAssembly instruction: `i32|i64|f32|f64.eq`.
pub fn (mut func Function) eq(typ NumType) {
	match typ {
		.i32_t { func.code << 0x46 } // i32.eq
		.i64_t { func.code << 0x51 } // i64.eq
		.f32_t { func.code << 0x5B } // f32.eq
		.f64_t { func.code << 0x61 } // f64.eq
	}
}

// ne checks if two values with type `typ` are not equal, places an i32 boolean value on the stack.
// WebAssembly instruction: `i32|i64|f32|f64.ne`.
pub fn (mut func Function) ne(typ NumType) {
	match typ {
		.i32_t { func.code << 0x47 } // i32.ne
		.i64_t { func.code << 0x52 } // i64.ne
		.f32_t { func.code << 0x5C } // f32.ne
		.f64_t { func.code << 0x62 } // f64.ne
	}
}

// lt checks if two values with type `typ` with respect to `is_signed` are less than another, places an i32 boolean value on the stack.
// WebAssembly instructions: `i32|i64.lt_s`, `i32|i64.lt_u`, `f32|f64.lt`.
pub fn (mut func Function) lt(typ NumType, is_signed bool) {
	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x48 // i32.lt_s
			} else {
				func.code << 0x49 // i32.lt_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x53 // i64.lt_s
			} else {
				func.code << 0x54 // i64.lt_u
			}
		}
		.f32_t {
			func.code << 0x5D // f32.lt
		}
		.f64_t {
			func.code << 0x63 // f64.lt
		}
	}
}

// gt checks if two values with type `typ` with respect to `is_signed` are greater than another, places an i32 boolean value on the stack.
// WebAssembly instructions: `i32|i64.gt_s`, `i32|i64.gt_u`, `f32|f64.gt`.
pub fn (mut func Function) gt(typ NumType, is_signed bool) {
	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x4A // i32.gt_s
			} else {
				func.code << 0x4B // i32.gt_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x55 // i64.gt_s
			} else {
				func.code << 0x56 // i64.gt_u
			}
		}
		.f32_t {
			func.code << 0x5E
		} // f32.gt
		.f64_t {
			func.code << 0x64
		} // f64.gt
	}
}

// le checks if two values with type `typ` with respect to `is_signed` are less than or equal to another, places an i32 boolean value on the stack.
// WebAssembly instructions: `i32|i64.le_s`, `i32|i64.le_u`, `f32|f64.le`.
pub fn (mut func Function) le(typ NumType, is_signed bool) {
	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x4C // i32.le_s
			} else {
				func.code << 0x4D // i32.le_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x57 // i64.le_s
			} else {
				func.code << 0x58 // i64.le_u
			}
		}
		.f32_t {
			func.code << 0x5F
		} // f32.le
		.f64_t {
			func.code << 0x65
		} // f64.le
	}
}

// ge checks if two values with type `typ` with respect to `is_signed` are greater than or equal to another, places an i32 boolean value on the stack.
// WebAssembly instructions: `i32|i64.ge_s`, `i32|i64.ge_u`, `f32|f64.ge`.
pub fn (mut func Function) ge(typ NumType, is_signed bool) {
	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x4E // i32.ge_s
			} else {
				func.code << 0x4F // i32.ge_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x59 // i64.ge_s
			} else {
				func.code << 0x5A // i64.ge_u
			}
		}
		.f32_t {
			func.code << 0x60
		} // f32.ge
		.f64_t {
			func.code << 0x66
		} // f64.ge
	}
}

// sign_extend8 extends the value of a 8-bit integer of type `typ`.
// WebAssembly instruction: `i32|i64.extend8_s`.
pub fn (mut func Function) sign_extend8(typ ValType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0xC0 } // i32.extend8_s
		.i64_t { func.code << 0xC2 } // i64.extend8_s
		else {}
	}
}

// sign_extend16 extends the value of a 16-bit integer of type `typ`.
// WebAssembly instruction: `i32|i64.extend16_s`.
pub fn (mut func Function) sign_extend16(typ ValType) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0xC1 } // i32.extend16_s
		.i64_t { func.code << 0xC3 } // i64.extend16_s
		else {}
	}
}

// sign_extend32_i64 extends the value of a 32-bit integer of type i64.
// WebAssembly instruction: `i64.extend64_s`.
pub fn (mut func Function) sign_extend32_i64() {
	func.code << 0xC4 // i64.extend64_s
}

// cast casts a value of type `a` with respect to `is_signed`, to type `b`.
// A generic utility function over a large amount of WebAssembly instructions.
// Note: This function uses non-trapping float conversion operators, see `cast_trapping` to use opcodes that cause a runtime exception.
// WebAssembly instructions:
// - `i32|i64.trunc_sat_f32_s`, `i32|i64.trunc_sat_f64_s`.
// - `f32.demote_f64`, `f64.promote_f32`.
// - `i32.wrap_i64`, `i64.extend_i32_s`, `i64.extend_i32_u`.
// - `f32|f64.convert_i32_s`, `f32|f64.convert_i32_u`.
// - `f32|f64.convert_i64_s`, `f32|f64.convert_i64_u`.
pub fn (mut func Function) cast(a NumType, is_signed bool, b NumType) {
	if a in [.f32_t, .f64_t] {
		if a == .f32_t {
			match b {
				.i32_t {
					func.code << 0xFC // sat opcode
					func.code << 0x00 // i32.trunc_sat_f32_s
				}
				.i64_t {
					func.code << 0xFC // sat opcode
					func.code << 0x04 // i64.trunc_sat_f32_s
				}
				.f64_t {
					func.code << 0xBB // f64.promote_f32
				}
				else {}
			}
		} else {
			match b {
				.i32_t {
					func.code << 0xFC // sat opcode
					func.code << 0x02 // i32.trunc_sat_f64_s
				}
				.i64_t {
					func.code << 0xFC // sat opcode
					func.code << 0x06 // i64.trunc_sat_f64_s
				}
				.f32_t {
					func.code << 0xB6 // f32.demote_f64
				}
				else {}
			}
		}
		return
	}

	if a == .i64_t && b == .i32_t {
		func.code << 0xA7 // i32.wrap_i64
		return
	}

	if is_signed {
		match a {
			.i32_t {
				match b {
					.i64_t {
						func.code << 0xAC // i64.extend_i32_s
					}
					.f32_t {
						func.code << 0xB2 // f32.convert_i32_s
					}
					.f64_t {
						func.code << 0xB7 // f64.convert_i32_s
					}
					else {}
				}
			}
			.i64_t {
				match b {
					.f32_t {
						func.code << 0xB4 // f32.convert_i64_s
					}
					.f64_t {
						func.code << 0xB9 // f64.convert_i64_s
					}
					else {}
				}
			}
			else {}
		}
	} else {
		match a {
			.i32_t {
				match b {
					.i64_t {
						func.code << 0xAD // i64.extend_i32_u
					}
					.f32_t {
						func.code << 0xB3 // f32.convert_i32_u
					}
					.f64_t {
						func.code << 0xB8 // f64.convert_i32_u
					}
					else {}
				}
			}
			.i64_t {
				match b {
					.f32_t {
						func.code << 0xB5 // f32.convert_i64_u
					}
					.f64_t {
						func.code << 0xBA // f64.convert_i64_u
					}
					else {}
				}
			}
			else {}
		}
	}
}

// cast_trapping casts a value of type `a` with respect to `is_signed`, to type `b`.
// A generic utility function over a large amount of WebAssembly instructions.
// Note: This function uses trapping float conversion operators, see `cast` to use opcodes that do NOT cause a runtime exception.
// WebAssembly instructions:
// - `i32|i64.trunc_f32_s`, `i32|i64.trunc_f64_s`.
// - See function `cast` for the rest.
pub fn (mut func Function) cast_trapping(a NumType, is_signed bool, b NumType) {
	if a in [.f32_t, .f64_t] {
		if a == .f32_t {
			match b {
				.i32_t {
					func.code << 0xA8 // i32.trunc_f32_s
					return
				}
				.i64_t {
					func.code << 0xAE // i64.trunc_f32_s
					return
				}
				else {}
			}
		} else {
			match b {
				.i32_t {
					func.code << 0xAA // i32.trunc_f64_s
					return
				}
				.i64_t {
					func.code << 0xB0 // i64.trunc_f64_s
					return
				}
				else {}
			}
		}
	}

	func.cast(a, is_signed, b)
}

// reinterpret returns a value which has the same bit-pattern as its operand value, in its result type.
// WebAssembly instruction: `f32.reinterpret_i32`, `i32.reinterpret_f32`, `f64.reinterpret_i64`, `i64.reinterpret_f64`.
pub fn (mut func Function) reinterpret(a NumType) {
	match a {
		.f32_t { func.code << 0xBC } // i32.reinterpret_f32
		.i32_t { func.code << 0xBE } // f32.reinterpret_i32
		.f64_t { func.code << 0xBD } // i64.reinterpret_f64
		.i64_t { func.code << 0xBF } // f64.reinterpret_i64
	}
}

// unreachable denotes a point in code that should not be reachable, it is an unconditional trap.
// WebAssembly instruction: `unreachable`.
pub fn (mut func Function) unreachable() {
	func.code << 0x00
}

// nop instruction, does nothing.
// WebAssembly instruction: `nop`.
pub fn (mut func Function) nop() {
	func.code << 0x01
}

pub type LabelIndex = int

// c_block creates a label that can later be branched out of with `c_br` and `c_br_if`.
// Blocks are strongly typed, you must supply a list of types for `parameters` and `results`.
// All blocks must be ended, see the `c_end` function.
pub fn (mut func Function) c_block(parameters []ValType, results []ValType) LabelIndex {
	func.label++
	func.code << 0x02
	func.blocktype(parameters: parameters, results: results)
	return func.label
}

// c_loop creates a label that can later be branched to with `c_br` and `c_br_if`.
// Loops are strongly typed, you must supply a list of types for `parameters` and `results`.
// All loops must be ended, see the `c_end` function.
pub fn (mut func Function) c_loop(parameters []ValType, results []ValType) LabelIndex {
	func.label++
	func.code << 0x03
	func.blocktype(parameters: parameters, results: results)
	return func.label
}

// c_if opens an if expression. It executes a statement if the last item on the stack is true.
// It creates a label that can later be branched out of with `c_br` and `c_br_if`.
// If expressions are strongly typed, you must supply a list of types for `parameters` and `results`.
// Call `c_else` to open the else case of an if expression, or close it by calling `c_end_if`.
// All if expressions must be ended, see the `c_end` function.
pub fn (mut func Function) c_if(parameters []ValType, results []ValType) LabelIndex {
	func.label++
	func.code << 0x04
	func.blocktype(parameters: parameters, results: results)
	return func.label
}

// c_else opens the else case of an if expression, it must be closed by calling `c_end`.
pub fn (mut func Function) c_else(label LabelIndex) {
	assert func.label == label, 'c_else: called with an invalid label ${label}'
	func.code << 0x05
}

// c_return returns from a function.
// WebAssembly instruction: `return`.
pub fn (mut func Function) c_return() {
	func.code << 0x0F // return
}

// c_end ends the block, loop or if expression with the label passed in at `label`.
pub fn (mut func Function) c_end(label LabelIndex) {
	assert func.label == label, 'c_end: called with an invalid label ${label}'
	func.label--
	assert func.label >= 0, 'c_end: negative label index, unbalanced calls'
	func.code << 0x0B // END expression opcode
}

// c_br branches to a loop or block with the label passed in at `label`.
// WebAssembly instruction: `br`.
pub fn (mut func Function) c_br(label LabelIndex) {
	v := func.label - label
	assert v >= 0, 'c_br: malformed label index'
	func.code << 0x0C // br
	func.u32(u32(v))
}

// c_br_if branches to a loop or block with the label passed in at `label`, based on an i32 condition.
// WebAssembly instruction: `br_if`.
pub fn (mut func Function) c_br_if(label LabelIndex) {
	v := func.label - label
	assert v >= 0, 'c_br_if: malformed label index'
	func.code << 0x0D // br_if
	func.u32(u32(v))
}

// call calls a locally defined function.
// If this function does not exist when calling `compile` on the module, it will panic.
// WebAssembly instruction: `call`.
pub fn (mut func Function) call(name string) {
	func.code << 0x10 // call
	func.patches << CallPatch(FunctionCallPatch{
		name: name
		pos: func.code.len
	})
}

// call calls an imported function.
// If the imported function does not exist when calling `compile` on the module, it will panic.
// WebAssembly instruction: `call`.
pub fn (mut func Function) call_import(mod string, name string) {
	func.code << 0x10 // call
	func.patches << CallPatch(ImportCallPatch{
		mod: mod
		name: name
		pos: func.code.len
	})
}

// load loads a value with type `typ` from memory.
// WebAssembly instruction: `i32|i64|f32|f64.load`.
pub fn (mut func Function) load(typ NumType, align int, offset int) {
	match typ {
		.i32_t { func.code << 0x28 } // i32.load
		.i64_t { func.code << 0x29 } // i64.load
		.f32_t { func.code << 0x2A } // f32.load
		.f64_t { func.code << 0x2B } // f64.load
	}
	func.u32(u32(align))
	func.u32(u32(offset))
}

// load8 loads a 8-bit value with type `typ` with respect to `is_signed` from memory.
// WebAssembly instructions: `i32|i64.load8_s`, `i32|i64.load8_u`.
pub fn (mut func Function) load8(typ NumType, is_signed bool, align int, offset int) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x2C // i32.load8_s
			} else {
				func.code << 0x2D // i32.load8_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x30 // i64.load8_s
			} else {
				func.code << 0x31 // i64.load8_u
			}
		}
		else {}
	}
	func.u32(u32(align))
	func.u32(u32(offset))
}

// load16 loads a 16-bit value with type `typ` with respect to `is_signed` from memory.
// WebAssembly instructions: `i32|i64.load16_s`, `i32|i64.load16_u`.
pub fn (mut func Function) load16(typ NumType, is_signed bool, align int, offset int) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t {
			if is_signed {
				func.code << 0x2E // i32.load16_s
			} else {
				func.code << 0x2F // i32.load16_u
			}
		}
		.i64_t {
			if is_signed {
				func.code << 0x32 // i64.load16_s
			} else {
				func.code << 0x33 // i64.load16_u
			}
		}
		else {}
	}
	func.u32(u32(align))
	func.u32(u32(offset))
}

// load32_i64 loads a 32-bit value of type i64 with respect to `is_signed` from memory.
// WebAssembly instructions: `i64.load32_s`, `i64.load32_u`.
pub fn (mut func Function) load32_i64(is_signed bool, align int, offset int) {
	if is_signed {
		func.code << 0x34 // i64.load32_s
	} else {
		func.code << 0x35 // i64.load32_u
	}
	func.u32(u32(align))
	func.u32(u32(offset))
}

// store stores a value with type `typ` into memory.
// WebAssembly instruction: `i32|i64|f32|f64.store`.
pub fn (mut func Function) store(typ NumType, align int, offset int) {
	match typ {
		.i32_t { func.code << 0x36 } // i32.store
		.i64_t { func.code << 0x37 } // i64.store
		.f32_t { func.code << 0x38 } // f32.store
		.f64_t { func.code << 0x39 } // f64.store
	}
	func.u32(u32(align))
	func.u32(u32(offset))
}

// store8 stores a 8-bit value with type `typ` into memory.
// WebAssembly instruction: `i32|i64.store8`.
pub fn (mut func Function) store8(typ NumType, align int, offset int) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x3A } // i32.store8
		.i64_t { func.code << 0x3C } // i64.store8
		else {}
	}
	func.u32(u32(align))
	func.u32(u32(offset))
}

// store16 stores a 16-bit value with type `typ` into memory.
// WebAssembly instruction: `i32|i64.store16`.
pub fn (mut func Function) store16(typ NumType, align int, offset int) {
	assert typ in [.i32_t, .i64_t]

	match typ {
		.i32_t { func.code << 0x3B } // i32.store16
		.i64_t { func.code << 0x3D } // i64.store16
		else {}
	}
	func.u32(u32(align))
	func.u32(u32(offset))
}

// store16 stores a 32-bit value of type i64 into memory.
// WebAssembly instruction: `i64.store32`.
pub fn (mut func Function) store32_i64(align int, offset int) {
	func.code << 0x3E // i64.store32
	func.u32(u32(align))
	func.u32(u32(offset))
}

// memory_size gets the size of the memory instance.
// WebAssembly instruction: `memory.size`.
pub fn (mut func Function) memory_size() {
	func.code << 0x3F
	func.code << 0x00
}

// memory_grow increases the size of the memory instance.
// WebAssembly instruction: `memory.grow`.
pub fn (mut func Function) memory_grow() {
	func.code << 0x40
	func.code << 0x00
}

// memory_init copies from a passive memory segment to the memory instance.
// WebAssembly instruction: `memory.init`.
pub fn (mut func Function) memory_init(idx DataSegmentIndex) {
	func.code << 0xFC
	func.code << 0x08
	func.u32(u32(idx))
	func.code << 0x00
}

// data_drop prevents further use of a passive memory segment.
// WebAssembly instruction: `data.drop`.
pub fn (mut func Function) data_drop(idx DataSegmentIndex) {
	func.code << 0xFC
	func.code << 0x09
	func.u32(u32(idx))
}

// memory_copy copies one region of memory to another.
// Similar to `memcpy` and `memmove`, memory regions can overlap.
// WebAssembly instruction: `memory.copy`.
pub fn (mut func Function) memory_copy() {
	func.code << [u8(0xFC), 0x0A, 0x00, 0x00]
}

// memory_fill sets a memory region to a byte value.
// Similar to `memset`.
// WebAssembly instruction: `memory.copy`.
pub fn (mut func Function) memory_fill() {
	func.code << [u8(0xFC), 0x0B, 0x00]
}

// ref_null places a null reference on the stack.
// WebAssembly instruction: `ref.null`.
pub fn (mut func Function) ref_null(rt RefType) {
	func.code << 0xD0 // ref.null
	func.code << u8(rt)
}

// ref_is_null checks if the reference value on the stack is null, places an i32 boolean value on the stack.
// WebAssembly instruction: `ref_is_null`.
pub fn (mut func Function) ref_is_null(rt RefType) {
	func.code << 0xD1 // ref_is_null
}

// ref_func places a reference to a function with `name` on the stack.
// If this function does not exist when calling `compile` on the module, it will panic.
// WebAssembly instruction: `ref.func`.
pub fn (mut func Function) ref_func(name string) {
	func.code << 0xD2 // ref.func
	func.patches << CallPatch(FunctionCallPatch{
		name: name
		pos: func.code.len
	})
}

// ref_func_import places a reference to an imported function with `name` on the stack.
// If the imported function does not exist when calling `compile` on the module, it will panic.
// WebAssembly instruction: `ref.func`.
pub fn (mut func Function) ref_func_import(mod string, name string) {
	func.code << 0xD2 // ref.func
	func.patches << CallPatch(ImportCallPatch{
		mod: mod
		name: name
		pos: func.code.len
	})
}