// 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 cleanc

import v2.ast
import v2.types

// set_export_const_symbols controls whether emitted module const macros
// also get exported as linkable global symbols.
pub fn (mut g Gen) set_export_const_symbols(enable bool) {
	g.export_const_symbols = enable
}

// set_cache_bundle_name sets the cache bundle label used for emitting a
// deterministic cache-init function (e.g. __v2_cached_init_builtin).
pub fn (mut g Gen) set_cache_bundle_name(name string) {
	g.cache_bundle_name = name.trim_space()
}

fn (mut g Gen) gen_file_extern_globals(file ast.File) {
	g.set_file_module(file)
	for stmt in file.stmts {
		if !stmt_has_valid_data(stmt) {
			continue
		}
		if stmt is ast.GlobalDecl {
			g.gen_global_decl_extern(stmt)
		}
	}
}

fn (mut g Gen) gen_file_extern_consts(file ast.File) {
	g.set_file_module(file)
	for stmt in file.stmts {
		if !stmt_has_valid_data(stmt) {
			continue
		}
		if stmt is ast.ConstDecl {
			g.gen_const_decl_extern(stmt)
		}
	}
}

fn runtime_const_target_key(mod string, name string) string {
	return '${mod}::${name}'
}

fn generated_decl_name_for_module(mod string, field_name string) ?string {
	if field_name == '' || field_name.starts_with('C.') {
		return none
	}
	if mod != '' && mod != 'main' && mod != 'builtin' {
		return '${mod}__${field_name}'
	}
	return field_name
}

fn (g &Gen) generated_decl_name(field_name string) ?string {
	return generated_decl_name_for_module(g.cur_module, field_name)
}

fn (mut g Gen) const_storage_name(name string) string {
	if cname := g.const_c_names[name] {
		return cname
	}
	if name in g.declared_fn_names {
		cname := '__v_const_${name}'
		g.const_c_names[name] = cname
		return cname
	}
	return name
}

fn (g &Gen) renamed_const_name_for_ident(name string) ?string {
	if generated_name := generated_decl_name_for_module(g.cur_module, name) {
		if cname := g.const_c_names[generated_name] {
			return cname
		}
	}
	if cname := g.const_c_names[name] {
		return cname
	}
	return none
}

fn (g &Gen) is_scalar_zero_init_type(typ string) bool {
	if typ in primitive_types || typ.ends_with('*') || typ in ['byteptr', 'charptr', 'voidptr'] {
		return true
	}
	return g.is_enum_type(typ)
}

fn (g &Gen) global_initializer_needs_runtime(expr ast.Expr) bool {
	match expr {
		ast.EmptyExpr {
			return false
		}
		ast.InitExpr, ast.MapInitExpr, ast.IfExpr, ast.CallOrCastExpr {
			return true
		}
		ast.OrExpr, ast.StringInterLiteral, ast.UnsafeExpr, ast.LockExpr, ast.MatchExpr {
			return true
		}
		ast.ComptimeExpr {
			return g.global_initializer_needs_runtime(expr.expr)
		}
		ast.ArrayInitExpr {
			if expr.typ is ast.Type && expr.typ is ast.ArrayFixedType {
				return g.contains_call_expr(expr)
			}
			return true
		}
		ast.CastExpr {
			return g.global_initializer_needs_runtime(expr.expr)
		}
		ast.ParenExpr {
			return g.global_initializer_needs_runtime(expr.expr)
		}
		ast.PrefixExpr {
			return g.global_initializer_needs_runtime(expr.expr)
		}
		ast.PostfixExpr {
			return g.global_initializer_needs_runtime(expr.expr)
		}
		ast.ModifierExpr {
			return g.global_initializer_needs_runtime(expr.expr)
		}
		ast.IndexExpr {
			return g.global_initializer_needs_runtime(expr.lhs)
				|| g.global_initializer_needs_runtime(expr.expr)
		}
		ast.InfixExpr {
			return g.global_initializer_needs_runtime(expr.lhs)
				|| g.global_initializer_needs_runtime(expr.rhs)
		}
		else {
			return g.contains_call_expr(expr)
		}
	}
}

fn (g &Gen) const_initializer_needs_runtime(expr ast.Expr) bool {
	match expr {
		ast.OrExpr, ast.StringInterLiteral, ast.UnsafeExpr, ast.IfExpr {
			return true
		}
		ast.ComptimeExpr {
			return g.const_initializer_needs_runtime(expr.expr)
		}
		ast.CastExpr {
			return g.const_initializer_needs_runtime(expr.expr)
		}
		ast.ParenExpr {
			return g.const_initializer_needs_runtime(expr.expr)
		}
		ast.PrefixExpr {
			return g.const_initializer_needs_runtime(expr.expr)
		}
		ast.PostfixExpr {
			return g.const_initializer_needs_runtime(expr.expr)
		}
		ast.ModifierExpr {
			return g.const_initializer_needs_runtime(expr.expr)
		}
		ast.IndexExpr {
			return g.const_initializer_needs_runtime(expr.lhs)
				|| g.const_initializer_needs_runtime(expr.expr)
		}
		ast.InfixExpr {
			return g.const_initializer_needs_runtime(expr.lhs)
				|| g.const_initializer_needs_runtime(expr.rhs)
		}
		ast.ArrayInitExpr {
			for elem in expr.exprs {
				if g.const_initializer_needs_runtime(elem) {
					return true
				}
			}
			return (expr.init !is ast.EmptyExpr && g.const_initializer_needs_runtime(expr.init))
				|| (expr.len !is ast.EmptyExpr && g.const_initializer_needs_runtime(expr.len))
				|| (expr.cap !is ast.EmptyExpr && g.const_initializer_needs_runtime(expr.cap))
		}
		else {
			return g.contains_call_expr(expr)
		}
	}
}

