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::class_symbol::ClassSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;

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

impl Statement {
    pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
        match self {
            Statement::Let(let_statement) => {
                let_statement.init_scopes(symbol_table, container_scope);
            }
            Statement::Expression(expression_statement) => {
                expression_statement.init_scopes(symbol_table, container_scope);
            }
            Statement::Assign(assign_statement) => {
                assign_statement.init_scopes(symbol_table, container_scope);
            }
        }
    }

    pub fn analyze_constructor_local_names(
        &self,
        symbol_table: &mut SymbolTable,
        class_symbol: &ClassSymbol,
    ) -> Vec<Diagnostic> {
        match self {
            Statement::Let(let_statement) => {
                let_statement.analyze_constructor_local_names(symbol_table, class_symbol)
            }
            Statement::Expression(expression_statement) => {
                expression_statement.check_constructor_local_names(symbol_table, class_symbol)
            }
            Statement::Assign(assign_statement) => {
                assign_statement.check_constructor_local_names(symbol_table, class_symbol)
            }
        }
    }

    pub fn analyze_method_local_names(
        &self,
        symbol_table: &mut SymbolTable,
        class_symbol: &ClassSymbol,
    ) -> Vec<Diagnostic> {
        match self {
            Statement::Let(let_statement) => {
                let_statement.analyze_method_local_names(symbol_table, class_symbol)
            }
            Statement::Expression(expression_statement) => {
                expression_statement.check_method_local_names(symbol_table, class_symbol)
            }
            Statement::Assign(assign_statement) => {
                assign_statement.check_method_local_names(symbol_table, class_symbol)
            }
        }
    }

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

    pub fn type_check(
        &mut self,
        symbol_table: &SymbolTable,
        types_table: &mut TypesTable,
        must_return_type_info: Option<&TypeInfo>,
    ) -> Result<(), Vec<Diagnostic>> {
        match self {
            Statement::Let(let_statement) => let_statement.type_check(symbol_table, types_table),
            Statement::Expression(expression_statement) => {
                expression_statement.type_check(symbol_table, types_table, must_return_type_info)
            }
            Statement::Assign(assign_statement) => {
                assign_statement.type_check(symbol_table, types_table)
            }
        }
    }

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