// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.

module cleanc

import strings
import v2.ast
import v2.types

fn array_alias_elem_type(arr_type string) string {
    base := arr_type.trim_right('*')
    if base.starts_with('Array_fixed_') {
        without_prefix := base['Array_fixed_'.len..]
        last_underscore := without_prefix.last_index('_') or { return '' }
        return unmangle_c_ptr_type(without_prefix[..last_underscore])
    }
    if base.starts_with('Array_') {
        return unmangle_c_ptr_type(base['Array_'.len..])
    }
    if base in ['strings__Builder', 'Builder'] {
        return 'u8'
    }
    return ''
}

fn (mut g Gen) array_alias_base_type(arr_type string) string {
    base := arr_type.trim_space().trim_right('*')
    if base == '' {
        return ''
    }
    if base.starts_with('Array_') || base.starts_with('Array_fixed_') {
        return base
    }
    if alias_base := g.alias_base_types[base] {
        return alias_base.trim_space().trim_right('*')
    }
    if raw := g.lookup_type_by_c_name(base) {
        if raw is types.Alias {
            return g.types_type_to_c(raw.base_type).trim_space().trim_right('*')
        }
    }
    return ''
}

fn (mut g Gen) array_alias_elem_type_from_c_type(arr_type string) string {
    elem := array_alias_elem_type(arr_type)
    if elem != '' {
        return elem
    }
    base := g.array_alias_base_type(arr_type)
    if base != '' {
        return array_alias_elem_type(base)
    }
    return ''
}

fn c_type_is_array_value(typ string) bool {
    base := typ.trim_space().trim_right('*')
    return base == 'array' || base.starts_with('Array_')
}

fn specialized_generic_elem_type_from_value(declared_elem string, value_elem string) string {
    declared := unmangle_c_ptr_type(declared_elem.trim_space())
    inferred := unmangle_c_ptr_type(value_elem.trim_space())
    if declared == '' || inferred == '' || !inferred.contains('_T_') {
        return ''
    }
    base := inferred.all_before('_T_')
    if declared == base || short_type_name(declared) == short_type_name(base) {
        return inferred
    }
    return ''
}

fn (mut g Gen) selector_array_value_type(sel ast.SelectorExpr) string {
    mut field_type := g.selector_declared_field_type(sel)
    if !c_type_is_array_value(field_type) {
        field_type = g.selector_generated_field_type(sel)
    }
    if !c_type_is_array_value(field_type) {
        field_type = g.selector_field_type(sel)
    }
    if c_type_is_array_value(field_type) {
        return field_type
    }
    return ''
}

fn is_builtin_array_file(path string) bool {
    normalized := path.replace('\\', '/')
    return normalized.ends_with('vlib/builtin/array.v')
}

fn should_keep_builtin_array_decl(decl ast.FnDecl) bool {
    return decl.name in [
        '__new_array',
        '__new_array_with_default',
        '__new_array_with_multi_default',
        '__new_array_with_array_default',
        '__new_array_with_map_default',
        'new_array_from_c_array',
        'new_array_from_c_array_no_alloc',
        'new_array_from_array_and_c_array',
        'ensure_cap',
        'repeat',
        'repeat_to_depth',
        'insert',
        'insert_many',
        'prepend',
        'prepend_many',
        'delete',
        'delete_many',
        'clear',
        'reset',
        'trim',
        'drop',
        'get_unsafe',
        'get',
        'get_with_check',
        'first',
        'last',
        'pop_left',
        'pop',
        'delete_last',
        'slice',
        'slice_ni',
        'contains',
        'clone_static_to_depth',
        'clone',
        'clone_to_depth',
        'set_unsafe',
        'set',
        'push',
        'push_many',
        'reverse_in_place',
        'reverse',
        'free',
        'sort',
        'sort_with_compare',
        'sorted_with_compare',
        'copy',
        'write_u8',
        'write_rune',
        'write_string',
        'write_ptr',
        'grow_cap',
        'grow_len',
        'pointers',
        'panic_on_negative_len',
        'panic_on_negative_cap',
    ]
}

fn array_interface_repeat_fn_name(iface_name string) string {
    return '__v_array_repeat_interface__' + mangle_alias_component(iface_name)
}

fn (g &Gen) array_clone_depth_for_c_type(type_name string) int {
    elem_type := array_alias_elem_type(type_name)
    if elem_type == '' {
        return 0
    }
    if elem_type == 'string' || elem_type == 'builtin__string' || elem_type == 'map'
        || elem_type.starts_with('Map_') {
        return 1
    }
    if elem_type == 'array' || elem_type.starts_with('Array_') {
        return 1 + g.array_clone_depth_for_c_type(elem_type)
    }
    return 0
}

fn (mut g Gen) emit_array_interface_repeat_decls() {
    mut names := g.emitted_interface_bodies.keys()
    names.sort()
    for name in names {
        g.sb.writeln('static inline array ${array_interface_repeat_fn_name(name)}(array a, int count);')
    }
    if names.len > 0 {
        g.sb.writeln('')
    }
}

fn (mut g Gen) emit_array_interface_repeat_body(iface_name string) {
    repeat_fn := array_interface_repeat_fn_name(iface_name)
    clone_fn := interface_clone_fn_name(iface_name)
    g.sb.writeln('static inline array ${repeat_fn}(array a, int count) {')
    g.sb.writeln('\tarray res = array__repeat_to_depth(a, count, 0);')
    g.sb.writeln('\tif (a.len > 0) {')
    g.sb.writeln('\t\tfor (int i = 0; i < res.len; ++i) {')
    g.sb.writeln('\t\t\t((${iface_name}*)res.data)[i] = ${clone_fn}(((${iface_name}*)a.data)[i % a.len]);')
    g.sb.writeln('\t\t}')
    g.sb.writeln('\t}')
    g.sb.writeln('\treturn res;')
    g.sb.writeln('}')
    g.sb.writeln('')
}

fn (mut g Gen) emit_array_interface_repeat_helpers() {
    mut names := g.emitted_interface_bodies.keys()
    names.sort()
    for name in names {
        g.emit_array_interface_repeat_body(name)
    }
}

struct ArrayContainsFallbackSpec {
    fn_name   string
    arr_type  string
    elem_type string
}

