use crate::ir::ir_expression::IrExpression;
use crate::ir::ir_parameter::IrParameter;
use crate::ir::ir_variable::IrVariable;
use crate::type_info::TypeInfo;
use std::cell::RefCell;
use std::rc::Rc;

pub struct FunctionSymbol {
    name: Rc<str>,
    is_platform: bool,
    parameters: Option<Vec<Rc<RefCell<ParameterSymbol>>>>,
    return_type: TypeInfo,
}

impl FunctionSymbol {
    pub fn new(name: &str, is_platform: bool, return_type: TypeInfo) -> Self {
        Self {
            name: name.into(),
            is_platform,
            parameters: None,
            return_type,
        }
    }

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

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

    pub fn set_parameters(&mut self, parameters: Vec<Rc<RefCell<ParameterSymbol>>>) {
        self.parameters = Some(parameters);
    }

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

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

    pub fn is_platform(&self) -> bool {
        self.is_platform
    }
}

pub struct ParameterSymbol {
    name: Rc<str>,
    type_info: TypeInfo,
    ir_parameter: Option<Rc<IrParameter>>,

    #[deprecated]
    stack_frame_offset: Option<isize>,
}

impl ParameterSymbol {
    pub fn new(name: &str, type_info: TypeInfo) -> Self {
        Self {
            name: name.into(),
            type_info,
            ir_parameter: None,
            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_ir_parameter(&mut self, ir_parameter: Rc<IrParameter>) {
        self.ir_parameter = Some(ir_parameter);
    }

    pub fn ir_parameter(&self) -> &Rc<IrParameter> {
        self.ir_parameter.as_ref().unwrap()
    }

    #[deprecated]
    pub fn set_stack_frame_offset(&mut self, offset: isize) {
        self.stack_frame_offset = Some(offset);
    }

    #[deprecated]
    pub fn stack_frame_offset(&self) -> isize {
        self.stack_frame_offset.unwrap()
    }
}

pub struct VariableSymbol {
    name: Rc<str>,
    type_info: Option<TypeInfo>,
    ir_variable: Option<Rc<IrVariable>>,

    #[deprecated]
    register: Option<usize>,
}

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

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

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

    pub fn set_type_info(&mut self, type_info: TypeInfo) {
        self.type_info = Some(type_info);
    }

    pub fn type_info(&self) -> &TypeInfo {
        self.type_info
            .as_ref()
            .expect("TypeInfo not initialized. Did you type check?")
    }

    pub fn set_ir_variable(&mut self, ir_variable: Rc<IrVariable>) {
        self.ir_variable = Some(ir_variable);
    }

    pub fn ir_variable(&self) -> &Rc<IrVariable> {
        self.ir_variable
            .as_ref()
            .expect("ir_variable not yet initialized")
    }

    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<RefCell<FunctionSymbol>>),
    Parameter(Rc<RefCell<ParameterSymbol>>),
    Variable(Rc<RefCell<VariableSymbol>>),
}

impl ExpressibleSymbol {
    pub fn ir_expression(&self) -> IrExpression {
        match self {
            ExpressibleSymbol::Function(_) => {
                panic!("Cannot get ir_variable for FunctionSymbol");
            }
            ExpressibleSymbol::Parameter(parameter_symbol) => {
                IrExpression::Parameter(parameter_symbol.borrow().ir_parameter().clone())
            }
            ExpressibleSymbol::Variable(variable_symbol) => {
                IrExpression::Variable(variable_symbol.borrow().ir_variable().clone())
            }
        }
    }
}