// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.

module c

import v2.ssa
import strings

pub struct Gen {
	mod &ssa.Module
pub mut:
	link_builtin bool // When true, skip emitting runtime helpers (they come from builtin.o)
mut:
	sb              strings.Builder
	indent          int
	current_fn_name string
	current_fn_idx  int
	current_fn_ret  ssa.TypeID
}

pub fn Gen.new(mod &ssa.Module) &Gen {
	return &Gen{
		mod: mod
		sb:  strings.new_builder(4096)
	}
}

// new_gen creates a C backend generator without relying on static method lookup.
pub fn new_gen(mod &ssa.Module) &Gen {
	return &Gen{
		mod: mod
		sb:  strings.new_builder(4096)
	}
}

pub fn (mut g Gen) gen() string {
	g.sb.writeln('// Generated by V2 SSA Compiler')
	g.sb.writeln('#include <stdint.h>')
	g.sb.writeln('#include <stdbool.h>')
	g.sb.writeln('#include <stddef.h>')
	g.sb.writeln('#include <stdio.h>')
	g.sb.writeln('#include <stdlib.h>')
	g.sb.writeln('#include <string.h>')
	g.sb.writeln('#include <pthread.h>')
	g.sb.writeln('')
	// Undefine macOS macros that conflict with struct field names
	g.sb.writeln('#ifdef __APPLE__')
	g.sb.writeln('#undef sa_handler')
	g.sb.writeln('#undef sa_sigaction')
	g.sb.writeln('#endif')
	g.sb.writeln('')

	// Builtin type aliases
	g.sb.writeln('typedef int8_t i8;')
	g.sb.writeln('typedef int16_t i16;')
	g.sb.writeln('typedef int32_t i32;')
	g.sb.writeln('typedef int64_t i64;')
	g.sb.writeln('typedef uint8_t u8;')
	g.sb.writeln('typedef uint16_t u16;')
	g.sb.writeln('typedef uint32_t u32;')
	g.sb.writeln('typedef uint64_t u64;')
	g.sb.writeln('typedef float f32;')
	g.sb.writeln('typedef double f64;')
	g.sb.writeln('typedef int64_t isize;')
	g.sb.writeln('typedef uint64_t usize;')
	g.sb.writeln('typedef u8 rune;')
	g.sb.writeln('')

	// wyhash implementation (used by map)
	g.gen_wyhash()

	// Runtime helpers (only when not linking against builtin.o)
	if !g.link_builtin {
		g.gen_runtime_helpers()
		g.sb.writeln('')
	}

	// Struct declarations
	g.gen_struct_decls()

	// Global declarations
	g.gen_globals()

	// Function forward declarations for all functions
	g.gen_fn_forward_decls()

	// Spawn wrapper functions (pre-scanned from all spawn_call instructions)
	g.gen_spawn_wrappers()

	// Function bodies (skip stub functions - they'll come from builtin.o)
	for i, func in g.mod.funcs {
		if func.blocks.len == 0 {
			continue
		}
		if g.is_stub_function(func) {
			continue
		}
		g.current_fn_idx = i
		g.gen_function(func)
	}

	return g.sb.str()
}

// gen_spawn_wrappers pre-scans all functions for spawn_call instructions with
// arguments and emits wrapper functions that unpack the args struct and call the
// original function. These must be emitted before function bodies so that the
// wrappers are visible at each pthread_create call site.
fn (mut g Gen) gen_spawn_wrappers() {
	for func in g.mod.funcs {
		for blk_id in func.blocks {
			block := g.mod.blocks[blk_id]
			for instr_id in block.instrs {
				val := g.mod.values[instr_id]
				if val.kind != .instruction {
					continue
				}
				instr := g.mod.instrs[val.index]
				if instr.op !in [.spawn_call, .go_call] || instr.operands.len < 2 {
					continue
				}
				fn_ref := instr.operands[0]
				fn_val := g.mod.values[fn_ref]
				fn_name := sanitize_c_ident(fn_val.name)
				prefix := if instr.op == .spawn_call { '_spawn' } else { '_go' }
				wrapper_id := '${fn_name}_${val.name}'
				arg_count := instr.operands.len - 1

				g.sb.write_string('struct ${prefix}_args_${wrapper_id} { ')
				for ai in 0 .. arg_count {
					arg_type := g.type_name(g.mod.values[instr.operands[ai + 1]].typ)
					g.sb.write_string('${arg_type} a${ai}; ')
				}
				g.sb.writeln('};')
				g.sb.writeln('static void* ${prefix}_wrapper_${wrapper_id}(void* _arg) {')
				g.sb.writeln('\tstruct ${prefix}_args_${wrapper_id}* _args = (struct ${prefix}_args_${wrapper_id}*)_arg;')
				g.sb.write_string('\t${fn_name}(')
				for ai in 0 .. arg_count {
					if ai > 0 {
						g.sb.write_string(', ')
					}
					g.sb.write_string('_args->a${ai}')
				}
				g.sb.writeln(');')
				g.sb.writeln('\tfree(_arg);')
				g.sb.writeln('\treturn NULL;')
				g.sb.writeln('}')
				g.sb.writeln('')
			}
		}
	}
}