fn (g &Gen) missing_array_contains_fallback_specs() []ArrayContainsFallbackSpec {
    mut fn_name_set := map[string]bool{}
    for fn_name in g.fn_param_types.keys() {
        fn_name_set[fn_name] = true
    }
    for fn_name in g.called_fn_names.keys() {
        if fn_name.starts_with('Array_') && fn_name.ends_with('_contains') {
            fn_name_set[fn_name] = true
        }
    }
    mut fn_names := fn_name_set.keys()
    fn_names.sort()
    mut specs := []ArrayContainsFallbackSpec{}
    for fn_name in fn_names {
        if !fn_name.starts_with('Array_') || !fn_name.ends_with('_contains') {
            continue
        }
        if fn_name !in g.called_fn_names {
            continue
        }
        fn_key := 'fn_${fn_name}'
        if fn_key in g.emitted_types {
            continue
        }
        has_signature := fn_name in g.fn_param_types
        if has_signature {
            if g.fn_return_types[fn_name] or { '' } != 'bool' {
                continue
            }
        }
        param_types := g.fn_param_types[fn_name] or { []string{} }
        mut arr_type := ''
        mut elem_type := ''
        if param_types.len == 2 {
            arr_type = param_types[0]
            elem_type = param_types[1]
        } else if fn_name.starts_with('Array_') && fn_name.ends_with('_contains') {
            elem_type = fn_name['Array_'.len..fn_name.len - '_contains'.len]
            arr_type = 'Array_${elem_type}'
        } else {
            continue
        }
        if arr_type.len == 0 || elem_type.len == 0 {
            continue
        }
        specs << ArrayContainsFallbackSpec{
            fn_name:   fn_name
            arr_type:  arr_type
            elem_type: elem_type
        }
    }
    return specs
}

fn array_contains_fallback_decls(specs []ArrayContainsFallbackSpec) string {
    if specs.len == 0 {
        return ''
    }
    mut sb := strings.new_builder(specs.len * 80)
    for spec in specs {
        sb.writeln('bool ${spec.fn_name}(${spec.arr_type} a, ${spec.elem_type} v);')
    }
    sb.writeln('')
    return sb.str()
}

fn (mut g Gen) emit_array_contains_fallbacks(specs []ArrayContainsFallbackSpec) {
    mut emitted_any := false
    for spec in specs {
        fn_key := 'fn_${spec.fn_name}'
        if fn_key in g.emitted_types {
            continue
        }
        g.emitted_types[fn_key] = true
        g.sb.writeln('')
        if g.is_freestanding_target() && g.pref != unsafe { nil } && g.pref.skip_builtin {
            g.sb.writeln('_Static_assert(0, "${freestanding_missing_heap_runtime_message}: ${spec.fn_name}");')
            emitted_any = true
            continue
        }
        // Fixed arrays are C arrays (e.g., voidptr[20]), not structs — use direct indexing.
        is_fixed := spec.arr_type.starts_with('Array_fixed_')
        if is_fixed {
            _, fixed_len := g.parse_fixed_array_type(spec.arr_type)
            g.sb.writeln('__attribute__((weak)) bool ${spec.fn_name}(${spec.arr_type} a, ${spec.elem_type} v) {')
            g.sb.writeln('\tfor (int i = 0; i < ${fixed_len}; i++) {')
            if spec.elem_type == 'string' {
                g.sb.writeln('\t\tif (string__eq(a[i], v)) {')
            } else {
                g.sb.writeln('\t\tif (memcmp(&a[i], &v, sizeof(${spec.elem_type})) == 0) {')
            }
        } else {
            g.sb.writeln('__attribute__((weak)) bool ${spec.fn_name}(${spec.arr_type} a, ${spec.elem_type} v) {')
            g.sb.writeln('\tfor (int i = 0; (i < a.len); i += 1) {')
            if spec.elem_type == 'string' {
                g.sb.writeln('\t\tif (string__eq(*((string*)(array__get(a, i))), v)) {')
            } else {
                left_cmp := '_cmp_l_${g.tmp_counter}'
                right_cmp := '_cmp_r_${g.tmp_counter + 1}'
                g.tmp_counter += 2
                g.sb.writeln('\t\tif (({ ${spec.elem_type} ${left_cmp} = *((${spec.elem_type}*)(array__get(a, i))); ${spec.elem_type} ${right_cmp} = v; memcmp(&${left_cmp}, &${right_cmp}, sizeof(${spec.elem_type})) == 0; })) {')
            }
        }
        g.sb.writeln('\t\t\treturn true;')
        g.sb.writeln('\t\t}')
        g.sb.writeln('\t}')
        g.sb.writeln('\treturn false;')
        g.sb.writeln('}')
        emitted_any = true
    }
    if emitted_any {
        g.sb.writeln('')
    }
}

fn (mut g Gen) emit_deferred_fixed_array_aliases() {
    mut names := g.array_aliases.keys()
    // Sort by name length then alphabetically so leaf types (shorter names)
    // are emitted before compound types that depend on them.
    // E.g. Array_fixed_string_2 before Array_fixed_Array_fixed_string_2_2.
    for i := 0; i < names.len; i++ {
        for j := i + 1; j < names.len; j++ {
            if names[i].len > names[j].len || (names[i].len == names[j].len && names[i] > names[j]) {
                names[i], names[j] = names[j], names[i]
            }
        }
    }
    for name in names {
        if !name.starts_with('Array_fixed_') {
            continue
        }
        // Skip if already emitted (safe to call this function multiple times).
        alias_key := 'alias_${name}'
        if alias_key in g.emitted_types {
            continue
        }
        if info := g.collected_fixed_array_types[name] {
            if !g.fixed_array_elem_type_ready(info.elem_type) {
                continue
            }
            g.sb.writeln('typedef ${info.elem_type} ${name} [${info.size}];')
            body_key := 'body_${name}'
            g.emitted_types[alias_key] = true
            g.emitted_types[body_key] = true
            // Emit fallback str macros for fixed array types (only if no real function was generated)
            str_fn := '${name}_str'
            if str_fn !in g.fn_return_types {
                g.sb.writeln('#define ${name}_str(a) ((string){.str = "${name}", .len = ${name.len}, .is_lit = 1})')
                g.sb.writeln('#define ${name}__str(a) ${name}_str(a)')
            }
        }
    }
}

fn (g &Gen) fixed_array_elem_type_ready(elem_type string) bool {
    if elem_type in primitive_types
        || elem_type in ['char', 'voidptr', 'charptr', 'byteptr', 'void*', 'char*'] {
        return true
    }
    if elem_type in g.primitive_type_aliases {
        return true
    }
    if elem_type.starts_with('Array_fixed_') {
        return 'body_${elem_type}' in g.emitted_types || 'alias_${elem_type}' in g.emitted_types
    }
    if elem_type.ends_with('*') || g.is_c_type_name(elem_type) {
        return true
    }
    if base_type := g.alias_base_types[elem_type] {
        if base_type != elem_type {
            return g.fixed_array_elem_type_ready(base_type)
        }
    }
    return 'body_${elem_type}' in g.emitted_types || 'enum_${elem_type}' in g.emitted_types
}

