use crate::ast::expression_statement::ExpressionStatement;
use crate::ast::ir_builder::IrBuilder;
use crate::ast::let_statement::LetStatement;
use crate::diagnostic::Diagnostic;
use crate::symbol::FunctionSymbol;
use crate::symbol_table::SymbolTable;
use std::cell::RefCell;
use std::rc::Rc;

pub enum Statement {
    Let(LetStatement),
    Expression(ExpressionStatement),
}

impl Statement {
    pub fn gather_declared_names(
        &mut self,
        symbol_table: &mut SymbolTable,
    ) -> Result<(), Vec<Diagnostic>> {
        match self {
            Statement::Let(let_statement) => let_statement.gather_declared_names(symbol_table),
            Statement::Expression(expression_statement) => {
                expression_statement.gather_declared_names(symbol_table)
            }
        }
    }

    pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
        match self {
            Statement::Let(let_statement) => let_statement.check_name_usages(symbol_table),
            Statement::Expression(expression_statement) => {
                expression_statement.check_name_usages(symbol_table)
            }
        }
    }

    pub fn type_check(
        &mut self,
        symbol_table: &SymbolTable,
        is_last: bool,
        function_symbol: &Rc<RefCell<FunctionSymbol>>,
    ) -> Result<(), Vec<Diagnostic>> {
        match self {
            Statement::Let(let_statement) => let_statement.type_check(symbol_table),
            Statement::Expression(expression_statement) => {
                expression_statement.type_check(symbol_table, is_last, function_symbol)
            }
        }
    }

    pub fn to_ir(
        &self,
        builder: &mut IrBuilder,
        symbol_table: &SymbolTable,
        should_return_value: bool,
    ) {
        match self {
            Statement::Let(let_statement) => {
                let_statement.to_ir(builder, symbol_table);
            }
            Statement::Expression(expression_statement) => {
                expression_statement.to_ir(builder, symbol_table, should_return_value);
            }
        }
    }
}