use crate::nodes::InnerNode;
use crate::nodes::*;
use crate::source::Range;

/// Generic combination of all known nodes.
#[derive(Debug, Clone, PartialEq)]
pub enum Node {
    Alias(Box<Alias>),
    And(Box<And>),
    AndAsgn(Box<AndAsgn>),
    Arg(Box<Arg>),
    Args(Box<Args>),
    Array(Box<Array>),
    ArrayPattern(Box<ArrayPattern>),
    ArrayPatternWithTail(Box<ArrayPatternWithTail>),
    BackRef(Box<BackRef>),
    Begin(Box<Begin>),
    Block(Box<Block>),
    Blockarg(Box<Blockarg>),
    BlockPass(Box<BlockPass>),
    Break(Box<Break>),
    Case(Box<Case>),
    CaseMatch(Box<CaseMatch>),
    Casgn(Box<Casgn>),
    Cbase(Box<Cbase>),
    Class(Box<Class>),
    Complex(Box<Complex>),
    Const(Box<Const>),
    ConstPattern(Box<ConstPattern>),
    CSend(Box<CSend>),
    Cvar(Box<Cvar>),
    Cvasgn(Box<Cvasgn>),
    Def(Box<Def>),
    Defined(Box<Defined>),
    Defs(Box<Defs>),
    Dstr(Box<Dstr>),
    Dsym(Box<Dsym>),
    EFlipFlop(Box<EFlipFlop>),
    EmptyElse(Box<EmptyElse>),
    Encoding(Box<Encoding>),
    Ensure(Box<Ensure>),
    Erange(Box<Erange>),
    False(Box<False>),
    File(Box<File>),
    FindPattern(Box<FindPattern>),
    Float(Box<Float>),
    For(Box<For>),
    ForwardArg(Box<ForwardArg>),
    ForwardedArgs(Box<ForwardedArgs>),
    Gvar(Box<Gvar>),
    Gvasgn(Box<Gvasgn>),
    Hash(Box<Hash>),
    HashPattern(Box<HashPattern>),
    Heredoc(Box<Heredoc>),
    If(Box<If>),
    IfGuard(Box<IfGuard>),
    IFlipFlop(Box<IFlipFlop>),
    IfMod(Box<IfMod>),
    IfTernary(Box<IfTernary>),
    Index(Box<Index>),
    IndexAsgn(Box<IndexAsgn>),
    InMatch(Box<InMatch>),
    InPattern(Box<InPattern>),
    Int(Box<Int>),
    Irange(Box<Irange>),
    Ivar(Box<Ivar>),
    Ivasgn(Box<Ivasgn>),
    Kwarg(Box<Kwarg>),
    KwBegin(Box<KwBegin>),
    Kwnilarg(Box<Kwnilarg>),
    Kwoptarg(Box<Kwoptarg>),
    Kwrestarg(Box<Kwrestarg>),
    Kwsplat(Box<Kwsplat>),
    Lambda(Box<Lambda>),
    Line(Box<Line>),
    Lvar(Box<Lvar>),
    Lvasgn(Box<Lvasgn>),
    Masgn(Box<Masgn>),
    MatchAlt(Box<MatchAlt>),
    MatchAs(Box<MatchAs>),
    MatchCurrentLine(Box<MatchCurrentLine>),
    MatchNilPattern(Box<MatchNilPattern>),
    MatchRest(Box<MatchRest>),
    MatchVar(Box<MatchVar>),
    MatchWithLvasgn(Box<MatchWithLvasgn>),
    Mlhs(Box<Mlhs>),
    Module(Box<Module>),
    Next(Box<Next>),
    Nil(Box<Nil>),
    NthRef(Box<NthRef>),
    Numblock(Box<Numblock>),
    OpAsgn(Box<OpAsgn>),
    Optarg(Box<Optarg>),
    Or(Box<Or>),
    OrAsgn(Box<OrAsgn>),
    Pair(Box<Pair>),
    Pin(Box<Pin>),
    Postexe(Box<Postexe>),
    Preexe(Box<Preexe>),
    Procarg0(Box<Procarg0>),
    Rational(Box<Rational>),
    Redo(Box<Redo>),
    Regexp(Box<Regexp>),
    RegOpt(Box<RegOpt>),
    Rescue(Box<Rescue>),
    RescueBody(Box<RescueBody>),
    Restarg(Box<Restarg>),
    Retry(Box<Retry>),
    Return(Box<Return>),
    SClass(Box<SClass>),
    Self_(Box<Self_>),
    Send(Box<Send>),
    Shadowarg(Box<Shadowarg>),
    Splat(Box<Splat>),
    Str(Box<Str>),
    Super(Box<Super>),
    Sym(Box<Sym>),
    True(Box<True>),
    Undef(Box<Undef>),
    UnlessGuard(Box<UnlessGuard>),
    Until(Box<Until>),
    UntilPost(Box<UntilPost>),
    When(Box<When>),
    While(Box<While>),
    WhilePost(Box<WhilePost>),
    XHeredoc(Box<XHeredoc>),
    Xstr(Box<Xstr>),
    Yield(Box<Yield>),
    ZSuper(Box<ZSuper>),
}