fn (mut g Gen) array_append_elem_type(lhs ast.Expr, rhs ast.Expr) (bool, string) {
    mut lhs_type := g.get_expr_type(lhs).trim_space()
    lhs_base_type := lhs_type.trim_right('*')
    mut elem_type := ''
    mut is_array_append := lhs_base_type == 'array' || lhs_base_type.starts_with('Array_')
    if lhs_base_type.starts_with('Array_') {
        elem_type = lhs_base_type['Array_'.len..]
    }
    if !is_array_append {
        if alias_base := g.alias_base_c_type(lhs_base_type) {
            alias_base_clean := alias_base.trim_right('*')
            if alias_base_clean == 'array' || alias_base_clean.starts_with('Array_') {
                is_array_append = true
                if alias_base_clean.starts_with('Array_') {
                    elem_type = alias_base_clean['Array_'.len..]
                }
            }
        }
    }
    if raw_type := g.get_raw_type(lhs) {
        match raw_type {
            types.Array {
                is_array_append = true
                if elem_type == '' {
                    elem_type = g.types_type_to_c(raw_type.elem_type)
                }
            }
            types.Alias {
                if raw_type.base_type is types.Array {
                    is_array_append = true
                    if elem_type == '' {
                        elem_type = g.types_type_to_c(raw_type.base_type.elem_type)
                    }
                }
            }
            types.Pointer {
                match raw_type.base_type {
                    types.Array {
                        is_array_append = true
                        if elem_type == '' {
                            elem_type = g.types_type_to_c(raw_type.base_type.elem_type)
                        }
                    }
                    types.Alias {
                        if raw_type.base_type.base_type is types.Array {
                            is_array_append = true
                            if elem_type == '' {
                                elem_type =
                                    g.types_type_to_c(raw_type.base_type.base_type.elem_type)
                            }
                        }
                    }
                    else {}
                }
            }
            else {}
        }
    }
    if !is_array_append {
        return false, ''
    }
    if elem_type == '' || elem_type == 'int' {
        rhs_type := g.get_expr_type(rhs)
        if rhs_type != '' && rhs_type !in ['int_literal', 'float_literal'] {
            elem_type = rhs_type.trim_right('*')
        }
        if elem_type == '' || elem_type == 'int' {
            rhs_c_type := g.expr_type_to_c(rhs)
            if rhs_c_type != '' && rhs_c_type !in ['int', 'int_literal', 'float_literal'] {
                elem_type = rhs_c_type.trim_right('*')
            }
        }
    }
    // When raw_type gives a module-qualified name (e.g. term__Coord) but the rhs
    // is a local struct (e.g. Coord), prefer the rhs type to match the actual typedef.
    if elem_type.contains('__') {
        rhs_type := g.get_expr_type(rhs).trim_right('*')
        if rhs_type != '' && !rhs_type.contains('__')
            && rhs_type !in ['int', 'int_literal', 'float_literal', 'void', 'void*', 'voidptr']
            && elem_type.ends_with('__${rhs_type}') {
            elem_type = rhs_type
        }
    }
    if elem_type == '' {
        elem_type = 'int'
    }
    return true, unmangle_c_ptr_type(elem_type)
}

fn (mut g Gen) array_append_lhs_is_pointer(lhs ast.Expr) bool {
    unwrapped := strip_expr_wrappers(lhs)
    if unwrapped is ast.Ident {
        if unwrapped.name in g.cur_fn_mut_params {
            return true
        }
        if local_type := g.get_local_var_c_type(unwrapped.name) {
            local_type_clean := local_type.trim_space()
            return local_type_clean.ends_with('*')
                || local_type_clean in ['voidptr', 'charptr', 'byteptr', 'chan']
        }
    }
    return g.expr_is_pointer(lhs)
}

fn (mut g Gen) gen_array_append_target(lhs ast.Expr) {
    unwrapped := strip_expr_wrappers(lhs)
    if unwrapped is ast.PrefixExpr && unwrapped.op == .amp {
        inner := strip_expr_wrappers(unwrapped.expr)
        if g.array_append_lhs_is_pointer(inner) {
            g.expr(inner)
            return
        }
        g.expr(lhs)
        return
    }
    if g.array_append_lhs_is_pointer(lhs) {
        g.expr(lhs)
    } else {
        g.sb.write_string('&')
        g.expr(lhs)
    }
}

fn (mut g Gen) map_index_key_value_types(node ast.IndexExpr) (bool, string, string, bool) {
    mut key_type := ''
    mut value_type := ''
    mut lhs_is_ptr := g.expr_is_pointer(node.lhs)
    mut lhs_c_type := g.get_expr_type(node.lhs).trim_space()
    if lhs_c_type.ends_with('*') {
        lhs_is_ptr = true
    }
    if raw_type := g.get_raw_type(node.lhs) {
        match raw_type {
            types.Map {
                key_type = g.types_type_to_c(raw_type.key_type)
                value_type = g.types_type_to_c(raw_type.value_type)
            }
            types.Pointer {
                lhs_is_ptr = true
                match raw_type.base_type {
                    types.Map {
                        key_type = g.types_type_to_c(raw_type.base_type.key_type)
                        value_type = g.types_type_to_c(raw_type.base_type.value_type)
                    }
                    types.Alias {
                        if raw_type.base_type.base_type is types.Map {
                            key_type = g.types_type_to_c(raw_type.base_type.base_type.key_type)
                            value_type = g.types_type_to_c(raw_type.base_type.base_type.value_type)
                        }
                    }
                    else {}
                }
            }
            types.Alias {
                if raw_type.base_type is types.Map {
                    key_type = g.types_type_to_c(raw_type.base_type.key_type)
                    value_type = g.types_type_to_c(raw_type.base_type.value_type)
                }
            }
            else {}
        }
    }
    if key_type == '' || value_type == '' {
        mut map_c_type := lhs_c_type
        if node.lhs is ast.SelectorExpr {
            mut selector_type := g.selector_storage_field_type(node.lhs).trim_space()
            if selector_type == '' {
                selector_type = g.selector_field_type(node.lhs).trim_space()
            }
            if selector_type != '' {
                map_c_type = selector_type
            }
        }
        if map_c_type.ends_with('*') {
            map_c_type = map_c_type[..map_c_type.len - 1].trim_space()
        }
        if map_c_type.starts_with('Map_') {
            key, value := g.parse_map_kv_types(map_c_type['Map_'.len..])
            key_type = key
            value_type = value
        }
    }
    if key_type == '' || value_type == '' {
        return false, '', '', false
    }
    return true, key_type, value_type, lhs_is_ptr
}

