// Copyright (c) 2020-2024 Joe Conigliaro. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module transformer

import os
import v2.ast
import v2.token

// LiveReloadParts is the pure-computation bundle produced by `live_reload_parts`.
pub struct LiveReloadParts {
pub:
    source_file  string
    c_decls      []ast.Stmt
    global_decls []ast.Stmt
    preamble     []ast.Stmt
    check_stmts  []ast.Stmt
}

// live_reload_parts is the pure-computation extraction of the pre-splice
// state previously inline in `inject_live_reload`. Returns the resolved
// source-file path plus the four stmt slices (C extern decls, GlobalDecls,
// main() preamble, and per-for-body reload-check stmts) that the caller
// splices into the file containing `main()`. Returns `none` when there are
// no @[live] functions (the legacy early-return).
//
// Does NOT mutate `files` or any caller state. Caller decides whether to
// splice the result into a legacy `[]ast.File` (via `inject_live_reload`)
// or into a `FlatBuilder` (future `post_pass_to_flat`).
//
// Third Phase 5 (post_pass port) `_parts` extraction (follows s144's
// `runtime_const_init_fn_stmts_parts` and s145's
// `runtime_const_init_main_calls_parts`). Bit-equal: identical
// `os.real_path` resolution + identical builder-helper outputs.
pub fn (mut t Transformer) live_reload_parts() ?LiveReloadParts {
    if t.live_fns.len == 0 {
        return none
    }
    source_file := os.real_path(t.live_source_file)
    return LiveReloadParts{
        source_file:  source_file
        c_decls:      build_live_c_decls()
        global_decls: t.build_live_globals()
        preamble:     t.build_live_preamble(source_file)
        check_stmts:  t.build_live_check(source_file)
    }
}

// LiveReloadFlatParts couples the locator output (file_idx of the main fn's
// file) with the pure-computation LiveReloadParts payload, so the splice
// step can run without re-locating.
pub struct LiveReloadFlatParts {
pub:
    file_idx int
    parts    LiveReloadParts
}

// inject_live_reload_parts_from_flat locates the FIRST file in the flat AST
// that contains a top-level non-method `fn main()` AND computes the
// LiveReloadParts payload. Returns `none` when no @[live] functions exist
// (live_reload_parts is empty) OR no main function is present in any file.
//
// The "first match wins" semantics of the legacy loop are preserved:
// `inject_live_reload` breaks out of its file loop on the first file it
// changes (the one containing main).
pub fn (mut t Transformer) inject_live_reload_parts_from_flat(flat &ast.FlatAst) ?LiveReloadFlatParts {
    parts := t.live_reload_parts() or { return none }
    for i in 0 .. flat.files.len {
        fc := flat.file_cursor(i)
        stmts := fc.stmts()
        for j in 0 .. stmts.len() {
            c := stmts.at(j)
            if c.kind() == .stmt_fn_decl && !c.flag(ast.flag_is_method) && c.name() == 'main' {
                return LiveReloadFlatParts{
                    file_idx: i
                    parts:    parts
                }
            }
        }
    }
    return none
}

// inject_live_reload_to_flat is the FlatBuilder-side splice counterpart to
// the legacy `inject_live_reload(mut []ast.File)`. Locates the main file
// via `inject_live_reload_parts_from_flat`, cursor-prescans each non-main
// function, rewrites matching bodies from cursors, then uses the FlatBuilder
// primitives to splice the result back:
//   - `replace_fn_body_stmts(old_fn_id, new_body_ids)` for each rewritten FnDecl
//   - `replace_file_stmt(file_idx, stmt_idx, new_fn_id)` to rewire the file
//   - `prepend_file_stmts(file_idx, c_decl_ids + global_decl_ids)` for the
//     file-level C-extern + GlobalDecl prepend
//
// Bit-equal w.r.t. `signature()` to running legacy
// `inject_live_reload(mut files)` followed by `ast.flatten_files(files)`.
pub fn (mut t Transformer) inject_live_reload_to_flat(mut out ast.FlatBuilder) {
    flat_parts := t.inject_live_reload_parts_from_flat(&out.flat) or { return }
    file_idx := flat_parts.file_idx
    parts := flat_parts.parts

    // Per-FnDecl rewrite: capture (stmt_idx, new_fn_id) replacements; apply
    // them AFTER the loop while stmt indices are still stable (prepend
    // happens after all replaces). file_stmts is built from the OLD file
    // root and references OLD fn ids — those nodes stay reachable from the
    // builder even when the file's stmts list gets rewired.
    fc := out.flat.file_cursor(file_idx)
    file_stmts := fc.stmts()

    mut replacement_idxs := []int{}
    mut replacement_ids := []ast.FlatNodeId{}

    for j in 0 .. file_stmts.len() {
        stmt_cursor := file_stmts.at(j)
        if !stmt_cursor.is_valid() || stmt_cursor.kind() != .stmt_fn_decl {
            continue
        }
        is_main := !stmt_cursor.flag(ast.flag_is_method) && stmt_cursor.name() == 'main'
        if !is_main && !t.fn_body_may_need_live_rewrite_from_flat(stmt_cursor.list_at(3)) {
            continue
        }
        body_stmts := stmt_cursor.list_at(3)
        mut new_body_ids := []ast.FlatNodeId{}
        mut had_change := false
        if is_main {
            new_body_ids = []ast.FlatNodeId{cap: parts.preamble.len + body_stmts.len()}
            for ps in parts.preamble {
                new_body_ids << out.emit_stmt(ps)
            }
            live_ids, _ :=
                t.inject_live_into_cursor_stmts_to_flat(body_stmts, parts.check_stmts, mut out)
            new_body_ids << live_ids
            had_change = true
        } else {
            live_ids, fn_changed := t.inject_live_into_cursor_stmts_to_flat(body_stmts,
                parts.check_stmts, mut out)
            if !fn_changed {
                continue
            }
            new_body_ids = live_ids.clone()
            had_change = true
        }
        if !had_change {
            continue
        }
        old_fn_id := stmt_cursor.id
        new_fn_id := out.replace_fn_body_stmts(old_fn_id, new_body_ids)
        replacement_idxs << j
        replacement_ids << new_fn_id
    }

    for k in 0 .. replacement_idxs.len {
        out.replace_file_stmt(file_idx, replacement_idxs[k], replacement_ids[k])
    }

    mut prepended_ids := []ast.FlatNodeId{cap: parts.c_decls.len + parts.global_decls.len}
    for cd in parts.c_decls {
        prepended_ids << out.emit_stmt(cd)
    }
    for gd in parts.global_decls {
        prepended_ids << out.emit_stmt(gd)
    }
    out.prepend_file_stmts(file_idx, prepended_ids)
}

