module transform

import v3.flat

// trim_pointer_type transforms trim pointer type data for transform.
fn (t &Transformer) trim_pointer_type(typ string) string {
	if typ.starts_with('&') {
		return typ[1..]
	}
	return typ
}

// resolve_variant resolves resolve variant information for transform.
fn (t &Transformer) resolve_variant(sum_name string, variant string) string {
	if variant.contains('.') {
		return variant
	}
	resolved_sum := t.resolve_sum_name(sum_name)
	if resolved_variant := t.sum_variant_name(resolved_sum, variant) {
		return resolved_variant
	}
	if resolved_sum.contains('.') {
		return '${resolved_sum.all_before_last('.')}.${variant}'
	}
	if sum_name.contains('.') {
		return '${sum_name.all_before_last('.')}.${variant}'
	}
	return variant
}

// resolve_sum_name resolves resolve sum name information for transform.
fn (t &Transformer) resolve_sum_name(sum_name string) string {
	if sum_name.len == 0 {
		return sum_name
	}
	if isnil(t.sum_cache) {
		return t.resolve_sum_name_uncached(sum_name)
	}
	mut c := t.sum_cache
	if c.module != t.cur_module {
		c.module = t.cur_module
		c.entries.clear()
	}
	if cached := c.entries[sum_name] {
		return cached
	}
	result := t.resolve_sum_name_uncached(sum_name)
	c.entries[sum_name] = result
	return result
}

// resolve_sum_name_uncached resolves resolve sum name uncached information for transform.
fn (t &Transformer) resolve_sum_name_uncached(sum_name string) string {
	if sum_name in t.sum_types {
		return sum_name
	}
	if sum_name.contains('.') {
		short_sum := sum_name.all_after_last('.')
		if short_sum in t.sum_types {
			return short_sum
		}
	}
	if !sum_name.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
		&& t.cur_module != 'builtin' {
		qsum := '${t.cur_module}.${sum_name}'
		if qsum in t.sum_types {
			return qsum
		}
	}
	if !sum_name.contains('.') {
		mut found := ''
		for key, _ in t.sum_types {
			if key.contains('.') && key.all_after_last('.') == sum_name {
				if found.len > 0 && found != key {
					found = ''
					break
				}
				found = key
			}
		}
		if found.len > 0 {
			return found
		}
	}
	if !isnil(t.tc) {
		if sum_name in t.tc.sum_types {
			return sum_name
		}
		if sum_name.contains('.') {
			short_sum := sum_name.all_after_last('.')
			if short_sum in t.tc.sum_types {
				return short_sum
			}
		}
		if !sum_name.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
			&& t.cur_module != 'builtin' {
			qsum := '${t.cur_module}.${sum_name}'
			if qsum in t.tc.sum_types {
				return qsum
			}
		}
		if !sum_name.contains('.') {
			mut found := ''
			for key, _ in t.tc.sum_types {
				if key.contains('.') && key.all_after_last('.') == sum_name {
					if found.len > 0 && found != key {
						found = ''
						break
					}
					found = key
				}
			}
			if found.len > 0 {
				return found
			}
		}
	}
	return sum_name
}

// is_sum_type_name reports whether is sum type name applies in transform.
fn (t &Transformer) is_sum_type_name(name string) bool {
	if name.len == 0 {
		return false
	}
	resolved := t.resolve_sum_name(name)
	return resolved in t.sum_types
}

// is_interface_type_name reports whether is interface type name applies in transform.
fn (t &Transformer) is_interface_type_name(name string) bool {
	if name.len == 0 || isnil(t.tc) {
		return false
	}
	clean := t.trim_pointer_type(t.normalize_type_alias(name))
	if clean == 'IError' || clean in t.tc.interface_names {
		return true
	}
	if !clean.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
		&& t.cur_module != 'builtin' {
		return '${t.cur_module}.${clean}' in t.tc.interface_names
	}
	return false
}

// interface_variant_type supports interface variant type handling for Transformer.
fn (t &Transformer) interface_variant_type(variant string) string {
	if variant.contains('.') {
		return variant
	}
	if variant in t.structs {
		return variant
	}
	if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
		qvariant := '${t.cur_module}.${variant}'
		if qvariant in t.structs {
			return qvariant
		}
	}
	for name, _ in t.structs {
		if name.contains('.') && name.all_after_last('.') == variant {
			return name
		}
	}
	return variant
}

// smartcast_target_type supports smartcast target type handling for Transformer.
fn (t &Transformer) smartcast_target_type(sc SmartcastContext) string {
	if t.is_interface_type_name(sc.sum_type_name) {
		return t.interface_variant_type(sc.variant_name)
	}
	return t.resolve_variant(sc.sum_type_name, sc.variant_name)
}