fn (mut g Gen) collect_runtime_const_targets() {
	g.runtime_const_targets = map[string]bool{}
	mut module_consts := map[string]map[string]bool{}
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			fc := g.flat.file_cursor(i)
			module_name := flat_file_module_name(fc)
			mut const_names := if module_name in module_consts {
				module_consts[module_name].clone()
			} else {
				map[string]bool{}
			}
			stmts := fc.stmts()
			for j in 0 .. stmts.len() {
				stmt := stmts.at(j)
				if stmt.kind() != .stmt_const_decl {
					continue
				}
				const_decl := stmt.const_decl()
				for field in const_decl.fields {
					if field.name != '' && !field.name.starts_with('C.') {
						const_names[field.name] = true
					}
				}
			}
			module_consts[module_name] = const_names.clone()
		}
		for i in 0 .. g.flat.files.len {
			fc := g.flat.file_cursor(i)
			g.set_file_cursor_module(fc)
			const_names := if g.cur_module in module_consts {
				module_consts[g.cur_module].clone()
			} else {
				map[string]bool{}
			}
			if const_names.len == 0 {
				continue
			}
			stmts := fc.stmts()
			for j in 0 .. stmts.len() {
				stmt := stmts.at(j)
				if stmt.kind() != .stmt_fn_decl || !stmt.name().starts_with('__v_init_consts_') {
					continue
				}
				body := stmt.list_at(3)
				for k in 0 .. body.len() {
					body_stmt := body.at(k)
					if body_stmt.kind() != .stmt_assign {
						continue
					}
					if body_stmt.extra_int() != 1 {
						continue
					}
					lhs := body_stmt.edge(0)
					if lhs.kind() != .expr_ident {
						continue
					}
					if lhs.name() !in const_names {
						continue
					}
					g.runtime_const_targets[runtime_const_target_key(g.cur_module, lhs.name())] = true
				}
			}
		}
	} else {
		for file in g.files {
			mut const_names := if file.mod in module_consts {
				module_consts[file.mod].clone()
			} else {
				map[string]bool{}
			}
			for stmt in file.stmts {
				if stmt !is ast.ConstDecl {
					continue
				}
				const_decl := stmt as ast.ConstDecl
				for field in const_decl.fields {
					if field.name != '' && !field.name.starts_with('C.') {
						const_names[field.name] = true
					}
				}
			}
			module_consts[file.mod] = const_names.clone()
		}
		for file in g.files {
			g.set_file_module(file)
			const_names := if g.cur_module in module_consts {
				module_consts[g.cur_module].clone()
			} else {
				map[string]bool{}
			}
			if const_names.len == 0 {
				continue
			}
			for stmt in file.stmts {
				if stmt !is ast.FnDecl {
					continue
				}
				fn_decl := stmt as ast.FnDecl
				if !fn_decl.name.starts_with('__v_init_consts_') {
					continue
				}
				for body_stmt in fn_decl.stmts {
					if body_stmt !is ast.AssignStmt {
						continue
					}
					assign_stmt := body_stmt as ast.AssignStmt
					if assign_stmt.lhs.len != 1 {
						continue
					}
					lhs_expr := assign_stmt.lhs[0]
					if lhs_expr !is ast.Ident {
						continue
					}
					lhs_ident := lhs_expr as ast.Ident
					if lhs_ident.name !in const_names {
						continue
					}

					g.runtime_const_targets[runtime_const_target_key(g.cur_module, lhs_ident.name)] = true
				}
			}
		}
	}
}

fn (g &Gen) is_runtime_const_target(field_name string) bool {
	return runtime_const_target_key(g.cur_module, field_name) in g.runtime_const_targets
}

fn (mut g Gen) lookup_const_expr(mod string, name string) ?ast.Expr {
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			fc := g.flat.file_cursor(i)
			if flat_file_module_name(fc) != mod {
				continue
			}
			stmts := fc.stmts()
			for j in 0 .. stmts.len() {
				stmt := stmts.at(j)
				if stmt.kind() != .stmt_const_decl {
					continue
				}
				const_decl := stmt.const_decl()
				for field in const_decl.fields {
					if field.name == name {
						return field.value
					}
				}
			}
		}
		return none
	}
	for file in g.files {
		if file.mod != mod {
			continue
		}
		for stmt in file.stmts {
			if stmt !is ast.ConstDecl {
				continue
			}
			const_decl := stmt as ast.ConstDecl
			for field in const_decl.fields {
				if field.name == name {
					return field.value
				}
			}
		}
	}
	return none
}

fn (mut g Gen) lookup_generated_const_expr(generated_name string) ?ast.Expr {
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			fc := g.flat.file_cursor(i)
			module_name := flat_file_module_name(fc)
			stmts := fc.stmts()
			for j in 0 .. stmts.len() {
				stmt := stmts.at(j)
				if stmt.kind() != .stmt_const_decl {
					continue
				}
				const_decl := stmt.const_decl()
				for field in const_decl.fields {
					name := generated_decl_name_for_module(module_name, field.name) or { continue }
					if name == generated_name {
						return field.value
					}
				}
			}
		}
		return none
	}
	for file in g.files {
		for stmt in file.stmts {
			if stmt !is ast.ConstDecl {
				continue
			}
			const_decl := stmt as ast.ConstDecl
			for field in const_decl.fields {
				name := generated_decl_name_for_module(file.mod, field.name) or { continue }
				if name == generated_name {
					return field.value
				}
			}
		}
	}
	return none
}

