use super::util;

impl core::fmt::Display for util::defs::AstNode {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        use util::defs::{
            BinaryExpr, AST_ADDRESS_OF, AST_ARG, AST_ASSIGNMENT, AST_BINARY_OP, AST_BLOCK,
            AST_DEREF, AST_FUNCTION, AST_IF, AST_NUMBER, AST_PLACE_TO_VALUE, AST_RETURN_STATEMENT,
            AST_VALUE_TO_PLACE, AST_VAR_DECL, AST_VAR_REF,
        };
        match self.kind {
            AST_NUMBER => {
                write!(f, "Number({})", self.data as usize)
            }
            AST_DEREF => {
                write!(f, "Deref(expr: {})", self.data as usize)
            }
            AST_ADDRESS_OF => {
                write!(f, "AddressOf(expr: {})", self.data as usize)
            }
            AST_ARG => {
                let arg = unsafe { self.data.cast::<util::defs::AstArgument>().read() };
                write!(
                    f,
                    "Arg(name: {:?}, arg_type: {})",
                    unsafe {
                        std::str::from_utf8(std::slice::from_raw_parts(arg.name, arg.name_len))
                    },
                    arg.arg_type,
                )
            }
            AST_VAR_REF => {
                let var_ref = unsafe { self.data.cast::<util::defs::AstVarRef>().read() };
                if var_ref.resolved != u64::MAX {
                    write!(f, "VarRef({})", var_ref.resolved)
                } else {
                    write!(f, "VarRef(name: {:?})", unsafe {
                        std::str::from_utf8(std::slice::from_raw_parts(
                            var_ref.name,
                            var_ref.name_len,
                        ))
                    },)
                }
            }
            AST_VAR_DECL => {
                let var_decl = unsafe { self.data.cast::<util::defs::AstVarDecl>().read() };
                write!(
                    f,
                    "VarDecl(name: {:?}, var_type: {})",
                    unsafe {
                        std::str::from_utf8(std::slice::from_raw_parts(
                            var_decl.name,
                            var_decl.name_len,
                        ))
                    },
                    var_decl.var_type,
                )
            }
            AST_ASSIGNMENT => {
                write!(
                    f,
                    "Assignment(dest: {}, src: {})",
                    self.data as usize, self.extra
                )
            }
            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: {:?}, args: {:?}, return_type: {}, body: {})",
                    unsafe {
                        std::str::from_utf8(std::slice::from_raw_parts(func.name, func.name_len))
                    },
                    unsafe {
                        std::slice::from_raw_parts(func.args.cast::<u64>(), func.args_len as usize)
                    },
                    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)
                })
            }
            AST_IF => {
                let if_node = unsafe { self.data.cast::<util::defs::AstIfExpr>().read() };
                write!(
                    f,
                    "If(cond: {}, then_branch: {}, else_branch: {:?})",
                    if_node.condition,
                    if_node.then,
                    match if_node.else_ {
                        u64::MAX => None,
                        v => Some(v),
                    }
                )
            }
            AST_PLACE_TO_VALUE => {
                write!(f, "PlaceToValue(place: {})", self.data as usize)
            }
            AST_VALUE_TO_PLACE => {
                write!(f, "ValueToPlace(value: {})", self.data as usize)
            }
            kind => write!(f, "UnknownNode(kind: {kind})"),
        }
    }
}

impl core::fmt::Display for util::defs::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)?;
        }
        write!(f, "\n]")
    }
}

impl core::fmt::Display for util::defs::SymEntry {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("SymEntry")
            .field_with("key", |f| {
                f.debug_struct("Key")
                    .field_with("kind", |f| {
                        f.write_str(match self.key.kind {
                            util::defs::SYM_KEY_SCOPE => "Scope",
                            util::defs::SYM_KEY_SCOPE_NAME => "ScopeName",
                            util::defs::SYM_KEY_PARENT_SCOPE => "ParentScope",
                            util::defs::SYM_KEY_ARG => "Argument",
                            util::defs::SYM_KEY_VAR => "Variable",
                            _ => "Unknown",
                        })
                    })
                    .field("scope", &self.key.scope_index)
                    .field("span", &self.key.span)
                    .field_with("ident", |f| {
                        f.write_str(unsafe {
                            &core::str::from_utf8_unchecked(core::slice::from_raw_parts(
                                self.key.ident,
                                self.key.ident_len,
                            ))
                        })
                    })
                    .finish()
            })
            .field_with("value", |f| {
                let stct = &mut f.debug_struct("Value");
                if self.extra == 0 {
                    stct.field("ast_index", &self.index).finish()
                } else if self.index != 0 {
                    stct.field_with("ident", |f| {
                        f.write_str(unsafe {
                            core::str::from_utf8_unchecked(core::slice::from_raw_parts(
                                self.index as *const u8,
                                self.extra as usize,
                            ))
                        })
                    })
                    .finish()
                } else {
                    stct.field("index", &self.index)
                        .field("extra", &self.extra)
                        .finish()
                }
            })
            .finish()
    }
}