// sum_type_index supports sum type index handling for Transformer.
fn (t &Transformer) sum_type_index(sum_name string, variant string) int {
	resolved_sum := t.resolve_sum_name(sum_name)
	variants := t.sum_types[resolved_sum] or {
		if !isnil(t.tc) {
			tc_variants := t.tc.sum_types[resolved_sum] or { return 0 }
			return sum_type_index_in_variants(tc_variants, variant)
		}
		return 0
	}
	return sum_type_index_in_variants(variants, variant)
}

// sum_type_index_in_variants supports sum type index in variants handling for transform.
fn sum_type_index_in_variants(variants []string, variant string) int {
	short_variant := variant_short_name_text(variant)
	for i, v in variants {
		short_v := variant_short_name_text(v)
		if v == variant || short_v == short_variant {
			return i + 1
		}
	}
	return 0
}

// transform_is_expr transforms transform is expr data for transform.
fn (mut t Transformer) transform_is_expr(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.children_count == 0 {
		return id
	}
	expr_id := t.a.child(&node, 0)
	expr_type := t.node_type(expr_id)
	clean_type0 := t.trim_pointer_type(expr_type)
	clean_type := if clean_type0 in t.sum_types {
		clean_type0
	} else {
		t.find_sum_type_for_variant(node.value)
	}
	if t.is_interface_type_name(clean_type0) {
		new_expr := t.transform_expr(expr_id)
		object := t.make_selector_op(new_expr, '_object', 'voidptr', if expr_type.starts_with('&') {
			.arrow
		} else {
			.dot
		})
		return t.make_infix(.ne, object, t.a.add(.nil_literal))
	}
	if clean_type.len == 0 || clean_type !in t.sum_types {
		return t.make_bool_literal(true)
	}
	new_expr := t.transform_expr(expr_id)
	if check := t.make_sum_type_pattern_check(new_expr, expr_type, clean_type, node.value) {
		return check
	}
	return t.make_bool_literal(true)
}

// make_sum_is_check builds make sum is check data for transform.
fn (mut t Transformer) make_sum_is_check(expr flat.NodeId, expr_type string, sum_name string, variant string) flat.NodeId {
	tag := t.make_selector_op(expr, 'typ', 'int', if expr_type.starts_with('&') {
		.arrow
	} else {
		.dot
	})
	idx := t.make_int_literal(t.sum_type_index(sum_name, variant))
	return t.make_infix(.eq, tag, idx)
}

// sum_variant_path supports sum variant path handling for Transformer.
fn (t &Transformer) sum_variant_path(sum_name string, variant string) []string {
	mut visited := map[string]bool{}
	return t.sum_variant_path_inner(sum_name, variant, mut visited)
}

// sum_variant_path_inner supports sum variant path inner handling for Transformer.
fn (t &Transformer) sum_variant_path_inner(sum_name string, variant string, mut visited map[string]bool) []string {
	resolved_sum := t.resolve_sum_name(t.trim_pointer_type(sum_name))
	if resolved_sum.len == 0 || resolved_sum in visited {
		return []string{}
	}
	visited[resolved_sum] = true
	if direct := t.sum_variant_name(resolved_sum, variant) {
		return [direct]
	}
	variants := t.sum_types[resolved_sum] or { return []string{} }
	for direct in variants {
		direct_sum := t.resolve_sum_name(t.trim_pointer_type(direct))
		if direct_sum == resolved_sum || direct_sum !in t.sum_types {
			continue
		}
		nested := t.sum_variant_path_inner(direct_sum, variant, mut visited)
		if nested.len == 0 {
			continue
		}
		mut path := []string{cap: nested.len + 1}
		path << direct
		path << nested
		return path
	}
	return []string{}
}

// make_sum_type_pattern_check builds make sum type pattern check data for transform.
fn (mut t Transformer) make_sum_type_pattern_check(expr flat.NodeId, expr_type string, sum_name string, variant string) ?flat.NodeId {
	resolved_sum := t.resolve_sum_name(t.trim_pointer_type(sum_name))
	path := t.sum_variant_path(resolved_sum, variant)
	if path.len == 0 {
		return none
	}
	mut current := expr
	mut current_type := expr_type
	mut current_sum := resolved_sum
	mut chain := flat.empty_node
	for i, path_variant in path {
		cmp := t.make_sum_is_check(current, current_type, current_sum, path_variant)
		if int(chain) < 0 {
			chain = cmp
		} else {
			chain = t.make_infix(.logical_and, chain, cmp)
		}
		if i == path.len - 1 {
			break
		}
		qv := t.resolve_variant(current_sum, path_variant)
		use_ptr := t.variant_references_sum(qv, current_sum)
		field_type := if use_ptr { '&${qv}' } else { qv }
		current = t.make_selector_op(current, t.sum_field_name(qv), field_type, if current_type.starts_with('&') {
			.arrow
		} else {
			.dot
		})
		current_type = field_type
		current_sum = t.resolve_sum_name(t.trim_pointer_type(qv))
	}
	return chain
}