fn (mut g Gen) enum_const_selector_type(expr ast.Expr) string {
	if expr !is ast.SelectorExpr {
		return ''
	}
	sel := expr as ast.SelectorExpr
	if raw_type := g.get_raw_type(sel) {
		match raw_type {
			types.Enum {
				enum_type := g.types_type_to_c(raw_type)
				if enum_type != '' {
					return enum_type
				}
			}
			types.Alias {
				if raw_type.base_type is types.Enum {
					enum_type := g.types_type_to_c(raw_type)
					if enum_type != '' {
						return enum_type
					}
				}
			}
			else {}
		}
	}
	lhs_type := g.get_expr_type(sel.lhs)
	if lhs_type != '' && g.is_enum_type(lhs_type) && g.enum_has_field(lhs_type, sel.rhs.name) {
		return lhs_type
	}
	return ''
}

fn (mut g Gen) const_decl_storage_type(expr ast.Expr) string {
	if expr is ast.Ident {
		if const_expr := g.lookup_const_expr(g.cur_module, expr.name) {
			return g.const_decl_storage_type(const_expr)
		}
		if g.cur_module != 'builtin' {
			if const_expr := g.lookup_const_expr('builtin', expr.name) {
				return g.const_decl_storage_type(const_expr)
			}
		}
		if const_expr := g.lookup_generated_const_expr(expr.name) {
			return g.const_decl_storage_type(const_expr)
		}
	}
	if expr is ast.SelectorExpr && expr.lhs is ast.Ident {
		if const_expr := g.lookup_const_expr(expr.lhs.name, expr.rhs.name) {
			return g.const_decl_storage_type(const_expr)
		}
	}
	if expr is ast.CallExpr && expr.lhs is ast.Ident {
		fn_name := (expr.lhs as ast.Ident).name
		if fn_name in ['builtin__new_array_from_c_array_noscan', 'builtin__new_array_from_c_array',
			'new_array_from_c_array'] {
			return 'array'
		}
	}
	enum_type := g.enum_const_selector_type(expr)
	if enum_type != '' {
		return enum_type
	}
	if expr is ast.InfixExpr {
		if expr.op in [.eq, .ne, .lt, .gt, .le, .ge, .and, .logical_or] {
			return 'bool'
		}
		if expr.op in [.plus, .minus, .mul, .div, .mod] {
			lhs_type := g.const_decl_storage_type(expr.lhs)
			rhs_type := g.const_decl_storage_type(expr.rhs)
			if expr.op == .plus && (lhs_type == 'string' || rhs_type == 'string') {
				return 'string'
			}
			return promote_numeric_c_types(lhs_type, rhs_type)
		}
	}
	if raw_type := g.get_raw_type(expr) {
		raw_c_type := g.types_type_to_c(raw_type)
		if raw_c_type != '' && raw_c_type != 'void' && !raw_c_type.contains('literal') {
			return raw_c_type
		}
	}
	mut typ := g.get_expr_type(expr)
	if typ == '' || typ == 'void' || typ == 'int_literal' || typ == 'float_literal' {
		if expr is ast.InfixExpr {
			numeric_type := g.infer_numeric_expr_type(expr)
			if numeric_type != '' && !numeric_type.contains('literal') {
				return numeric_type
			}
		}
		if expr is ast.BasicLiteral {
			if expr.kind == .number {
				if expr.value.contains('.') || expr.value.contains('e') || expr.value.contains('E') {
					return 'f64'
				}
				return 'int'
			}
		}
		if typ == 'float_literal' {
			return 'f64'
		}
		return 'int'
	}
	if expr is ast.InfixExpr && typ == 'string' {
		numeric_type := g.infer_numeric_expr_type(expr)
		if numeric_type != '' && !numeric_type.contains('literal') && numeric_type != 'string' {
			return numeric_type
		}
	}
	return typ
}

fn (mut g Gen) const_expr_c_value_for_header(expr ast.Expr) ?string {
	return g.const_expr_c_value_for_header_in_module(expr, g.cur_module, 0)
}

fn (mut g Gen) resolved_scalar_const_expr(expr ast.Expr, rendered string) string {
	if expr_contains_ident(expr) {
		if value := g.const_expr_c_value_for_header(expr) {
			return value
		}
		return g.resolve_const_expr(rendered)
	}
	return rendered
}