fn (mut g Gen) gen_runtime_helpers() {
	// println
	g.sb.writeln('static void println(string s) {')
	g.sb.writeln('\tif (s.str && s.len > 0) {')
	g.sb.writeln('\t\tfwrite(s.str, 1, s.len, stdout);')
	g.sb.writeln('\t}')
	g.sb.writeln('\tputchar(10);')
	g.sb.writeln('}')
	g.sb.writeln('')

	// print
	g.sb.writeln('static void print(string s) {')
	g.sb.writeln('\tif (s.str && s.len > 0) {')
	g.sb.writeln('\t\tfwrite(s.str, 1, s.len, stdout);')
	g.sb.writeln('\t}')
	g.sb.writeln('}')
	g.sb.writeln('')

	// eprintln
	g.sb.writeln('static void eprintln(string s) {')
	g.sb.writeln('\tif (s.str && s.len > 0) {')
	g.sb.writeln('\t\tfwrite(s.str, 1, s.len, stderr);')
	g.sb.writeln('\t}')
	g.sb.writeln('\tfputc(10, stderr);')
	g.sb.writeln('}')
	g.sb.writeln('')

	// int_str helper (converts int to string)
	g.sb.writeln('static string int_str(i64 val) {')
	g.sb.writeln('\tstatic char buf[32];')
	g.sb.writeln('\tint len = snprintf(buf, sizeof(buf), "%lld", (long long)val);')
	g.sb.writeln('\treturn (string){.str = (i8*)buf, .len = len, .is_lit = 1};')
	g.sb.writeln('}')
	g.sb.writeln('')

	// string__plus helper
	g.sb.writeln('static string string__plus(string a, string b) {')
	g.sb.writeln('\ti64 new_len = a.len + b.len;')
	g.sb.writeln('\ti8* s = (i8*)malloc(new_len + 1);')
	g.sb.writeln('\tif (a.str && a.len > 0) memcpy(s, a.str, a.len);')
	g.sb.writeln('\tif (b.str && b.len > 0) memcpy(s + a.len, b.str, b.len);')
	g.sb.writeln('\ts[new_len] = 0;')
	g.sb.writeln('\treturn (string){.str = s, .len = new_len, .is_lit = 0};')
	g.sb.writeln('}')
}

fn (mut g Gen) gen_module_init_stubs() {
	// Generate empty stubs for module __v_init_consts functions
	// that the transformer injects into main()
	mut emitted := map[string]bool{}
	for func in g.mod.funcs {
		if func.blocks.len == 0 {
			continue
		}
		for block_id in func.blocks {
			block := g.mod.blocks[block_id]
			for instr_id in block.instrs {
				val := g.mod.values[instr_id]
				if val.kind != .instruction {
					continue
				}
				instr := g.mod.instrs[val.index]
				if instr.op == .call && instr.operands.len > 0 {
					fn_val := g.mod.values[instr.operands[0]]
					if fn_val.kind == .func_ref && fn_val.name.contains('__v_init_consts') {
						c_name := sanitize_c_ident(fn_val.name)
						if c_name !in emitted {
							g.sb.writeln('static void ${c_name}(void) {}')
							emitted[c_name] = true
						}
					}
				}
			}
		}
	}
}

fn (mut g Gen) gen_struct_decls() {
	// Forward declarations for all registered structs
	for _, name in g.mod.c_struct_names {
		g.sb.writeln('typedef struct ${name} ${name};')
	}
	g.sb.writeln('')

	// Full struct definitions
	for type_id, name in g.mod.c_struct_names {
		typ := g.mod.type_store.types[type_id]
		g.sb.writeln('struct ${name} {')
		for fi, field_type in typ.fields {
			field_name := if fi < typ.field_names.len {
				typ.field_names[fi]
			} else {
				'field_${fi}'
			}
			g.sb.writeln('\t${g.type_name(field_type)} ${field_name};')
		}
		g.sb.writeln('};')
		g.sb.writeln('')
	}
}

fn (g &Gen) struct_name(type_id ssa.TypeID) string {
	// Check if there's a registered struct name in the module
	if name := g.mod.c_struct_names[type_id] {
		return name
	}
	return 'Struct_${type_id}'
}

fn (mut g Gen) gen_globals() {
	for glob in g.mod.globals {
		if glob.linkage == .external {
			g.sb.write_string('extern ')
		}
		g.sb.writeln('${g.type_name(glob.typ)} ${sanitize_c_ident(glob.name)};')
	}
	if g.mod.globals.len > 0 {
		g.sb.writeln('')
	}
}

fn (mut g Gen) gen_fn_forward_decls() {
	for func in g.mod.funcs {
		if func.name == 'main' {
			g.sb.writeln('int main(int argc, char** argv);')
			continue
		}
		// Skip C extern functions — they conflict with system header declarations.
		// Non-standard C functions (wyhash, etc.) are provided via inline headers.
		if func.is_c_extern {
			continue
		}
		c_name := g.fn_c_name(func.name)
		ret_type := g.type_name(func.typ)
		mut params := []string{}
		for i, pid in func.params {
			val := g.mod.values[pid]
			ptype := g.type_name(val.typ)
			if val.name.len == 0 {
				// C extern functions may have unnamed parameters
				params << '${ptype} _p${i}'
			} else {
				pname := sanitize_c_ident(val.name)
				params << '${ptype} ${pname}'
			}
		}
		param_str := if params.len > 0 { params.join(', ') } else { 'void' }
		g.sb.writeln('${ret_type} ${c_name}(${param_str});')
	}
	g.sb.writeln('')
}

