module transform

import v3.flat

// transform_field_init_expr transforms transform field init expr data for transform.
fn (mut t Transformer) transform_field_init_expr(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.children_count == 0 {
		return id
	}
	val_id := t.a.child(&node, 0)
	val_node := t.a.nodes[int(val_id)]
	new_val := if inferred_sum := t.sum_type_for_field_variant(node.value, val_id, val_node) {
		t.wrap_sum_value(val_id, inferred_sum)
	} else {
		t.transform_expr(val_id)
	}
	start := t.a.children.len
	t.a.children << new_val
	return t.a.add_node(flat.Node{
		kind:           .field_init
		op:             node.op
		children_start: start
		children_count: 1
		pos:            node.pos
		value:          node.value
		typ:            node.typ
	})
}

// transform_struct_fields transforms struct initialization fields with enum resolution.
// For each .field_init child, transforms the value expression. If the struct field type
// is a known enum, resolves shorthand enum values (e.g. `.red` -> `Color.red`).
fn (mut t Transformer) transform_struct_fields(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.children_count == 0 {
		return t.add_missing_struct_defaults(id, node)
	}
	info := t.lookup_struct_info(node.value) or {
		// Unknown struct: fall back to generic child transform
		return t.transform_struct_children(id, node)
	}
	// Build a field name -> type lookup from the struct definition
	mut field_types := map[string]string{}
	mut field_order := []string{cap: info.fields.len}
	for f in info.fields {
		field_types[f.name] = f.typ
		field_order << f.name
	}
	mut field_ids := []flat.NodeId{}
	mut promoted_fields := map[string][]flat.NodeId{}
	mut promoted_types := map[string]string{}
	mut prelude := []flat.NodeId{}
	t.drain_pending(mut prelude)
	for i in 0 .. node.children_count {
		child_id := t.a.child(&node, i)
		child := t.a.nodes[int(child_id)]
		if child.kind == .field_init && child.children_count > 0 {
			val_id := t.a.child(&child, 0)
			val_node := t.a.nodes[int(val_id)]
			field_name := if child.value.len > 0 {
				child.value
			} else if i < field_order.len {
				field_order[i]
			} else {
				''
			}
			mut target_field_name := field_name
			mut field_type := field_types[field_name] or { '' }
			mut promoted_parent := ''
			if field_type.len == 0 {
				if embedded := t.embedded_field_for_promoted_field(info, field_name) {
					promoted_parent = embedded.name
					promoted_types[promoted_parent] = embedded.typ
					if embedded_info := t.lookup_struct_info(embedded.typ) {
						if promoted_type := t.struct_field_type(embedded_info, field_name) {
							field_type = promoted_type
						}
					}
				}
			}
			if val_node.kind == .array_literal && t.is_fixed_array_type(field_type) {
				t.a.nodes[int(val_id)].typ = field_type
			}
			value_type := t.node_type(val_id)
			sum_field_type := t.struct_field_sum_type(field_type, info.module)
			enum_field_type := t.enum_type_name_for_expected(field_type, info.module)
			// Check if the value is an enum shorthand and the field type is an enum
			mut new_val := if val_node.kind == .enum_val && enum_field_type.len > 0 {
				t.transform_enum_shorthand(val_id, val_node, enum_field_type)
			} else if field_type.starts_with('[]') && t.is_fixed_array_type(value_type) {
				t.fixed_array_value_to_array(val_id, value_type, field_type)
			} else if sum_field_type.len > 0 {
				t.wrap_sum_value(val_id, sum_field_type)
			} else if inferred_sum := t.sum_type_for_field_variant(field_name, val_id, val_node) {
				t.wrap_sum_value(val_id, inferred_sum)
			} else if field_type.starts_with('&') {
				t.transform_expr_for_type(val_id, field_type)
			} else if field_type.len > 0 {
				t.transform_expr_for_type(val_id, field_type)
			} else {
				t.transform_expr(val_id)
			}
			if sum_field_type.len == 0 && field_type.len > 0 {
				new_val = t.coerce_transformed_expr_to_type(new_val, val_id, field_type)
			}
			t.drain_pending(mut prelude)
			fi_start := t.a.children.len
			t.a.children << new_val
			new_field := t.a.add_node(flat.Node{
				kind:           .field_init
				op:             child.op
				children_start: fi_start
				children_count: 1
				pos:            child.pos
				value:          target_field_name
				typ:            child.typ
			})
			if promoted_parent.len > 0 {
				mut promoted := promoted_fields[promoted_parent] or { []flat.NodeId{} }
				promoted << new_field
				promoted_fields[promoted_parent] = promoted
			} else {
				field_ids << new_field
			}
		} else {
			field_ids << child_id
		}
	}
	for parent, promoted in promoted_fields {
		promoted_start := t.a.children.len
		for fid in promoted {
			t.a.children << fid
		}
		embedded_type := promoted_types[parent] or { parent }
		embedded_init := t.a.add_node(flat.Node{
			kind:           .struct_init
			children_start: promoted_start
			children_count: flat.child_count(promoted.len)
			value:          embedded_type
			typ:            embedded_type
		})
		fi_start := t.a.children.len
		t.a.children << embedded_init
		field_ids << t.a.add_node(flat.Node{
			kind:           .field_init
			children_start: fi_start
			children_count: 1
			value:          parent
			typ:            embedded_type
		})
	}
	start := t.a.children.len
	for fid in field_ids {
		t.a.children << fid
	}
	new_id := t.a.add_node(flat.Node{
		kind:           .struct_init
		op:             node.op
		children_start: start
		children_count: flat.child_count(field_ids.len)
		pos:            node.pos
		value:          node.value
		typ:            node.typ
	})
	final_id := t.add_missing_struct_defaults(new_id, t.a.nodes[int(new_id)])
	for stmt in prelude {
		t.pending_stmts << stmt
	}
	return final_id
}

