use crate::ast::ast_node::{AstNode, AstNodeRef};
use crate::ast::node::{CompilationUnit, Identifier, UseStatement, UseStatementSuffix};
use crate::diagnostic::DmDiagnostic;
use crate::name_analysis::symbol::source_definition::SourceDefinition;
use crate::name_analysis::symbol::use_symbol::StarUseStatementSymbol;
use crate::name_analysis::symbol::UseStatementSymbol;
use crate::name_analysis::symbol_table::SymbolTable;
use std::collections::HashMap;

fn gather_identifier(
    identifier: &Identifier,
    symbol_table: &SymbolTable,
    identifier_scope_ids: &mut HashMap<Identifier, usize>,
) {
    identifier_scope_ids.insert(identifier.clone(), symbol_table.current_scope_id());
}

fn gather_use_statement(
    use_statement: &UseStatement,
    symbol_table: &mut SymbolTable,
    diagnostics: &mut Vec<DmDiagnostic>,
) {
    let mut fully_qualified_name = String::new();
    for prefix in use_statement.prefixes() {
        fully_qualified_name.push_str(&format!("{}::", prefix.identifier().name()));
    }
    match use_statement.suffix() {
        UseStatementSuffix::Identifier(identifier) => {}
        UseStatementSuffix::Star => {
            let symbol_inner = StarUseStatementSymbol::new(
                &fully_qualified_name,
                Some(SourceDefinition::from_use_statement(use_statement)),
            );
            let symbol = UseStatementSymbol::Star(symbol_inner);
            symbol_table.insert_use_statement_symbol(symbol);
            todo!()
        }
        UseStatementSuffix::UseList(use_list) => {}
    }
}

fn gather_node_children(
    node: &impl AstNode,
    symbol_table: &mut SymbolTable,
    diagnostics: &mut Vec<DmDiagnostic>,
) {
    for child in node.children() {
        gather_node(child, symbol_table, diagnostics);
    }
}

