module c

import v3.flat
import v3.types

// gen_for emits for output for c.
fn (mut g FlatGen) gen_for(node flat.Node) {
	g.tc.push_scope()
	defer_start := g.defers.len
	init_node := g.a.child_node(&node, 0)
	cond_id := g.a.child(&node, 1)
	cond_node := g.a.nodes[int(cond_id)]
	post_node := g.a.child_node(&node, 2)

	if init_node.kind == .empty && cond_node.kind == .empty && post_node.kind == .empty {
		g.writeln('for (;;) {')
	} else if init_node.kind == .empty && post_node.kind == .empty {
		g.write('while (')
		g.gen_expr(cond_id)
		g.writeln(') {')
	} else {
		g.write('for (')
		if init_node.kind != .empty {
			g.gen_node_inline(g.a.child(&node, 0))
		}
		g.write('; ')
		if cond_node.kind != .empty {
			g.gen_expr(cond_id)
		}
		g.write('; ')
		if post_node.kind != .empty {
			g.gen_node_inline(g.a.child(&node, 2))
		}
		g.writeln(') {')
	}
	g.indent++
	for i in 3 .. node.children_count {
		g.gen_node(g.a.child(&node, i))
	}
	g.gen_defers_from(defer_start)
	g.trim_defers(defer_start)
	g.indent--
	g.writeln('}')
	g.tc.pop_scope()
}

// gen_for_in emits for in output for c.
fn (mut g FlatGen) gen_for_in(node flat.Node) {
	g.tc.push_scope()
	header_count := node.value.int()
	val_id := g.a.child(&node, 1)
	var_node := if int(val_id) >= 0 {
		g.a.child_node(&node, 1)
	} else {
		g.a.child_node(&node, 0)
	}
	var_name := g.c_loop_local_name(var_node.value)
	g.tc.cur_scope.insert(var_node.value, types.Type(types.int_))
	body_start := header_count

	if header_count == 4 {
		panic('internal error: range for-in reached C backend after transform')
	} else if header_count == 3 {
		container := g.a.child_node(&node, 2)
		if container.kind == .range {
			panic('internal error: range for-in reached C backend after transform')
		} else {
			container_type := g.usable_expr_type(g.a.child(&node, 2))
			has_index := int(val_id) >= 0
			idx_var := if has_index {
				g.c_loop_local_name(g.a.child_node(&node, 0).value)
			} else {
				'__iter_${var_name}'
			}
			elem_var := if has_index {
				g.c_loop_local_name(g.a.child_node(&node, 1).value)
			} else {
				var_name
			}
			clean_container_type := types.unwrap_pointer(container_type)
			mut map_snapshot_var := ''
			if clean_container_type is types.Map {
				c_key := g.value_c_type(clean_container_type.key_type)
				c_val := g.value_c_type(clean_container_type.value_type)
				container_str := g.expr_to_string(g.a.child(&node, 2))
				iter_var := '__mi_${g.tmp_count}'
				g.tmp_count++
				key_var := if has_index { idx_var } else { '__mk_${g.tmp_count}' }
				val_var_ := if has_index { elem_var } else { var_name }
				use_snapshot := g.for_in_body_contains_delete_call(node, body_start)
				key_values := if use_snapshot {
					map_snapshot_var = '__for_map_${g.tmp_count}'
					g.tmp_count++
					if container_type is types.Pointer {
						g.writeln('map ${map_snapshot_var} = map__clone(${container_str});')
					} else {
						map_src := '__for_map_src_${g.tmp_count}'
						g.tmp_count++
						g.writeln('map ${map_src} = ${container_str};')
						g.writeln('map ${map_snapshot_var} = map__clone(&${map_src});')
					}
					'${map_snapshot_var}.key_values'
				} else {
					access := if container_type is types.Pointer { '->' } else { '.' }
					'(${container_str})${access}key_values'
				}
				g.writeln('for (int ${iter_var} = 0; ${iter_var} < ${key_values}.len; ${iter_var}++) {')
				g.indent++
				g.writeln('if (${key_values}.all_deleted && ${key_values}.all_deleted[${iter_var}]) continue;')
				key_slot := '${key_values}.keys + ${iter_var} * ${key_values}.key_bytes'
				if key_fixed := array_fixed_type(clean_container_type.key_type) {
					c_elem, dims := g.fixed_array_decl_parts(key_fixed)
					g.writeln('${c_elem} ${key_var}${dims};')
					g.writeln('memmove(${key_var}, ${key_slot}, sizeof(${key_var}));')
				} else {
					g.writeln('${c_key} ${key_var} = *(${c_key}*)(${key_slot});')
				}
				val_slot := '${key_values}.values + ${iter_var} * ${key_values}.value_bytes'
				if val_fixed := array_fixed_type(clean_container_type.value_type) {
					c_elem, dims := g.fixed_array_decl_parts(val_fixed)
					g.writeln('${c_elem} ${val_var_}${dims};')
					g.writeln('memmove(${val_var_}, ${val_slot}, sizeof(${val_var_}));')
				} else {
					g.writeln('${c_val} ${val_var_} = *(${c_val}*)(${val_slot});')
				}
				if has_index {
					g.tc.cur_scope.insert(key_var, clean_container_type.key_type)
				}
				g.tc.cur_scope.insert(val_var_, clean_container_type.value_type)
			} else if container_type is types.Array {
				c_elem := g.value_c_type(container_type.elem_type)
				mut container_str := g.expr_to_string(g.a.child(&node, 2))
				// A call-valued container (e.g. `threads.wait()`, `xs.map(..)`) is not
				// idempotent and is referenced multiple times below; bind it to a temp so
				// it runs exactly once.
				if g.a.nodes[int(g.a.child(&node, 2))].kind == .call {
					arr_tmp := '__for_arr_${g.tmp_count}'
					g.tmp_count++
					g.writeln('Array ${arr_tmp} = ${container_str};')
					container_str = arr_tmp
				}
				g.writeln('for (int ${idx_var} = 0; ${idx_var} < ${container_str}.len; ${idx_var}++) {')
				g.indent++
				g.write('${c_elem} ${elem_var} = *(')
				g.write(c_elem)
				g.writeln('*)array_get(${container_str}, ${idx_var});')
				g.tc.cur_scope.insert(elem_var, container_type.elem_type)
			} else if container_type is types.String {
				container_str := g.expr_to_string(g.a.child(&node, 2))
				g.writeln('for (int ${idx_var} = 0; ${idx_var} < ${container_str}.len; ${idx_var}++) {')
				g.indent++
				g.writeln('u8 ${elem_var} = ((u8*)${container_str}.str)[${idx_var}];')
				g.tc.cur_scope.insert(elem_var, types.Type(types.u8_))
			} else if container_type is types.ArrayFixed {
				af := container_type
				c_elem := g.value_c_type(af.elem_type)
				arr_len := g.fixed_array_len_value(af)
				g.writeln('for (int ${idx_var} = 0; ${idx_var} < ${arr_len}; ${idx_var}++) {')
				g.indent++
				g.write('${c_elem} ${elem_var} = ')
				g.gen_expr(g.a.child(&node, 2))
				g.writeln('[${idx_var}];')
				g.tc.cur_scope.insert(elem_var, af.elem_type)
			} else {
				g.writeln('for (int ${idx_var} = 0; ${idx_var} < 0; ${idx_var}++) {')
				g.indent++
				g.writeln('int ${elem_var} = 0;')
				g.tc.cur_scope.insert(elem_var, types.Type(types.int_))
			}
			if has_index && container_type !is types.Map {
				g.tc.cur_scope.insert(idx_var, types.Type(types.int_))
			}
			for i in body_start .. node.children_count {
				g.gen_node(g.a.child(&node, i))
			}
			g.indent--
			g.writeln('}')
			if map_snapshot_var.len > 0 {
				g.writeln('map__free(&${map_snapshot_var});')
			}
			g.tc.pop_scope()
			return
		}
	} else {
		g.tc.pop_scope()
		return
	}
	g.indent++
	for i in body_start .. node.children_count {
		g.gen_node(g.a.child(&node, i))
	}
	g.indent--
	g.writeln('}')
	g.tc.pop_scope()
}