// transform_struct_children is a fallback for struct inits where the struct type is unknown.
// Transforms all field_init value expressions without enum resolution.
fn (mut t Transformer) transform_struct_children(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.children_count == 0 {
		return id
	}
	mut field_ids := []flat.NodeId{}
	for i in 0 .. node.children_count {
		child_id := t.a.child(&node, i)
		child := t.a.nodes[int(child_id)]
		if child.kind == .field_init && child.children_count > 0 {
			val_id := t.a.child(&child, 0)
			new_val := t.transform_expr(val_id)
			fi_start := t.a.children.len
			t.a.children << new_val
			field_ids << t.a.add_node(flat.Node{
				kind:           .field_init
				op:             child.op
				children_start: fi_start
				children_count: 1
				pos:            child.pos
				value:          child.value
				typ:            child.typ
			})
		} else {
			field_ids << child_id
		}
	}
	start := t.a.children.len
	for fid in field_ids {
		t.a.children << fid
	}
	return t.a.add_node(flat.Node{
		kind:           .struct_init
		op:             node.op
		children_start: start
		children_count: flat.child_count(field_ids.len)
		pos:            node.pos
		value:          node.value
		typ:            node.typ
	})
}

// add_missing_struct_defaults checks if any fields with default values are missing
// from the struct initialization. This is a hook point for future default-fill logic.
// Currently returns the node unchanged because StructInfo does not yet store default values.
fn (mut t Transformer) add_missing_struct_defaults(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.value.len == 0 {
		return id
	}
	info := t.lookup_struct_info(node.value) or { return id }
	mut provided := map[string]bool{}
	mut field_ids := []flat.NodeId{cap: int(node.children_count) + info.fields.len}
	mut prelude := []flat.NodeId{}
	t.drain_pending(mut prelude)
	for i in 0 .. node.children_count {
		child_id := t.a.child(&node, i)
		child := t.a.nodes[int(child_id)]
		if child.kind == .field_init {
			provided[child.value] = true
		}
		field_ids << child_id
	}
	old_module := t.cur_module
	if info.module.len > 0 {
		t.cur_module = info.module
	}
	mut added := false
	for field in info.fields {
		if field.name in provided || int(field.default_expr) < 0 {
			continue
		}
		default_node := t.a.nodes[int(field.default_expr)]
		enum_field_type := t.enum_type_name_for_expected(field.typ, info.module)
		new_val := if default_node.kind == .enum_val && enum_field_type.len > 0 {
			t.transform_enum_shorthand(field.default_expr, default_node, enum_field_type)
		} else if t.is_sum_type_name(field.typ) {
			// A sum-type field default (e.g. `typ_expr Expr = EmptyExpr{}`) must be
			// wrapped into the sum, not emitted as the bare variant. wrap_sum_value
			// is a no-op when the value already is the sum type.
			t.wrap_sum_value(field.default_expr, field.typ)
		} else {
			t.transform_expr_for_type(field.default_expr, field.typ)
		}
		t.drain_pending(mut prelude)
		fi_start := t.a.children.len
		t.a.children << new_val
		field_ids << t.a.add_node(flat.Node{
			kind:           .field_init
			children_start: fi_start
			children_count: 1
			value:          field.name
			typ:            field.typ
		})
		provided[field.name] = true
		added = true
	}
	t.cur_module = old_module
	if !added {
		for stmt in prelude {
			t.pending_stmts << stmt
		}
		return id
	}
	start := t.a.children.len
	for fid in field_ids {
		t.a.children << fid
	}
	final_id := t.a.add_node(flat.Node{
		kind:           .struct_init
		op:             node.op
		children_start: start
		children_count: flat.child_count(field_ids.len)
		pos:            node.pos
		value:          node.value
		typ:            node.typ
	})
	for stmt in prelude {
		t.pending_stmts << stmt
	}
	return final_id
}