fn (mut g Gen) const_expr_c_value_for_header_in_module(expr ast.Expr, mod string, depth int) ?string {
	if depth > 20 {
		return none
	}
	match expr {
		ast.BasicLiteral {
			if expr.kind == .number {
				return sanitize_c_number_literal(expr.value)
			}
		}
		ast.Ident {
			if const_expr := g.lookup_const_expr(mod, expr.name) {
				return g.const_expr_c_value_for_header_in_module(const_expr, mod, depth + 1)
			}
			if mod != 'builtin' {
				if const_expr := g.lookup_const_expr('builtin', expr.name) {
					return g.const_expr_c_value_for_header_in_module(const_expr, 'builtin', depth +
						1)
				}
			}
		}
		ast.SelectorExpr {
			if expr.lhs is ast.Ident {
				lhs_ident := expr.lhs as ast.Ident
				mut module_names := [lhs_ident.name]
				resolved_mod_name := g.resolve_module_name(lhs_ident.name)
				if resolved_mod_name !in module_names {
					module_names << resolved_mod_name
				}
				for mod_name in module_names {
					if const_expr := g.lookup_const_expr(mod_name, expr.rhs.name) {
						return g.const_expr_c_value_for_header_in_module(const_expr, mod_name,

							depth + 1)
					}
				}
			}
		}
		ast.InfixExpr {
			lhs := g.const_expr_c_value_for_header_in_module(expr.lhs, mod, depth + 1) or {
				return none
			}
			rhs := g.const_expr_c_value_for_header_in_module(expr.rhs, mod, depth + 1) or {
				return none
			}
			op := match expr.op {
				.plus { '+' }
				.minus { '-' }
				.mul { '*' }
				.div { '/' }
				.mod { '%' }
				.amp { '&' }
				.pipe { '|' }
				.xor { '^' }
				.left_shift { '<<' }
				.right_shift { '>>' }
				else { return none }
			}

			return '(${lhs} ${op} ${rhs})'
		}
		ast.PrefixExpr {
			value := g.const_expr_c_value_for_header_in_module(expr.expr, mod, depth + 1) or {
				return none
			}
			op := match expr.op {
				.minus { '-' }
				.plus { '+' }
				.bit_not { '~' }
				else { return none }
			}

			return '${op}${value}'
		}
		ast.ParenExpr {
			value := g.const_expr_c_value_for_header_in_module(expr.expr, mod, depth + 1) or {
				return none
			}
			return '(${value})'
		}
		ast.CastExpr {
			value := g.const_expr_c_value_for_header_in_module(expr.expr, mod, depth + 1) or {
				return none
			}
			typ := g.expr_type_to_c(expr.typ)
			if typ == '' || typ == 'void' {
				return value
			}
			return '((${typ})(${value}))'
		}
		ast.CallOrCastExpr {
			value := g.const_expr_c_value_for_header_in_module(expr.expr, mod, depth + 1) or {
				return none
			}
			if !g.call_or_cast_lhs_is_type(expr.lhs) {
				return none
			}
			typ := g.expr_type_to_c(expr.lhs)
			if typ == '' || typ == 'void' {
				return value
			}
			return '((${typ})(${value}))'
		}
		ast.CallExpr {
			if !g.call_or_cast_lhs_is_type(expr.lhs) || expr.args.len != 1 {
				return none
			}
			value := g.const_expr_c_value_for_header_in_module(expr.args[0], mod, depth + 1) or {
				return none
			}
			typ := g.expr_type_to_c(expr.lhs)
			if typ == '' || typ == 'void' {
				return value
			}
			return '((${typ})(${value}))'
		}
		else {}
	}

	return none
}

fn (mut g Gen) emit_runtime_const_storage_decl(name string, typ string) {
	if typ == 'string' {
		g.sb.writeln('string ${name} = {0};')
		return
	}
	if g.is_scalar_zero_init_type(typ) {
		g.sb.writeln('${typ} ${name} = 0;')
		return
	}
	g.sb.writeln('${typ} ${name} = {0};')
}

fn (g &Gen) is_generated_non_type_ident(expr ast.Expr) bool {
	if expr !is ast.Ident {
		return false
	}
	value_ident := expr as ast.Ident
	return value_ident.name.contains('__') && !g.is_type_name(value_ident.name)
}

fn (mut g Gen) is_type_only_const_expr(expr ast.Expr) bool {
	if is_header_type_only_const_expr(expr) {
		return true
	}
	if expr is ast.Ident {
		if expr.name.contains('.') {
			return g.is_type_name(g.expr_type_to_c(expr))
		}
		return g.is_type_name(expr.name)
	}
	if expr is ast.SelectorExpr {
		return g.is_type_name(g.expr_type_to_c(expr))
	}
	return false
}

struct FileScopeGenContext {
	cur_fn_scope           &types.Scope = unsafe { nil }
	cur_fn_name            string
	cur_fn_c_name          string
	cur_fn_ret_type        string
	cur_fn_c_ret_type      string
	cur_fn_scope_miss_key  string
	runtime_local_types    map[string]string
	runtime_decl_types     map[string]string
	cur_fn_mut_params      map[string]bool
	cur_fn_returned_idents map[string]bool
	not_local_var_cache    map[string]bool
}

fn (mut g Gen) enter_file_scope_context() FileScopeGenContext {
	ctx := FileScopeGenContext{
		cur_fn_scope:           g.cur_fn_scope
		cur_fn_name:            g.cur_fn_name
		cur_fn_c_name:          g.cur_fn_c_name
		cur_fn_ret_type:        g.cur_fn_ret_type
		cur_fn_c_ret_type:      g.cur_fn_c_ret_type
		cur_fn_scope_miss_key:  g.cur_fn_scope_miss_key
		runtime_local_types:    g.runtime_local_types.clone()
		runtime_decl_types:     g.runtime_decl_types.clone()
		cur_fn_mut_params:      g.cur_fn_mut_params.clone()
		cur_fn_returned_idents: g.cur_fn_returned_idents.clone()
		not_local_var_cache:    g.not_local_var_cache.clone()
	}
	g.cur_fn_scope = unsafe { nil }
	g.cur_fn_name = ''
	g.cur_fn_c_name = ''
	g.cur_fn_ret_type = ''
	g.cur_fn_c_ret_type = ''
	g.cur_fn_scope_miss_key = ''
	g.runtime_local_types.clear()
	g.runtime_decl_types.clear()
	g.cur_fn_mut_params.clear()
	g.cur_fn_returned_idents.clear()
	g.not_local_var_cache.clear()
	return ctx
}