// is_stub_function returns true for functions that only have a trivial
// entry block with a return (empty stubs generated for non-main-module functions).
// These functions will be provided by the linked builtin.o.
fn (g &Gen) is_stub_function(func ssa.Function) bool {
	if func.blocks.len != 1 {
		return false
	}
	block := g.mod.blocks[func.blocks[0]]
	// A stub has 0-2 instructions (just a return, possibly with a zero constant)
	mut real_instrs := 0
	for instr_id in block.instrs {
		val := g.mod.values[instr_id]
		if val.kind != .instruction {
			continue
		}
		instr := g.mod.instrs[val.index]
		if instr.op == .ret {
			continue
		}
		if instr.op in [.alloca, .heap_alloc, .load] {
			// alloca/heap_alloc+load for struct return stubs
			continue
		}
		real_instrs++
	}
	return real_instrs == 0
}

fn (g &Gen) fn_c_name(name string) string {
	c_name := sanitize_c_ident(name)
	// Check if this function name conflicts with a struct name
	for _, sname in g.mod.c_struct_names {
		if c_name == sname {
			return '${c_name}_fn'
		}
	}
	return c_name
}

fn (mut g Gen) gen_function(func ssa.Function) {
	g.current_fn_name = func.name
	g.current_fn_ret = func.typ

	if func.blocks.len == 0 {
		return
	}

	// Function signature
	if func.name == 'main' {
		g.sb.write_string('int main(int argc, char** argv)')
	} else {
		c_name := g.fn_c_name(func.name)
		ret_type := g.type_name(func.typ)
		mut params := []string{}
		for pid in func.params {
			val := g.mod.values[pid]
			ptype := g.type_name(val.typ)
			pname := sanitize_c_ident(val.name)
			params << '${ptype} ${pname}'
		}
		param_str := if params.len > 0 { params.join(', ') } else { 'void' }
		g.sb.write_string('${ret_type} ${c_name}(${param_str})')
	}

	g.sb.writeln(' {')
	g.indent = 1

	// Collect all allocas and local variable declarations
	mut declared_vars := map[int]bool{}

	// Generate blocks
	for bi, block_id in func.blocks {
		block := g.mod.blocks[block_id]

		// Emit label for non-entry blocks
		if bi > 0 {
			g.sb.writeln('${block.name}:;')
		}

		for instr_id in block.instrs {
			val := g.mod.values[instr_id]
			if val.kind != .instruction {
				continue
			}
			instr := g.mod.instrs[val.index]

			match instr.op {
				.alloca {
					// Declare local variable
					elem_type := g.mod.type_store.types[instr.typ].elem_type
					if elem_type != 0 {
						g.write_indent()
						// Check if this is a multi-element alloca (fixed-size array on stack)
						mut count := 1
						if instr.operands.len > 0 {
							count_val := g.mod.values[instr.operands[0]]
							count = count_val.name.int()
							if count < 1 {
								count = 1
							}
						}
						if count > 1 {
							g.sb.writeln('${g.type_name(elem_type)} ${val.name}[${count}];')
						} else {
							g.sb.writeln('${g.type_name(elem_type)} ${val.name};')
						}
						declared_vars[val.id] = true
					}
				}
				.heap_alloc {
					// Heap-allocate: declare as pointer and call calloc
					elem_type := g.mod.type_store.types[instr.typ].elem_type
					if elem_type != 0 {
						g.write_indent()
						g.sb.writeln('${g.type_name(elem_type)}* ${val.name} = (${g.type_name(elem_type)}*)calloc(1, sizeof(${g.type_name(elem_type)}));')
						declared_vars[val.id] = true
					}
				}
				.store {
					if instr.operands.len >= 2 {
						src := instr.operands[0]
						dst := instr.operands[1]
						dst_val := g.mod.values[dst]
						src_val := g.mod.values[src]
						g.write_indent()
						if dst_val.kind == .global || (dst_val.kind == .instruction
							&& g.mod.instrs[dst_val.index].op in [.alloca, .heap_alloc]) {
							if dst_val.kind == .instruction
								&& g.mod.instrs[dst_val.index].op == .heap_alloc {
								g.sb.write_string('*${sanitize_c_ident(dst_val.name)} = ')
							} else {
								g.sb.write_string('${sanitize_c_ident(dst_val.name)} = ')
							}
							// If src is an alloca and dst's elem type is a pointer,
							// we need & (e.g., storing &Point{} alloca into a Point* variable)
							if src_val.kind == .instruction
								&& g.mod.instrs[src_val.index].op == .alloca {
								mut dst_ptr_typ := ssa.TypeID(0)
								if dst_val.kind == .global {
									dst_ptr_typ = dst_val.typ
								} else {
									dst_ptr_typ = g.mod.instrs[dst_val.index].typ
								}
								if dst_ptr_typ < g.mod.type_store.types.len {
									dst_elem := g.mod.type_store.types[dst_ptr_typ].elem_type
									if dst_elem < g.mod.type_store.types.len
										&& g.mod.type_store.types[dst_elem].kind == .ptr_t {
										g.sb.write_string('&')
									}
								}
							}
							g.gen_value(src)
							g.sb.writeln(';')
						} else {
							g.sb.write_string('*(')
							g.gen_value(dst)
							g.sb.write_string(') = ')
							g.gen_value(src)
							g.sb.writeln(';')
						}
					}
				}
				.load {
					if instr.operands.len >= 1 {
						src := instr.operands[0]
						src_val := g.mod.values[src]
						// Check if this load result is actually used
						if val.uses.len > 0 {
							g.write_indent()
							g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
							if src_val.kind == .global
								|| (src_val.kind == .instruction
								&& g.mod.instrs[src_val.index].op == .alloca) {
								g.gen_value(src)
							} else {
								g.sb.write_string('*(')
								g.gen_value(src)
								g.sb.write_string(')')
							}
							g.sb.writeln(';')
						}
					}
				}
				.ret {
					g.write_indent()
					if instr.operands.len > 0 {
						g.sb.write_string('return ')
						g.gen_value(instr.operands[0])
						g.sb.writeln(';')
					} else {
						if g.current_fn_name == 'main' {
							g.sb.writeln('return 0;')
						} else {
							g.sb.writeln('return;')
						}
					}
				}
				.br {
					// Conditional branch: br cond, then_label, else_label
					if instr.operands.len >= 3 {
						cond := instr.operands[0]
						then_block := g.mod.get_block_from_val(instr.operands[1])
						else_block := g.mod.get_block_from_val(instr.operands[2])
						g.write_indent()
						g.sb.write_string('if (')
						g.gen_value(cond)
						g.sb.write_string(') goto ${g.mod.blocks[then_block].name}; ')
						g.sb.writeln('else goto ${g.mod.blocks[else_block].name};')
					}
				}
				.jmp {
					if instr.operands.len >= 1 {
						target_block := g.mod.get_block_from_val(instr.operands[0])
						g.write_indent()
						g.sb.writeln('goto ${g.mod.blocks[target_block].name};')
					}
				}
				.call {
					if instr.operands.len >= 1 {
						fn_ref := instr.operands[0]
						fn_val := g.mod.values[fn_ref]
						fn_name := sanitize_c_ident(fn_val.name)

						// Look up target function to get parameter types
						mut target_fn_params := []ssa.ValueID{}
						for f in g.mod.funcs {
							if sanitize_c_ident(f.name) == fn_name {
								target_fn_params = f.params.clone()
								break
							}
						}

						g.write_indent()
						// Only declare result if used and non-void
						if val.uses.len > 0 && instr.typ != 0 {
							g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
						}

						g.sb.write_string('${fn_name}(')
						for ai := 1; ai < instr.operands.len; ai++ {
							if ai > 1 {
								g.sb.write_string(', ')
							}
							arg_val := g.mod.values[instr.operands[ai]]
							param_idx := ai - 1
							// Check if arg is an alloca being passed to a pointer param
							if arg_val.kind == .instruction
								&& g.mod.instrs[arg_val.index].op == .alloca
								&& param_idx < target_fn_params.len {
								param_type := g.mod.values[target_fn_params[param_idx]].typ
								if param_type < g.mod.type_store.types.len
									&& g.mod.type_store.types[param_type].kind == .ptr_t {
									// Parameter expects a pointer - emit &var
									g.sb.write_string('&')
									g.gen_value(instr.operands[ai])
									continue
								}
							}
							// Check if arg is a pointer type but param expects non-pointer (auto-deref)
							if param_idx < target_fn_params.len {
								param_type := g.mod.values[target_fn_params[param_idx]].typ
								arg_type := arg_val.typ
								if arg_type < g.mod.type_store.types.len
									&& g.mod.type_store.types[arg_type].kind == .ptr_t
									&& param_type < g.mod.type_store.types.len
									&& g.mod.type_store.types[param_type].kind != .ptr_t {
									// Arg is pointer but param expects value - emit *var
									g.sb.write_string('*(')
									g.gen_value(instr.operands[ai])
									g.sb.write_string(')')
									continue
								}
							}
							g.gen_value(instr.operands[ai])
						}
						g.sb.writeln(');')
					}
				}
				.add, .sub, .mul, .sdiv, .srem, .fadd, .fsub, .fmul, .fdiv {
					if instr.operands.len >= 2 {
						op_str := match instr.op {
							.add, .fadd { '+' }
							.sub, .fsub { '-' }
							.mul, .fmul { '*' }
							.sdiv, .fdiv { '/' }
							.srem { '%' }
							else { '+' }
						}

						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
						g.gen_value(instr.operands[0])
						g.sb.write_string(' ${op_str} ')
						g.gen_value(instr.operands[1])
						g.sb.writeln(';')
					}
				}
				.eq, .ne, .lt, .gt, .le, .ge {
					if instr.operands.len >= 2 {
						op_str := match instr.op {
							.eq { '==' }
							.ne { '!=' }
							.lt { '<' }
							.gt { '>' }
							.le { '<=' }
							.ge { '>=' }
							else { '==' }
						}

						g.write_indent()
						g.sb.write_string('bool ${val.name} = ')
						g.gen_value(instr.operands[0])
						g.sb.write_string(' ${op_str} ')
						g.gen_value(instr.operands[1])
						g.sb.writeln(';')
					}
				}
				.and_ {
					if instr.operands.len >= 2 {
						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
						g.gen_value(instr.operands[0])
						// Use logical && for bool, bitwise & for integers
						is_bool := instr.typ < g.mod.type_store.types.len
							&& g.mod.type_store.types[instr.typ].kind == .int_t
							&& g.mod.type_store.types[instr.typ].width == 1
						g.sb.write_string(if is_bool { ' && ' } else { ' & ' })
						g.gen_value(instr.operands[1])
						g.sb.writeln(';')
					}
				}
				.or_ {
					if instr.operands.len >= 2 {
						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
						g.gen_value(instr.operands[0])
						// Use logical || for bool, bitwise | for integers
						is_bool := instr.typ < g.mod.type_store.types.len
							&& g.mod.type_store.types[instr.typ].kind == .int_t
							&& g.mod.type_store.types[instr.typ].width == 1
						g.sb.write_string(if is_bool { ' || ' } else { ' | ' })
						g.gen_value(instr.operands[1])
						g.sb.writeln(';')
					}
				}
				.xor {
					if instr.operands.len >= 2 {
						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
						g.gen_value(instr.operands[0])
						g.sb.write_string(' ^ ')
						g.gen_value(instr.operands[1])
						g.sb.writeln(';')
					}
				}
				.shl {
					if instr.operands.len >= 2 {
						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
						g.gen_value(instr.operands[0])
						g.sb.write_string(' << ')
						g.gen_value(instr.operands[1])
						g.sb.writeln(';')
					}
				}
				.ashr, .lshr {
					if instr.operands.len >= 2 {
						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
						g.gen_value(instr.operands[0])
						g.sb.write_string(' >> ')
						g.gen_value(instr.operands[1])
						g.sb.writeln(';')
					}
				}
				.sext, .zext, .trunc, .bitcast {
					if instr.operands.len >= 1 {
						g.write_indent()
						target_tn := g.type_name(instr.typ)
						src_type := g.mod.values[instr.operands[0]].typ
						src_kind := if src_type < g.mod.type_store.types.len {
							g.mod.type_store.types[src_type].kind
						} else {
							ssa.TypeKind.void_t
						}
						dst_kind := if instr.typ < g.mod.type_store.types.len {
							g.mod.type_store.types[instr.typ].kind
						} else {
							ssa.TypeKind.void_t
						}
						// Pointer-to-struct cast: dereference through typed pointer
						if src_kind == .ptr_t && dst_kind == .struct_t {
							g.sb.write_string('${target_tn} ${val.name} = *(${target_tn}*)')
						} else {
							g.sb.write_string('${target_tn} ${val.name} = (${target_tn})')
						}
						g.gen_value(instr.operands[0])
						g.sb.writeln(';')
					}
				}
				.sitofp, .uitofp {
					if instr.operands.len >= 1 {
						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = (${g.type_name(instr.typ)})')
						g.gen_value(instr.operands[0])
						g.sb.writeln(';')
					}
				}
				.fptosi, .fptoui {
					if instr.operands.len >= 1 {
						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = (${g.type_name(instr.typ)})')
						g.gen_value(instr.operands[0])
						g.sb.writeln(';')
					}
				}
				.get_element_ptr {
					// GEP -> struct field address: &base.field_name
					if instr.operands.len >= 2 {
						base_val := g.mod.values[instr.operands[0]]
						idx_val := g.mod.values[instr.operands[1]]
						field_idx := idx_val.name.int()
						// Check if base is a struct pointer (alloca produces ptr to struct)
						base_typ := g.mod.type_store.types[base_val.typ]
						mut emitted := false
						if base_typ.kind == .ptr_t {
							elem_typ := g.mod.type_store.types[base_typ.elem_type]
							if elem_typ.kind == .struct_t && field_idx < elem_typ.field_names.len {
								g.write_indent()
								g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = &')
								g.gen_value(instr.operands[0])
								// If base is an alloca, access as lvalue directly
								if base_val.kind == .instruction
									&& g.mod.instrs[base_val.index].op == .alloca {
									g.sb.writeln('.${elem_typ.field_names[field_idx]};')
								} else {
									g.sb.writeln('->${elem_typ.field_names[field_idx]};')
								}
								emitted = true
							}
						}
						if !emitted {
							// Pointer arithmetic: base + index
							g.write_indent()
							g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
							g.gen_value(instr.operands[0])
							g.sb.write_string(' + ')
							g.gen_value(instr.operands[1])
							g.sb.writeln(';')
						}
					}
				}
				.extractvalue {
					if instr.operands.len >= 2 {
						g.write_indent()
						g.sb.write_string('${g.type_name(instr.typ)} ${val.name} = ')
						g.gen_value(instr.operands[0])
						// Get field name from index constant
						idx_val := g.mod.values[instr.operands[1]]
						field_idx := idx_val.name.int()
						base_val := g.mod.values[instr.operands[0]]
						base_typ := g.mod.type_store.types[base_val.typ]
						if base_typ.kind == .struct_t && field_idx < base_typ.field_names.len {
							g.sb.writeln('.${base_typ.field_names[field_idx]};')
						} else {
							g.sb.writeln('; /* extractvalue idx=${field_idx} */')
						}
					}
				}
				.struct_init {
					g.write_indent()
					type_name := g.type_name(instr.typ)
					g.sb.write_string('${type_name} ${val.name} = (${type_name}){')
					typ := g.mod.type_store.types[instr.typ]
					for fi, op in instr.operands {
						if fi > 0 {
							g.sb.write_string(', ')
						}
						if fi < typ.field_names.len {
							g.sb.write_string('.${typ.field_names[fi]} = ')
						}
						g.gen_value(op)
					}
					g.sb.writeln('};')
				}
				.inline_string_init {
					if instr.operands.len >= 3 {
						g.write_indent()
						g.sb.write_string('string ${val.name} = (string){.str = (i8*)')
						g.gen_value(instr.operands[0])
						g.sb.write_string(', .len = ')
						g.gen_value(instr.operands[1])
						g.sb.write_string(', .is_lit = ')
						g.gen_value(instr.operands[2])
						g.sb.writeln('};')
					}
				}
				.unreachable {
					g.write_indent()
					g.sb.writeln('__builtin_unreachable();')
				}
				.go_call {
					// go fn(args...) -> goroutines__goroutine_create(fn, args)
					if instr.operands.len >= 1 {
						fn_ref := instr.operands[0]
						fn_val := g.mod.values[fn_ref]
						fn_name := sanitize_c_ident(fn_val.name)
						arg_count := instr.operands.len - 1

						if arg_count == 0 {
							// No arguments: pass function directly with NULL arg
							g.write_indent()
							g.sb.writeln('goroutines__goroutine_create((void*)(void(*)())${fn_name}, NULL, 0);')
						} else {
							wrapper_id := '${fn_name}_${val.name}'

							g.write_indent()
							g.sb.writeln('{')
							g.indent++

							// Declare args struct on heap
							g.write_indent()
							g.sb.write_string('struct _go_args_${wrapper_id} { ')
							for ai in 0 .. arg_count {
								arg_type := g.type_name(g.mod.values[instr.operands[ai + 1]].typ)
								g.sb.write_string('${arg_type} a${ai}; ')
							}
							g.sb.writeln('};')

							g.write_indent()
							g.sb.writeln('struct _go_args_${wrapper_id}* _args = (struct _go_args_${wrapper_id}*)malloc(sizeof(struct _go_args_${wrapper_id}));')

							// Pack arguments
							for ai in 0 .. arg_count {
								g.write_indent()
								g.sb.write_string('_args->a${ai} = ')
								g.gen_value(instr.operands[ai + 1])
								g.sb.writeln(';')
							}

							// Call goroutine_create with the unpacking wrapper
							g.write_indent()
							g.sb.writeln('goroutines__goroutine_create((void*)(void(*)())_go_wrapper_${wrapper_id}, _args, sizeof(struct _go_args_${wrapper_id}));')

							g.indent--
							g.write_indent()
							g.sb.writeln('}')
						}
					}
				}
				.spawn_call {
					// spawn fn(args...) -> launch OS thread via pthread_create
					if instr.operands.len >= 1 {
						fn_ref := instr.operands[0]
						fn_val := g.mod.values[fn_ref]
						fn_name := sanitize_c_ident(fn_val.name)
						arg_count := instr.operands.len - 1

						g.write_indent()
						g.sb.writeln('{')
						g.indent++

						g.write_indent()
						g.sb.writeln('pthread_t _spawn_thread;')

						if arg_count == 0 {
							g.write_indent()
							g.sb.writeln('pthread_create(&_spawn_thread, NULL, (void*(*)(void*))${fn_name}, NULL);')
						} else {
							wrapper_id := '${fn_name}_${val.name}'

							g.write_indent()
							g.sb.write_string('struct _spawn_args_${wrapper_id} { ')
							for ai in 0 .. arg_count {
								arg_type := g.type_name(g.mod.values[instr.operands[ai + 1]].typ)
								g.sb.write_string('${arg_type} a${ai}; ')
							}
							g.sb.writeln('};')

							g.write_indent()
							g.sb.writeln('struct _spawn_args_${wrapper_id}* _args = (struct _spawn_args_${wrapper_id}*)malloc(sizeof(struct _spawn_args_${wrapper_id}));')

							for ai in 0 .. arg_count {
								g.write_indent()
								g.sb.write_string('_args->a${ai} = ')
								g.gen_value(instr.operands[ai + 1])
								g.sb.writeln(';')
							}

							g.write_indent()
							g.sb.writeln('pthread_create(&_spawn_thread, NULL, _spawn_wrapper_${wrapper_id}, _args);')
						}

						g.write_indent()
						g.sb.writeln('pthread_detach(_spawn_thread);')

						g.indent--
						g.write_indent()
						g.sb.writeln('}')
					}
				}
				else {
					// Other ops: emit as comment
					g.write_indent()
					g.sb.writeln('/* TODO: ${instr.op} */')
				}
			}
		}
	}

	g.sb.writeln('}')
	g.sb.writeln('')
}

