use super::*;
use derive_more::From;

#[derive(Default, Debug, PartialEq, Eq)]
pub struct Ignore;

#[derive(From)]
pub struct IgnoreParser(IgnoreParserInner);

enum IgnoreParserInner {
    Initial,
    InTag { name: Vec<u8>, depth: u8 },
}

impl Parser for IgnoreParser {
    type Output = Result<Ignore>;

    fn consume<'a>(
        self: Self,
        _: ResolveResult,
        event: &Event<'a>,
    ) -> Continuation<Self, Self::Output> {
        match self.0 {
            IgnoreParserInner::Initial => match event {
                Event::Start(bytes) => {
                    let name = bytes.name().0.to_owned();
                    Continuation::Continue(IgnoreParserInner::InTag { name, depth: 0 }.into())
                }
                Event::Empty(_) => Continuation::Final(Ok(Ignore)),
                _ => Continuation::Final(Ok(Ignore)),
            },
            IgnoreParserInner::InTag { name, depth } => match event {
                Event::End(bytes) if name == bytes.name().0 => {
                    if depth == 0 {
                        Continuation::Final(Ok(Ignore))
                    } else {
                        Continuation::Continue(
                            IgnoreParserInner::InTag {
                                name,
                                depth: depth - 1,
                            }
                            .into(),
                        )
                    }
                }
                _ => Continuation::Continue(IgnoreParserInner::InTag { name, depth }.into()),
            },
        }
    }
}

impl FromXml for Ignore {
    type P = IgnoreParser;

    fn parse() -> Self::P {
        IgnoreParserInner::Initial.into()
    }
}

impl ToXml for () {
    fn serialize(&self, _: &mut Vec<Event<'static>>) {}
}