fn (t &Transformer) inject_live_into_cursor_stmts_to_flat(stmts ast.CursorList, check_stmts []ast.Stmt, mut out ast.FlatBuilder) ([]ast.FlatNodeId, bool) {
    mut result := []ast.FlatNodeId{cap: stmts.len()}
    mut any_changed := false
    for i in 0 .. stmts.len() {
        stmt := stmts.at(i)
        if stmt.kind() == .stmt_for {
            any_changed = true
            mut new_body_ids := []ast.FlatNodeId{cap: check_stmts.len + stmt.for_body_list().len()}
            for cs in check_stmts {
                new_body_ids << out.emit_stmt(cs)
            }
            body := stmt.for_body_list()
            for bi in 0 .. body.len() {
                body_stmt_id, _ := t.rewrite_live_call_in_stmt_cursor_to_flat(body.at(bi), mut out)
                new_body_ids << body_stmt_id
            }
            init_id := out.copy_subtree_from(stmt.edge(0).flat, stmt.edge(0).id)
            cond_id := out.copy_subtree_from(stmt.edge(1).flat, stmt.edge(1).id)
            post_id := out.copy_subtree_from(stmt.edge(2).flat, stmt.edge(2).id)
            result << out.emit_for_stmt_by_ids(init_id, cond_id, post_id, new_body_ids)
            continue
        }
        new_stmt_id, changed := t.rewrite_live_call_in_stmt_cursor_to_flat(stmt, mut out)
        if changed {
            any_changed = true
        }
        result << new_stmt_id
    }
    return result, any_changed
}

fn (t &Transformer) rewrite_live_call_in_stmt_cursor_to_flat(stmt ast.Cursor, mut out ast.FlatBuilder) (ast.FlatNodeId, bool) {
    match stmt.kind() {
        .stmt_expr {
            new_expr_id, changed :=
                t.rewrite_live_call_in_expr_cursor_to_flat(stmt.edge(0), mut out)
            if changed {
                return out.emit_expr_stmt_by_id(new_expr_id), true
            }
        }
        .stmt_assign {
            lhs_len := stmt.extra_int()
            mut rhs_ids := []ast.FlatNodeId{cap: stmt.edge_count() - lhs_len}
            mut any_changed := false
            for i in lhs_len .. stmt.edge_count() {
                rhs_id, changed := t.rewrite_live_call_in_expr_cursor_to_flat(stmt.edge(i), mut out)
                rhs_ids << rhs_id
                if changed {
                    any_changed = true
                }
            }
            if any_changed {
                mut lhs_ids := []ast.FlatNodeId{cap: lhs_len}
                for i in 0 .. lhs_len {
                    lhs := stmt.edge(i)
                    lhs_ids << out.copy_subtree_from(lhs.flat, lhs.id)
                }
                op := unsafe { token.Token(int(stmt.aux())) }
                return out.emit_assign_stmt_by_ids(op, lhs_ids, rhs_ids, token.Pos{}), true
            }
        }
        else {}
    }

    return out.copy_subtree_from(stmt.flat, stmt.id), false
}