fn (mut g Gen) gen_value(id ssa.ValueID) {
	if id == 0 {
		g.sb.write_string('0')
		return
	}
	val := g.mod.values[id]
	match val.kind {
		.constant {
			g.sb.write_string(val.name)
		}
		.argument {
			g.sb.write_string(sanitize_c_ident(val.name))
		}
		.global {
			g.sb.write_string(sanitize_c_ident(val.name))
		}
		.instruction {
			g.sb.write_string(val.name)
		}
		.string_literal {
			// Emit as V string struct literal
			escaped := escape_c_string(val.name)
			g.sb.write_string('(string){.str = (i8*)"${escaped}", .len = ${val.name.len}, .is_lit = 1}')
		}
		.c_string_literal {
			// Emit as raw C string (char*) — no re-escaping needed,
			// the value already contains C escape sequences from the source
			g.sb.write_string('"${val.name}"')
		}
		.func_ref {
			g.sb.write_string(g.fn_c_name(val.name))
		}
		.basic_block {
			g.sb.write_string(val.name)
		}
		.unknown {
			g.sb.write_string('0')
		}
	}
}

fn (g &Gen) type_name(id ssa.TypeID) string {
	if id == 0 {
		return 'void'
	}
	if id >= g.mod.type_store.types.len {
		return 'void'
	}
	typ := g.mod.type_store.types[id]
	match typ.kind {
		.void_t {
			return 'void'
		}
		.int_t {
			return match typ.width {
				1 { 'bool' }
				8 { 'i8' }
				16 { 'i16' }
				32 { 'i32' }
				64 { 'i64' }
				else { 'i64' }
			}
		}
		.float_t {
			return if typ.width == 32 { 'f32' } else { 'f64' }
		}
		.ptr_t {
			base := g.type_name(typ.elem_type)
			return '${base}*'
		}
		.struct_t {
			if typ.field_names.len > 0 {
				// Only use struct name if it was registered
				if _ := g.mod.c_struct_names[id] {
					return g.struct_name(id)
				}
			}
			return 'void*'
		}
		.array_t {
			return 'void*'
		}
		.func_t {
			return 'void*'
		}
		.label_t {
			return 'void*'
		}
		.metadata_t {
			return 'void*'
		}
	}
}

