use crate::ast::compilation_unit::CompilationUnit;
use crate::ast::statement::Statement;
use crate::diagnostic::Diagnostics;
use crate::semantic_analysis::collect_scopes::{
    collect_scopes_compilation_unit, collect_scopes_statement,
};
use crate::semantic_analysis::collect_symbols::{
    SymbolCollectionResult, collect_symbols_compilation_unit,
};
use crate::semantic_analysis::collect_types::collect_types;
use crate::semantic_analysis::resolve_names::{
    NameResolutionResult, resolve_names_in_compilation_unit, resolve_names_in_statement,
};
use crate::semantic_analysis::resolve_types::{
    ResolveTypesResult, resolve_types_in_compilation_unit, resolve_types_in_statement,
};
use analysis_context::AnalysisContext;

pub mod analysis_context;
mod collect_scopes;
mod collect_symbols;
mod collect_types;
mod diagnostic_helpers;
mod resolve_names;
mod resolve_types;
pub mod scope;
pub mod symbol;
pub mod type_info;

pub fn analyze_compilation_unit(
    compilation_unit: &CompilationUnit,
    ctx: &mut AnalysisContext,
) -> Diagnostics {
    let mut diagnostics = Diagnostics::new();

    collect_scopes_compilation_unit(compilation_unit, ctx);

    let SymbolCollectionResult(mut collect_symbols_diagnostics) =
        collect_symbols_compilation_unit(compilation_unit, ctx);
    diagnostics.append(&mut collect_symbols_diagnostics);

    let NameResolutionResult(mut resolve_names_diagnostics) =
        resolve_names_in_compilation_unit(compilation_unit, ctx);
    diagnostics.append(&mut resolve_names_diagnostics);

    collect_types(compilation_unit, ctx);

    let ResolveTypesResult(mut resolve_types_diagnostics) =
        resolve_types_in_compilation_unit(compilation_unit, ctx);
    diagnostics.append(&mut resolve_types_diagnostics);

    diagnostics
}

pub fn analyze_statement(statement: &Statement, ctx: &mut AnalysisContext) -> Diagnostics {
    let mut diagnostics = Diagnostics::new();

    collect_scopes_statement(statement, ctx);

    // collect symbols for a statement is currently a no-op, so not needed here

    let NameResolutionResult(mut resolve_names_diagnostics) =
        resolve_names_in_statement(statement, ctx);
    diagnostics.append(&mut resolve_names_diagnostics);

    // collect types for a statement is currently a no-op, so not needed here

    let ResolveTypesResult(mut resolve_types_diagnostics) =
        resolve_types_in_statement(statement, ctx);
    diagnostics.append(&mut resolve_types_diagnostics);

    diagnostics
}