fn (mut g Gen) leave_file_scope_context(ctx FileScopeGenContext) {
	g.cur_fn_scope = ctx.cur_fn_scope
	g.cur_fn_name = ctx.cur_fn_name
	g.cur_fn_c_name = ctx.cur_fn_c_name
	g.cur_fn_ret_type = ctx.cur_fn_ret_type
	g.cur_fn_c_ret_type = ctx.cur_fn_c_ret_type
	g.cur_fn_scope_miss_key = ctx.cur_fn_scope_miss_key
	g.runtime_local_types = ctx.runtime_local_types.clone()
	g.runtime_decl_types = ctx.runtime_decl_types.clone()
	g.cur_fn_mut_params = ctx.cur_fn_mut_params.clone()
	g.cur_fn_returned_idents = ctx.cur_fn_returned_idents.clone()
	g.not_local_var_cache = ctx.not_local_var_cache.clone()
}

fn (mut g Gen) gen_const_decl_extern(node ast.ConstDecl) {
	file_scope_ctx := g.enter_file_scope_context()
	defer {
		g.leave_file_scope_context(file_scope_ctx)
	}
	for field in node.fields {
		name := g.generated_decl_name(field.name) or { continue }
		c_name := g.const_storage_name(name)
		// Skip constants already emitted as either extern or #define
		// (can happen when both .vh and full source files are parsed).
		extern_key := 'extern_const_${c_name}'
		macro_key := 'extern_const_macro_${c_name}'
		if extern_key in g.emitted_types || macro_key in g.emitted_types {
			continue
		}
		mut is_type_only := g.is_type_only_const_expr(field.value)
		if is_type_only && g.is_generated_non_type_ident(field.value) {
			is_type_only = false
		}
		if g.is_runtime_const_target(field.name) {
			typ := g.const_decl_storage_type(field.value)
			if typ == '' || typ == 'void' {
				continue
			}
			g.emitted_types[extern_key] = true
			g.sb.writeln('extern ${typ} ${c_name};')
			continue
		}
		if is_type_only {
			key := extern_key
			typ := g.expr_type_to_c(field.value)
			if typ == '' || typ == 'void' {
				continue
			}
			if typ.starts_with('Array_fixed_') || typ.contains(' ') || typ.contains('literal')
				|| typ == 'mach_timebase_info_data_t' {
				continue
			}
			g.emitted_types[key] = true
			g.sb.writeln('extern ${typ} ${c_name};')
			continue
		}
		value_expr := g.expr_to_string(field.value)
		if value_expr.len == 0 {
			continue
		}
		// Array consts with static backing data or inline compound literals
		// cannot be #defined across translation units. Emit extern declarations instead.
		if value_expr.contains('__const_array_data_')
			|| value_expr.contains('new_array_from_c_array') {
			g.emitted_types[macro_key] = true
			g.sb.writeln('extern array ${c_name};')
			continue
		}
		mut macro_expr := value_expr
		if macro_expr.contains('\n') {
			// Keep macro definitions valid when value expressions are rendered
			// across multiple lines (e.g. large string literals).
			macro_expr = macro_expr.replace('\n', ' \\\n')
		}
		g.emitted_types[macro_key] = true
		// Unqualified numeric consts use #define with fully-resolved literal
		// values and also store into const_exprs so that downstream consts
		// that reference them can be resolved too. This avoids macro
		// collisions with local variables of the same name (e.g. max_len
		// from sorted_map.v vs max_len parameter in eprint_space_padding).
		if !name.contains('__') && is_numeric_const_expr(field.value) {
			typ := g.const_decl_storage_type(field.value)
			if typ != '' && typ != 'void' {
				resolved := g.resolved_scalar_const_expr(field.value, macro_expr)
				g.const_exprs[name] = resolved
				g.sb.writeln('static const ${typ} ${c_name} = ${resolved};')
				continue
			}
		}
		if !name.contains('__') {
			typ := g.const_decl_storage_type(field.value)
			if g.is_scalar_zero_init_type(typ) || typ == 'string' {
				resolved := g.resolved_scalar_const_expr(field.value, macro_expr)
				g.sb.writeln('static const ${typ} ${c_name} = ${resolved};')
				continue
			}
		}
		// C struct zero-init consts are emitted as global variables in
		// gen_const_decl, so the extern declaration must match.
		if is_c_struct_init(field.value) {
			typ := g.const_decl_storage_type(field.value)
			if typ != '' && typ != 'void' && typ != 'int' {
				g.sb.writeln('extern ${typ} ${c_name};')
				continue
			}
		}
		g.sb.writeln('#define ${c_name} ${macro_expr}')
	}
}

fn module_storage_c_name(module_name string, name string) string {
	if name == '' || name.starts_with('C.') {
		return name
	}
	if module_name != '' && module_name != 'main' && module_name != 'builtin' {
		return '${module_name}__${name}'
	}
	return name
}

fn module_storage_field_is_c_extern(node ast.GlobalDecl, field ast.FieldDecl) bool {
	return field.name.starts_with('C.') || node.attributes.has('c_extern')
		|| field.attributes.has('c_extern')
}

fn module_storage_field_c_name(module_name string, node ast.GlobalDecl, field ast.FieldDecl) string {
	if module_storage_field_is_c_extern(node, field) {
		return if field.name.starts_with('C.') { field.name.all_after('C.') } else { field.name }
	}
	return module_storage_c_name(module_name, field.name)
}

