use crate::ast::expression::Expression;
use crate::ast::ir_builder::IrBuilder;
use crate::diagnostic::Diagnostic;
use crate::ir::ir_return::IrReturn;
use crate::ir::ir_statement::IrStatement;
use crate::symbol_table::SymbolTable;

pub struct ExpressionStatement {
    expression: Box<Expression>,
}

impl ExpressionStatement {
    pub fn new(expression: Expression) -> Self {
        Self {
            expression: expression.into(),
        }
    }

    pub fn expression(&self) -> &Expression {
        &self.expression
    }

    pub fn gather_declared_names(
        &mut self,
        symbol_table: &mut SymbolTable,
    ) -> Result<(), Vec<Diagnostic>> {
        self.expression.gather_declared_names(symbol_table)
    }

    pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
        self.expression.check_name_usages(symbol_table)
    }

    pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
        self.expression.type_check(symbol_table)
    }

    pub fn to_ir(
        &self,
        builder: &mut IrBuilder,
        symbol_table: &SymbolTable,
        should_return_value: bool,
    ) {
        let ir_expression = self.expression.to_ir(builder, symbol_table);
        if ir_expression.is_some() && should_return_value {
            builder
                .current_block_mut()
                .add_statement(IrStatement::Return(IrReturn::new(ir_expression)));
        }
    }
}