module c

import v3.flat
import v3.types

// gen_string_interp emits string interp output for c.
fn (mut g FlatGen) gen_string_interp(node flat.Node) {
	n := node.children_count
	if n == 0 {
		sid := g.intern_string('')
		g.write('_str_${sid}')
		return
	}
	g.write('string_plus_many(${n}, (string[${n}]){')
	for i in 0 .. n {
		if i > 0 {
			g.write(', ')
		}
		child_id := g.a.child(&node, i)
		child := g.a.nodes[int(child_id)]
		if child.kind == .string_literal {
			sid := g.intern_string(child.value)
			g.write('_str_${sid}')
		} else if child.typ == 'string' {
			g.gen_expr(child_id)
		} else {
			mut typ := g.tc.resolve_type(child_id)
			// For a bare ident, prefer the live cgen scope binding when present: it reflects
			// locals introduced during generation (e.g. the `err` of an or-body lowered here,
			// or for-loop vars) that resolve_type may stale-cache as `int`.
			if child.kind == .ident {
				if scope_typ := g.tc.cur_scope.lookup(child.value) {
					if scope_typ !is types.Void {
						typ = scope_typ
					}
				}
			}
			typ_name := types.Type(typ).name()
			if typ is types.String {
				g.gen_expr(child_id)
			} else if g.gen_map_str_expr(child_id, typ) {
				// emitted by gen_map_str_expr
			} else if typ_name == 'IError' || typ_name.ends_with('.IError') {
				// IError may resolve as Interface/Alias/Struct depending on context; match by
				// name and interpolate its `.message` (mirrors the transformer's IError path).
				g.gen_expr(child_id)
				g.write('.message')
			} else if typ is types.Primitive {
				prim_name := types.Type(typ).name()
				g.write('${c_name('${prim_name}.str')}(')
				g.gen_expr(child_id)
				g.write(')')
			} else if typ is types.ISize || typ is types.USize {
				g.write('${c_name('${typ.name()}.str')}(')
				g.gen_expr(child_id)
				g.write(')')
			} else if typ is types.Struct {
				g.write('${c_name(typ.name)}__str(')
				g.gen_expr(child_id)
				g.write(')')
			} else if typ is types.SumType {
				g.write('${c_name(typ.name)}__str(')
				g.gen_expr(child_id)
				g.write(')')
			} else {
				g.write('int__str(')
				g.gen_expr(child_id)
				g.write(')')
			}
		}
	}
	g.write('})')
}

// is_string_node reports whether is string node applies in c.
fn (g &FlatGen) is_string_node(id flat.NodeId) bool {
	return g.tc.resolve_type(id) is types.String
}

// string_literals supports string literals handling for FlatGen.
fn (mut g FlatGen) string_literals() {
	for i, s in g.str_lits {
		escaped := s.replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n').replace('\t',
			'\\t').replace('\r', '\\r')
		g.writeln('string _str_${i} = {"${escaped}", ${s.len}, 1};')
	}
	if g.str_lits.len > 0 {
		g.writeln('')
	}
}

// intern_string supports intern string handling for FlatGen.
fn (mut g FlatGen) intern_string(s string) int {
	if s in g.str_lit_ids {
		return g.str_lit_ids[s]
	}
	id := g.str_lits.len
	g.str_lits << s
	g.str_lit_ids[s] = id
	return id
}