// 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 v2.ast
import v2.types

struct InterfaceMethodInfo {
    name           string // method name (e.g., "draw")
    cast_signature string // function pointer cast (e.g., "int (*)(void*)")
    ret_type       string
    param_types    []string
}

struct InterfaceWrapperSpec {
    fn_name       string
    concrete_type string
    method        InterfaceMethodInfo
}

struct EmbeddedMethodResolve {
    fn_name       string
    owner_path    string
    receiver_type string
}

struct InterfaceDataFieldInfo {
    name   string
    c_type string
}

fn (mut g Gen) interface_method_info_from_ast(name string, fn_type ast.FnType) InterfaceMethodInfo {
    mut ret := 'void'
    if fn_type.return_type !is ast.EmptyExpr {
        ret = g.expr_type_to_c(fn_type.return_type)
    }
    mut param_types := []string{}
    mut cast_sig := '${ret} (*)(void*'
    for param in fn_type.params {
        mut t := g.expr_type_to_c(param.typ)
        if param.is_mut && !t.ends_with('*') {
            t += '*'
        }
        cast_sig += ', ${t}'
        param_types << t
    }
    cast_sig += ')'
    return InterfaceMethodInfo{
        name:           name
        cast_signature: cast_sig
        ret_type:       ret
        param_types:    param_types
    }
}

fn (mut g Gen) interface_method_info_from_raw(name string, raw types.Type) ?InterfaceMethodInfo {
    if !type_has_valid_data(raw) {
        return none
    }
    match raw {
        types.FnType {
            mut ret := 'void'
            if ret_type := raw.get_return_type() {
                ret = g.types_type_to_c(ret_type)
            }
            mut param_types := []string{}
            for param_type in raw.get_param_types() {
                param_types << g.types_type_to_c(param_type)
            }
            mut cast_sig := '${ret} (*)(void*'
            for param_type in param_types {
                cast_sig += ', ${param_type}'
            }
            cast_sig += ')'
            return InterfaceMethodInfo{
                name:           name
                cast_signature: cast_sig
                ret_type:       ret
                param_types:    param_types
            }
        }
        types.Alias {
            if raw.base_type is types.FnType {
                return g.interface_method_info_from_raw(name, raw.base_type)
            }
            return none
        }
        else {
            return none
        }
    }
}

fn (mut g Gen) interface_method_info(field ast.FieldDecl) ?InterfaceMethodInfo {
    if !field.is_interface_method {
        return none
    }
    if fn_type := g.get_fn_type_from_expr(field.typ) {
        return g.interface_method_info_from_ast(field.name, fn_type)
    }
    if raw := g.get_raw_type(field.typ) {
        // Only treat as method if the AST type was directly a FnType,
        // NOT if it's a named type alias for a function (e.g. `on_scroll_change ScrollViewChangedFn`).
        // Named fn-type aliases are interface data fields, not vtable methods.
        if raw is types.Alias && raw.base_type is types.FnType {
            // This is a fn-type alias field, not a method declaration
            return none
        }
        return g.interface_method_info_from_raw(field.name, raw)
    }
    return none
}

fn interface_type_id_for_name(name string) int {
    match name {
        'None__' {
            return 1
        }
        'Error' {
            return 2
        }
        'MessageError' {
            return 3
        }
        else {
            // Derive a deterministic non-zero id for all other concrete/interface types.
            // This keeps `if iface is ConcreteType` checks working beyond IError variants.
            if name.len == 0 {
                return 0
            }
            mut hash := u32(2166136261)
            for b in name.bytes() {
                hash ^= u32(b)
                hash *= 16777619
            }
            mut type_id := int(hash & 0x7fffffff)
            if type_id <= 3 {
                type_id += 4
            }
            return type_id
        }
    }
}

fn interface_wrapper_name(iface_name string, concrete_type string, method_name string) string {
    return '__iface_wrap_' + mangle_alias_component(iface_name) + '_' +
        mangle_alias_component(concrete_type) + '_' + method_name
}

fn interface_clone_fn_name(iface_name string) string {
    return '__v_interface_clone__' + mangle_alias_component(iface_name)
}