// transform_as_expr converts transform as expr data for transform.
fn (mut t Transformer) transform_as_expr(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.children_count == 0 {
		return id
	}
	expr_id := t.a.child(&node, 0)
	expr_type := t.node_type(expr_id)
	clean_type0 := t.trim_pointer_type(expr_type)
	clean_type := if clean_type0 in t.sum_types {
		clean_type0
	} else {
		t.find_sum_type_for_variant(node.value)
	}
	if clean_type.len == 0 || clean_type !in t.sum_types {
		return t.transform_expr(expr_id)
	}
	qv := t.resolve_variant(clean_type, node.value)
	if qv.len > 0 && t.normalize_type_alias(clean_type0) == t.normalize_type_alias(qv) {
		return t.transform_expr(expr_id)
	}
	sc_key := t.expr_key(expr_id)
	if sc_key.len > 0 {
		contexts := t.smartcasts_for(sc_key)
		mut matched_contexts := []SmartcastContext{}
		for i, sc in contexts {
			mut sc_variant := sc.variant_name
			if sc.variant_name.contains('.') {
				sc_variant = sc.variant_name.all_after_last('.')
			}
			mut target_variant := node.value
			if node.value.contains('.') {
				target_variant = node.value.all_after_last('.')
			}
			if sc_variant == target_variant {
				end := i + 1
				matched_contexts = contexts[..end].clone()
			}
		}
		if matched_contexts.len > 0 {
			base := t.make_plain_expr_for_smartcast(expr_id)
			return t.apply_smartcast_contexts(base, t.original_expr_type(expr_id), matched_contexts)
		}
	}
	field := t.sum_field_name(qv)
	new_expr := t.transform_expr(expr_id)
	use_ptr := t.variant_references_sum(qv, clean_type)
	field_typ := if use_ptr { '&${qv}' } else { qv }
	field_sel := t.make_selector_op(new_expr, field, field_typ, if expr_type.starts_with('&') {
		.arrow
	} else {
		.dot
	})
	if use_ptr {
		return t.make_prefix(.mul, field_sel)
	}
	return field_sel
}

// wrap_sum_return_expr transforms wrap sum return expr data for transform.
fn (mut t Transformer) wrap_sum_return_expr(expr_id flat.NodeId) flat.NodeId {
	was_return_expr := t.in_return_expr
	t.in_return_expr = true
	result := if t.cur_fn_ret_type.len == 0 || t.cur_fn_ret_type !in t.sum_types {
		t.transform_expr(expr_id)
	} else {
		t.wrap_sum_value(expr_id, t.cur_fn_ret_type)
	}
	t.in_return_expr = was_return_expr
	return result
}