fn (t &Transformer) rewrite_live_call_in_expr_cursor_to_flat(expr ast.Cursor, mut out ast.FlatBuilder) (ast.FlatNodeId, bool) {
    match expr.kind() {
        .expr_call {
            lhs := expr.edge(0)
            if lhs.kind() == .expr_ident {
                for lf in t.live_fns {
                    if !lf.is_method && lhs.name() == lf.decl_name {
                        arg_ids := transform_mut_arg_cursors_to_flat(expr, mut out)
                        lhs_id := out.emit_ident_by_name('__live_${lf.mangled_name}', token.Pos{})
                        return out.emit_call_expr_by_ids(lhs_id, arg_ids, token.Pos{}), true
                    }
                }
            }
            if lhs.kind() == .expr_selector {
                for lf in t.live_fns {
                    if lf.is_method && lhs.edge(1).name() == lf.decl_name {
                        receiver := lhs.edge(0)
                        receiver_id := out.copy_subtree_from(receiver.flat, receiver.id)
                        receiver_arg_id :=
                            out.emit_prefix_expr_by_id(.amp, receiver_id, token.Pos{})
                        mut arg_ids := []ast.FlatNodeId{cap: expr.edge_count()}
                        arg_ids << receiver_arg_id
                        arg_ids << transform_mut_arg_cursors_to_flat(expr, mut out)
                        lhs_id := out.emit_ident_by_name('__live_${lf.mangled_name}', token.Pos{})
                        return out.emit_call_expr_by_ids(lhs_id, arg_ids, token.Pos{}), true
                    }
                }
            }
        }
        .expr_ident {
            for lf in t.live_fns {
                if !lf.is_method && expr.name() == lf.decl_name {
                    return out.emit_ident_by_name('__live_${lf.mangled_name}', token.Pos{}), true
                }
            }
        }
        else {}
    }

    return out.copy_subtree_from(expr.flat, expr.id), false
}

fn transform_mut_arg_cursors_to_flat(call ast.Cursor, mut out ast.FlatBuilder) []ast.FlatNodeId {
    args_cap := if call.edge_count() > 1 { call.edge_count() - 1 } else { 0 }
    mut arg_ids := []ast.FlatNodeId{cap: args_cap}
    for i in 1 .. call.edge_count() {
        arg := call.edge(i)
        if arg.kind() == .expr_modifier && unsafe { token.Token(int(arg.aux())) } == .key_mut {
            inner := arg.edge(0)
            arg_ids << out.copy_subtree_from(inner.flat, inner.id)
            continue
        }
        arg_ids << out.copy_subtree_from(arg.flat, arg.id)
    }
    return arg_ids
}

fn (t &Transformer) fn_body_may_need_live_rewrite_from_flat(stmts ast.CursorList) bool {
    for i in 0 .. stmts.len() {
        if t.stmt_may_need_live_rewrite_from_flat(stmts.at(i)) {
            return true
        }
    }
    return false
}

