use crate::type_info::TypeInfo;
use std::cell::RefCell;
use std::rc::Rc;

pub struct FunctionSymbol {
    name: Rc<str>,
    parameters: Vec<Rc<ParameterSymbol>>,
}

impl FunctionSymbol {
    pub fn new(name: &str, parameters: &[Rc<ParameterSymbol>]) -> Self {
        Self {
            name: name.into(),
            parameters: parameters.into(),
        }
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn name_owned(&self) -> Rc<str> {
        self.name.clone()
    }

    pub fn parameters(&self) -> &[Rc<ParameterSymbol>] {
        &self.parameters
    }

    pub fn return_type(&self) -> TypeInfo {
        todo!()
    }
}

pub struct ParameterSymbol {
    name: Rc<str>,
    type_info: TypeInfo,
    stack_frame_offset: Option<usize>,
}

impl ParameterSymbol {
    pub fn new(name: &str, type_info: TypeInfo) -> Self {
        Self {
            name: name.into(),
            type_info,
            stack_frame_offset: None,
        }
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn name_owned(&self) -> Rc<str> {
        self.name.clone()
    }

    pub fn type_info(&self) -> &TypeInfo {
        &self.type_info
    }

    pub fn set_stack_frame_offset(&mut self, offset: usize) {
        self.stack_frame_offset = Some(offset);
    }

    pub fn stack_frame_offset(&self) -> usize {
        self.stack_frame_offset.unwrap()
    }
}

pub struct VariableSymbol {
    name: Rc<str>,
    type_info: TypeInfo,
    register: Option<usize>,
}

impl VariableSymbol {
    pub fn new(name: &str, type_info: TypeInfo) -> Self {
        Self {
            name: name.into(),
            type_info,
            register: None,
        }
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn name_owned(&self) -> Rc<str> {
        self.name.clone()
    }

    pub fn type_info(&self) -> &TypeInfo {
        &self.type_info
    }

    pub fn set_register(&mut self, register: usize) {
        self.register = Some(register);
    }

    pub fn register(&self) -> usize {
        self.register.unwrap()
    }
}

pub enum ExpressibleSymbol {
    Function(Rc<FunctionSymbol>),
    Parameter(Rc<RefCell<ParameterSymbol>>),
    Variable(Rc<RefCell<VariableSymbol>>),
}