fn (mut g Gen) write_indent() {
	for _ in 0 .. g.indent {
		g.sb.write_string('\t')
	}
}

fn sanitize_c_ident(name string) string {
	if name.len == 0 {
		return '_empty'
	}
	// C interop: strip C__ prefix
	if name.starts_with('C__') {
		return name[3..]
	}
	mut s := name.replace('.', '__')
	s = s.replace('-', '_')
	// Replace operator symbols that can't appear in C identifiers
	s = s.replace('==', '_eq')
	s = s.replace('!=', '_ne')
	s = s.replace('<=', '_le')
	s = s.replace('>=', '_ge')
	s = s.replace('<<', '_shl')
	s = s.replace('>>', '_shr')
	s = s.replace('<', '_lt')
	s = s.replace('>', '_gt')
	s = s.replace('+', '_plus')
	s = s.replace('*', '_mul')
	s = s.replace('/', '_div')
	s = s.replace('%', '_mod')
	// Reserved C keywords
	if s in ['auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do', 'double', 'else',
		'enum', 'extern', 'float', 'for', 'goto', 'if', 'inline', 'int', 'long', 'register',
		'restrict', 'return', 'short', 'signed', 'sizeof', 'static', 'struct', 'switch', 'typedef',
		'union', 'unsigned', 'void', 'volatile', 'while', 'unix', 'linux', 'error'] {
		return 'v__${s}'
	}
	return s
}

