module transform

import v3.flat

// match_has_sum_type_subject checks if a match_stmt's subject expression
// resolves to a sum type. This determines whether the match needs to be
// lowered with is_expr conditions (sum type dispatch) or plain equality
// checks (value matching).
fn (mut t Transformer) match_has_sum_type_subject(node flat.Node) bool {
	if node.children_count == 0 {
		return false
	}
	subject_id := t.a.child(&node, 0)
	subject_type := t.resolve_expr_type(subject_id)
	if subject_type.len == 0 {
		return false
	}
	return subject_type in t.sum_types
}

// resolve_match_subject_type determines the type of a match subject expression.
// Uses resolve_expr_type on child 0 (the match expression).
fn (mut t Transformer) resolve_match_subject_type(node flat.Node) string {
	if node.children_count == 0 {
		return ''
	}
	subject_id := t.a.child(&node, 0)
	return t.resolve_expr_type(subject_id)
}

// transform_match_branch_body transforms a match branch body with smartcast
// awareness. When the branch matches a sum type variant, the subject variable
// should be narrowed to that variant's type within the branch body.
//
// For now, this performs basic body transformation without smartcast injection.
// When smartcast support is fully wired up, this will:
//   1. Push a smartcast context for the subject variable narrowed to the variant
//   2. Transform the body statements under that context
//   3. Pop the smartcast context
//   4. Rebuild the block with the transformed statements
fn (mut t Transformer) transform_match_branch_body(branch_id flat.NodeId, subject_name string, variant_name string) flat.NodeId {
	if int(branch_id) < 0 {
		return branch_id
	}
	branch := t.a.nodes[int(branch_id)]
	if branch.children_count == 0 {
		return branch_id
	}
	// Collect the body statement ids from the branch
	mut body_ids := []flat.NodeId{}
	// Determine where the body starts (after the condition values)
	n_conds := t.count_conds(branch)
	for i in n_conds .. branch.children_count {
		body_ids << t.a.child(&branch, i)
	}
	if body_ids.len == 0 {
		return branch_id
	}
	// Push smartcast if we have a sum type variant match
	mut has_sc := subject_name.len > 0 && variant_name.len > 0
	if has_sc {
		sum_type_name := t.find_sum_type_for_variant(variant_name)
		if sum_type_name.len > 0 {
			t.push_smartcast(subject_name, variant_name, sum_type_name)
		} else {
			has_sc = false
		}
	}
	// Transform the body statements under smartcast context
	new_body := t.transform_stmts(body_ids)
	if has_sc {
		t.pop_smartcast()
	}
	return t.make_block(new_body)
}