fn (t &Transformer) stmt_may_need_live_rewrite_from_flat(stmt_c ast.Cursor) bool {
    if !stmt_c.is_valid() {
        return false
    }
    match stmt_c.kind() {
        .stmt_for {
            return true
        }
        .stmt_expr {
            return t.expr_may_need_live_rewrite_from_flat(stmt_c.edge(0))
        }
        .stmt_assign {
            lhs_len := stmt_c.extra_int()
            for i in lhs_len .. stmt_c.edge_count() {
                if t.expr_may_need_live_rewrite_from_flat(stmt_c.edge(i)) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (t &Transformer) expr_may_need_live_rewrite_from_flat(expr_c ast.Cursor) bool {
    if !expr_c.is_valid() {
        return false
    }
    match expr_c.kind() {
        .expr_call {
            return t.call_lhs_may_need_live_rewrite_from_flat(expr_c.edge(0))
        }
        .expr_ident {
            return t.is_live_plain_fn_name(expr_c.name())
        }
        else {}
    }

    return false
}

fn (t &Transformer) call_lhs_may_need_live_rewrite_from_flat(lhs ast.Cursor) bool {
    match lhs.kind() {
        .expr_ident {
            return t.is_live_plain_fn_name(lhs.name())
        }
        .expr_selector {
            return t.is_live_method_name(lhs.edge(1).name())
        }
        else {}
    }

    return false
}

fn (t &Transformer) is_live_plain_fn_name(name string) bool {
    for lf in t.live_fns {
        if !lf.is_method && name == lf.decl_name {
            return true
        }
    }
    return false
}

fn (t &Transformer) is_live_method_name(name string) bool {
    for lf in t.live_fns {
        if lf.is_method && name == lf.decl_name {
            return true
        }
    }
    return false
}

// inject_live_reload generates hot code reloading infrastructure for @[live] functions.
//
// Approach: function pointer indirection with direct memory patching.
// @[live] functions are recompiled via `v2 -backend arm64 -hot-fn` which extracts
// raw machine code. The code is read into an mmap'd executable page and the
// global function pointer is updated to point at it.
//
// Supports multiple @[live] functions (including methods) across different callers.
//
// 1. Injects GlobalDecl for function pointers, code page, and mtime tracking
// 2. Adds initialization code to main() (mmap code page, init pointers, read initial mtime)
// 3. Replaces calls to @[live] functions with indirect calls through global pointers
// 4. Injects reload checks at the top of for-loop bodies in ALL functions
fn (mut t Transformer) inject_live_reload(mut files []ast.File) {
    parts := t.live_reload_parts() or { return }
    c_decls := parts.c_decls
    global_decls := parts.global_decls
    preamble := parts.preamble
    check_stmts := parts.check_stmts

    // Find the user file that contains main()
    for i, file in files {
        mut has_main := false
        for stmt in file.stmts {
            if stmt is ast.FnDecl && !stmt.is_method && stmt.name == 'main' {
                has_main = true
                break
            }
        }
        if !has_main {
            continue
        }

        mut new_stmts := []ast.Stmt{cap: c_decls.len + global_decls.len + file.stmts.len}

        // Prepend C function declarations
        for cd in c_decls {
            new_stmts << cd
        }

        // Prepend GlobalDecl statements
        for gd in global_decls {
            new_stmts << gd
        }

        mut changed := false
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                if !stmt.is_method && stmt.name == 'main' {
                    // Inject preamble + rewrite calls + inject reload checks
                    mut fn_stmts := []ast.Stmt{cap: preamble.len + stmt.stmts.len}
                    for ps in preamble {
                        fn_stmts << ps
                    }
                    live_stmts, _ := t.inject_live_into_stmts(stmt.stmts, check_stmts)
                    for fs in live_stmts {
                        fn_stmts << fs
                    }
                    new_stmts << ast.FnDecl{
                        attributes: stmt.attributes
                        is_public:  stmt.is_public
                        is_method:  stmt.is_method
                        is_static:  stmt.is_static
                        receiver:   stmt.receiver
                        language:   stmt.language
                        name:       stmt.name
                        typ:        stmt.typ
                        stmts:      fn_stmts
                        pos:        stmt.pos
                    }
                    changed = true
                    continue
                }
                // For ALL other functions: rewrite calls + inject reload checks into for loops
                live_stmts, fn_changed := t.inject_live_into_stmts(stmt.stmts, check_stmts)
                if fn_changed {
                    new_stmts << ast.FnDecl{
                        attributes: stmt.attributes
                        is_public:  stmt.is_public
                        is_method:  stmt.is_method
                        is_static:  stmt.is_static
                        receiver:   stmt.receiver
                        language:   stmt.language
                        name:       stmt.name
                        typ:        stmt.typ
                        stmts:      live_stmts
                        pos:        stmt.pos
                    }
                    changed = true
                    continue
                }
            }
            new_stmts << stmt
        }

        if changed {
            files[i] = ast.File{
                attributes: file.attributes
                mod:        file.mod
                name:       file.name
                stmts:      new_stmts
                imports:    file.imports
            }
            break
        }
    }
}

// inject_live_into_stmts walks a statement list, prepends reload-check
// statements to the body of every ForStmt, and replaces calls to @[live]
// functions with indirect calls through global pointers.
// Returns the modified stmts and whether any changes were made.
fn (t &Transformer) inject_live_into_stmts(stmts []ast.Stmt, check_stmts []ast.Stmt) ([]ast.Stmt, bool) {
    mut result := []ast.Stmt{cap: stmts.len}
    mut any_changed := false
    for stmt in stmts {
        if stmt is ast.ForStmt {
            any_changed = true
            // Prepend check stmts to the for-loop body, then rewrite calls in body
            mut new_body := []ast.Stmt{cap: check_stmts.len + stmt.stmts.len}
            for cs in check_stmts {
                new_body << cs
            }
            for fs in stmt.stmts {
                new_body << t.rewrite_live_call_in_stmt(fs)
            }
            result << ast.Stmt(ast.ForStmt{
                init:  stmt.init
                cond:  stmt.cond
                post:  stmt.post
                stmts: new_body
            })
            continue
        }
        new_stmt, changed := t.rewrite_live_call_in_stmt_b(stmt)
        if changed {
            any_changed = true
        }
        result << new_stmt
    }
    return result, any_changed
}

// rewrite_live_call_in_stmt rewrites calls to @[live] functions in a statement
// with indirect calls through global pointers. Always returns the rewritten stmt.
fn (t &Transformer) rewrite_live_call_in_stmt(stmt ast.Stmt) ast.Stmt {
    new_stmt, _ := t.rewrite_live_call_in_stmt_b(stmt)
    return new_stmt
}

// rewrite_live_call_in_stmt_b rewrites calls to @[live] functions in a statement
// with indirect calls through global pointers. Returns the stmt and whether it changed.
fn (t &Transformer) rewrite_live_call_in_stmt_b(stmt ast.Stmt) (ast.Stmt, bool) {
    if stmt is ast.ExprStmt {
        new_expr, changed := t.rewrite_live_call_in_expr(stmt.expr)
        if changed {
            return ast.Stmt(ast.ExprStmt{
                expr: new_expr
            }), true
        }
    } else if stmt is ast.AssignStmt {
        mut new_rhs := []ast.Expr{cap: stmt.rhs.len}
        mut any_changed := false
        for rhs in stmt.rhs {
            new_rhs_expr, changed := t.rewrite_live_call_in_expr(rhs)
            new_rhs << new_rhs_expr
            if changed {
                any_changed = true
            }
        }
        if any_changed {
            return ast.Stmt(ast.AssignStmt{
                op:  stmt.op
                lhs: stmt.lhs
                rhs: new_rhs
            }), true
        }
    }
    return stmt, false
}

// rewrite_live_call_in_expr checks if an expression is a call to a @[live] function
// and if so, replaces it with an indirect call through the global pointer.
fn (t &Transformer) rewrite_live_call_in_expr(expr ast.Expr) (ast.Expr, bool) {
    if expr is ast.CallExpr {
        // Check regular function calls: fn_name(args)
        if expr.lhs is ast.Ident {
            for lf in t.live_fns {
                if !lf.is_method && expr.lhs.name == lf.decl_name {
                    return ast.Expr(ast.CallExpr{
                        lhs:  mk_ident('__live_${lf.mangled_name}')
                        args: transform_mut_args(expr.args)
                    }), true
                }
            }
        }
        // Check method calls: obj.method_name(args)
        if expr.lhs is ast.SelectorExpr {
            for lf in t.live_fns {
                if lf.is_method && expr.lhs.rhs.name == lf.decl_name {
                    mut new_args := []ast.Expr{cap: 1 + expr.args.len}
                    new_args << ast.Expr(ast.PrefixExpr{
                        op:   .amp
                        expr: expr.lhs.lhs
                    })
                    for arg in transform_mut_args(expr.args) {
                        new_args << arg
                    }
                    return ast.Expr(ast.CallExpr{
                        lhs:  mk_ident('__live_${lf.mangled_name}')
                        args: new_args
                    }), true
                }
            }
        }
    }
    // Check function references in struct init: frame_fn: frame → frame_fn: __live_frame
    if expr is ast.Ident {
        for lf in t.live_fns {
            if !lf.is_method && expr.name == lf.decl_name {
                return mk_ident('__live_${lf.mangled_name}'), true
            }
        }
    }
    return expr, false
}

// transform_mut_args strips `mut` modifiers from arguments so that call_indirect
// (which has no function signature) passes the value directly.
fn transform_mut_args(args []ast.Expr) []ast.Expr {
    mut result := []ast.Expr{cap: args.len}
    for arg in args {
        if arg is ast.ModifierExpr && arg.kind == .key_mut {
            result << arg.expr
        } else {
            result << arg
        }
    }
    return result
}

// build_live_globals generates GlobalDecl statements for live reload state.
fn (t &Transformer) build_live_globals() []ast.Stmt {
    mut stmts := []ast.Stmt{}

    // __global __live_mtime : i64
    stmts << mk_global_decl('__live_mtime', 'i64')

    // __global __live_code_page : voidptr  (mmap'd RWX page for hot code)
    stmts << mk_global_decl('__live_code_page', 'voidptr')

    // __global __live_code_offset : i64  (current write offset into code page)
    stmts << mk_global_decl('__live_code_offset', 'i64')

    // Per live function: global function pointer
    for lf in t.live_fns {
        stmts << mk_global_decl('__live_${lf.mangled_name}', 'voidptr')
    }

    return stmts
}

// build_live_preamble generates the statements prepended to main() body.
// mmap a code page, init function pointers, read initial source file mtime.
fn (t &Transformer) build_live_preamble(source_file string) []ast.Stmt {
    mut stmts := []ast.Stmt{}

    // Per live function: init function pointer to original function address
    for lf in t.live_fns {
        // __live_<mangled> = voidptr(&fn_name)
        stmts << mk_assign('__live_${lf.mangled_name}', mk_cast('voidptr', ast.Expr(ast.PrefixExpr{
            op:   .amp
            expr: mk_ident(lf.mangled_name)
        })))
    }

    // __live_code_page = C.mmap(nil, 0x4000, 3, 0x1802, -1, 0)
    // PROT_READ|PROT_WRITE=3, MAP_ANON|MAP_PRIVATE|MAP_JIT=0x1802
    stmts << mk_assign('__live_code_page', mk_call('C.mmap', [
        mk_unsafe_nil(),
        mk_hex('0x4000'),
        mk_int('3'),
        mk_hex('0x1802'),
        mk_neg_one(),
        mk_int('0'),
    ]))

    // mut __live_sb := [144]u8{}
    stmts << mk_decl_assign('__live_sb', mk_fixed_array_init('144', 'u8'))

    // if C.stat(c'source.v', &__live_sb[0]) == 0 {
    //     __live_mtime = unsafe { *(&i64(&__live_sb[48])) }
    // }
    stmts << mk_stat_check('__live_sb', source_file, '__live_mtime')

    return stmts
}

// build_live_check generates the reload-check statements injected at the top
// of for-loop bodies. Checks if source file changed, recompiles each @[live]
// function to raw machine code, reads it into the code page, and updates the pointer.
fn (t &Transformer) build_live_check(source_file string) []ast.Stmt {
    mut stmts := []ast.Stmt{}

    // mut __live_ns := [144]u8{}
    stmts << mk_decl_assign('__live_ns', mk_fixed_array_init('144', 'u8'))

    // if C.stat(c'source.v', &__live_ns[0]) == 0 { ... }
    stat_call := mk_call('C.stat', [
        mk_cstring(source_file),
        ast.Expr(ast.PrefixExpr{
            op:   .amp
            expr: ast.Expr(ast.IndexExpr{
                lhs:  mk_ident('__live_ns')
                expr: mk_int('0')
            })
        }),
    ])

    // Inner: __live_nm := unsafe { *(&i64(&__live_ns[48])) }
    mtime_read := mk_decl_assign('__live_nm', mk_unsafe_deref_i64('__live_ns', '48'))

    // if __live_nm > __live_mtime { ... reload all live functions ... }
    mut reload_body := []ast.Stmt{}

    // __live_mtime = __live_nm
    reload_body << mk_assign('__live_mtime', mk_ident('__live_nm'))

    // __live_t0 := C.clock_gettime_nsec_np(4)  -- CLOCK_MONOTONIC_RAW
    reload_body << mk_decl_assign('__live_t0', mk_call('C.clock_gettime_nsec_np', [
        mk_int('4'),
    ]))

    // C.printf(c'[live] reloading...\n')
    reload_body << mk_call_stmt('C.printf', [mk_cstring('[live] reloading...\\n')])
    reload_body << mk_call_stmt('C.fflush', [mk_unsafe_nil()])

    // Resolve v2 binary path
    v2_path := if t.pref != unsafe { nil } && t.pref.vroot.len > 0 {
        t.pref.vroot + '/cmd/v2/v2'
    } else {
        './v2'
    }

    // For each @[live] function: recompile, fread, patch
    for lf in t.live_fns {
        bin_path := '/tmp/_hot_${lf.mangled_name}.bin'
        compile_cmd := '${v2_path} -backend arm64 -nocache -hot-fn ${lf.mangled_name} -o ${bin_path} ${source_file} >/dev/null 2>&1'

        // C.system(c'v2 -backend arm64 -nocache -hot-fn <name> -o /tmp/_hot_<name>.bin source.v ...')
        reload_body << mk_call_stmt('C.system', [mk_cstring(compile_cmd)])

        // __live_f := C.fopen(c'/tmp/_hot_<name>.bin', c'rb')
        f_var := '__live_f_${lf.mangled_name}'
        reload_body << mk_decl_assign(f_var, mk_call('C.fopen', [
            mk_cstring(bin_path),
            mk_cstring('rb'),
        ]))

        // if __live_f != nil { ... read code, patch pointer ... }
        mut patch_body := []ast.Stmt{}

        // C.fseek(f, 0, 2)  -- SEEK_END
        patch_body << mk_call_stmt('C.fseek', [mk_ident(f_var),
            mk_int('0'), mk_int('2')])

        // __live_sz := int(C.ftell(f))
        sz_var := '__live_sz_${lf.mangled_name}'
        patch_body << mk_decl_assign(sz_var, mk_cast('int', mk_call('C.ftell', [
            mk_ident(f_var),
        ])))

        // C.fseek(f, 0, 0)  -- SEEK_SET
        patch_body << mk_call_stmt('C.fseek', [mk_ident(f_var),
            mk_int('0'), mk_int('0')])

        // __live_dest := voidptr(u64(__live_code_page) + u64(__live_code_offset))
        dest_var := '__live_dest_${lf.mangled_name}'
        patch_body << mk_decl_assign(dest_var, mk_cast('voidptr', ast.Expr(ast.InfixExpr{
            op:  .plus
            lhs: mk_cast('u64', mk_ident('__live_code_page'))
            rhs: mk_cast('u64', mk_ident('__live_code_offset'))
        })))

        // C.mprotect(__live_code_page, 0x4000, 3)  -- PROT_READ|PROT_WRITE
        patch_body << mk_call_stmt('C.mprotect', [
            mk_ident('__live_code_page'),
            mk_hex('0x4000'),
            mk_int('3'),
        ])

        // C.fread(__live_dest, 1, usize(__live_sz), f)
        patch_body << mk_call_stmt('C.fread', [
            mk_ident(dest_var),
            mk_int('1'),
            mk_cast('usize', mk_ident(sz_var)),
            mk_ident(f_var),
        ])

        // C.fclose(f)
        patch_body << mk_call_stmt('C.fclose', [mk_ident(f_var)])

        // C.mprotect(__live_code_page, 0x4000, 5)  -- PROT_READ|PROT_EXEC
        patch_body << mk_call_stmt('C.mprotect', [
            mk_ident('__live_code_page'),
            mk_hex('0x4000'),
            mk_int('5'),
        ])

        // C.sys_icache_invalidate(__live_code_page, 0x4000)
        patch_body << mk_call_stmt('C.sys_icache_invalidate', [
            mk_ident('__live_code_page'),
            mk_hex('0x4000'),
        ])

        // __live_<name> = __live_dest
        patch_body << mk_assign('__live_${lf.mangled_name}', mk_ident(dest_var))

        // __live_code_offset = __live_code_offset + i64(__live_sz)
        // Align to 16 bytes: offset = (offset + sz + 15) & ~15
        patch_body << mk_assign('__live_code_offset', ast.Expr(ast.InfixExpr{
            op:  .amp
            lhs: ast.Expr(ast.InfixExpr{
                op:  .plus
                lhs: ast.Expr(ast.InfixExpr{
                    op:  .plus
                    lhs: mk_ident('__live_code_offset')
                    rhs: mk_cast('i64', mk_ident(sz_var))
                })
                rhs: mk_int('15')
            })
            rhs: mk_neg('16')
        }))

        // C.printf(c'[live] patched %s (%d bytes)\n', c'<name>', __live_sz)
        patch_body << mk_call_stmt('C.printf', [
            mk_cstring('[live] patched %s (%d bytes)\\n'),
            mk_cstring(lf.mangled_name),
            mk_ident(sz_var),
        ])

        // if __live_f != nil { ...patch_body... }
        reload_body << ast.Stmt(ast.ExprStmt{
            expr: ast.IfExpr{
                cond:  ast.Expr(ast.InfixExpr{
                    op:  .ne
                    lhs: mk_ident(f_var)
                    rhs: mk_unsafe_nil()
                })
                stmts: patch_body
            }
        })
    }

    // __live_t1 := C.clock_gettime_nsec_np(4)
    reload_body << mk_decl_assign('__live_t1', mk_call('C.clock_gettime_nsec_np', [
        mk_int('4'),
    ]))

    // __live_ms := (__live_t1 - __live_t0) / 1000000
    reload_body << mk_decl_assign('__live_ms', ast.Expr(ast.InfixExpr{
        op:  .div
        lhs: ast.Expr(ast.InfixExpr{
            op:  .minus
            lhs: mk_ident('__live_t1')
            rhs: mk_ident('__live_t0')
        })
        rhs: mk_int('1000000')
    }))

    // C.printf(c'[live] done (%lldms)\n', __live_ms)
    reload_body << mk_call_stmt('C.printf', [
        mk_cstring('[live] done (%lldms)\\n'),
        mk_ident('__live_ms'),
    ])
    reload_body << mk_call_stmt('C.fflush', [mk_unsafe_nil()])

    // if __live_nm > __live_mtime { ...reload_body... }
    inner_if := ast.Stmt(ast.ExprStmt{
        expr: ast.IfExpr{
            cond:  ast.Expr(ast.InfixExpr{
                op:  .gt
                lhs: mk_ident('__live_nm')
                rhs: mk_ident('__live_mtime')
            })
            stmts: reload_body
        }
    })

    // Full if C.stat(...) == 0 { mtime_read; inner_if }
    stmts << ast.Stmt(ast.ExprStmt{
        expr: ast.IfExpr{
            cond:  ast.Expr(ast.InfixExpr{
                op:  .eq
                lhs: stat_call
                rhs: mk_int('0')
            })
            stmts: [mtime_read, inner_if]
        }
    })

    return stmts
}

// mk_global_decl generates: __global <name> : <type>
fn mk_global_decl(name string, typ_name string) ast.Stmt {
    return ast.Stmt(ast.GlobalDecl{
        fields: [
            ast.FieldDecl{
                name:   name
                typ:    mk_ident(typ_name)
                is_mut: true
            },
        ]
    })
}

// mk_stat_check generates:
//   if C.stat(c'<source>', &<buf_name>[0]) == 0 {
//       <mtime_var> = unsafe { *(&i64(&<buf_name>[48])) }
//   }
fn mk_stat_check(buf_name string, source_file string, mtime_var string) ast.Stmt {
    stat_call := mk_call('C.stat', [
        mk_cstring(source_file),
        ast.Expr(ast.PrefixExpr{
            op:   .amp
            expr: ast.Expr(ast.IndexExpr{
                lhs:  mk_ident(buf_name)
                expr: mk_int('0')
            })
        }),
    ])

    mtime_assign := mk_assign(mtime_var, mk_unsafe_deref_i64(buf_name, '48'))

    return ast.Stmt(ast.ExprStmt{
        expr: ast.IfExpr{
            cond:  ast.Expr(ast.InfixExpr{
                op:  .eq
                lhs: stat_call
                rhs: mk_int('0')
            })
            stmts: [mtime_assign]
        }
    })
}

// mk_unsafe_deref_i64 generates: unsafe { *(&i64(&<buf>[<offset>])) }
fn mk_unsafe_deref_i64(buf_name string, offset string) ast.Expr {
    return ast.Expr(ast.UnsafeExpr{
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.PrefixExpr{
                    op:   .mul
                    expr: ast.Expr(ast.PrefixExpr{
                        op:   .amp
                        expr: mk_cast('i64', ast.Expr(ast.PrefixExpr{
                            op:   .amp
                            expr: ast.Expr(ast.IndexExpr{
                                lhs:  mk_ident(buf_name)
                                expr: mk_int(offset)
                            })
                        }))
                    })
                })
            }),
        ]
    })
}