fn escape_c_string(s string) string {
	mut sb := strings.new_builder(s.len + 8)
	for ch in s {
		match ch {
			`"` { sb.write_string('\\"') }
			`\\` { sb.write_string('\\\\') }
			`\n` { sb.write_string('\\n') }
			`\r` { sb.write_string('\\r') }
			`\t` { sb.write_string('\\t') }
			0 { sb.write_string('\\0') }
			else { sb.write_u8(ch) }
		}
	}
	return sb.str()
}

fn (mut g Gen) gen_wyhash() {
	g.sb.writeln('#ifndef wyhash_final_version_4_2')
	g.sb.writeln('#define wyhash_final_version_4_2')
	g.sb.writeln('#define WYHASH_CONDOM 1')
	g.sb.writeln('#define WYHASH_32BIT_MUM 0')
	g.sb.writeln('#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)')
	g.sb.writeln('  #define _likely_(x) __builtin_expect(x,1)')
	g.sb.writeln('  #define _unlikely_(x) __builtin_expect(x,0)')
	g.sb.writeln('#else')
	g.sb.writeln('  #define _likely_(x) (x)')
	g.sb.writeln('  #define _unlikely_(x) (x)')
	g.sb.writeln('#endif')
	g.sb.writeln('static inline uint64_t _wyrot(uint64_t x) { return (x>>32)|(x<<32); }')
	g.sb.writeln('static inline void _wymum(uint64_t *A, uint64_t *B){')
	g.sb.writeln('#if defined(__SIZEOF_INT128__)')
	g.sb.writeln('  __uint128_t r=*A; r*=*B; *A=(uint64_t)r; *B=(uint64_t)(r>>64);')
	g.sb.writeln('#elif defined(_MSC_VER) && defined(_M_X64)')
	g.sb.writeln('  *A=_umul128(*A,*B,B);')
	g.sb.writeln('#else')
	g.sb.writeln('  uint64_t ha=*A>>32, hb=*B>>32, la=(uint32_t)*A, lb=(uint32_t)*B, hi, lo;')
	g.sb.writeln('  uint64_t rh=ha*hb, rm0=ha*lb, rm1=hb*la, rl=la*lb, t=rl+(rm0<<32), c=t<rl;')
	g.sb.writeln('  lo=t+(rm1<<32); c+=lo<t; hi=rh+(rm0>>32)+(rm1>>32)+c;')
	g.sb.writeln('  *A=lo; *B=hi;')
	g.sb.writeln('#endif')
	g.sb.writeln('}')
	g.sb.writeln('static inline uint64_t _wymix(uint64_t A, uint64_t B){ _wymum(&A,&B); return A^B; }')
	g.sb.writeln('#ifndef WYHASH_LITTLE_ENDIAN')
	g.sb.writeln('  #ifdef TARGET_ORDER_IS_LITTLE')
	g.sb.writeln('    #define WYHASH_LITTLE_ENDIAN 1')
	g.sb.writeln('  #else')
	g.sb.writeln('    #define WYHASH_LITTLE_ENDIAN 0')
	g.sb.writeln('  #endif')
	g.sb.writeln('#endif')
	g.sb.writeln('#if (WYHASH_LITTLE_ENDIAN)')
	g.sb.writeln('  static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v;}')
	g.sb.writeln('  static inline uint64_t _wyr4(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return v;}')
	g.sb.writeln('#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)')
	g.sb.writeln('  static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return __builtin_bswap64(v);}')
	g.sb.writeln('  static inline uint64_t _wyr4(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return __builtin_bswap32(v);}')
	g.sb.writeln('#else')
	g.sb.writeln('  static inline uint64_t _wyr8(const uint8_t *p) {')
	g.sb.writeln('    uint64_t v; memcpy(&v, p, 8);')
	g.sb.writeln('    return (((v >> 56) & 0xff)| ((v >> 40) & 0xff00)| ((v >> 24) & 0xff0000)| ((v >>  8) & 0xff000000)| ((v <<  8) & 0xff00000000)| ((v << 24) & 0xff0000000000)| ((v << 40) & 0xff000000000000)| ((v << 56) & 0xff00000000000000));')
	g.sb.writeln('  }')
	g.sb.writeln('  static inline uint64_t _wyr4(const uint8_t *p) {')
	g.sb.writeln('    uint32_t v; memcpy(&v, p, 4);')
	g.sb.writeln('    return (((v >> 24) & 0xff)| ((v >>  8) & 0xff00)| ((v <<  8) & 0xff0000)| ((v << 24) & 0xff000000));')
	g.sb.writeln('  }')
	g.sb.writeln('#endif')
	g.sb.writeln('static inline uint64_t _wyr3(const uint8_t *p, size_t k) { return (((uint64_t)p[0])<<16)|(((uint64_t)p[k>>1])<<8)|p[k-1];}')
	g.sb.writeln('static inline uint64_t wyhash(const void *key, size_t len, uint64_t seed, const uint64_t *secret){')
	g.sb.writeln('  const uint8_t *p=(const uint8_t *)key; seed^=_wymix(seed^secret[0]^len,secret[1]); uint64_t a, b;')
	g.sb.writeln('  if(_likely_(len<=16)){')
	g.sb.writeln('    if(_likely_(len>=4)){ a=(_wyr4(p)<<32)|_wyr4(p+((len>>3)<<2)); b=(_wyr4(p+len-4)<<32)|_wyr4(p+len-4-((len>>3)<<2)); }')
	g.sb.writeln('    else if(_likely_(len>0)){ a=_wyr3(p,len); b=0; }')
	g.sb.writeln('    else a=b=0;')
	g.sb.writeln('  } else {')
	g.sb.writeln('    size_t i=len;')
	g.sb.writeln('    if(_unlikely_(i>=48)){')
	g.sb.writeln('      uint64_t see1=seed, see2=seed;')
	g.sb.writeln('      do{')
	g.sb.writeln('        seed=_wymix(_wyr8(p)^secret[1],_wyr8(p+8)^seed);')
	g.sb.writeln('        see1=_wymix(_wyr8(p+16)^secret[2],_wyr8(p+24)^see1);')
	g.sb.writeln('        see2=_wymix(_wyr8(p+32)^secret[3],_wyr8(p+40)^see2);')
	g.sb.writeln('        p+=48; i-=48;')
	g.sb.writeln('      }while(_likely_(i>=48));')
	g.sb.writeln('      seed^=see1^see2;')
	g.sb.writeln('    }')
	g.sb.writeln('    while(_unlikely_(i>16)){ seed=_wymix(_wyr8(p)^secret[1],_wyr8(p+8)^seed); i-=16; p+=16; }')
	g.sb.writeln('    a=_wyr8(p+i-16); b=_wyr8(p+i-8);')
	g.sb.writeln('  }')
	g.sb.writeln('  a^=secret[1]; b^=seed; _wymum(&a,&b);')
	g.sb.writeln('  return _wymix(a^secret[0]^len,b^secret[1]);')
	g.sb.writeln('}')
	g.sb.writeln('static const uint64_t _wyp[4] = {0x2d358dccaa6c78a5ull, 0x8bb84b93962eacc9ull, 0x4b33a62ed433d4a3ull, 0x4d5a2da51de1aa47ull};')
	g.sb.writeln('static inline uint64_t wyhash64(uint64_t A, uint64_t B){ A^=0x2d358dccaa6c78a5ull; B^=0x8bb84b93962eacc9ull; _wymum(&A,&B); return _wymix(A^0x2d358dccaa6c78a5ull,B^0x8bb84b93962eacc9ull);}')
	g.sb.writeln('#endif')
	g.sb.writeln('')
}