fn (mut g Gen) collect_interface_wrapper_specs() {
    if g.interface_wrapper_specs.len > 0 {
        return
    }
    mut iface_names := g.interface_methods.keys()
    iface_names.sort()
    mut fn_names := g.fn_param_is_ptr.keys()
    fn_names.sort()
    for iface_name in iface_names {
        methods := g.interface_methods[iface_name]
        for method in methods {
            suffix := '__${method.name}'
            for fn_name in fn_names {
                if !fn_name.ends_with(suffix) {
                    continue
                }
                ptr_params := g.fn_param_is_ptr[fn_name] or { continue }
                if ptr_params.len == 0 || ptr_params[0] {
                    // Pointer receivers can be called directly through void*.
                    continue
                }
                fn_params := g.fn_param_types[fn_name] or { continue }
                if fn_params.len != method.param_types.len + 1 {
                    continue
                }
                if fn_ret := g.fn_return_types[fn_name] {
                    if fn_ret != method.ret_type {
                        continue
                    }
                }
                concrete_type := fn_name[..fn_name.len - suffix.len]
                receiver_type := fn_params[0].trim_right('*')
                if receiver_type != concrete_type {
                    continue
                }
                wrapper_name := interface_wrapper_name(iface_name, concrete_type, method.name)
                if wrapper_name in g.interface_wrapper_specs {
                    continue
                }
                g.interface_wrapper_specs[wrapper_name] = InterfaceWrapperSpec{
                    fn_name:       fn_name
                    concrete_type: concrete_type
                    method:        method
                }
            }
        }
    }
    for iface_name in iface_names {
        methods := g.interface_methods[iface_name]
        if g.has_flat() {
            for i in 0 .. g.flat.files.len {
                fc := g.flat.file_cursor(i)
                g.set_file_cursor_module(fc)
                stmts := fc.stmts()
                for j in 0 .. stmts.len() {
                    stmt := stmts.at(j)
                    if stmt.kind() != .stmt_struct_decl {
                        continue
                    }
                    decl := stmt.struct_decl()
                    if decl.language != .v {
                        continue
                    }
                    concrete_type := g.get_struct_name(decl)
                    if concrete_type == '' || g.is_interface_type(concrete_type) {
                        continue
                    }
                    for method in methods {
                        direct_name := '${concrete_type}__${method.name}'
                        if direct_name in g.fn_param_is_ptr || direct_name in g.fn_return_types {
                            continue
                        }
                        resolved := g.resolve_embedded_method_info(concrete_type, method.name) or {
                            continue
                        }
                        wrapper_name := interface_wrapper_name(iface_name, concrete_type,
                            method.name)
                        if wrapper_name in g.interface_wrapper_specs {
                            continue
                        }
                        g.interface_wrapper_specs[wrapper_name] = InterfaceWrapperSpec{
                            fn_name:       resolved.fn_name
                            concrete_type: concrete_type
                            method:        method
                        }
                    }
                }
            }
            continue
        }
        for file in g.files {
            g.set_file_module(file)
            for stmt in file.stmts {
                if stmt is ast.StructDecl && stmt.language == .v {
                    concrete_type := g.get_struct_name(stmt)
                    if concrete_type == '' || g.is_interface_type(concrete_type) {
                        continue
                    }
                    for method in methods {
                        direct_name := '${concrete_type}__${method.name}'
                        if direct_name in g.fn_param_is_ptr || direct_name in g.fn_return_types {
                            continue
                        }
                        resolved := g.resolve_embedded_method_info(concrete_type, method.name) or {
                            continue
                        }
                        wrapper_name := interface_wrapper_name(iface_name, concrete_type,
                            method.name)
                        if wrapper_name in g.interface_wrapper_specs {
                            continue
                        }
                        g.interface_wrapper_specs[wrapper_name] = InterfaceWrapperSpec{
                            fn_name:       resolved.fn_name
                            concrete_type: concrete_type
                            method:        method
                        }
                    }
                }
            }
        }
    }
}

fn (mut g Gen) emit_interface_method_wrapper_decls() {
    mut names := g.interface_wrapper_specs.keys()
    names.sort()
    for name in names {
        spec := g.interface_wrapper_specs[name]
        g.sb.write_string('static ${spec.method.ret_type} ${name}(void* _obj')
        for i, param_type in spec.method.param_types {
            g.sb.write_string(', ${param_type} _arg${i}')
        }
        g.sb.writeln(');')
    }
    if names.len > 0 {
        g.sb.writeln('')
    }
}

fn (mut g Gen) emit_interface_method_wrapper_body(name string, spec InterfaceWrapperSpec) {
    g.sb.write_string('static ${spec.method.ret_type} ${name}(void* _obj')
    for i, param_type in spec.method.param_types {
        g.sb.write_string(', ${param_type} _arg${i}')
    }
    g.sb.writeln(') {')
    if spec.method.ret_type != 'void' {
        g.sb.write_string('\treturn ')
    } else {
        g.sb.write_string('\t')
    }
    mut receiver_type := spec.concrete_type
    if param_types := g.fn_param_types[spec.fn_name] {
        if param_types.len > 0 {
            receiver_type = param_types[0].trim_space().trim_right('*')
        }
    }
    ptr_params := g.fn_param_is_ptr[spec.fn_name] or { []bool{} }
    receiver_is_ptr := ptr_params.len > 0 && ptr_params[0]
    owner_path := if receiver_type != spec.concrete_type {
        g.embedded_owner_path_for_type(spec.concrete_type, receiver_type)
    } else {
        ''
    }
    g.sb.write_string('${spec.fn_name}(')
    if owner_path != '' {
        if receiver_is_ptr {
            g.sb.write_string('&(((${spec.concrete_type}*)_obj)->${owner_path})')
        } else {
            g.sb.write_string('(((${spec.concrete_type}*)_obj)->${owner_path})')
        }
    } else if receiver_is_ptr {
        g.sb.write_string('((${spec.concrete_type}*)_obj)')
    } else {
        g.sb.write_string('*(((${spec.concrete_type}*)_obj))')
    }
    for i in 0 .. spec.method.param_types.len {
        g.sb.write_string(', _arg${i}')
    }
    g.sb.writeln(');')
    g.sb.writeln('}')
    g.sb.writeln('')
}