impl Node {
    pub(crate) fn inner_ref(&self) -> &dyn InnerNode {
        match &self {
            Node::Alias(inner) => inner.as_ref(),
            Node::And(inner) => inner.as_ref(),
            Node::AndAsgn(inner) => inner.as_ref(),
            Node::Arg(inner) => inner.as_ref(),
            Node::Args(inner) => inner.as_ref(),
            Node::Array(inner) => inner.as_ref(),
            Node::ArrayPattern(inner) => inner.as_ref(),
            Node::ArrayPatternWithTail(inner) => inner.as_ref(),
            Node::BackRef(inner) => inner.as_ref(),
            Node::Begin(inner) => inner.as_ref(),
            Node::Block(inner) => inner.as_ref(),
            Node::Blockarg(inner) => inner.as_ref(),
            Node::BlockPass(inner) => inner.as_ref(),
            Node::Break(inner) => inner.as_ref(),
            Node::Case(inner) => inner.as_ref(),
            Node::CaseMatch(inner) => inner.as_ref(),
            Node::Casgn(inner) => inner.as_ref(),
            Node::Cbase(inner) => inner.as_ref(),
            Node::Class(inner) => inner.as_ref(),
            Node::Complex(inner) => inner.as_ref(),
            Node::Const(inner) => inner.as_ref(),
            Node::ConstPattern(inner) => inner.as_ref(),
            Node::CSend(inner) => inner.as_ref(),
            Node::Cvar(inner) => inner.as_ref(),
            Node::Cvasgn(inner) => inner.as_ref(),
            Node::Def(inner) => inner.as_ref(),
            Node::Defined(inner) => inner.as_ref(),
            Node::Defs(inner) => inner.as_ref(),
            Node::Dstr(inner) => inner.as_ref(),
            Node::Dsym(inner) => inner.as_ref(),
            Node::EFlipFlop(inner) => inner.as_ref(),
            Node::EmptyElse(inner) => inner.as_ref(),
            Node::Encoding(inner) => inner.as_ref(),
            Node::Ensure(inner) => inner.as_ref(),
            Node::Erange(inner) => inner.as_ref(),
            Node::False(inner) => inner.as_ref(),
            Node::File(inner) => inner.as_ref(),
            Node::FindPattern(inner) => inner.as_ref(),
            Node::Float(inner) => inner.as_ref(),
            Node::For(inner) => inner.as_ref(),
            Node::ForwardArg(inner) => inner.as_ref(),
            Node::ForwardedArgs(inner) => inner.as_ref(),
            Node::Gvar(inner) => inner.as_ref(),
            Node::Gvasgn(inner) => inner.as_ref(),
            Node::Hash(inner) => inner.as_ref(),
            Node::HashPattern(inner) => inner.as_ref(),
            Node::Heredoc(inner) => inner.as_ref(),
            Node::If(inner) => inner.as_ref(),
            Node::IfGuard(inner) => inner.as_ref(),
            Node::IFlipFlop(inner) => inner.as_ref(),
            Node::IfMod(inner) => inner.as_ref(),
            Node::IfTernary(inner) => inner.as_ref(),
            Node::Index(inner) => inner.as_ref(),
            Node::IndexAsgn(inner) => inner.as_ref(),
            Node::InMatch(inner) => inner.as_ref(),
            Node::InPattern(inner) => inner.as_ref(),
            Node::Int(inner) => inner.as_ref(),
            Node::Irange(inner) => inner.as_ref(),
            Node::Ivar(inner) => inner.as_ref(),
            Node::Ivasgn(inner) => inner.as_ref(),
            Node::Kwarg(inner) => inner.as_ref(),
            Node::KwBegin(inner) => inner.as_ref(),
            Node::Kwnilarg(inner) => inner.as_ref(),
            Node::Kwoptarg(inner) => inner.as_ref(),
            Node::Kwrestarg(inner) => inner.as_ref(),
            Node::Kwsplat(inner) => inner.as_ref(),
            Node::Lambda(inner) => inner.as_ref(),
            Node::Line(inner) => inner.as_ref(),
            Node::Lvar(inner) => inner.as_ref(),
            Node::Lvasgn(inner) => inner.as_ref(),
            Node::Masgn(inner) => inner.as_ref(),
            Node::MatchAlt(inner) => inner.as_ref(),
            Node::MatchAs(inner) => inner.as_ref(),
            Node::MatchCurrentLine(inner) => inner.as_ref(),
            Node::MatchNilPattern(inner) => inner.as_ref(),
            Node::MatchRest(inner) => inner.as_ref(),
            Node::MatchVar(inner) => inner.as_ref(),
            Node::MatchWithLvasgn(inner) => inner.as_ref(),
            Node::Mlhs(inner) => inner.as_ref(),
            Node::Module(inner) => inner.as_ref(),
            Node::Next(inner) => inner.as_ref(),
            Node::Nil(inner) => inner.as_ref(),
            Node::NthRef(inner) => inner.as_ref(),
            Node::Numblock(inner) => inner.as_ref(),
            Node::OpAsgn(inner) => inner.as_ref(),
            Node::Optarg(inner) => inner.as_ref(),
            Node::Or(inner) => inner.as_ref(),
            Node::OrAsgn(inner) => inner.as_ref(),
            Node::Pair(inner) => inner.as_ref(),
            Node::Pin(inner) => inner.as_ref(),
            Node::Postexe(inner) => inner.as_ref(),
            Node::Preexe(inner) => inner.as_ref(),
            Node::Procarg0(inner) => inner.as_ref(),
            Node::Rational(inner) => inner.as_ref(),
            Node::Redo(inner) => inner.as_ref(),
            Node::Regexp(inner) => inner.as_ref(),
            Node::RegOpt(inner) => inner.as_ref(),
            Node::Rescue(inner) => inner.as_ref(),
            Node::RescueBody(inner) => inner.as_ref(),
            Node::Restarg(inner) => inner.as_ref(),
            Node::Retry(inner) => inner.as_ref(),
            Node::Return(inner) => inner.as_ref(),
            Node::SClass(inner) => inner.as_ref(),
            Node::Self_(inner) => inner.as_ref(),
            Node::Send(inner) => inner.as_ref(),
            Node::Shadowarg(inner) => inner.as_ref(),
            Node::Splat(inner) => inner.as_ref(),
            Node::Str(inner) => inner.as_ref(),
            Node::Super(inner) => inner.as_ref(),
            Node::Sym(inner) => inner.as_ref(),
            Node::True(inner) => inner.as_ref(),
            Node::Undef(inner) => inner.as_ref(),
            Node::UnlessGuard(inner) => inner.as_ref(),
            Node::Until(inner) => inner.as_ref(),
            Node::UntilPost(inner) => inner.as_ref(),
            Node::When(inner) => inner.as_ref(),
            Node::While(inner) => inner.as_ref(),
            Node::WhilePost(inner) => inner.as_ref(),
            Node::XHeredoc(inner) => inner.as_ref(),
            Node::Xstr(inner) => inner.as_ref(),
            Node::Yield(inner) => inner.as_ref(),
            Node::ZSuper(inner) => inner.as_ref(),
        }
    }

    /// Returs a whitequark/parser -like representation of `self`.
    ///
    /// Used in tests and example scripts
    pub fn inspect(&self, indent: usize) -> String {
        self.inner_ref().inspect(indent)
    }

    /// Returns location of the full node expression
    pub fn expression(&self) -> &Range {
        self.inner_ref().expression()
    }

    /// Returns a whitequark/parser -like node name.
    ///
    /// Used in tests and example scripts
    pub fn str_type(&self) -> &'static str {
        self.inner_ref().str_type()
    }

    /// Prints itself + location information
    pub fn print_with_locs(&self) {
        self.inner_ref().print_with_locs()
    }
}