#![feature(debug_closure_helpers)]

#[path = "shared/shared.rs"]
mod util;

#[path = "shared/ast_debug.rs"]
mod ast_debug;

unsafe extern "C" {
    unsafe fn bump_init();

    unsafe fn tokeniser_init_buf(bytes: *const u8, len: usize) -> ();
}

use util::defs::{parse_expr, parse_func, Ast};

fn main() {
    unsafe {
        bump_init();
    }
    println!("Bump allocator initialized.");

    fn print_ast(src: &[u8], parser: impl FnOnce(&mut Ast) -> u64) {
        unsafe {
            tokeniser_init_buf(src.as_ptr(), src.len());
            let mut ast = Ast {
                nodes: util::vec::Vec::new(),
            };
            let expr_id = parser(&mut ast);
            eprintln!("Parsed expression ID: {}", expr_id);
            println!("{:#}", &ast);

            // unsafe extern "C" fn visit_node(
            //     _this: *mut (),
            //     ast: *mut Ast,
            //     node_id: u64,
            //     scope: u64,
            // ) {
            //     let ast = unsafe { &*ast };
            //     let node = ast.nodes.get(node_id as usize).unwrap();
            //     eprintln!("{scope}: Visiting node {node_id}: {node}");
            // }

            // util::defs::ast_walk_for_each(&mut ast, expr_id, core::ptr::null_mut(), visit_node);

            let mut symtable = core::mem::MaybeUninit::<util::defs::SymbolTable>::uninit();
            util::defs::ast_build_symtable(&mut ast, expr_id, &mut symtable);
            let mut symtable = symtable.assume_init();
            use util::DisplayedSliceExt;
            println!(
                "Symbol Table: {:#?}",
                symtable.symtable.as_slice().displayed()
            );

            util::defs::ast_resolve_var_refs(&mut ast, &mut symtable, expr_id);

            println!("{:#}", &ast);
        };
    }

    print_ast(
        b"fn main() -> void { return 1 * 2 + 3 * 4; }",
        |ast| unsafe { parse_func(ast) },
    );

    print_ast(b"3 + 4", |ast| unsafe { parse_expr(ast) });
    print_ast(b"fn main() -> void { return 1 + 2; }", |ast| unsafe {
        parse_func(ast)
    });
    print_ast(
        b"fn main() -> void { ;;;return (1 + (2)); }",
        |ast| unsafe { parse_func(ast) },
    );
    print_ast(
        b"fn main() -> void { return (1 + (2 * 3)) / 4; }",
        |ast| unsafe { parse_func(ast) },
    );
    print_ast(b"fn main() -> void { return 1 + 2 * 3; }", |ast| unsafe {
        parse_func(ast)
    });

    print_ast(b"fn main() -> void { let x: u32 = 4; }", |ast| unsafe {
        parse_func(ast)
    });
    print_ast(
        b"fn main(a: u32) -> void { let x: u32 = a + 4; }",
        |ast| unsafe { parse_func(ast) },
    );
    print_ast(
        b"fn main(a: u32) -> void {
        let y: u32 = a + 4;
        let y: *u32 = &y;
        return *y;
        }",
        |ast| unsafe { parse_func(ast) },
    );
    print_ast(
        b"fn main(a: u32) -> void {
    let y: u32 = a + 4;
    {
      let y: u32 = 10;
    }
    let y: *u32 = &y;
    return *y;
    }",
        |ast| unsafe { parse_func(ast) },
    );
    print_ast(
        b"fn main(a: *u32, b: u32) -> void {
*a = b;
a = &b;
}",
        |ast| unsafe { parse_func(ast) },
    );
    print_ast(
        b"fn main(a: u32) -> void {
    if (a == 0) {
        return 1;
    } else {
        return 0;
    }
}",
        |ast| unsafe { parse_func(ast) },
    );
}