fn (mut g Gen) emit_needed_interface_method_wrappers() {
    mut names := g.needed_interface_wrappers.keys()
    names.sort()
    if names.len == 0 {
        return
    }
    for name in names {
        spec := g.interface_wrapper_specs[name] or { continue }
        g.emit_interface_method_wrapper_body(name, spec)
    }
}

fn (mut g Gen) emit_interface_clone_decls() {
    mut names := g.emitted_interface_bodies.keys()
    names.sort()
    for name in names {
        g.sb.writeln('static inline ${name} ${interface_clone_fn_name(name)}(${name} x);')
    }
    if names.len > 0 {
        g.sb.writeln('')
    }
}

fn (mut g Gen) interface_clone_ptr_expr(ctype string, ptr_name string) string {
    if ctype == 'string' || ctype == 'builtin__string' {
        return '(${ctype}*)memdup(&(${ctype}){string__clone(*(${ctype}*)${ptr_name})}, sizeof(${ctype}))'
    }
    if ctype == 'map' || ctype.starts_with('Map_') {
        return '(${ctype}*)memdup(&(${ctype}){map__clone((${ctype}*)${ptr_name})}, sizeof(${ctype}))'
    }
    if ctype == 'array' || ctype.starts_with('Array_') {
        depth := g.array_clone_depth_for_c_type(ctype)
        return '(${ctype}*)memdup(&(${ctype}){array__clone_to_depth((${ctype}*)${ptr_name}, ${depth})}, sizeof(${ctype}))'
    }
    return '(${ctype}*)memdup(${ptr_name}, sizeof(${ctype}))'
}

fn (mut g Gen) emit_interface_clone_body(iface_name string) {
    clone_fn := interface_clone_fn_name(iface_name)
    g.sb.writeln('static inline ${iface_name} ${clone_fn}(${iface_name} x) {')
    g.sb.writeln('\tif (x._object == 0) {')
    g.sb.writeln('\t\treturn x;')
    g.sb.writeln('\t}')
    data_fields := g.interface_data_fields[iface_name] or { []InterfaceDataFieldInfo{} }
    for ctype in g.find_concrete_types_for_interface(iface_name) {
        type_short := if ctype.contains('__') {
            ctype.all_after_last('__')
        } else {
            ctype
        }
        type_id := interface_type_id_for_name(type_short)
        clone_ptr_expr := g.interface_clone_ptr_expr(ctype, 'x._object')
        g.sb.writeln('\tif (x._type_id == ${type_id}) {')
        g.sb.writeln('\t\t${ctype}* _clone = ${clone_ptr_expr};')
        g.sb.writeln('\t\t${iface_name} cloned = x;')
        g.sb.writeln('\t\tcloned._object = (void*)_clone;')
        for df in data_fields {
            owner := g.embedded_owner_for(ctype, df.name)
            if owner != '' {
                g.sb.writeln('\t\tcloned.${df.name} = &(_clone->${owner}.${df.name});')
            } else {
                g.sb.writeln('\t\tcloned.${df.name} = &(_clone->${df.name});')
            }
        }
        g.sb.writeln('\t\treturn cloned;')
        g.sb.writeln('\t}')
    }
    g.sb.writeln('\treturn x;')
    g.sb.writeln('}')
    g.sb.writeln('')
}

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

fn (mut g Gen) emit_option_string_clone_helper() {
    if '_option_string' !in g.option_aliases {
        return
    }
    g.sb.writeln('static _option_string builtin__Option_string__clone(_option_string s) {')
    g.sb.writeln('\tif (s.state == 0) {')
    g.sb.writeln('\t\tstring _val = string__clone(*(string*)(((u8*)(&s.err)) + sizeof(IError)));')
    g.sb.writeln('\t\t_option_string _opt = (_option_string){ .state = 2 };')
    g.sb.writeln('\t\t_option_ok(&_val, (_option*)&_opt, sizeof(_val));')
    g.sb.writeln('\t\treturn _opt;')
    g.sb.writeln('\t}')
    g.sb.writeln('\treturn s;')
    g.sb.writeln('}')
    g.sb.writeln('')
}

fn (mut g Gen) struct_type_embeds_error(st types.Struct) bool {
    for embedded in st.embedded {
        embedded_c := g.types_type_to_c(embedded)
        if short_type_name(embedded_c) in ['Error', 'MessageError']
            || ('${embedded_c}__msg' in g.fn_return_types
            && '${embedded_c}__code' in g.fn_return_types) {
            return true
        }
        live_emb := if embedded.fields.len == 0 {
            g.lookup_struct_type_by_c_name(embedded_c)
        } else {
            embedded
        }
        if (live_emb.fields.len > 0 || live_emb.embedded.len > 0)
            && g.struct_type_embeds_error(live_emb) {
            return true
        }
    }
    return false
}

fn (mut g Gen) struct_c_type_embeds_error(c_type string) bool {
    st := g.lookup_struct_type_by_c_name(c_type.trim_right('*'))
    if st.fields.len == 0 && st.embedded.len == 0 {
        return false
    }
    return g.struct_type_embeds_error(st)
}

fn (mut g Gen) concrete_ierror_base_for_c_type(c_type string) string {
    base := g.qualify_ierror_concrete_base(c_type.trim_right('*'))
    if base == '' || base == 'int' || base in ['IError', 'builtin__IError'] {
        return ''
    }
    if g.c_type_has_ierror_shape(base) || g.struct_c_type_embeds_error(base) {
        return base
    }
    return ''
}