fn gather_node(
    node: AstNodeRef,
    symbol_table: &mut SymbolTable,
    diagnostics: &mut Vec<DmDiagnostic>,
) {
    match node {
        AstNodeRef::Operator(_) => {}
        AstNodeRef::Identifier(_) => {}
        AstNodeRef::FullyQualifiedName(_) => {}
        AstNodeRef::TypeUseList(_) => {}
        AstNodeRef::IdentifierList(_) => {}
        AstNodeRef::ParenthesesOptionalTypeUseList(_) => {}
        AstNodeRef::TypeUse(_) => {}
        AstNodeRef::PrimitiveType(_) => {}
        AstNodeRef::TypedArray(_) => {}
        AstNodeRef::InterfaceOrClassTypeUse(_) => {}
        AstNodeRef::TupleTypeUse(_) => {}
        AstNodeRef::FunctionTypeUse(_) => {}
        AstNodeRef::GenericArguments(_) => {}
        AstNodeRef::GenericParameters(_) => {}
        AstNodeRef::TupleArguments(_) => {}
        AstNodeRef::ImplementsList(_) => {}
        AstNodeRef::Parameters(_) => {}
        AstNodeRef::Parameter(_) => {}
        AstNodeRef::ReturnType(_) => {}
        AstNodeRef::CompilationUnit(compilation_unit) => {
            gather_node_children(compilation_unit, symbol_table, diagnostics);
        }
        AstNodeRef::ParentMod(_) => {}
        AstNodeRef::UseStatement(use_statement) => {
            gather_use_statement(use_statement, symbol_table, diagnostics);
        }
        AstNodeRef::UseStatementPrefix(_) => {}
        AstNodeRef::UseStatementSuffix(_) => {}
        AstNodeRef::UseList(_) => {}
        AstNodeRef::ModuleLevelDeclaration(_) => {}
        AstNodeRef::InterfaceLevelDeclaration(_) => {}
        AstNodeRef::ClassLevelDeclaration(_) => {}
        AstNodeRef::Module(_) => {}
        AstNodeRef::CompanionModule(_) => {}
        AstNodeRef::Interface(_) => {}
        AstNodeRef::Class(_) => {}
        AstNodeRef::Function(_) => {}
        AstNodeRef::OperatorFunction(_) => {}
        AstNodeRef::PlatformFunction(_) => {}
        AstNodeRef::InterfaceFunction(_) => {}
        AstNodeRef::InterfaceDefaultFunction(_) => {}
        AstNodeRef::InterfaceOperatorFunction(_) => {}
        AstNodeRef::InterfaceDefaultOperatorFunction(_) => {}
        AstNodeRef::FunctionBody(_) => {}
        AstNodeRef::FunctionEqualsBody(_) => {}
        AstNodeRef::FunctionAliasBody(_) => {}
        AstNodeRef::FunctionBlockBody(_) => {}
        AstNodeRef::ClassConstructor(_) => {}
        AstNodeRef::Member(_) => {}
        AstNodeRef::Statement(_) => {}
        AstNodeRef::VariableDeclaration(_) => {}
        AstNodeRef::AssignmentStatement(_) => {}
        AstNodeRef::ExpressionStatement(_) => {}
        AstNodeRef::IfStatement(_) => {}
        AstNodeRef::IfClause(_) => {}
        AstNodeRef::IfElseIf(_) => {}
        AstNodeRef::IfElse(_) => {}
        AstNodeRef::WhileStatement(_) => {}
        AstNodeRef::ForStatement(_) => {}
        AstNodeRef::Expression(_) => {}
        AstNodeRef::TernaryExpression(_) => {}
        AstNodeRef::TernaryRhs(_) => {}
        AstNodeRef::OrExpression(_) => {}
        AstNodeRef::OrRhs(_) => {}
        AstNodeRef::AndExpression(_) => {}
        AstNodeRef::AndRhs(_) => {}
        AstNodeRef::ComparisonExpression(_) => {}
        AstNodeRef::ComparisonRhs(_) => {}
        AstNodeRef::ComparisonOperator(_) => {}
        AstNodeRef::ShiftExpression(_) => {}
        AstNodeRef::ShiftRhs(_) => {}
        AstNodeRef::ShiftOperator(_) => {}
        AstNodeRef::AdditiveExpression(_) => {}
        AstNodeRef::AdditiveRhs(_) => {}
        AstNodeRef::AdditiveOperator(_) => {}
        AstNodeRef::MultiplicativeExpression(_) => {}
        AstNodeRef::MultiplicativeRhs(_) => {}
        AstNodeRef::MultiplicativeOperator(_) => {}
        AstNodeRef::PrefixExpression(_) => {}
        AstNodeRef::PrefixOperator(_) => {}
        AstNodeRef::SuffixExpression(_) => {}
        AstNodeRef::SuffixOperator(_) => {}
        AstNodeRef::ObjectProperty(_) => {}
        AstNodeRef::ObjectIndex(_) => {}
        AstNodeRef::ListExpression(_) => {}
        AstNodeRef::Call(_) => {}
        AstNodeRef::ParenthesesCall(_) => {}
        AstNodeRef::NonParenthesesCall(_) => {}
        AstNodeRef::TurboFish(_) => {}
        AstNodeRef::ExpressionList(_) => {}
        AstNodeRef::Closure(_) => {}
        AstNodeRef::ClosureParameters(_) => {}
        AstNodeRef::ClosureParameter(_) => {}
        AstNodeRef::Literal(_) => {}
        AstNodeRef::DString(_) => {}
        AstNodeRef::DStringExpression(_) => {}
        AstNodeRef::BacktickString(_) => {}
    }
}

pub fn gather_compilation_unit(
    compilation_unit: &mut CompilationUnit,
    symbol_table: &mut SymbolTable,
    identifier_scope_ids: &mut HashMap<Identifier, usize>,
    diagnostics: &mut Vec<DmDiagnostic>,
) {
    gather_node(compilation_unit.as_node_ref(), symbol_table, diagnostics);
}