// lookup_struct_info resolves lookup struct info information for transform.
fn (t &Transformer) lookup_struct_info(name string) ?StructInfo {
	if info := t.lookup_struct_info_preferred(name) {
		return info
	}
	normalized := t.normalize_type_alias(name)
	if normalized != name {
		return t.lookup_struct_info_direct(normalized)
	}
	return none
}

fn (t &Transformer) lookup_struct_info_preferred(name string) ?StructInfo {
	if name.contains('.') {
		if name in t.structs {
			return t.structs[name]
		}
	} else if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
		qname := '${t.cur_module}.${name}'
		if qname in t.structs {
			return t.structs[qname]
		}
	} else if name in t.structs {
		return t.structs[name]
	}
	return none
}

fn (t &Transformer) lookup_struct_info_direct(name string) ?StructInfo {
	if name.contains('.') {
		if name in t.structs {
			return t.structs[name]
		}
	} else if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
		qname := '${t.cur_module}.${name}'
		if qname in t.structs {
			return t.structs[qname]
		}
	}
	if name in t.structs {
		return t.structs[name]
	}
	if name.contains('.') {
		short_name := name.all_after_last('.')
		if short_name in t.structs {
			return t.structs[short_name]
		}
	}
	return none
}

// struct_field_type supports struct field type handling for Transformer.
fn (t &Transformer) struct_field_type(info StructInfo, field_name string) ?string {
	for field in info.fields {
		if field.name == field_name {
			return field.typ
		}
	}
	return none
}

// embedded_field_for_promoted_field
// supports helper handling in transform.
fn (t &Transformer) embedded_field_for_promoted_field(info StructInfo, field_name string) ?FieldInfo {
	for field in info.fields {
		if !t.is_embedded_field(field) {
			continue
		}
		embedded_info := t.lookup_struct_info(field.typ) or { continue }
		if _ := t.struct_field_type(embedded_info, field_name) {
			return field
		}
	}
	return none
}

// is_embedded_field reports whether is embedded field applies in transform.
fn (t &Transformer) is_embedded_field(field FieldInfo) bool {
	if field.name.len == 0 || field.typ.len == 0 {
		return false
	}
	short_typ := if field.typ.contains('.') { field.typ.all_after_last('.') } else { field.typ }
	short_name := if field.name.contains('.') { field.name.all_after_last('.') } else { field.name }
	return short_name == short_typ
}

