use crate::name_analysis::symbol::source_definition::SourceDefinition;
use crate::name_analysis::symbol::usable_symbol::UsableSymbol;
use crate::name_analysis::symbol::Symbol;
use crate::name_analysis::util::join_fqn_parts;
use std::cell::RefCell;
use std::fmt::{Debug, Formatter};
use std::rc::Rc;

#[derive(Debug)]
pub enum UseSymbol {
    Concrete(Rc<RefCell<ConcreteUseSymbol>>),
    Star(StarUseSymbol),
}

impl UseSymbol {
    pub fn source_definition(&self) -> Option<SourceDefinition> {
        match self {
            UseSymbol::Concrete(concrete) => concrete.borrow().source_definition().cloned(),
            UseSymbol::Star(star) => star.source_definition().cloned(),
        }
    }
}

pub struct ConcreteUseSymbol {
    fqn_parts: Vec<Rc<str>>,
    source_definition: Option<SourceDefinition>,
    resolved_symbol: Option<UsableSymbol>,
}

impl ConcreteUseSymbol {
    pub fn new(fqn_parts: &[Rc<str>], source_definition: Option<SourceDefinition>) -> Self {
        Self {
            fqn_parts: fqn_parts.to_vec(),
            source_definition,
            resolved_symbol: None,
        }
    }

    pub fn fqn_parts(&self) -> &[Rc<str>] {
        &self.fqn_parts
    }

    pub fn declared_name(&self) -> &str {
        self.fqn_parts.last().unwrap()
    }
    
    pub fn declared_name_owned(&self) -> Rc<str> {
        self.fqn_parts.last().unwrap().clone()
    }

    pub fn resolved_symbol(&self) -> Option<&UsableSymbol> {
        self.resolved_symbol.as_ref()
    }

    pub fn set_resolved_symbol(&mut self, symbol: UsableSymbol) {
        self.resolved_symbol = Some(symbol);
    }
}

impl Symbol for ConcreteUseSymbol {
    fn source_definition(&self) -> Option<&SourceDefinition> {
        self.source_definition.as_ref()
    }
}

impl Debug for ConcreteUseSymbol {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ConcreteUseStatementSymbol")
            .field("fqn_parts", &self.fqn_parts)
            .field("source_definition", &self.source_definition)
            .finish()
    }
}

#[derive(Clone)]
pub struct StarUseSymbol {
    fqn_parts: Vec<Rc<str>>,
    source_definition: Option<SourceDefinition>,
}

impl StarUseSymbol {
    pub fn new(fqn_parts: &[Rc<str>], source_definition: Option<SourceDefinition>) -> Self {
        Self {
            fqn_parts: fqn_parts.to_vec(),
            source_definition,
        }
    }
    
    pub fn fqn_parts(&self) -> &[Rc<str>] {
        &self.fqn_parts
    }
}

impl Symbol for StarUseSymbol {
    fn source_definition(&self) -> Option<&SourceDefinition> {
        self.source_definition.as_ref()
    }
}

impl Debug for StarUseSymbol {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("StarUseStatementSymbol")
            .field("fqn", &join_fqn_parts(&self.fqn_parts))
            .field("source_definition", &self.source_definition)
            .finish()
    }
}