use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::constructor_symbol::ConstructorSymbol;
use crate::symbol::expressible_symbol::ExpressibleSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol::type_symbol::TypeSymbol;
use crate::symbol::variable_symbol::VariableSymbol;
use std::rc::Rc;

pub mod callable_symbol;
pub mod class_symbol;
pub mod constructor_symbol;
pub mod expressible_symbol;
pub mod field_symbol;
pub mod function_symbol;
pub mod generic_parameter_symbol;
pub mod parameter_symbol;
pub mod type_symbol;
pub mod variable_symbol;

#[derive(Clone, Eq, PartialEq, Hash)]
pub enum Symbol {
    Class(Rc<ClassSymbol>),
    GenericParameter(Rc<GenericParameterSymbol>),
    Field(Rc<FieldSymbol>),
    Constructor(Rc<ConstructorSymbol>),
    Function(Rc<FunctionSymbol>),
    Parameter(Rc<ParameterSymbol>),
    Variable(Rc<VariableSymbol>),
}

impl Symbol {
    pub fn scope_id(&self) -> usize {
        match self {
            Symbol::Class(class_symbol) => class_symbol.scope_id(),
            Symbol::GenericParameter(generic_parameter_symbol) => {
                generic_parameter_symbol.scope_id()
            }
            Symbol::Field(field_symbol) => field_symbol.scope_id(),
            Symbol::Constructor(constructor_symbol) => constructor_symbol.scope_id(),
            Symbol::Function(function_symbol) => function_symbol.scope_id(),
            Symbol::Parameter(parameter_symbol) => parameter_symbol.scope_id(),
            Symbol::Variable(variable_symbol) => variable_symbol.scope_id(),
        }
    }

    pub fn declared_name(&self) -> &str {
        match self {
            Symbol::Class(class_symbol) => class_symbol.declared_name(),
            Symbol::GenericParameter(generic_parameter_symbol) => {
                generic_parameter_symbol.declared_name()
            }
            Symbol::Field(field_symbol) => field_symbol.declared_name(),
            Symbol::Constructor(constructor_symbol) => constructor_symbol.declared_name(),
            Symbol::Function(function_symbol) => function_symbol.declared_name(),
            Symbol::Parameter(parameter_symbol) => parameter_symbol.declared_name(),
            Symbol::Variable(variable_symbol) => variable_symbol.declared_name(),
        }
    }

    pub fn declared_name_source_range(&self) -> Option<&SourceRange> {
        match self {
            Symbol::Class(class_symbol) => class_symbol.declared_name_source_range(),
            Symbol::GenericParameter(generic_parameter_symbol) => {
                Some(generic_parameter_symbol.declared_name_source_range())
            }
            Symbol::Field(field_symbol) => Some(field_symbol.declared_name_source_range()),
            Symbol::Constructor(constructor_symbol) => {
                Some(constructor_symbol.declared_name_source_range())
            }
            Symbol::Function(function_symbol) => Some(function_symbol.declared_name_source_range()),
            Symbol::Parameter(parameter_symbol) => parameter_symbol.declared_name_source_range(),
            Symbol::Variable(variable_symbol) => Some(variable_symbol.declared_name_source_range()),
        }
    }

    pub fn unwrap_type_symbol(&self) -> TypeSymbol {
        match self {
            Symbol::Class(class_symbol) => TypeSymbol::Class(class_symbol.clone()),
            Symbol::GenericParameter(generic_parameter_symbol) => {
                TypeSymbol::GenericParameter(generic_parameter_symbol.clone())
            }
            _ => panic!(),
        }
    }

    pub fn unwrap_expressible_symbol(&self) -> ExpressibleSymbol {
        match self {
            Symbol::Class(class_symbol) => ExpressibleSymbol::Class(class_symbol.clone()),
            Symbol::Field(field_symbol) => ExpressibleSymbol::Field(field_symbol.clone()),
            Symbol::Function(function_symbol) => {
                ExpressibleSymbol::Function(function_symbol.clone())
            }
            Symbol::Parameter(parameter_symbol) => {
                ExpressibleSymbol::Parameter(parameter_symbol.clone())
            }
            Symbol::Variable(variable_symbol) => {
                ExpressibleSymbol::Variable(variable_symbol.clone())
            }
            _ => panic!(),
        }
    }

    pub fn unwrap_function_symbol(&self) -> &Rc<FunctionSymbol> {
        match self {
            Symbol::Function(function_symbol) => function_symbol,
            _ => panic!(),
        }
    }

    pub fn unwrap_variable_symbol(&self) -> &Rc<VariableSymbol> {
        match self {
            Symbol::Variable(variable_symbol) => variable_symbol,
            _ => panic!(),
        }
    }

    pub fn unwrap_class_symbol(&self) -> &Rc<ClassSymbol> {
        match self {
            Symbol::Class(class_symbol) => class_symbol,
            _ => panic!(),
        }
    }

    pub fn unwrap_field_symbol(&self) -> &Rc<FieldSymbol> {
        match self {
            Symbol::Field(field_symbol) => field_symbol,
            _ => panic!(),
        }
    }
}