// transform_assoc_expr transforms transform assoc expr data for transform.
fn (mut t Transformer) transform_assoc_expr(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.kind != .assoc || node.children_count == 0 {
		return id
	}
	base_id := t.a.child(&node, 0)
	base_type := t.node_type(base_id)
	mut assoc_type := node.value
	if assoc_type.len == 0 {
		assoc_type = base_type
	}
	if assoc_type.starts_with('&') {
		assoc_type = assoc_type[1..]
	}
	mut field_types := map[string]string{}
	mut assoc_module := ''
	if info := t.lookup_struct_info(assoc_type) {
		assoc_module = info.module
		for field in info.fields {
			field_types[field.name] = field.typ
		}
	}

	tmp_name := t.new_temp('assoc')
	outer_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()

	mut prelude := []flat.NodeId{}
	transformed_base := t.transform_expr(base_id)
	base := if base_type.starts_with('&') {
		t.make_prefix(.mul, transformed_base)
	} else {
		transformed_base
	}
	t.drain_pending(mut prelude)
	prelude << t.make_decl_assign_typed(tmp_name, base, assoc_type)

	for i in 1 .. node.children_count {
		field_id := t.a.child(&node, i)
		field := t.a.nodes[int(field_id)]
		if field.kind != .field_init || field.children_count == 0 {
			continue
		}
		value_id := t.a.child(&field, 0)
		value_node := t.a.nodes[int(value_id)]
		field_type := field_types[field.value] or { '' }
		if value_node.kind == .array_literal && t.is_fixed_array_type(field_type) {
			t.a.nodes[int(value_id)].typ = field_type
		}
		value_type := t.node_type(value_id)
		enum_field_type := t.enum_type_name_for_expected(field_type, assoc_module)
		value := if value_node.kind == .enum_val && enum_field_type.len > 0 {
			t.transform_enum_shorthand(value_id, value_node, enum_field_type)
		} else if field_type.starts_with('[]') && t.is_fixed_array_type(value_type) {
			t.fixed_array_value_to_array(value_id, value_type, field_type)
		} else if t.is_sum_type_name(field_type) {
			t.wrap_sum_value(value_id, field_type)
		} else if field_type.len > 0 {
			t.transform_expr_for_type(value_id, field_type)
		} else {
			t.transform_expr(value_id)
		}
		t.drain_pending(mut prelude)
		prelude << t.make_assign(t.make_selector(t.make_ident(tmp_name), field.value, field_type),
			value)
	}

	t.pending_stmts = outer_pending
	for stmt in prelude {
		t.pending_stmts << stmt
	}
	result := t.make_ident(tmp_name)
	t.a.nodes[int(result)].typ = assoc_type
	return result
}

// transform_amp_assoc_expr_for_type supports transform_amp_assoc_expr_for_type handling.
fn (mut t Transformer) transform_amp_assoc_expr_for_type(_id flat.NodeId, node flat.Node, target_type string) ?flat.NodeId {
	if node.kind != .prefix || node.op != .amp || node.children_count != 1 {
		return none
	}
	child_id := t.a.child(&node, 0)
	child := t.a.nodes[int(child_id)]
	if child.kind != .assoc {
		return none
	}
	value := t.transform_assoc_expr(child_id, child)
	mut value_type := t.node_type(value)
	if value_type.len == 0 {
		value_type = t.node_type(child_id)
	}
	if value_type.starts_with('&') {
		value_type = value_type[1..]
	}
	if value_type.len == 0 {
		return none
	}
	addr := t.make_prefix(.amp, value)
	size := t.make_sizeof_type(value_type)
	dup := t.make_call_typed('memdup', arr2(addr, size), 'voidptr')
	mut ptr_type := target_type
	if ptr_type.len == 0 {
		ptr_type = node.typ
	}
	if !ptr_type.starts_with('&') {
		ptr_type = '&${value_type}'
	}
	cast := t.make_cast(ptr_type, dup, ptr_type)
	t.a.nodes[int(cast)].typ = ptr_type
	return cast
}

