module builtin

// print_backtrace shows a backtrace of the current call stack on stdout.
pub fn print_backtrace() {
    // At the time of backtrace_symbols_fd call, the C stack would look something like this:
    // * print_backtrace_skipping_top_frames
    // * print_backtrace itself
    // * the rest of the backtrace frames
    // => top 2 frames should be skipped, since they will not be informative to the developer
    $if !no_backtrace ? {
        $if freestanding {
            println(bare_backtrace())
        } $else $if tinyc {
            C.tcc_backtrace(c'Backtrace')
        } $else $if use_libbacktrace ? {
            $if openbsd {
                print_backtrace_skipping_top_frames(2)
            } $else {
                // NOTE: TCC doesn't have the unwind library
                print_libbacktrace(1)
            }
        } $else {
            print_backtrace_skipping_top_frames(2)
        }
    }
}

// demangle_v_symbol converts a C-mangled V symbol name to a human-readable V name.
// For example: `veb__run_T_main__App_main__Context` => `veb.run[main.App, main.Context]`
@[direct_array_access]
fn demangle_v_symbol(cname string) string {
    mut name := cname
    // Strip builtin__ prefix:
    if name.starts_with('builtin__') {
        name = name[9..]
    }
    // Replace pointer type encoding:
    name = name.replace('__ptr__', '&')
    // Split base name from generic parameters on `_T_`:
    // C mangling: `base_T_type1_type2` where each type is prefixed with `_`
    // and types may contain `__` for module separators.
    t_pos := name.index('_T_') or { -1 }
    if t_pos >= 0 {
        base := name[..t_pos].replace('__', '.')
        generic_suffix := name[t_pos + 3..]
        // Split on single `_` that is not part of `__` (double underscore).
        params := split_generic_params(generic_suffix)
        mut demangled_params := []string{cap: params.len}
        for param in params {
            demangled_params << param.replace('__', '.')
        }
        return base + '[' + demangled_params.join(', ') + ']'
    }
    // No generics - just replace module separator:
    name = name.replace('__', '.')
    // `main.main` is V's internal C mangling, in V it's just `main`:
    if name == 'main.main' {
        return 'main'
    }
    return name
}

// split_generic_params splits a generic suffix like `main__App_main__Context`
// into individual type parameters [`main__App`, `main__Context`].
// Splits on single `_` but not `__` (double underscore used for module separators).
@[direct_array_access]
fn split_generic_params(s string) []string {
    mut params := []string{}
    mut start := 0
    mut i := 0
    for i < s.len {
        if s[i] == `_` {
            if i + 1 < s.len && s[i + 1] == `_` {
                // Part of `__` (module separator), skip both.
                i += 2
            } else {
                // Single `_` is a generic param separator.
                if i > start {
                    params << s[start..i]
                }
                i++
                start = i
            }
        } else {
            i++
        }
    }
    if start < s.len {
        params << s[start..]
    }
    return params
}

// demangle_backtrace_sym demangles a V symbol within a Linux-style backtrace fragment.
// Linux format: `./executable(symbol_name+0x1a4) `
fn demangle_backtrace_sym(s string) string {
    paren_start := s.index('(') or { return s }
    plus_pos := s.index_after_('+', paren_start)
    if plus_pos < 0 {
        return s
    }
    symbol := s[paren_start + 1..plus_pos]
    if symbol.len == 0 {
        return s
    }
    return s[..paren_start + 1] + demangle_v_symbol(symbol) + s[plus_pos..]
}

fn eprint_space_padding(output string, max_len int) {
    padding_len := max_len - output.len
    if padding_len > 0 {
        for _ in 0 .. padding_len {
            eprint(' ')
        }
    }
}