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

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, AstNode};

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

    let src = b"3 + 4";

    unsafe {
        // tokeniser_init_buf(src.as_ptr(), src.len());
        // let mut ast = Ast {
        //     nodes: util::vec::Vec::new(),
        // };
        // let expr_id = parse_expr(&mut ast);
        // println!("Parsed expression with ID: {}", expr_id);
        // println!("{:#}", &ast);

        let src = b"fn main() -> void { return 1 + 2; }";
        tokeniser_init_buf(src.as_ptr(), src.len());
        let mut ast = Ast {
            nodes: util::vec::Vec::new(),
        };
        let expr_id = parse_func(&mut ast);
        println!("Parsed function with ID: {}", expr_id);
        println!("{:#}", &ast);
    }
}

impl std::fmt::Display for AstNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use util::defs::{
            BinaryExpr, AST_BINARY_OP, AST_BLOCK, AST_FUNCTION, AST_NUMBER, AST_RETURN_STATEMENT,
        };
        match self.kind as u32 {
            AST_NUMBER => {
                write!(f, "Number({})", self.data as usize)
            }
            AST_BINARY_OP => {
                let BinaryExpr {
                    left,
                    operator,
                    right,
                } = unsafe { self.data.cast::<util::defs::BinaryExpr>().read() };
                write!(
                    f,
                    "BinaryOp(op: {}, left: {}, right: {})",
                    operator, left, right
                )
            }
            AST_RETURN_STATEMENT => {
                let return_expr_id = self.data as usize;
                write!(f, "ReturnStatement(expr: {})", return_expr_id)
            }
            AST_FUNCTION => {
                let func = unsafe { self.data.cast::<util::defs::AstFunction>().read() };
                write!(
                    f,
                    "Function(name: {:?}, return_type: {:?}, body: {})",
                    unsafe {
                        std::str::from_utf8(std::slice::from_raw_parts(func.name, func.name_len))
                    },
                    func.return_type,
                    func.body
                )
            }
            AST_BLOCK => {
                write!(f, "Block(statements: {:?})", unsafe {
                    std::slice::from_raw_parts(self.data.cast::<u64>(), self.extra as usize)
                })
            }
            _ => write!(f, "UnknownNode"),
        }
    }
}

impl core::fmt::Display for Ast {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        writeln!(f, "[")?;
        for (i, item) in self.nodes.as_slice().iter().enumerate() {
            if i > 0 {
                writeln!(f, ", ")?;
            }
            write!(f, "\t{i}: {}", item)?;
        }
        writeln!(f, "\n]")
    }
}