use derive_more::From;
use quick_xml::events::Event;
use quick_xml::name::{Namespace, ResolveResult};

use crate::protos::xmpp::bind::BindRequest;
use crate::protos::xmpp::client::{Iq, Message, Presence};
use crate::protos::xmpp::roster::RosterQuery;
use crate::protos::xmpp::session::Session;
use crate::util::xml::*;

use crate::prelude::*;

#[derive(PartialEq, Eq, Debug, From)]
pub enum IqClientBody {
    Bind(BindRequest),
    Session(Session),
    Roster(RosterQuery),
}

#[derive(From)]
pub struct IqClientBodyParser(IqClientBodyParserInner);

#[derive(From)]
enum IqClientBodyParserInner {
    Initial,
    Bind(<BindRequest as FromXml>::P),
    SessionV(<Session as FromXml>::P),
    RosterV(<RosterQuery as FromXml>::P),
}

impl FromXml for IqClientBody {
    type P = IqClientBodyParser;

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

impl Parser for IqClientBodyParser {
    type Output = Result<IqClientBody>;

    fn consume<'a>(
        self: Self,
        namespace: quick_xml::name::ResolveResult,
        event: &quick_xml::events::Event<'a>,
    ) -> crate::util::xml::Continuation<Self, Self::Output> {
        use IqClientBodyParserInner::*;
        match self.0 {
            Initial => {
                let bytes = match event {
                    Event::Start(bytes) => bytes,
                    Event::Empty(bytes) => bytes,
                    _ => {
                        return Continuation::Final(Err(ffail!("Unexpected XML event: {event:?}")))
                    }
                };
                let name = bytes.name();
                match_parser!(IqClientBodyParser, name, namespace, event;
                    BindRequest,
                    Session,
                    RosterQuery
                )
            }
            Bind(p) => delegate_parsing!(p, IqClientBodyParserInner, namespace, event),
            SessionV(p) => delegate_parsing!(p, IqClientBodyParserInner, namespace, event),
            RosterV(p) => delegate_parsing!(p, IqClientBodyParserInner, namespace, event),
        }
    }
}

#[derive(PartialEq, Eq, Debug, From)]
pub enum ClientPacket {
    Iq(Iq<IqClientBody>),
    Message(Message),
    Presence(Presence<Ignore>),
}

#[derive(From)]
pub struct ClientPacketParser(ClientPacketParserInner);

impl FromXml for ClientPacket {
    type P = ClientPacketParser;

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

#[derive(From)]
enum ClientPacketParserInner {
    Initial,
    IqV(<Iq<IqClientBody> as FromXml>::P),
    MessageV(<Message as FromXml>::P),
    PresenceV(<Presence<Ignore> as FromXml>::P),
}

impl Parser for ClientPacketParser {
    type Output = Result<ClientPacket>;

    fn consume<'a>(
        self: Self,
        namespace: ResolveResult,
        event: &Event<'a>,
    ) -> Continuation<Self, Self::Output> {
        use ClientPacketParserInner::*;
        match self.0 {
            Initial => {
                let Event::Start(bytes) = event else {
                    return Continuation::Final(Err(ffail!("Unexpected XML event: {event:?}")));
                };
                let name = bytes.name();
                match_parser!(ClientPacketParser, name, namespace, event;
                    Iq::<IqClientBody>,
                    Presence::<Ignore>,
                    Message
                )
            }
            IqV(p) => delegate_parsing!(p, ClientPacketParserInner, namespace, event),
            MessageV(p) => delegate_parsing!(p, ClientPacketParserInner, namespace, event),
            PresenceV(p) => delegate_parsing!(p, ClientPacketParserInner, namespace, event),
        }
    }
}