fn (mut g Gen) gen_global_decl(node ast.GlobalDecl) {
	for field in node.fields {
		// Skip C globals that are already provided by C headers or cheaders.
		if module_storage_field_is_c_extern(node, field) {
			continue
		}
		name := module_storage_field_c_name(g.cur_module, node, field)
		key := 'global_${name}'
		if key in g.emitted_types {
			continue
		}
		g.emitted_types[key] = true
		g.write_indent()
		if field.typ is ast.Type && field.typ is ast.ArrayFixedType {
			fixed_typ := field.typ as ast.ArrayFixedType
			elem_type := g.expr_type_to_c(fixed_typ.elem_type)
			g.fixed_array_globals[name] = true
			g.sb.write_string('${elem_type} ${name}[')
			if len_expr := g.const_expr_c_value_for_header(fixed_typ.len) {
				g.sb.write_string(len_expr)
			} else {
				g.expr(fixed_typ.len)
			}
			g.sb.write_string(']')
			if field.value !is ast.EmptyExpr {
				g.sb.write_string(' = ')
				g.expr(field.value)
			}
			g.sb.writeln(';')
			continue
		}
		mut typ := ''
		if field.typ !is ast.EmptyExpr {
			typ = g.expr_type_to_c(field.typ)
		} else if field.value !is ast.EmptyExpr {
			typ = g.get_expr_type(field.value)
		}
		if typ == '' || typ == 'void' {
			typ = 'int'
		}
		if typ.starts_with('Array_fixed_') {
			g.fixed_array_globals[name] = true
			g.global_var_types[name] = typ
			g.sb.write_string('${typ} ${name}')
			if field.value !is ast.EmptyExpr {
				g.sb.write_string(' = ')
				if field.value is ast.ArrayInitExpr {
					array_init := field.value as ast.ArrayInitExpr
					if array_init.exprs.len == 0 && array_init.init is ast.EmptyExpr {
						g.sb.write_string('{0}')
					} else {
						g.expr(field.value)
					}
				} else {
					g.expr(field.value)
				}
			}
			g.sb.writeln(';')
			continue
		}
		g.global_var_types[name] = typ
		// With prealloc, g_memory_block must be thread-local so each thread
		// gets its own arena and the bump allocator is safe without locks.
		if name == 'g_memory_block' && g.pref != unsafe { nil } && g.pref.prealloc {
			g.sb.write_string('_Thread_local ${typ} ${name}')
		} else {
			g.sb.write_string('${typ} ${name}')
		}
		if field.value !is ast.EmptyExpr {
			// Function calls are not compile-time constants in C
			if g.global_initializer_needs_runtime(field.value) {
				g.sb.writeln(';')
			} else {
				g.sb.write_string(' = ')
				g.expr(field.value)
				g.sb.writeln(';')
			}
		} else {
			g.sb.writeln(';')
		}
	}
}

fn (mut g Gen) gen_global_decl_extern(node ast.GlobalDecl) {
	for field in node.fields {
		// C.foo selectors are provided by C headers/macros; raw @[c_extern]
		// globals below need an extern declaration, but C.foo does not.
		if field.name.starts_with('C.') {
			continue
		}
		name := module_storage_field_c_name(g.cur_module, node, field)
		key := 'extern_global_${name}'
		if key in g.emitted_types {
			continue
		}
		g.emitted_types[key] = true
		g.write_indent()
		if field.typ is ast.Type && field.typ is ast.ArrayFixedType {
			fixed_typ := field.typ as ast.ArrayFixedType
			elem_type := g.expr_type_to_c(fixed_typ.elem_type)
			g.sb.write_string('extern ${elem_type} ${name}[')
			// Extern declarations are emitted before module const definitions.
			// Resolve const-backed fixed-array lengths now, so C does not see an
			// undeclared bound like `extern int a[my_const];`.
			if len_expr := g.const_expr_c_value_for_header(fixed_typ.len) {
				g.sb.write_string(len_expr)
			} else {
				g.expr(fixed_typ.len)
			}
			g.sb.writeln('];')
			continue
		}
		mut typ := ''
		if field.typ !is ast.EmptyExpr {
			typ = g.expr_type_to_c(field.typ)
		} else if field.value !is ast.EmptyExpr {
			typ = g.get_expr_type(field.value)
		}
		if typ == 'mach_timebase_info_data_t' {
			continue
		}
		if typ == '' || typ == 'void' {
			typ = 'int'
		}
		g.global_var_types[name] = typ
		if name == 'g_memory_block' && g.pref != unsafe { nil } && g.pref.prealloc {
			g.sb.writeln('extern _Thread_local ${typ} ${name};')
		} else {
			g.sb.writeln('extern ${typ} ${name};')
		}
	}
}

fn (mut g Gen) queue_exported_const_symbol(name string, typ string, value string) {
	if name in g.exported_const_seen {
		return
	}
	g.exported_const_seen[name] = true
	g.exported_const_symbols << ExportedConstSymbol{
		name:  name
		typ:   typ
		value: value
	}
}

fn (mut g Gen) emit_exported_const_symbols() {
	if !g.export_const_symbols || g.exported_const_symbols.len == 0 {
		return
	}
	g.sb.writeln('')
	for sym in g.exported_const_symbols {
		g.sb.writeln('#ifdef ${sym.name}')
		g.sb.writeln('#undef ${sym.name}')
		g.sb.writeln('#endif')
		// Resolve references to other constants so the initializer is a
		// compile-time constant expression (required by TCC and strict C).
		resolved := g.resolve_const_expr(sym.value)
		g.sb.writeln('const ${sym.typ} ${sym.name} = ${resolved};')
	}
}