fn (mut g Gen) c_type_has_ierror_shape(base string) bool {
    if '${base}__msg' in g.fn_return_types {
        return true
    }
    mut names := [base]
    if base.contains('__') {
        names << base.all_after_last('__')
    }
    if g.env != unsafe { nil } {
        for name in names {
            if _ := g.env.lookup_method(name, 'msg') {
                return true
            }
        }
    }
    return false
}

fn is_ierror_c_type(c_type string) bool {
    mut typ := c_type.trim_space().trim_right('*').trim_space()
    if typ.starts_with('struct ') {
        typ = typ['struct '.len..].trim_space()
    }
    return is_ierror_interface_name(typ)
}

fn ierror_type_label_for_base(base string) string {
    if base.contains('__') {
        short_name := base.all_after_last('__')
        if short_name != '' {
            return short_name
        }
    }
    return base
}

fn (mut g Gen) gen_ierror_from_base_expr(base string, expr ast.Expr, expr_type string) bool {
    if base == '' || base == 'int' || base in ['IError', 'builtin__IError'] {
        return false
    }
    g.ierror_wrapper_bases[base] = true
    g.needed_ierror_wrapper_bases[base] = true
    type_label := ierror_type_label_for_base(base)
    type_id := interface_type_id_for_name(type_label)
    if expr_type.ends_with('*') {
        g.sb.write_string('((IError){._object = (void*)(')
        g.expr(expr)
        g.sb.write_string('), ._type_id = ${type_id}, .type_name = IError_${base}_type_name_wrapper, .msg = IError_${base}_msg_wrapper, .code = IError_${base}_code_wrapper})')
        return true
    }
    tmp_name := '_ierr_obj${g.tmp_counter}'
    g.tmp_counter++
    malloc_call := g.c_heap_malloc_call('sizeof(${base})')
    g.sb.write_string('({ ${base}* ${tmp_name} = (${base}*)${malloc_call}; *${tmp_name} = ')
    g.expr(expr)
    g.sb.write_string('; ((IError){._object = (void*)${tmp_name}, ._type_id = ${type_id}, .type_name = IError_${base}_type_name_wrapper, .msg = IError_${base}_msg_wrapper, .code = IError_${base}_code_wrapper}); })')
    return true
}

fn (mut g Gen) gen_ierror_from_concrete_expr(expr ast.Expr, expr_type string) bool {
    mut base := ''
    expr_base := g.ierror_concrete_base_for_expr(expr)
    if expr_base != '' {
        base = g.concrete_ierror_base_for_c_type(expr_base)
    }
    if base == '' {
        base = g.concrete_ierror_base_for_c_type(expr_type)
    }
    if base == '' {
        return false
    }
    return g.gen_ierror_from_base_expr(base, expr, expr_type)
}

fn (mut g Gen) collect_ierror_wrapper_bases() {
    for fn_name, ret_type in g.fn_return_types {
        if !fn_name.ends_with('__msg') || ret_type != 'string' {
            continue
        }
        base := fn_name[..fn_name.len - '__msg'.len]
        if base == '' || !is_c_identifier_like(base) {
            continue
        }
        g.ierror_wrapper_bases[base] = true
    }
    saved_module := g.cur_module
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(i)
            g.set_file_cursor_module(fc)
            stmts := fc.stmts()
            for j in 0 .. stmts.len() {
                stmt := stmts.at(j)
                if stmt.kind() == .stmt_struct_decl {
                    decl := stmt.struct_decl()
                    if decl.language == .v && decl.embedded.len > 0 {
                        base := g.get_struct_name(decl)
                        if g.struct_c_type_embeds_error(base) {
                            g.ierror_wrapper_bases[base] = true
                        }
                    }
                } else if stmt.kind() == .stmt_const_decl {
                    const_decl := stmt.const_decl()
                    for field in const_decl.fields {
                        if base := g.ierror_const_wrapper_base(field.value) {
                            g.ierror_wrapper_bases[base] = true
                        }
                    }
                }
            }
        }
        g.cur_module = saved_module
        return
    }
    for file in g.files {
        g.set_file_module(file)
        for stmt in file.stmts {
            if stmt is ast.StructDecl && stmt.language == .v && stmt.embedded.len > 0 {
                base := g.get_struct_name(stmt)
                if g.struct_c_type_embeds_error(base) {
                    g.ierror_wrapper_bases[base] = true
                }
            } else if stmt is ast.ConstDecl {
                const_decl := stmt as ast.ConstDecl
                for field in const_decl.fields {
                    if base := g.ierror_const_wrapper_base(field.value) {
                        g.ierror_wrapper_bases[base] = true
                    }
                }
            }
        }
    }
    g.cur_module = saved_module
}

fn (mut g Gen) ierror_const_wrapper_base(expr ast.Expr) ?string {
    match expr {
        ast.CastExpr {
            type_name := g.expr_type_to_c(expr.typ)
            if type_name in ['IError', 'builtin__IError'] {
                mut base :=
                    g.raw_concrete_type_for_interface_value(type_name, expr.expr).trim_right('*')
                if base == '' || base == 'int' || base in ['IError', 'builtin__IError'] {
                    base = g.ierror_init_expr_base(expr.expr) or { '' }
                }
                base = g.qualify_ierror_concrete_base(base.trim_right('*'))
                if base != '' && base != 'int' && base !in ['IError', 'builtin__IError'] {
                    return base
                }
            }
            return g.ierror_const_wrapper_base(expr.expr)
        }
        ast.ParenExpr {
            return g.ierror_const_wrapper_base(expr.expr)
        }
        else {
            return none
        }
    }
}