// struct_field_sum_type supports struct field sum type handling for Transformer.
fn (t &Transformer) struct_field_sum_type(field_type string, owner_module string) string {
	if t.is_sum_type_name(field_type) {
		return field_type
	}
	if field_type.len == 0 || field_type.contains('.') || owner_module.len == 0 {
		return ''
	}
	qname := '${owner_module}.${field_type}'
	if qname in t.sum_types {
		return qname
	}
	return ''
}

// sum_type_for_field_variant supports sum type for field variant handling for Transformer.
fn (t &Transformer) sum_type_for_field_variant(field_name string, val_id flat.NodeId, val_node flat.Node) ?string {
	if field_name != 'info' {
		return none
	}
	mut variant := if val_node.kind in [.struct_init, .cast_expr, .assoc] && val_node.value.len > 0 {
		val_node.value
	} else if val_node.kind == .assoc && val_node.children_count > 0 {
		t.node_type(t.a.child(&val_node, 0))
	} else {
		t.node_type(val_id)
	}
	if variant.starts_with('&') {
		variant = variant[1..]
	}
	if variant.len == 0 {
		return none
	}
	short_variant := if variant.contains('.') { variant.all_after_last('.') } else { variant }
	for sum_name, variants in t.sum_types {
		if sum_name != 'TypeInfo' && !sum_name.ends_with('.TypeInfo') {
			continue
		}
		for v in variants {
			short_v := if v.contains('.') { v.all_after_last('.') } else { v }
			if v == variant || short_v == short_variant {
				return sum_name
			}
		}
	}
	return none
}

// fixed_array_value_to_array converts fixed array value to array data for transform.
fn (mut t Transformer) fixed_array_value_to_array(value_id flat.NodeId, fixed_type string, array_type string) flat.NodeId {
	elem_type := fixed_array_elem_type(fixed_type)
	len_expr := t.make_fixed_array_len_expr(fixed_type)
	return t.make_call_typed('new_array_from_c_array', [
		len_expr,
		len_expr,
		t.make_sizeof_type(elem_type),
		t.transform_expr(value_id),
	], array_type)
}

// transform_array_init_expr transforms .array_init nodes (e.g. `[]int{len: n}`).
// Recursively transforms any child expressions (len, cap, init values).
fn (mut t Transformer) transform_array_init_expr(id flat.NodeId, node flat.Node) flat.NodeId {
	if fixed := t.transform_fixed_array_init_expr(node) {
		return fixed
	}
	lowered := t.lower_array_init_to_runtime(id, node)
	if lowered != id {
		return lowered
	}
	if node.children_count == 0 {
		return id
	}
	mut new_children := []flat.NodeId{cap: int(node.children_count)}
	for i in 0 .. node.children_count {
		child_id := t.a.child(&node, i)
		new_children << t.transform_expr(child_id)
	}
	start := t.a.children.len
	for nc in new_children {
		t.a.children << nc
	}
	return t.a.add_node(flat.Node{
		kind:           .array_init
		op:             node.op
		children_start: start
		children_count: node.children_count
		pos:            node.pos
		value:          node.value
		typ:            node.typ
	})
}

// transform_map_init_expr transforms .map_init nodes.
// Recursively transforms all child key/value expressions.
fn (mut t Transformer) transform_map_init_expr(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.value.starts_with('map[') || node.typ.starts_with('map[') {
		return t.lower_map_init_to_runtime(id, node)
	}
	if node.children_count == 0 {
		return id
	}
	mut new_children := []flat.NodeId{cap: int(node.children_count)}
	for i in 0 .. node.children_count {
		child_id := t.a.child(&node, i)
		new_children << t.transform_expr(child_id)
	}
	start := t.a.children.len
	for nc in new_children {
		t.a.children << nc
	}
	return t.a.add_node(flat.Node{
		kind:           .map_init
		op:             node.op
		children_start: start
		children_count: node.children_count
		pos:            node.pos
		value:          node.value
		typ:            node.typ
	})
}