fn (g &Gen) cached_init_function_name() string {
	if g.cache_bundle_name.len == 0 {
		return ''
	}
	return '__v2_cached_init_${g.cache_bundle_name}'
}

fn module_const_init_fn_name(module_name string) string {
	return if module_name == 'builtin' || module_name == 'main' {
		'__v_init_consts_${module_name}'
	} else {
		'${module_name}____v_init_consts_${module_name}'
	}
}

fn (mut g Gen) emit_cached_module_init_function() {
	if !g.export_const_symbols || g.emit_modules.len == 0 || g.cache_bundle_name.len == 0 {
		return
	}
	mut modules := g.emit_modules.keys()
	modules.sort()
	mut init_modules := []string{}
	for module_name in modules {
		if g.module_has_const_init_fn(module_name) {
			init_modules << module_name
		}
	}
	g.sb.writeln('')
	init_fn_name := g.cached_init_function_name()
	g.sb.writeln('void ${init_fn_name}(void) {')
	for module_name in init_modules {
		init_fn := module_const_init_fn_name(module_name)
		g.sb.writeln('\t${init_fn}();')
	}
	g.sb.writeln('}')
}

fn (g &Gen) module_has_const_init_fn(module_name string) bool {
	init_fn := module_const_init_fn_name(module_name)
	return init_fn in g.fn_return_types
}