fn (mut g Gen) ierror_init_expr_base(expr ast.Expr) ?string {
    match expr {
        ast.PrefixExpr {
            return g.ierror_init_expr_base(expr.expr)
        }
        ast.ParenExpr {
            return g.ierror_init_expr_base(expr.expr)
        }
        ast.InitExpr {
            base := g.expr_type_to_c(expr.typ).trim_right('*')
            if base != '' && base != 'int' {
                return base
            }
        }
        else {}
    }

    return none
}

fn (mut g Gen) mark_needed_ierror_wrapper_from_ident(name string) {
    base := ierror_wrapper_base_from_ident(name)
    if base == '' {
        return
    }
    g.needed_ierror_wrapper_bases[base] = true
}

fn (g &Gen) should_emit_ierror_wrappers() bool {
    return g.has_emitted_ierror_body()
}

fn (g &Gen) has_emitted_ierror_body() bool {
    for name, _ in g.emitted_interface_bodies {
        if is_ierror_interface_name(name) {
            return true
        }
    }
    return false
}

fn (mut g Gen) emit_ierror_wrapper_decls() {
    if !g.should_emit_ierror_wrappers() {
        return
    }
    g.collect_ierror_wrapper_bases()
    mut bases := g.ierror_wrapper_bases.keys()
    bases.sort()
    for base in bases {
        g.sb.writeln('static string IError_${base}_type_name_wrapper(void* _obj);')
        g.sb.writeln('static string IError_${base}_msg_wrapper(void* _obj);')
        g.sb.writeln('static int IError_${base}_code_wrapper(void* _obj);')
    }
    if bases.len > 0 {
        g.sb.writeln('')
    }
}

fn (mut g Gen) emit_ierror_wrapper_body(base string) {
    type_label := ierror_type_label_for_base(base)
    g.sb.writeln('static string IError_${base}_type_name_wrapper(void* _obj) {')
    g.sb.writeln('\t(void)_obj;')
    g.sb.writeln('\treturn ${c_static_v_string_expr(type_label)};')
    g.sb.writeln('}')
    g.sb.writeln('static string IError_${base}_msg_wrapper(void* _obj) {')
    if '${base}__msg' in g.fn_return_types {
        g.sb.writeln('\treturn ${base}__msg(*(${base}*)_obj);')
    } else if resolved := g.resolve_embedded_method_info(base, 'msg') {
        if params := g.fn_param_is_ptr[resolved.fn_name] {
            if params.len > 0 && params[0] {
                g.sb.writeln('\treturn ${resolved.fn_name}(&(((${base}*)_obj)->${resolved.owner_path}));')
            } else {
                g.sb.writeln('\treturn ${resolved.fn_name}(((${base}*)_obj)->${resolved.owner_path});')
            }
        } else {
            g.sb.writeln('\treturn ${resolved.fn_name}(((${base}*)_obj)->${resolved.owner_path});')
        }
    } else {
        g.sb.writeln('\t(void)_obj;')
        g.sb.writeln('\treturn ${c_empty_v_string_expr()};')
    }
    g.sb.writeln('}')
    g.sb.writeln('static int IError_${base}_code_wrapper(void* _obj) {')
    code_fn := '${base}__code'
    if code_fn in g.fn_return_types {
        g.sb.writeln('\treturn ${base}__code(*(${base}*)_obj);')
    } else if resolved := g.resolve_embedded_method_info(base, 'code') {
        if params := g.fn_param_is_ptr[resolved.fn_name] {
            if params.len > 0 && params[0] {
                g.sb.writeln('\treturn ${resolved.fn_name}(&(((${base}*)_obj)->${resolved.owner_path}));')
            } else {
                g.sb.writeln('\treturn ${resolved.fn_name}(((${base}*)_obj)->${resolved.owner_path});')
            }
        } else {
            g.sb.writeln('\treturn ${resolved.fn_name}(((${base}*)_obj)->${resolved.owner_path});')
        }
    } else {
        g.sb.writeln('\t(void)_obj;')
        g.sb.writeln('\treturn 1;')
    }
    g.sb.writeln('}')
}

fn (mut g Gen) emit_fn_decl_by_c_name(fn_name string) {
    if fn_name == '' || 'fn_${fn_name}' in g.emitted_types {
        return
    }
    saved_file_name := g.cur_file_name
    saved_module := g.cur_module
    saved_import_modules := g.cur_import_modules.clone()
    defer {
        g.cur_file_name = saved_file_name
        g.cur_module = saved_module
        g.cur_import_modules = saved_import_modules.clone()
        g.is_module_ident_cache.clear()
        g.resolved_module_names.clear()
    }
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(i)
            g.set_file_cursor_module(fc)
            if (g.emit_modules.len > 0 || g.emit_files.len > 0) && !g.should_emit_current_file() {
                continue
            }
            stmts := fc.stmts()
            for j in 0 .. stmts.len() {
                stmt := stmts.at(j)
                if stmt.kind() != .stmt_fn_decl {
                    continue
                }
                decl_sig := stmt.fn_decl_signature()
                if g.get_fn_name(decl_sig) == fn_name {
                    decl := stmt.fn_decl()
                    g.gen_fn_decl_with_name(decl, fn_name)
                    return
                }
            }
        }
        return
    }
    for file in g.files {
        g.set_file_module(file)
        if (g.emit_modules.len > 0 || g.emit_files.len > 0) && !g.should_emit_current_file() {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.FnDecl && g.get_fn_name(stmt) == fn_name {
                g.gen_fn_decl_with_name(stmt, fn_name)
                return
            }
        }
    }
}

