use std::fmt;
use std::fmt::Formatter;

#[derive(Eq, PartialEq, PartialOrd, Ord, Hash, Clone)]
pub struct LLVMType {
    /// integer, void, aggrigate and etc.
    pub kind: LLVMTypeKind,
}

#[allow(dead_code)]
impl LLVMType {
    fn new(k: LLVMTypeKind) -> Self {
        Self { kind: k }
    }

    pub fn new_int(bit_width: u32) -> Self {
        Self::new(LLVMTypeKind::INTEGER { bit_width })
    }
    pub fn new_uint(bit_width: u32) -> Self {
        Self::new(LLVMTypeKind::UNSIGNEDINTEGER { bit_width })
    }
    pub fn new_void() -> Self {
        Self::new(LLVMTypeKind::VOID)
    }
    pub fn new_pointer(inner: LLVMType) -> Self {
        Self::new(LLVMTypeKind::POINTER {
            inner: Box::new(inner),
        })
    }
    pub fn new_array(elem: LLVMType, len: usize) -> Self {
        Self::new(LLVMTypeKind::ARRAY {
            element_type: Box::new(elem),
            length: len,
        })
    }

    pub fn is_aggrigate(&self) -> bool {
        match &self.kind {
            LLVMTypeKind::ARRAY { element_type: _ty, length: _len } => true,
            _ => false,
        }
    }
}

impl fmt::Display for LLVMType {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.kind)
    }
}

#[derive(Eq, PartialEq, PartialOrd, Ord, Hash, Clone)]
pub enum LLVMTypeKind {
    VOID,
    INTEGER { bit_width: u32 },
    UNSIGNEDINTEGER { bit_width: u32 },
    POINTER { inner: Box<LLVMType> },
    ARRAY { element_type: Box<LLVMType>, length: usize },
}

impl fmt::Display for LLVMTypeKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::VOID => write!(f, "void"),
            Self::INTEGER { bit_width: bits } => write!(f, "i{}", bits),
            Self::UNSIGNEDINTEGER { bit_width: bits } => write!(f, "u{}", bits),
            Self::POINTER { inner: inner_ty } => write!(f, "{}*", inner_ty),
            Self::ARRAY { element_type: ty, length: len } => write!(f, "[{} x {}]", ty, len),
        }
    }
}