use crate::ast::assign_statement::AssignStatement;
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_table::SymbolTable;
use crate::type_info::TypeInfo;

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

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)
            }
            Statement::Assign(assign_statement) => {
                assign_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)
            }
            Statement::Assign(assign_statement) => assign_statement.check_name_usages(symbol_table),
        }
    }

    pub fn type_check(
        &mut self,
        symbol_table: &SymbolTable,
        must_return_type_info: Option<&TypeInfo>,
    ) -> 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, must_return_type_info)
            }
            Statement::Assign(assign_statement) => assign_statement.type_check(symbol_table),
        }
    }

    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);
            }
            Statement::Assign(assign_statement) => {
                assign_statement.to_ir(builder, symbol_table);
            }
        }
    }
}