fn (mut g Gen) emit_ierror_wrapper_dependencies(base string) {
    for method_name in ['msg', 'code'] {
        direct_name := '${base}__${method_name}'
        if direct_name in g.fn_return_types || direct_name in g.v_fn_return_types {
            g.emit_fn_decl_by_c_name(direct_name)
            continue
        }
        if resolved := g.resolve_embedded_method_info(base, method_name) {
            g.emit_fn_decl_by_c_name(resolved.fn_name)
        }
    }
}

fn (mut g Gen) emit_needed_ierror_wrappers() {
    if !g.should_emit_ierror_wrappers() {
        return
    }
    mut bases := g.needed_ierror_wrapper_bases.keys()
    bases.sort()
    if bases.len == 0 {
        return
    }
    mut emitted_any := false
    for base in bases {
        if base !in g.ierror_wrapper_bases {
            continue
        }
        g.emit_ierror_wrapper_dependencies(base)
        g.emit_ierror_wrapper_body(base)
        emitted_any = true
    }
    if emitted_any {
        g.sb.writeln('')
    }
}

fn (mut g Gen) get_interface_name(node ast.InterfaceDecl) string {
    if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin' {
        return '${g.cur_module}__${node.name}'
    }
    return node.name
}

fn (g &Gen) lookup_interface_data_field(iface_name string, field_name string) ?InterfaceDataFieldInfo {
    mut candidates := []string{cap: 3}
    candidates << iface_name
    if iface_name.contains('__') {
        candidates << iface_name.all_after_last('__')
    }
    for candidate in candidates {
        if fields := g.interface_data_fields[candidate] {
            for field in fields {
                if field.name == field_name {
                    return field
                }
            }
        }
    }
    return none
}

fn (mut g Gen) selector_interface_data_field(sel ast.SelectorExpr) ?InterfaceDataFieldInfo {
    if raw_type := g.get_raw_type(sel.lhs) {
        match raw_type {
            types.Interface {
                return g.lookup_interface_data_field(g.types_type_to_c(raw_type), sel.rhs.name)
            }
            types.Pointer {
                if raw_type.base_type is types.Interface {
                    return g.lookup_interface_data_field(g.types_type_to_c(raw_type.base_type),
                        sel.rhs.name)
                }
            }
            else {}
        }
    }
    lhs_type := g.get_expr_type(sel.lhs)
    if lhs_type != '' {
        if field := g.lookup_interface_data_field(lhs_type, sel.rhs.name) {
            return field
        }
    }
    return none
}

fn (g &Gen) interface_type_ready(type_name string) bool {
    typ := type_name.trim_space()
    if typ == '' || typ == 'void' {
        return true
    }
    if typ in primitive_types {
        return true
    }
    if g.is_c_type_name(typ) {
        return true
    }
    if typ.ends_with('*') || typ.ends_with('ptr') {
        return true
    }
    if typ == 'string' || typ == 'builtin__string' {
        return 'body_string' in g.emitted_types || 'body_builtin__string' in g.emitted_types
    }
    if typ.starts_with('_option_') {
        return typ in g.emitted_option_structs
    }
    if typ.starts_with('_result_') {
        return typ in g.emitted_result_structs
    }
    if typ.starts_with('Array_fixed_') {
        return 'body_${typ}' in g.emitted_types || 'alias_${typ}' in g.emitted_types
    }
    if typ == 'array' || typ.starts_with('Array_') || typ in g.array_aliases {
        return 'body_array' in g.emitted_types
    }
    if typ == 'map' || typ.starts_with('Map_') || typ in g.map_aliases {
        return 'body_map' in g.emitted_types
    }
    return 'body_${typ}' in g.emitted_types || 'enum_${typ}' in g.emitted_types
        || 'alias_${typ}' in g.emitted_types
}

fn (mut g Gen) interface_fields_resolved(node ast.InterfaceDecl) bool {
    if !g.interface_type_ready('string') {
        return false
    }
    for field in node.fields {
        if method := g.interface_method_info(field) {
            if !g.interface_type_ready(method.ret_type) {
                return false
            }
            for param_type in method.param_types {
                if !g.interface_type_ready(param_type) {
                    return false
                }
            }
            continue
        }
        field_type := g.field_type_name(field.typ)
        if !g.interface_type_ready(field_type) {
            return false
        }
    }
    return true
}

// resolve_embedded_method checks if a method exists on an embedded struct type.
// For example, ssl__SSLConn embeds openssl__SSLConn, so ssl__SSLConn__addr
// resolves to openssl__SSLConn__addr.
fn (mut g Gen) resolve_embedded_method(struct_name string, method_name string) string {
    if resolved := g.resolve_embedded_method_info(struct_name, method_name) {
        return resolved.fn_name
    }
    return ''
}