fn (mut g Gen) gen_map_index_array_append(lhs ast.IndexExpr, rhs ast.Expr, elem_type string) bool {
    ok, key_type, value_type, lhs_is_ptr := g.map_index_key_value_types(lhs)
    if !ok {
        return false
    }
    if value_type.trim_space().ends_with('*') {
        return false
    }
    value_base := value_type.trim_right('*')
    mut is_array_value := c_type_is_array_value(value_base)
    if !is_array_value {
        if alias_base := g.alias_base_c_type(value_base) {
            is_array_value = c_type_is_array_value(alias_base)
        }
    }
    if !is_array_value {
        return false
    }
    key_tmp := '_map_key${g.tmp_counter}'
    g.tmp_counter++
    zero_tmp := '_map_zero${g.tmp_counter}'
    g.tmp_counter++
    arr_tmp := '_map_arr${g.tmp_counter}'
    g.tmp_counter++
    g.sb.write_string('({ ${key_type} ${key_tmp} = ')
    g.expr(lhs.expr)
    g.sb.write_string('; ${value_type} ${zero_tmp} = __new_array_with_default_noscan(0, 0, sizeof(${elem_type}), NULL); ${value_type}* ${arr_tmp} = (${value_type}*)map__get_and_set(')
    if lhs_is_ptr {
        g.expr(lhs.lhs)
    } else {
        g.sb.write_string('&(')
        g.expr(lhs.lhs)
        g.sb.write_string(')')
    }
    g.sb.write_string(', (void*)&${key_tmp}, (void*)&${zero_tmp}); ')
    if g.expr_is_array_value(rhs) {
        rhs_tmp := '_arr_append_tmp_${g.tmp_counter}'
        g.tmp_counter++
        arr_rhs_type := g.expr_array_runtime_type(rhs)
        g.sb.write_string('${arr_rhs_type} ${rhs_tmp} = ')
        g.expr(rhs)
        g.sb.write_string('; array__push_many((array*)${arr_tmp}, ${rhs_tmp}.data, ${rhs_tmp}.len); })')
        return true
    }
    g.sb.write_string('array__push((array*)${arr_tmp}, ')
    if elem_type == 'string' {
        g.sb.write_string('&(string[1]){ string__clone(')
        g.expr(rhs)
        g.sb.write_string(') }')
    } else {
        g.gen_addr_of_expr(rhs, elem_type)
    }
    g.sb.write_string('); })')
    return true
}

fn (mut g Gen) expr_is_array_value(expr ast.Expr) bool {
    if expr is ast.ParenExpr {
        return g.expr_is_array_value(expr.expr)
    }
    if expr is ast.PrefixExpr && expr.op == .mul {
        // `*ptr_to_array` is an array value.
        return g.expr_is_array_value(expr.expr)
    }
    if expr is ast.InfixExpr && expr.op in [.amp, .pipe, .xor, .left_shift, .right_shift] {
        return false
    }
    if expr is ast.SelectorExpr && g.selector_array_value_type(expr) != '' {
        return true
    }
    expr_type := g.get_expr_type(expr)
    if c_type_is_array_value(expr_type) {
        return true
    }
    if alias_base := g.alias_base_c_type(expr_type.trim_right('*')) {
        if c_type_is_array_value(alias_base) {
            return true
        }
    }
    if expr is ast.Ident {
        local_type := g.get_local_var_c_type(expr.name) or { '' }
        if c_type_is_array_value(local_type) {
            return true
        }
        if alias_base := g.alias_base_c_type(local_type.trim_right('*')) {
            if c_type_is_array_value(alias_base) {
                return true
            }
        }
    }
    // Or-data-access: _or_tN.data where _or_tN has type _result_Array_X or _option_Array_X
    if expr is ast.SelectorExpr && expr.rhs.name == 'data' {
        if expr.lhs is ast.Ident {
            lhs_type := g.get_expr_type(expr.lhs)
            if (lhs_type.starts_with('_result_Array_') || lhs_type.starts_with('_result_array'))
                || (lhs_type.starts_with('_option_Array_') || lhs_type.starts_with('_option_array')) {
                return true
            }
        }
    }
    if raw_type := g.get_raw_type(expr) {
        match raw_type {
            types.Array {
                return true
            }
            types.Alias {
                return raw_type.base_type is types.Array
            }
            types.Pointer {
                match raw_type.base_type {
                    types.Array {
                        return true
                    }
                    types.Alias {
                        return raw_type.base_type.base_type is types.Array
                    }
                    else {
                        return false
                    }
                }
            }
            else {
                return false
            }
        }
    }
    return false
}

fn (mut g Gen) expr_array_runtime_type(expr ast.Expr) string {
    if expr is ast.ParenExpr {
        return g.expr_array_runtime_type(expr.expr)
    }
    if expr is ast.PrefixExpr && expr.op == .mul {
        // Try direct dereferenced type first.
        deref_type := g.get_expr_type(expr)
        if deref_type != '' && deref_type != 'int_literal' && deref_type != 'float_literal' {
            return deref_type
        }
        inner_type := g.expr_array_runtime_type(expr.expr)
        if inner_type.ends_with('*') {
            return inner_type[..inner_type.len - 1]
        }
    }
    if expr is ast.SelectorExpr {
        field_type := g.selector_array_value_type(expr)
        if field_type != '' {
            return field_type
        }
        expr_type := g.get_expr_type(expr)
        if alias_base := g.alias_base_c_type(expr_type.trim_right('*')) {
            if c_type_is_array_value(alias_base) {
                return expr_type.trim_right('*')
            }
        }
    }
    // Or-data-access: _or_tN.data — extract array type from result/option wrapper
    if expr is ast.SelectorExpr && expr.rhs.name == 'data' && expr.lhs is ast.Ident {
        lhs_type := g.get_expr_type(expr.lhs)
        if lhs_type.starts_with('_result_') {
            return lhs_type['_result_'.len..]
        }
        if lhs_type.starts_with('_option_') {
            return lhs_type['_option_'.len..]
        }
    }
    mut typ := g.get_expr_type(expr)
    if expr is ast.Ident {
        local_type := g.get_local_var_c_type(expr.name) or { '' }
        if c_type_is_array_value(local_type) {
            typ = local_type
        }
    }
    if typ != '' && typ != 'int_literal' && typ != 'float_literal' {
        return typ
    }
    if raw_type := g.get_raw_type(expr) {
        typ = g.types_type_to_c(raw_type)
    }
    if typ == '' {
        return 'array'
    }
    return typ
}