// wrap_sum_value transforms wrap sum value data for transform.
fn (mut t Transformer) wrap_sum_value(expr_id flat.NodeId, target_sum string) flat.NodeId {
	resolved_sum := t.resolve_sum_name(target_sum)
	if resolved_sum.len == 0 || resolved_sum !in t.sum_types {
		return t.transform_expr(expr_id)
	}
	expr := t.a.nodes[int(expr_id)]
	if expr.kind == .if_expr {
		branch_type := t.if_expr_branch_result_type(expr)
		if t.if_expr_branch_overrides_sum_target(branch_type, resolved_sum) {
			return t.transform_expr(expr_id)
		}
		if lowered := t.try_expand_if_expr_value_for_type(expr_id, expr, resolved_sum) {
			return lowered
		}
	}
	expr_type := t.node_type(expr_id)
	mut variant := expr_type
	mut expr_smartcast := SmartcastContext{}
	key := t.expr_key(expr_id)
	if key.len > 0 {
		if sc := t.find_smartcast(key) {
			expr_smartcast = sc
		}
	}
	has_expr_smartcast := expr_smartcast.expr_name.len > 0
	if has_expr_smartcast && t.resolve_sum_name(expr_smartcast.sum_type_name) == resolved_sum {
		variant = t.resolve_variant(expr_smartcast.sum_type_name, expr_smartcast.variant_name)
	}
	if expr.kind == .prefix && expr.op == .mul && expr.children_count > 0 {
		inner_type := t.node_type(t.a.child(&expr, 0))
		if inner_type.starts_with('&') {
			variant = inner_type[1..]
		}
	}
	if expr.kind == .struct_init || expr.kind == .cast_expr {
		variant = expr.value
	} else if expr.kind == .as_expr && expr.value.len > 0 {
		variant = expr.value
	} else if expr.kind == .assoc && expr.value.len > 0 {
		variant = expr.value
	} else if expr.kind == .assoc && expr.children_count > 0 {
		variant = t.node_type(t.a.child(&expr, 0))
	}
	if expr.kind !in [.assoc, .as_expr, .prefix] && !has_expr_smartcast
		&& t.resolve_sum_name(expr_type) == resolved_sum {
		return t.transform_expr(expr_id)
	}
	if expr_type.starts_with('&') && t.resolve_sum_name(expr_type[1..]) == resolved_sum {
		inner := t.transform_expr(expr_id)
		deref := t.make_prefix(.mul, inner)
		t.a.nodes[int(deref)].typ = resolved_sum
		return deref
	}
	if variant.len == 0 {
		return t.transform_expr(expr_id)
	}
	mut clean_variant := if variant.starts_with('&') { variant[1..] } else { variant }
	if clean_variant.starts_with('ptr') && clean_variant.len > 3 && clean_variant[3..].contains('.') {
		clean_variant = clean_variant[3..]
	}
	if clean_variant.starts_with('ptr') && clean_variant.len > 3
		&& clean_variant[3..].contains('__') {
		clean_variant = clean_variant[3..].replace('__', '.')
	}
	short_variant := t.variant_short_name(clean_variant)
	mut matches := false
	mut matched_variant := clean_variant
	for v in t.sum_types[resolved_sum] {
		short_v := t.variant_short_name(v)
		if v == clean_variant || short_v == short_variant {
			matches = true
			matched_variant = v
			break
		}
	}
	if !matches {
		return t.transform_expr(expr_id)
	}
	ref_variant := t.variant_references_sum(matched_variant, resolved_sum)
	mut pointer_variant_child := flat.empty_node
	if expr.kind == .prefix && expr.op == .mul && expr.children_count > 0 {
		pointer_variant_child = t.a.child(&expr, 0)
	}
	inner := if int(pointer_variant_child) >= 0 && ref_variant {
		t.transform_expr(pointer_variant_child)
	} else {
		t.transform_expr(expr_id)
	}
	if expr_type.starts_with('&') {
		return t.make_sum_literal(resolved_sum, matched_variant, inner)
	}
	if int(pointer_variant_child) >= 0 && ref_variant {
		return t.make_sum_literal(resolved_sum, matched_variant, inner)
	}
	if ref_variant {
		return t.make_sum_literal(resolved_sum, matched_variant, inner)
	}
	start := t.a.children.len
	t.a.children << inner
	return t.a.add_node(flat.Node{
		kind:           .cast_expr
		value:          resolved_sum
		children_start: start
		children_count: 1
		typ:            resolved_sum
	})
}

// ensure_sum_variant_ref supports ensure sum variant ref handling for Transformer.
fn (mut t Transformer) ensure_sum_variant_ref(value flat.NodeId, variant string) flat.NodeId {
	mut value_type := t.node_type(value)
	if value_type.starts_with('&') {
		return value
	}
	clean_variant := if variant.starts_with('&') { variant[1..] } else { variant }
	if value_type.len == 0 {
		value_type = clean_variant
	}
	if t.expr_can_take_address(value) || t.a.nodes[int(value)].kind == .struct_init {
		ref := t.make_prefix(.amp, value)
		t.a.nodes[int(ref)].typ = '&${clean_variant}'
		return ref
	}
	tmp_name := t.new_temp('sum_val')
	t.pending_stmts << t.make_decl_assign_typed(tmp_name, value, value_type)
	ref := t.make_prefix(.amp, t.make_ident(tmp_name))
	t.a.nodes[int(ref)].typ = '&${clean_variant}'
	return ref
}

// make_sum_literal builds make sum literal data for transform.
fn (mut t Transformer) make_sum_literal(sum_name string, variant string, value flat.NodeId) flat.NodeId {
	qvariant := t.resolve_variant(sum_name, variant)
	typ_field := t.make_sum_literal_field('typ', t.make_int_literal(t.sum_type_index(sum_name,
		qvariant)), 'int')
	raw_value_type := t.node_type(value)
	value_type := if raw_value_type.starts_with('&') {
		raw_value_type
	} else {
		qvariant
	}
	value_field := t.make_sum_literal_field(t.sum_field_name(qvariant), value, value_type)
	start := t.a.children.len
	t.a.children << typ_field
	t.a.children << value_field
	return t.a.add_node(flat.Node{
		kind:           .struct_init
		children_start: start
		children_count: 2
		value:          sum_name
		typ:            sum_name
	})
}

// make_sum_literal_field builds make sum literal field data for transform.
fn (mut t Transformer) make_sum_literal_field(name string, value flat.NodeId, typ string) flat.NodeId {
	start := t.a.children.len
	t.a.children << value
	return t.a.add_node(flat.Node{
		kind:           .field_init
		children_start: start
		children_count: 1
		value:          name
		typ:            typ
	})
}