fn (g &FlatGen) for_in_body_contains_delete_call(node flat.Node, body_start int) bool {
	for i in body_start .. node.children_count {
		if g.node_contains_delete_call(g.a.child(&node, i)) {
			return true
		}
	}
	return false
}

fn (g &FlatGen) node_contains_delete_call(id flat.NodeId) bool {
	if int(id) < 0 || int(id) >= g.a.nodes.len {
		return false
	}
	node := g.a.nodes[int(id)]
	if node.kind == .call && node.children_count > 0 {
		fn_node := g.a.child_node(&node, 0)
		if fn_node.kind == .selector && fn_node.value == 'delete' {
			return true
		}
		if fn_node.kind == .ident && fn_node.value in ['map.delete', 'map__delete'] {
			return true
		}
	}
	for i in 0 .. node.children_count {
		if g.node_contains_delete_call(g.a.child(&node, i)) {
			return true
		}
	}
	return false
}

fn (g &FlatGen) c_loop_local_name(name string) string {
	if name.contains('.') {
		return c_name(name.all_after_last('.'))
	}
	if name.contains('__') {
		prefix := name.all_before_last('__')
		suffix := name.all_after_last('__')
		if suffix == 'index' {
			return c_name(suffix)
		}
		if g.has_import_alias(prefix) {
			return c_name(suffix)
		}
		for _, mod_name in g.modules {
			short_mod := if mod_name.contains('.') { mod_name.all_after_last('.') } else { mod_name }
			if prefix == short_mod {
				return c_name(suffix)
			}
		}
	}
	return c_name(name)
}

// gen_node_inline emits node inline output for c.
fn (mut g FlatGen) gen_node_inline(id flat.NodeId) {
	node := g.a.nodes[int(id)]
	match node.kind {
		.expr_stmt {
			g.gen_expr(g.a.child(&node, 0))
		}
		.decl_assign {
			lhs_id := g.a.child(&node, 0)
			rhs_id := g.a.child(&node, 1)
			lhs := g.a.nodes[int(lhs_id)]
			v_type := g.tc.resolve_type(rhs_id)
			typ := g.tc.c_type(v_type)
			g.write('${typ} ')
			if lhs.kind == .ident {
				g.write(g.c_loop_local_name(lhs.value))
			} else {
				g.gen_expr(lhs_id)
			}
			g.write(' = ')
			g.gen_expr(rhs_id)
			if lhs.kind == .ident {
				g.tc.cur_scope.insert(lhs.value, v_type)
			}
		}
		.assign {
			g.gen_expr(g.a.child(&node, 0))
			g.write(' ${g.op_str(node.op)} ')
			g.gen_expr(g.a.child(&node, 1))
		}
		else {}
	}
}