fn (mut g Gen) gen_const_decl(node ast.ConstDecl) {
	file_scope_ctx := g.enter_file_scope_context()
	defer {
		g.leave_file_scope_context(file_scope_ctx)
	}
	for field in node.fields {
		name := g.generated_decl_name(field.name) or { continue }
		c_name := g.const_storage_name(name)
		const_key := 'const_${c_name}'
		if const_key in g.emitted_types {
			continue
		}
		g.emitted_types[const_key] = true
		mut is_type_only := g.is_type_only_const_expr(field.value)
		if is_type_only && g.is_generated_non_type_ident(field.value) {
			is_type_only = false
		}
		if !g.should_emit_module(g.cur_module) && is_type_only {
			continue
		}
		// Type-only consts from .vh headers have no value — emit as zero-initialized globals
		// for simple scalar types only. Complex types (fixed arrays, structs) are skipped
		// because they need typedefs/initializer-lists that aren't available from .vh data.
		if is_type_only {
			typ := g.expr_type_to_c(field.value)
			if typ == '' || typ == 'void' || typ.starts_with('Array_fixed_') || typ.contains(' ')
				|| typ.contains('literal') {
				continue
			}
			if typ == 'string' {
				g.sb.writeln('string ${c_name} = {0};')
			} else {
				g.sb.writeln('${typ} ${c_name} = 0;')
			}
			continue
		}
		if g.is_runtime_const_target(field.name) {
			typ := g.const_decl_storage_type(field.value)
			if typ == '' || typ == 'void' {
				continue
			}
			g.emit_runtime_const_storage_decl(c_name, typ)
			continue
		}
		mut is_fixed_array_const := false
		mut fixed_array_elem := ''
		mut fixed_array_len := 0
		if raw_type := g.get_raw_type(field.value) {
			if raw_type is types.ArrayFixed {
				is_fixed_array_const = true
				fixed_array_elem = g.types_type_to_c(raw_type.elem_type)
				fixed_array_len = raw_type.len
			}
		}
		if !is_fixed_array_const && field.value is ast.ArrayInitExpr {
			array_value := field.value as ast.ArrayInitExpr
			mut elem_type := g.extract_array_elem_type(array_value.typ)
			if elem_type == '' && array_value.exprs.len > 0 {
				elem_type = g.get_expr_type(array_value.exprs[0])
			}
			if elem_type != '' && elem_type != 'array' {
				// Check that no element contains a function call (not valid in C static initializers)
				mut has_call := false
				for i in 0 .. array_value.exprs.len {
					elem := array_value.exprs[i]
					if g.contains_call_expr(elem) {
						has_call = true
						break
					}
				}
				if !has_call {
					is_fixed_array_const = true
					fixed_array_elem = elem_type
					fixed_array_len = array_value.exprs.len
				}
			}
		}
		if is_fixed_array_const && fixed_array_elem != '' {
			g.fixed_array_globals[name] = true
			g.fixed_array_globals[c_name] = true
			if fixed_array_len > 0 {
				g.sb.write_string('static const ${fixed_array_elem} ${c_name}[${fixed_array_len}] = ')
			} else {
				g.sb.write_string('static const ${fixed_array_elem} ${c_name}[] = ')
			}
			if field.value is ast.ArrayInitExpr {
				g.gen_fixed_array_initializer(field.value as ast.ArrayInitExpr)
			} else {
				g.expr(field.value)
			}
			g.sb.writeln(';')
			continue
		}
		if g.try_emit_const_dynamic_array_call(c_name, field.value) {
			continue
		}
		typ := g.const_decl_storage_type(field.value)
		// Function calls and statement-expression lowerings are not compile-time
		// constants in C; emit as zero-initialized globals.
		if g.const_initializer_needs_runtime(field.value) {
			g.emit_runtime_const_storage_decl(c_name, typ)
			continue
		}
		if typ == 'string' {
			// String constants need a global variable
			g.sb.write_string('string ${c_name} = ')
			g.expr(field.value)
			g.sb.writeln(';')
		} else if
			typ in ['bool', 'char', 'rune', 'int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'usize', 'isize', 'f32', 'f64']
			|| g.is_enum_type(typ) {
			value_expr := g.expr_to_string(field.value)
			resolved_value_expr := g.resolved_scalar_const_expr(field.value, value_expr)
			g.const_exprs[name] = resolved_value_expr
			// Qualified const names are safe as macros and work in C constant-expression
			// contexts (array sizes, static initializers).
			if name.contains('__') {
				g.sb.writeln('#define ${c_name} ${resolved_value_expr}')
				if g.export_const_symbols {
					g.queue_exported_const_symbol(c_name, typ, resolved_value_expr)
				}
			} else {
				// Unqualified names use static const to avoid macro collisions.
				// If the expression references other constants, inline their values
				// so that tcc (and strict C) accepts the initializer.
				g.sb.writeln('static const ${typ} ${c_name} = ${resolved_value_expr};')
			}
		} else {
			// C struct zero-init consts must be real global variables, not
			// #define macros, because macros expand to temporaries — taking
			// their address (&) or mutating them in-place has no effect.
			if typ != '' && typ != 'void' && typ != 'int' && is_c_struct_init(field.value) {
				g.sb.writeln('${typ} ${c_name} = {0};')
			} else if typ != '' && typ != 'void' && typ != 'int' && !typ.starts_with('Array_')
				&& !typ.starts_with('Map_') && !typ.contains('*') && !typ.contains('(')
				&& field.value is ast.InitExpr && (field.value as ast.InitExpr).fields.len == 0 {
				// Zero-initialized struct const — emit as global variable.
				g.sb.writeln('${typ} ${c_name} = {0};')
			} else {
				// Fallback for aggregate literals and other complex consts.
				g.sb.write_string('#define ${c_name} ')
				g.expr(field.value)
				g.sb.writeln('')
			}
			if typ != '' && typ != 'int' {
				g.const_types[name] = typ
				g.const_types[c_name] = typ
			}
		}
	}
}

// is_c_struct_init returns true if the expression is a C struct zero-initialization
// like `C.mbedtls_ctr_drbg_context{}`. These must be emitted as global variables,
// not #define macros, because they need a stable memory address.
fn is_c_struct_init(e ast.Expr) bool {
	if e is ast.InitExpr {
		init := e as ast.InitExpr
		if init.typ is ast.Ident {
			ident := init.typ as ast.Ident
			return ident.name.starts_with('C.')
		}
	}
	return false
}

fn is_numeric_const_expr(e ast.Expr) bool {
	if e is ast.BasicLiteral {
		return true
	}
	if e is ast.InfixExpr {
		return is_numeric_const_expr(e.lhs) && is_numeric_const_expr(e.rhs)
	}
	if e is ast.CastExpr {
		return is_numeric_const_expr(e.expr)
	}
	if e is ast.ParenExpr {
		return is_numeric_const_expr(e.expr)
	}
	if e is ast.PrefixExpr {
		return is_numeric_const_expr(e.expr)
	}
	if e is ast.Ident {
		return true // references to other consts are still numeric
	}
	if e is ast.CallExpr {
		if e.lhs is ast.Ident && e.lhs.name in primitive_types && e.args.len == 1 {
			return is_numeric_const_expr(e.args[0])
		}
		// sizeof() is a compile-time numeric expression
		if e.lhs is ast.Ident {
			return e.lhs.name == 'sizeof'
		}
	}
	return false
}

fn expr_contains_ident(e ast.Expr) bool {
	if e is ast.Ident {
		return true
	}
	if e is ast.InfixExpr {
		return expr_contains_ident(e.lhs) || expr_contains_ident(e.rhs)
	}
	if e is ast.CastExpr {
		return expr_contains_ident(e.expr)
	}
	if e is ast.CallOrCastExpr {
		return expr_contains_ident(e.expr)
	}
	if e is ast.CallExpr {
		if expr_contains_ident(e.lhs) {
			return true
		}
		for arg in e.args {
			if expr_contains_ident(arg) {
				return true
			}
		}
	}
	if e is ast.SelectorExpr {
		return true
	}
	if e is ast.ParenExpr {
		return expr_contains_ident(e.expr)
	}
	if e is ast.PrefixExpr {
		return expr_contains_ident(e.expr)
	}
	return false
}

// resolve_const_expr replaces references to other constants in a C expression
// string with their expanded values, so that static const initializers
// contain only literal values (required by tcc and the C standard).
fn (g &Gen) resolve_const_expr(expr string) string {
	mut result := expr
	for _ in 0 .. 10 {
		mut changed := false
		for cname, cval in g.const_exprs {
			new_result := replace_whole_word(result, cname, cval)
			if new_result != result {
				result = new_result
				changed = true
			}
		}
		if !changed {
			break
		}
	}
	return result
}

fn replace_whole_word(s string, word string, replacement string) string {
	mut result := s
	mut pos := 0
	for {
		idx := result.index_after(word, pos) or { break }
		// Check word boundary before.
		if idx > 0 {
			c := result[idx - 1]
			if c == `_` || (c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`)
				|| (c >= `0` && c <= `9`) {
				pos = idx + word.len
				continue
			}
		}
		// Check word boundary after.
		end := idx + word.len
		if end < result.len {
			c := result[end]
			if c == `_` || (c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`)
				|| (c >= `0` && c <= `9`) {
				pos = idx + word.len
				continue
			}
		}
		result = result[..idx] + replacement + result[end..]
		pos = idx + replacement.len
	}
	return result
}