// array_elem_type_from_expr resolves the element type of an array expression
// using the types.Environment.
fn (mut g Gen) infer_array_elem_type_from_expr(arr_expr ast.Expr) string {
    match arr_expr {
        ast.ModifierExpr {
            return g.infer_array_elem_type_from_expr(arr_expr.expr)
        }
        ast.ParenExpr {
            return g.infer_array_elem_type_from_expr(arr_expr.expr)
        }
        ast.PrefixExpr {
            if arr_expr.op in [.amp, .mul] {
                return g.infer_array_elem_type_from_expr(arr_expr.expr)
            }
        }
        ast.CastExpr {
            return g.infer_array_elem_type_from_expr(arr_expr.expr)
        }
        ast.AsCastExpr {
            return g.infer_array_elem_type_from_expr(arr_expr.expr)
        }
        ast.IndexExpr {
            if arr_expr.expr is ast.RangeExpr {
                return g.infer_array_elem_type_from_expr(arr_expr.lhs)
            }
        }
        ast.SelectorExpr {
            field_type := g.selector_array_value_type(arr_expr)
            if field_type != '' {
                elem_type := array_alias_elem_type(field_type)
                if elem_type != '' {
                    return elem_type
                }
            }
        }
        else {}
    }

    if arr_expr is ast.ArrayInitExpr {
        elem_type := g.extract_array_elem_type(arr_expr.typ)
        value_elem_type := g.infer_array_init_value_elem_type(arr_expr)
        specialized := specialized_generic_elem_type_from_value(elem_type, value_elem_type)
        if specialized != '' {
            return specialized
        }
        if (elem_type == '' || elem_type == 'int') && value_elem_type != ''
            && value_elem_type != 'int' {
            return value_elem_type
        }
        if elem_type != '' {
            return elem_type
        }
        if arr_expr.exprs.len > 0 {
            first_expr_type := g.get_expr_type(arr_expr.exprs[0])
            if first_expr_type != '' && first_expr_type != 'int' && first_expr_type != 'int_literal' {
                return first_expr_type
            }
        }
    }
    // For slice calls, the return type is generic `array`; resolve from the source array.
    if arr_expr is ast.CallExpr {
        if arr_expr.lhs is ast.Ident {
            fn_name := sanitize_fn_ident(arr_expr.lhs.name)
            if fn_name in ['new_array_from_c_array', 'builtin__new_array_from_c_array', 'builtin__new_array_from_c_array_noscan']
                && arr_expr.args.len >= 3 {
                sizeof_arg := arr_expr.args[2]
                if sizeof_arg is ast.KeywordOperator && sizeof_arg.op == .key_sizeof
                    && sizeof_arg.exprs.len > 0 {
                    t := g.expr_type_to_c(sizeof_arg.exprs[0])
                    if arr_expr.args.len > 3 {
                        data_elem := g.infer_array_elem_type_from_expr(arr_expr.args[3])
                        specialized := specialized_generic_elem_type_from_value(t, data_elem)
                        if specialized != '' {
                            return specialized
                        }
                    }
                    if t != '' && t != 'int' {
                        return t
                    }
                }
                if arr_expr.args.len > 3 {
                    return g.infer_array_elem_type_from_expr(arr_expr.args[3])
                }
            }
            // __new_array_with_default_noscan(len, cap, sizeof(T), default)
            // arg[2] is sizeof(T) — extract T from the KeywordOperator
            if fn_name in ['__new_array_with_default_noscan', '__new_array_with_default', 'builtin____new_array_with_default_noscan', 'builtin____new_array_with_default']
                && arr_expr.args.len >= 3 {
                sizeof_arg := arr_expr.args[2]
                if sizeof_arg is ast.KeywordOperator && sizeof_arg.op == .key_sizeof
                    && sizeof_arg.exprs.len > 0 {
                    t := g.expr_type_to_c(sizeof_arg.exprs[0])
                    if t != '' && t != 'int' {
                        return t
                    }
                }
            }
            if fn_name in ['array__slice', 'array__slice_ni']
                || (fn_name.starts_with('Array_') && (fn_name.ends_with('__slice')
                || fn_name.ends_with('__slice_ni'))) {
                if arr_expr.args.len > 0 {
                    return g.infer_array_elem_type_from_expr(arr_expr.args[0])
                }
            }
            if fn_name in ['array__clone', 'array__clone_to_depth']
                || (fn_name.starts_with('Array_') && (fn_name.ends_with('__clone')
                || fn_name.ends_with('__clone_to_depth'))) {
                if arr_expr.args.len > 0 {
                    return g.infer_array_elem_type_from_expr(arr_expr.args[0])
                }
            }
        }
    }
    if raw_type := g.get_raw_type(arr_expr) {
        if elem := array_elem_type_from_raw(raw_type) {
            return g.types_type_to_c(elem)
        }
    }
    // Secondary path: when get_raw_type fails (e.g. SelectorExpr on sum type cast pointers
    // with invalid pos.ids), resolve the C type name back to a raw type.
    arr_type := g.get_expr_type(arr_expr)
    if arr_type != '' && arr_type != 'int' && arr_type != 'array' {
        if raw := g.resolve_c_type_to_raw(arr_type) {
            if elem := array_elem_type_from_raw(raw) {
                return g.types_type_to_c(elem)
            }
        }
    }
    // Last resort: string-based extraction (e.g. Array_int → int).
    return array_alias_elem_type(arr_type)
}

fn (mut g Gen) infer_array_init_value_elem_type(node ast.ArrayInitExpr) string {
    for expr in node.exprs {
        mut elem_type := g.get_expr_type(expr)
        if elem_type == '' || elem_type == 'int' || elem_type == 'int_literal'
            || elem_type == 'float_literal' || elem_type == 'void' {
            if raw_type := g.get_raw_type(expr) {
                elem_type = g.types_type_to_c(raw_type)
            }
        }
        if elem_type == '' || elem_type == 'int' || elem_type == 'int_literal'
            || elem_type == 'float_literal' || elem_type == 'void' {
            continue
        }
        return unmangle_c_ptr_type(elem_type)
    }
    return ''
}

// array_elem_type_from_raw extracts the element type from a raw types.Type
// that represents an array, unwrapping Pointer and Alias layers as needed.
fn array_elem_type_from_raw(t types.Type) ?types.Type {
    if !type_has_valid_data(t) {
        return none
    }
    match t {
        types.Array {
            return t.elem_type
        }
        types.Pointer {
            if elem := array_elem_type_from_raw(t.base_type) {
                return elem
            }
            return none
        }
        types.Alias {
            if elem := array_elem_type_from_raw(t.base_type) {
                return elem
            }
            return none
        }
        else {
            return none
        }
    }
}

fn (mut g Gen) infer_array_method_elem_type(expr ast.Expr) string {
    match expr {
        ast.CallExpr {
            if expr.lhs is ast.Ident
                && expr.lhs.name in ['array__pop', 'array__pop_left', 'array__first', 'array__last'] {
                if expr.args.len > 0 {
                    return g.infer_array_elem_type_from_expr(expr.args[0])
                }
            }
            if expr.lhs is ast.SelectorExpr
                && expr.lhs.rhs.name in ['pop', 'pop_left', 'first', 'last'] {
                arr_expr := if expr.args.len > 0 { expr.args[0] } else { expr.lhs.lhs }
                return g.infer_array_elem_type_from_expr(arr_expr)
            }
        }
        else {}
    }

    return ''
}