// Helper functions for constructing AST nodes

fn mk_ident(name string) ast.Expr {
    return ast.Expr(ast.Ident{
        name: name
    })
}

fn mk_int(value string) ast.Expr {
    return ast.Expr(ast.BasicLiteral{
        kind:  .number
        value: value
    })
}

fn mk_hex(value string) ast.Expr {
    return ast.Expr(ast.BasicLiteral{
        kind:  .number
        value: value
    })
}

fn mk_neg_one() ast.Expr {
    return ast.Expr(ast.PrefixExpr{
        op:   .minus
        expr: mk_int('1')
    })
}

fn mk_neg(value string) ast.Expr {
    return ast.Expr(ast.PrefixExpr{
        op:   .minus
        expr: mk_int(value)
    })
}

fn mk_cstring(value string) ast.Expr {
    return ast.Expr(ast.StringLiteral{
        kind:  .c
        value: "'${value}'"
    })
}

fn mk_cast(type_name string, expr ast.Expr) ast.Expr {
    return ast.Expr(ast.CallOrCastExpr{
        lhs:  mk_ident(type_name)
        expr: expr
    })
}

fn mk_call(fn_name string, args []ast.Expr) ast.Expr {
    // For C functions (C.stat, C.mmap, etc.), create a SelectorExpr so the SSA
    // builder's resolve_call_name correctly strips the C module prefix.
    lhs := if fn_name.starts_with('C.') {
        ast.Expr(ast.SelectorExpr{
            lhs: mk_ident('C')
            rhs: ast.Ident{
                name: fn_name[2..]
            }
        })
    } else {
        mk_ident(fn_name)
    }
    return ast.Expr(ast.CallExpr{
        lhs:  lhs
        args: args
    })
}