fn (mut g Gen) resolve_embedded_method_info(struct_name string, method_name string) ?EmbeddedMethodResolve {
    st := g.lookup_struct_type_by_c_name(struct_name)
    for emb in st.embedded {
        emb_c_name := g.types_type_to_c(types.Type(emb)).trim_right('*')
        if emb_c_name == '' {
            continue
        }
        owner := embedded_owner_field_name(emb_c_name)
        candidate := '${emb_c_name}__${method_name}'
        if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
            return EmbeddedMethodResolve{
                fn_name:       candidate
                owner_path:    owner
                receiver_type: emb_c_name
            }
        }
        nested := g.resolve_embedded_method_info(emb_c_name, method_name) or { continue }
        return EmbeddedMethodResolve{
            fn_name:       nested.fn_name
            owner_path:    '${owner}.${nested.owner_path}'
            receiver_type: nested.receiver_type
        }
    }
    return none
}

fn (mut g Gen) embedded_owner_path_for_type(struct_name string, target_type string) string {
    st := g.lookup_struct_type_by_c_name(struct_name)
    target_base := target_type.trim_right('*')
    for emb in st.embedded {
        emb_c_name := g.types_type_to_c(types.Type(emb)).trim_right('*')
        if emb_c_name == '' {
            continue
        }
        owner := embedded_owner_field_name(emb_c_name)
        if emb_c_name == target_base || short_type_name(emb_c_name) == short_type_name(target_base) {
            return owner
        }
        nested := g.embedded_owner_path_for_type(emb_c_name, target_base)
        if nested != '' {
            return '${owner}.${nested}'
        }
    }
    return ''
}

fn (mut g Gen) resolve_embedded_interface_fields(emb_name string) ?[]ast.FieldDecl {
    if decl := g.interface_decls[emb_name] {
        mut fields := []ast.FieldDecl{}
        // Recursively resolve further embeddings
        for emb_expr in decl.embedded {
            inner_name := g.expr_type_to_c(emb_expr)
            if inner_name != '' {
                if inner_fields := g.resolve_embedded_interface_fields(inner_name) {
                    fields << inner_fields
                }
            }
        }
        fields << decl.fields
        return fields
    }
    return none
}

fn (mut g Gen) gen_interface_decl(node ast.InterfaceDecl) {
    name := g.get_interface_name(node)
    body_key := 'body_${name}'
    if body_key in g.emitted_types {
        return
    }
    g.emitted_types[body_key] = true

    g.sb.writeln('struct ${name} {')
    g.sb.writeln('\tvoid* _object;')
    g.sb.writeln('\tint _type_id;')
    mut has_type_name := false
    for field in node.fields {
        if field.name == 'type_name' {
            has_type_name = true
            break
        }
    }
    if !has_type_name {
        g.sb.writeln('\tstring (*type_name)(void*);')
    }
    // Collect all fields including those from embedded interfaces
    mut all_fields := []ast.FieldDecl{}
    for emb_expr in node.embedded {
        emb_name := g.expr_type_to_c(emb_expr)
        if emb_name != '' {
            // Look up the embedded interface declaration and include its fields
            if emb_fields := g.resolve_embedded_interface_fields(emb_name) {
                all_fields << emb_fields
            }
        }
    }
    all_fields << node.fields
    // Generate function pointers for each method
    mut methods := []InterfaceMethodInfo{}
    mut data_fields := []InterfaceDataFieldInfo{}
    for field in all_fields {
        if method := g.interface_method_info(field) {
            g.sb.write_string('\t${method.ret_type} (*${method.name})(void*')
            for param_type in method.param_types {
                g.sb.write_string(', ${param_type}')
            }
            g.sb.writeln(');')
            methods << method
            continue
        }
        // IError.msg() and IError.code() — the AST may not expose the fn
        // type, but the C layout requires function pointer fields.
        if name == 'IError' && field.name == 'msg' {
            info := InterfaceMethodInfo{
                name:           'msg'
                cast_signature: 'string (*)(void*)'
                ret_type:       'string'
                param_types:    []string{}
            }
            g.sb.writeln('\tstring (*msg)(void*);')
            methods << info
            continue
        }
        if name == 'IError' && field.name == 'code' {
            info := InterfaceMethodInfo{
                name:           'code'
                cast_signature: 'int (*)(void*)'
                ret_type:       'int'
                param_types:    []string{}
            }
            g.sb.writeln('\tint (*code)(void*);')
            methods << info
            continue
        }
        // Regular field
        t := g.expr_type_to_c(field.typ)
        // Match the v1 C layout for interface data fields: store pointers to the
        // concrete value's fields instead of embedding copies by value. This avoids
        // impossible recursive layouts like `?Interface` inside the interface itself.
        g.sb.writeln('\t${t}* ${field.name};')
        data_fields << InterfaceDataFieldInfo{
            name:   field.name
            c_type: t
        }
    }
    g.interface_methods[name] = methods
    g.interface_data_fields[name] = data_fields
    g.sb.writeln('};')
    g.sb.writeln('')
    g.emitted_interface_bodies[name] = true
}