fn (mut g Gen) infer_array_contains_elem_type(name string, call_args []ast.Expr) string {
    arr_type := if call_args.len > 0 { g.get_expr_type(call_args[0]) } else { '' }
    if arr_type.starts_with('Array_fixed_') {
        if finfo := g.collected_fixed_array_types[arr_type] {
            return finfo.elem_type
        }
    } else if arr_type.starts_with('Array_') {
        return arr_type['Array_'.len..]
    }
    mut suffix := ''
    if name.starts_with('array__contains_') {
        suffix = name['array__contains_'.len..]
    }
    if suffix != '' && suffix != 'void' {
        return suffix
    }
    if call_args.len > 1 {
        rhs_type := g.get_expr_type(call_args[1])
        if rhs_type != '' && rhs_type != 'int_literal' && rhs_type != 'float_literal'
            && rhs_type != 'void' {
            return rhs_type.trim_right('*')
        }
    }
    return 'int'
}

fn (mut g Gen) fixed_array_selector_elem_type(sel ast.SelectorExpr) string {
    mut struct_name := ''
    if raw_type := g.get_raw_type(sel.lhs) {
        match raw_type {
            types.Pointer {
                if raw_type.base_type is types.Struct {
                    struct_name = raw_type.base_type.name
                } else if raw_type.base_type is types.Alias {
                    struct_name = raw_type.base_type.name
                }
            }
            types.Struct {
                struct_name = raw_type.name
            }
            types.Alias {
                struct_name = raw_type.name
            }
            else {}
        }
    }
    if struct_name == '' {
        struct_name = g.get_expr_type(sel.lhs).trim_right('*')
    }
    if struct_name != '' {
        field_key := '${struct_name}.${sel.rhs.name}'
        if elem := g.fixed_array_field_elem[field_key] {
            return elem
        }
    }
    if struct_name.contains('__') {
        short_name := struct_name.all_after_last('__')
        short_field_key := '${short_name}.${sel.rhs.name}'
        if elem := g.fixed_array_field_elem[short_field_key] {
            return elem
        }
    }
    return ''
}

fn (mut g Gen) is_fixed_array_selector(sel ast.SelectorExpr) bool {
    if g.fixed_array_selector_elem_type(sel) != '' {
        return true
    }
    return false
}

fn interface_type_names_match(left string, right string) bool {
    left_base := left.trim_right('*')
    right_base := right.trim_right('*')
    return left_base == right_base
        || left_base.all_after_last('__') == right_base.all_after_last('__')
}

fn (mut g Gen) expr_already_has_interface_type(expr ast.Expr, iface_type string) bool {
    expr_type := g.get_expr_type(expr)
    if expr_type != '' && interface_type_names_match(expr_type, iface_type)
        && g.is_interface_type(expr_type.trim_right('*')) {
        return true
    }
    if raw_type := g.get_raw_type(expr) {
        c_type := g.types_type_to_c(raw_type)
        return c_type != '' && interface_type_names_match(c_type, iface_type)
            && g.is_interface_type(c_type.trim_right('*'))
    }
    return false
}

fn (mut g Gen) gen_array_init_expr(node ast.ArrayInitExpr) {
    raw_elem := g.extract_array_elem_type(node.typ)
    // Convert C pointer syntax to mangled name for composite types:
    // Array_int* -> Array_intptr (typedef'd alias)
    elem_type := if raw_elem.ends_with('*')
        && (raw_elem.starts_with('Array_') || raw_elem.starts_with('Map_')) {
        mangle_alias_component(raw_elem)
    } else {
        unmangle_c_ptr_type(raw_elem)
    }
    is_dyn := g.is_dynamic_array_type(node.typ) && !array_init_has_fixed_len_marker(node)
    // Fallback: if dynamic array but elem type couldn't be extracted from type annotation,
    // infer from the first expression (e.g., for [][2]int where inner [2]int has type info)
    mut final_elem := elem_type
    if is_dyn && node.exprs.len > 0 {
        inferred := g.infer_array_init_value_elem_type(node)
        specialized := specialized_generic_elem_type_from_value(final_elem, inferred)
        if specialized != '' {
            final_elem = specialized
        }
    }
    if (final_elem == '' || final_elem == 'int') && is_dyn && node.exprs.len > 0 {
        inferred := g.infer_array_init_value_elem_type(node)
        if inferred != '' && inferred != 'array' && inferred != 'int' {
            final_elem = inferred
        }
    }
    if is_dyn && is_generic_placeholder_c_type_name(final_elem) && node.exprs.len == 1 {
        elem_expr_type := g.get_expr_type(node.exprs[0]).trim_space()
        if elem_expr_type != '' && elem_expr_type !in ['int', 'void', 'void*', 'voidptr']
            && !is_generic_placeholder_c_type_name(elem_expr_type) {
            final_elem = elem_expr_type
        }
    }
    if node.exprs.len > 0 {
        // Has elements
        if final_elem != '' && is_dyn {
            // Dynamic array compound literal: (elem_type[N]){e1, e2, ...}
            g.sb.write_string('(${final_elem}[${node.exprs.len}]){')
            is_iface_elem := g.is_interface_type(final_elem)
            for i in 0 .. node.exprs.len {
                e := node.exprs[i]
                if i > 0 {
                    g.sb.write_string(', ')
                }
                if is_iface_elem && !g.expr_already_has_interface_type(e, final_elem)
                    && g.gen_interface_cast(final_elem, e) {
                    // interface wrapping handled
                } else if g.get_sum_type_variants_for(final_elem).len > 0 {
                    g.gen_type_cast_expr(final_elem, e)
                } else {
                    g.expr(e)
                }
            }
            g.sb.write_string('}')
            return
        }
        // Fixed-size array or untyped: {e1, e2, ...}
        g.sb.write_string('{')
        for i in 0 .. node.exprs.len {
            e := node.exprs[i]
            if i > 0 {
                g.sb.write_string(', ')
            }
            if final_elem != '' && g.get_sum_type_variants_for(final_elem).len > 0 {
                g.gen_type_cast_expr(final_elem, e)
            } else {
                g.expr(e)
            }
        }
        g.sb.write_string('}')
        return
    }
    // Handle fixed array with init: clause (e.g., [3]int{init: 10} → {10, 10, 10})
    if node.init !is ast.EmptyExpr && !is_dyn {
        mut size := 0
        if node.typ is ast.Type && node.typ is ast.ArrayFixedType {
            fixed_typ := node.typ as ast.ArrayFixedType
            if fixed_typ.len is ast.BasicLiteral && fixed_typ.len.kind == .number {
                size = fixed_typ.len.value.int()
            }
        }
        if size > 0 {
            g.sb.write_string('{')
            for i := 0; i < size; i++ {
                if i > 0 {
                    g.sb.write_string(', ')
                }
                g.expr(node.init)
            }
            g.sb.write_string('}')
            return
        }
    }
    // Empty dynamic arrays should have been lowered by transformer to
    // __new_array_with_default_noscan(). Fixed arrays still use C zero-init.
    if !is_dyn {
        g.sb.write_string('{0}')
        return
    }
    g.sb.write_string('(array){0}')
}