fn mk_call_stmt(fn_name string, args []ast.Expr) ast.Stmt {
    return ast.Stmt(ast.ExprStmt{
        expr: mk_call(fn_name, args)
    })
}

fn mk_decl_assign(name string, value ast.Expr) ast.Stmt {
    return ast.Stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(ast.Ident{
            name: name
        })]
        rhs: [value]
    })
}

fn mk_assign(name string, value ast.Expr) ast.Stmt {
    return ast.Stmt(ast.AssignStmt{
        op:  .assign
        lhs: [ast.Expr(ast.Ident{
            name: name
        })]
        rhs: [value]
    })
}

fn mk_fixed_array_init(size string, elem_type string) ast.Expr {
    return ast.Expr(ast.ArrayInitExpr{
        typ: ast.Expr(ast.Type(ast.ArrayFixedType{
            len:       ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: size
            })
            elem_type: ast.Expr(ast.Ident{
                name: elem_type
            })
        }))
    })
}

fn mk_unsafe_nil() ast.Expr {
    return ast.Expr(ast.UnsafeExpr{
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.Keyword{
                    tok: .key_nil
                })
            }),
        ]
    })
}

// build_live_c_decls generates C extern function declarations needed by live reload.
fn build_live_c_decls() []ast.Stmt {
    mut decls := []ast.Stmt{}

    // fn C.stat(path &u8, buf &u8) int
    decls << mk_c_fn_decl('stat', [
        mk_param('path', '&u8'),
        mk_param('buf', '&u8'),
    ], 'int')

    // fn C.mmap(addr voidptr, len usize, prot int, flags int, fd int, offset i64) voidptr
    decls << mk_c_fn_decl('mmap', [
        mk_param('addr', 'voidptr'),
        mk_param('len', 'usize'),
        mk_param('prot', 'int'),
        mk_param('flags', 'int'),
        mk_param('fd', 'int'),
        mk_param('offset', 'i64'),
    ], 'voidptr')

    // fn C.mprotect(addr voidptr, len usize, prot int) int
    decls << mk_c_fn_decl('mprotect', [
        mk_param('addr', 'voidptr'),
        mk_param('len', 'usize'),
        mk_param('prot', 'int'),
    ], 'int')

    // fn C.sys_icache_invalidate(start voidptr, size usize)
    decls << mk_c_fn_decl('sys_icache_invalidate', [
        mk_param('start', 'voidptr'),
        mk_param('size', 'usize'),
    ], '')

    // fn C.fopen(path &u8, mode &u8) voidptr
    decls << mk_c_fn_decl('fopen', [
        mk_param('path', '&u8'),
        mk_param('mode', '&u8'),
    ], 'voidptr')

    // fn C.fread(buf voidptr, size usize, count usize, f voidptr) usize
    decls << mk_c_fn_decl('fread', [
        mk_param('buf', 'voidptr'),
        mk_param('size', 'usize'),
        mk_param('count', 'usize'),
        mk_param('f', 'voidptr'),
    ], 'usize')

    // fn C.fseek(f voidptr, offset i64, whence int) int
    decls << mk_c_fn_decl('fseek', [
        mk_param('f', 'voidptr'),
        mk_param('offset', 'i64'),
        mk_param('whence', 'int'),
    ], 'int')

    // fn C.ftell(f voidptr) i64
    decls << mk_c_fn_decl('ftell', [
        mk_param('f', 'voidptr'),
    ], 'i64')

    // fn C.fclose(f voidptr) int
    decls << mk_c_fn_decl('fclose', [
        mk_param('f', 'voidptr'),
    ], 'int')

    // fn C.system(cmd &u8) int
    decls << mk_c_fn_decl('system', [
        mk_param('cmd', '&u8'),
    ], 'int')

    // fn C.printf(fmt &u8) int  (variadic)
    decls << mk_c_fn_decl('printf', [
        mk_param('fmt', '&u8'),
    ], 'int')

    // fn C.fflush(f voidptr) int
    decls << mk_c_fn_decl('fflush', [
        mk_param('f', 'voidptr'),
    ], 'int')

    // fn C.clock_gettime_nsec_np(clock_id int) u64
    decls << mk_c_fn_decl('clock_gettime_nsec_np', [
        mk_param('clock_id', 'int'),
    ], 'u64')

    return decls
}

fn mk_c_fn_decl(name string, params []ast.Parameter, ret_type string) ast.Stmt {
    return ast.Stmt(ast.FnDecl{
        language: .c
        name:     name
        typ:      ast.FnType{
            params:      params
            return_type: if ret_type.len > 0 {
                mk_ident(ret_type)
            } else {
                ast.empty_expr
            }
        }
    })
}

fn mk_param(name string, typ_name string) ast.Parameter {
    typ_expr := if typ_name.starts_with('&') {
        ast.Expr(ast.PrefixExpr{
            op:   .amp
            expr: mk_ident(typ_name[1..])
        })
    } else {
        mk_ident(typ_name)
    }
    return ast.Parameter{
        name: name
        typ:  typ_expr
    }
}