// find_concrete_types_for_interface returns all concrete type names that implement
// the given interface (i.e., have all required methods AND data fields).
fn (mut g Gen) find_concrete_types_for_interface(iface_name string) []string {
    methods := g.interface_methods[iface_name] or { return [] }
    data_fields := g.interface_data_fields[iface_name] or { []InterfaceDataFieldInfo{} }
    if methods.len == 0 && data_fields.len == 0 {
        return []
    }
    // Collect candidate concrete types from the first method's suffix
    mut candidates := map[string]bool{}
    if methods.len > 0 {
        first_suffix := '__${methods[0].name}'
        for fn_name, _ in g.fn_return_types {
            if fn_name.ends_with(first_suffix) {
                base := fn_name[..fn_name.len - first_suffix.len]
                if base.len == 0 || g.is_interface_type(base) {
                    continue
                }
                param_types := g.fn_param_types[fn_name] or { []string{} }
                if param_types.len == 0 {
                    continue
                }
                receiver_type := param_types[0].trim_space().trim_right('*')
                if receiver_type != base {
                    continue
                }
                candidates[base] = true
            }
        }
    }
    // Filter to types that have ALL methods AND all data fields
    mut result := []string{}
    for cand, _ in candidates {
        mut has_all := true
        for method in methods {
            fn_name := '${cand}__${method.name}'
            if fn_name !in g.fn_return_types {
                has_all = false
                break
            }
            param_types := g.fn_param_types[fn_name] or { []string{} }
            if param_types.len == 0 {
                has_all = false
                break
            }
            receiver_type := param_types[0].trim_space().trim_right('*')
            if receiver_type != cand {
                has_all = false
                break
            }
        }
        if has_all {
            // Also check that the concrete type has all required data fields
            for df in data_fields {
                field_key := '${cand}.${df.name}'
                if field_key !in g.struct_field_types {
                    // Try with embedded struct owner
                    emb_key := '${cand}.${df.name}'
                    short_cand := if cand.contains('__') { cand.all_after_last('__') } else { cand }
                    emb_short_key := '${short_cand}.${df.name}'
                    if emb_key !in g.embedded_field_owner
                        && emb_short_key !in g.embedded_field_owner {
                        has_all = false
                        break
                    }
                }
            }
        }
        if has_all {
            body_key := 'body_${cand}'
            if body_key in g.emitted_types || body_key in g.pending_late_body_keys {
                result << cand
            }
        }
    }
    result.sort()
    return result
}

// gen_iface_to_iface_cast generates an inline interface-to-interface conversion
// using a GCC statement expression. Switches on _type_id to find the concrete type,
// then constructs the target interface from (ConcreteType*)(_object).
fn (mut g Gen) gen_iface_to_iface_cast(src_iface string, tgt_iface string, value_expr ast.Expr) bool {
    concrete_types := g.find_concrete_types_for_interface(tgt_iface)
    if concrete_types.len == 0 {
        // No known concrete types — fall back to raw expression
        g.expr(value_expr)
        return true
    }
    tmp := '_iconv${g.tmp_counter}'
    g.tmp_counter++
    g.sb.write_string('({ ${src_iface} ${tmp} = ')
    g.expr(value_expr)
    g.sb.write_string('; ')
    for i, ctype in concrete_types {
        type_short := if ctype.contains('__') {
            ctype.all_after_last('__')
        } else {
            ctype
        }
        type_id := interface_type_id_for_name(type_short)
        if i == 0 {
            g.sb.write_string('(${tmp}._type_id == ${type_id}) ? ')
        } else {
            g.sb.write_string(' : (${tmp}._type_id == ${type_id}) ? ')
        }
        // Construct target interface from (ConcreteType*)(src._object)
        g.sb.write_string('(${tgt_iface}){._object = ${tmp}._object, ._type_id = ${tmp}._type_id')
        // Method pointers
        if methods := g.interface_methods[tgt_iface] {
            for method in methods {
                fn_name := '${ctype}__${method.name}'
                mut target_name := fn_name
                if ptr_params := g.fn_param_is_ptr[fn_name] {
                    if ptr_params.len > 0 && !ptr_params[0] {
                        target_name = interface_wrapper_name(tgt_iface, ctype, method.name)
                        g.needed_interface_wrappers[target_name] = true
                        if target_name !in g.interface_wrapper_specs {
                            g.interface_wrapper_specs[target_name] = InterfaceWrapperSpec{
                                fn_name:       fn_name
                                concrete_type: ctype
                                method:        method
                            }
                        }
                    }
                }
                g.sb.write_string(', .${method.name} = (${method.cast_signature})${target_name}')
            }
        }
        // Data field pointers
        if data_fields := g.interface_data_fields[tgt_iface] {
            for df in data_fields {
                embedded_owner := g.embedded_owner_for(ctype, df.name)
                if embedded_owner != '' {
                    g.sb.write_string(', .${df.name} = &((${ctype}*)(${tmp}._object))->${embedded_owner}.${df.name}')
                } else {
                    g.sb.write_string(', .${df.name} = &((${ctype}*)(${tmp}._object))->${df.name}')
                }
            }
        }
        g.sb.write_string('}')
    }
    // Default: zeroed struct
    g.sb.write_string(' : (${tgt_iface}){0}')
    g.sb.write_string('; })')
    return true
}