fn (mut g Gen) gen_fixed_array_initializer(node ast.ArrayInitExpr) {
    if node.exprs.len > 0 {
        g.sb.write_string('{')
        for i in 0 .. node.exprs.len {
            if i > 0 {
                g.sb.write_string(', ')
            }
            elem := node.exprs[i]
            if !g.gen_fixed_array_initializer_from_expr(elem) {
                g.expr(elem)
            }
        }
        g.sb.write_string('}')
        return
    }
    if node.init !is ast.EmptyExpr {
        size := g.fixed_array_initializer_size(node)
        if size > 0 {
            g.sb.write_string('{')
            for i := 0; i < size; i++ {
                if i > 0 {
                    g.sb.write_string(', ')
                }
                g.expr(node.init)
            }
            g.sb.write_string('}')
            return
        }
    }
    g.sb.write_string('{0}')
}

fn (mut g Gen) gen_fixed_array_initializer_from_expr(expr ast.Expr) bool {
    unwrapped := strip_expr_wrappers(expr)
    match unwrapped {
        ast.ArrayInitExpr {
            g.gen_fixed_array_initializer(unwrapped)
            return true
        }
        ast.CallExpr {
            if unwrapped.lhs !is ast.Ident {
                return false
            }
            fn_name := (unwrapped.lhs as ast.Ident).name
            if fn_name !in ['builtin__new_array_from_c_array_noscan',
                'builtin__new_array_from_c_array', 'new_array_from_c_array'] {
                return false
            }
            if unwrapped.args.len < 4 {
                return false
            }
            array_data := extract_array_init_arg(unwrapped.args[3]) or { return false }
            g.gen_fixed_array_initializer(array_data)
            return true
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) fixed_array_initializer_size(node ast.ArrayInitExpr) int {
    if node.typ is ast.Type && node.typ is ast.ArrayFixedType {
        fixed_typ := node.typ as ast.ArrayFixedType
        resolved := g.expr_to_int_str_with_env(fixed_typ.len)
        if resolved != '0' {
            return resolved.int()
        }
    }
    if node.len !is ast.EmptyExpr {
        resolved := g.expr_to_int_str_with_env(node.len)
        if resolved != '0' {
            return resolved.int()
        }
    }
    return node.exprs.len
}

// extract_array_elem_expr extracts the element type expression from an array type

fn (g &Gen) extract_array_elem_expr(e ast.Expr) ast.Expr {
    match e {
        ast.Type {
            if e is ast.ArrayType {
                return e.elem_type
            }
            if e is ast.ArrayFixedType {
                return e.elem_type
            }
        }
        else {}
    }

    return ast.empty_expr
}

// extract_array_elem_type extracts the element C type from an array type expression

fn (mut g Gen) extract_array_elem_type(e ast.Expr) string {
    elem_expr := g.extract_array_elem_expr(e)
    if elem_expr != ast.empty_expr {
        return g.expr_type_to_c(elem_expr)
    }
    return ''
}

// is_dynamic_array_type checks if the type expression is a dynamic array (ArrayType, not ArrayFixedType)

fn (g &Gen) is_dynamic_array_type(e ast.Expr) bool {
    match e {
        ast.Type {
            if e is ast.ArrayType {
                return true
            }
        }
        else {}
    }

    return false
}

fn array_init_has_fixed_len_marker(node ast.ArrayInitExpr) bool {
    if node.len is ast.PostfixExpr {
        postfix := node.len as ast.PostfixExpr
        return postfix.op == .not && postfix.expr is ast.EmptyExpr
    }
    return false
}

fn extract_array_init_arg(expr ast.Expr) ?ast.ArrayInitExpr {
    unwrapped := strip_expr_wrappers(expr)
    match unwrapped {
        ast.ArrayInitExpr {
            return unwrapped
        }
        ast.PrefixExpr {
            if unwrapped.op == .amp {
                return extract_array_init_arg(unwrapped.expr)
            }
        }
        else {}
    }

    return none
}

fn (mut g Gen) try_emit_const_dynamic_array_call(name string, value ast.Expr) bool {
    base_value := strip_expr_wrappers(value)
    if base_value !is ast.CallExpr {
        return false
    }
    call := base_value as ast.CallExpr
    if call.lhs !is ast.Ident {
        return false
    }
    fn_name := (call.lhs as ast.Ident).name
    if fn_name !in ['builtin__new_array_from_c_array_noscan', 'builtin__new_array_from_c_array',
        'new_array_from_c_array'] {
        return false
    }
    if call.args.len < 4 {
        return false
    }
    array_data := extract_array_init_arg(call.args[3]) or { return false }
    mut elem_type := g.extract_array_elem_type(array_data.typ)
    if elem_type == '' && array_data.exprs.len > 0 {
        elem_type = g.get_expr_type(array_data.exprs[0])
    }
    if elem_type == '' || elem_type == 'array' {
        return false
    }
    // Check that no element contains a function call (not valid in C static initializers)
    for i in 0 .. array_data.exprs.len {
        elem := array_data.exprs[i]
        if g.const_initializer_needs_runtime(elem) {
            return false
        }
    }
    mut len_expr := expr_to_int_str(call.args[0])
    mut cap_expr := expr_to_int_str(call.args[1])
    if len_expr == '0' && array_data.exprs.len > 0 {
        len_expr = '${array_data.exprs.len}'
    }
    if cap_expr == '0' {
        cap_expr = len_expr
    }
    data_name := '__const_array_data_${name}'
    if array_data.exprs.len > 0 {
        g.sb.write_string('static ${elem_type} ${data_name}[${array_data.exprs.len}] = {')
        for i in 0 .. array_data.exprs.len {
            e := array_data.exprs[i]
            if i > 0 {
                g.sb.write_string(', ')
            }
            g.expr(e)
        }
        g.sb.writeln('};')
        g.sb.writeln('array ${name} = ((array){ .data = ${data_name}, .offset = 0, .len = ${len_expr}, .cap = ${cap_expr}, .flags = 0, .element_size = sizeof(${elem_type}) });')
    } else {
        g.sb.writeln('array ${name} = ((array){ .data = NULL, .offset = 0, .len = ${len_expr}, .cap = ${cap_expr}, .flags = 0, .element_size = sizeof(${elem_type}) });')
    }
    return true
}

fn (mut g Gen) gen_fixed_array_cmp_operand(expr ast.Expr, fixed_type string) {
    // For ArrayInitExpr (fixed array literals), wrap in compound literal
    if expr is ast.ArrayInitExpr {
        g.sb.write_string('(${fixed_type})')
        g.expr(expr)
        return
    }
    // Unwrap parens to find ArrayInitExpr inside
    if expr is ast.ParenExpr {
        inner := g.unwrap_parens(expr.expr)
        if inner is ast.ArrayInitExpr {
            g.sb.write_string('(${fixed_type})')
            g.expr(inner)
            return
        }
    }
    g.expr(expr)
}

// gen_typed_array_eq generates inline element-wise array comparison for struct/map element types.
// Uses GCC statement expression: ({ array _a = ...; array _b = ...; bool _eq = ...; ... _eq; })
fn (mut g Gen) gen_typed_array_eq(elem_type string, call_args []ast.Expr) {
    g.sb.write_string('({ array _a = ')
    if g.expr_is_pointer(call_args[0]) {
        g.sb.write_string('*')
    }
    g.expr(call_args[0])
    g.sb.write_string('; array _b = ')
    if g.expr_is_pointer(call_args[1]) {
        g.sb.write_string('*')
    }
    g.expr(call_args[1])
    g.sb.writeln('; bool _eq = (_a.len == _b.len);')
    g.sb.writeln(' for (int _i = 0; _eq && _i < _a.len; _i++) {')
    g.sb.writeln('  ${elem_type} _sa = ((${elem_type}*)_a.data)[_i];')
    g.sb.writeln('  ${elem_type} _sb = ((${elem_type}*)_b.data)[_i];')
    if elem_type.starts_with('Map_') {
        g.sb.writeln('  if (!${elem_type}_map_eq(_sa, _sb)) _eq = false;')
    } else {
        struct_type := g.lookup_struct_type_by_c_name(elem_type)
        if struct_type.fields.len > 0 {
            for field in struct_type.fields {
                fname := field.name
                ftype := field.typ
                match ftype {
                    types.String {
                        g.sb.writeln('  if (!string__eq(_sa.${fname}, _sb.${fname})) _eq = false;')
                    }
                    types.Map {
                        c_type := g.types_type_to_c(ftype)
                        if c_type.starts_with('Map_') {
                            g.sb.writeln('  if (!${c_type}_map_eq(_sa.${fname}, _sb.${fname})) _eq = false;')
                        } else {
                            g.sb.writeln('  if (!map_map_eq(_sa.${fname}, _sb.${fname})) _eq = false;')
                        }
                    }
                    types.Array {
                        g.sb.writeln('  if (!__v2_array_eq(_sa.${fname}, _sb.${fname})) _eq = false;')
                    }
                    else {
                        g.sb.writeln('  if (_sa.${fname} != _sb.${fname}) _eq = false;')
                    }
                }
            }
        } else {
            // Struct not found, fall back to memcmp
            g.sb.writeln('  if (memcmp(&_sa, &_sb, sizeof(${elem_type})) != 0) _eq = false;')
        }
    }
    g.sb.writeln(' }')
    g.sb.write_string(' _eq; })')
}

// parse_fixed_array_elem_type extracts element type and length from "Array_fixed_T_N".
fn parse_fixed_array_elem_type(fixed_type string) (string, int) {
    without_prefix := fixed_type['Array_fixed_'.len..]
    // Find the last underscore followed by digits (the array length)
    for i := without_prefix.len - 1; i >= 0; i-- {
        if without_prefix[i] == `_` {
            len_str := without_prefix[i + 1..]
            elem_type := without_prefix[..i]
            return elem_type, len_str.int()
        }
    }
    return without_prefix, 0
}

// fixed_array_elem_needs_deep_eq returns true if the element type requires deep comparison.
fn fixed_array_elem_needs_deep_eq(elem_type string) bool {
    if elem_type == 'string' || elem_type == 'array' || elem_type.starts_with('Map_') {
        return true
    }
    // Dynamic arrays (Array_T but not Array_fixed_T) always need deep eq
    if elem_type.starts_with('Array_') && !elem_type.starts_with('Array_fixed_') {
        return true
    }
    // For nested fixed arrays (Array_fixed_T_N), recursively check inner element type
    if elem_type.starts_with('Array_fixed_') {
        inner_elem, _ := parse_fixed_array_elem_type(elem_type)
        return fixed_array_elem_needs_deep_eq(inner_elem)
    }
    return false
}

// gen_fixed_array_deep_eq generates element-wise comparison for fixed arrays with non-trivial elements.
// Uses pointers to avoid C array assignment issues (C arrays can't be initialized with =).
// For nested fixed arrays (e.g., [2][2]string), flattens to the innermost non-fixed element type.
fn (mut g Gen) gen_fixed_array_deep_eq(fixed_type string, elem_type string, arr_len int, call_args []ast.Expr) {
    // Flatten nested fixed arrays to innermost element type
    mut flat_elem := elem_type
    mut total_len := arr_len
    for flat_elem.starts_with('Array_fixed_') {
        inner, inner_len := parse_fixed_array_elem_type(flat_elem)
        if inner_len <= 0 {
            break
        }
        total_len *= inner_len
        flat_elem = inner
    }
    // Determine C element type for pointer casting
    c_elem_type := if flat_elem == 'string' {
        'string'
    } else if flat_elem == 'array' || flat_elem.starts_with('Array_') {
        'array'
    } else if flat_elem.starts_with('Map_') {
        flat_elem
    } else {
        flat_elem
    }
    // Cast to flat element pointers (fixed arrays are contiguous in memory)
    g.sb.write_string('({ ${c_elem_type} *_pa = (${c_elem_type}*)')
    g.gen_fixed_array_cmp_operand(call_args[0], fixed_type)
    g.sb.write_string('; ${c_elem_type} *_pb = (${c_elem_type}*)')
    g.gen_fixed_array_cmp_operand(call_args[1], fixed_type)
    g.sb.writeln('; bool _eq = true;')
    g.sb.writeln(' for (int _i = 0; _eq && _i < ${total_len}; _i++) {')
    if flat_elem == 'string' {
        g.sb.writeln('  if (!string__eq(_pa[_i], _pb[_i])) _eq = false;')
    } else if flat_elem == 'array' || flat_elem.starts_with('Array_') {
        g.sb.writeln('  if (!__v2_array_eq(_pa[_i], _pb[_i])) _eq = false;')
    } else if flat_elem.starts_with('Map_') {
        g.sb.writeln('  if (!${flat_elem}_map_eq(_pa[_i], _pb[_i])) _eq = false;')
    }
    g.sb.writeln(' }')
    g.sb.write_string(' _eq; })')
}