use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};
use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    /// outgoing mailbox
    outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetVersion {}
impl IqRequestHandler for IqGetVersion {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got version query {} from {:?}", id, from);
        stanzas::make_version(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
        iq_get
    };
}
pub struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            state: Some(from.state),
        }
    }
}
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: std::rc::Rc::new(from),
            state: None,
        }
    }
}
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from,
            state: None,
        }
    }
}
impl MaybeXmppConnection {
    /// connects if nothing connected
    /// don't connect only if stop_future resolved
    pub fn connect<F>(
        self,
        stop_future: F,
    ) -> impl Future<Item = XmppConnection, Error = failure::Error>
    where
        F: future::Future + Clone + 'static,
        <F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
    {
        info!("xmpp connection...");
        let MaybeXmppConnection { account, state } = self;
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
        } else {
            Box::new(
                stop_future
                    .clone()
                    .select2(
                        future::loop_fn(account, move |account| {
                            info!("xmpp initialization...");
                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
                            // future to wait for online
                            Box::new(
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        data: std::default::Default::default(),
                                    },
                                    account,
                                }
                                .processing(XmppConnection::online, stop_future.clone())
                                .map_err(|(acc, _)| acc)
                                .and_then(|(conn, r)| match r {
                                    Ok(Either::A(_)) => future::ok(conn),
                                    Ok(Either::B(_)) => future::err(conn.account),
                                    Err(_e) => future::err(conn.account),
                                })
                                .and_then(|conn| conn.initial_roster(stop_future2))
                                .and_then(|conn| conn.self_presence(stop_future3))
                                .and_then(|conn| conn.enter_mucs(stop_future4))
                                .then(|r| match r {
                                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                                }),
                            )
                        })
                        .map_err(|_: ()| ()),
                    )
                    .then(|r| match r {
                        Ok(Either::A((_x, _b))) => future::err(format_err!("Stop XMMP connection")),
                        Ok(Either::B((x, _a))) => future::ok(x),
                        Err(Either::A((e, _b))) => future::err(e.into()),
                        Err(Either::B((_, _a))) => {
                            future::err(format_err!("Cann't initiate XMPP connection"))
                        }
                    }),
            )
        }
    }
}
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoItems {})
        }
    }
    /// Process version query
    /// see XEP-0092: Software Version
    fn incoming_iq_processing_get_version(
        &mut self,
        _version: xmpp_parsers::version::VersionQuery,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetVersion {})
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// process event from xmpp stream
    /// returns from future when condition met
    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future
    pub fn processing<S, F, T, E>(
        self,
        stop_condition: S,
        stop_future: F,
    ) -> impl Future<
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
    >
    where
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP sending error: {}", e);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Err(e),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Err(e)))
                                    }
                                })),
                            }),
                    ) as Box<dyn Future<Item = _, Error = _>>
                } else {
                    Box::new(
                        client
                            .into_future()
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A(((event, client), b))) => {
                                    if let Some(event) = event {
                                        let mut xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        if xmpp.xmpp_processing(&event) {
                                            match stop_condition(&mut xmpp, event) {
                                                Ok(true) => future::ok(future::Loop::Break((
                                                    xmpp,
                                                    Ok(Either::A(b)),
                                                ))),
                                                Ok(false) => future::ok(future::Loop::Continue((
                                                    xmpp,
                                                    b,
                                                    stop_condition,
                                                ))),
                                                Err(_e) => {
                                                    future::err((xmpp.account, Ok(Either::A(b))))
                                                }
                                            }
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                    } else {
                                        future::err((account, Ok(Either::A(b))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                    if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    future::err((account, Ok(Either::A(b))))
                                }
                                Err(Either::B((e, a))) => {
                                    if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    }
                                }
                            }),
                    )
                }
            },
        )
    }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(())
            }
        }
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;
        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        let account2 = account.clone();
        info!("Quering roster... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        client
            .send(Packet::Stanza(get_roster))
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(move |conn, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, data },
        } = self;
        use tokio::prelude::Sink;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
        info!("Sending presence... {}", String::from(&presence));
        client
            .send(Packet::Stanza(presence))
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(
                    move |conn, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    pub fn process_command(&mut self, cmd: XmppCommand) {
        info!("Got command");
        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::Ping => {
                self.state.data.counter += 1;
                let id_ping = format!("id_ping{}", self.state.data.counter);
                let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
                self.state.data.send_queue.push_back(ping);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        let account3 = account.clone();
        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                );
                info!("Sending muc presence... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}

use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};
use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Debug)]
pub enum XmppCommand {
    /// Send message to someone by jid
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    /// Send message to MUC
    Chatroom { muc_id: String, message: String },
    /// Send ping request to the server to test connection
    Ping,
    /// Check iq requests if some have expired timeouts
    TimeoutCleanup,
}
/// trait of processing iq
/// each function consumes handlers and
/// returns false if connection should be reset
trait IqHandler {
    /// process result
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool;
    /// process error
    fn error(
        self: Box<Self>,
        conn: &mut XmppConnection,
        error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool;
    /// process tmeout
    fn timeout(self: Box<Self>, conn: &mut XmppConnection) -> bool;
}
struct AddRosterIqHandler {
    jid: xmpp_parsers::Jid,
}
impl IqHandler for AddRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        match opt_element {
            Some(element) => {
                warn!(
                    "Wrong payload when adding {} to roster: {}",
                    self.jid,
                    String::from(&element)
                );
            }
            None => {
                if conn.state.data.roster.contains_key(&self.jid) {
                    info!("Jid {} updated to roster", self.jid);
                } else {
                    info!("Jid {} added in roster", self.jid);
                    conn.state.data.roster.insert(
                        self.jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                conn.process_jid(&self.jid);
            }
        }
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        true
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        true // ignore
    }
}
struct PingIqHandler {}
impl IqHandler for PingIqHandler {
    fn result(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        info!("ping successed");
        true
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
struct InitRosterIqHandler {}
impl IqHandler for InitRosterIqHandler {
    fn result(
        self: Box<Self>,
        conn: &mut XmppConnection,
        opt_element: Option<xmpp_parsers::Element>,
    ) -> bool {
        if let Some(result) = opt_element {
            use std::convert::TryInto;
            match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                Ok(roster) => {
                    conn.state.data.roster_init = true;
                    conn.state.data.roster.clear();
                    info!("Got first roster:");
                    for i in roster.items {
                        info!(" >>> {:?}", i);
                        conn.state
                            .data
                            .roster
                            .insert(i.jid, (i.subscription, i.ask));
                    }
                    true
                }
                Err(e) => {
                    error!("Cann't parse roster: {}", e);
                    false
                }
            }
        } else {
            error!("No roster responded");
            false
        }
    }
    fn error(
        self: Box<Self>,
        _conn: &mut XmppConnection,
        _error: xmpp_parsers::stanza_error::StanzaError,
    ) -> bool {
        false
    }
    fn timeout(self: Box<Self>, _conn: &mut XmppConnection) -> bool {
        false
    }
}
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// if roster was initialized
    /// ToDo: remove it as it is used only for initialization
    roster_init: bool,
    /// if self-presence accepted
    /// ToDo: remove it as it is used only for initialization
    self_presence: bool,
    /// ids counter
    counter: usize,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    /// outgoing mailbox
    outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,
    /// map from iq's id to handler of this type of iqs
    pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
trait IqRequestHandler {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq;
}
struct IqRequestUnknown {
    element: xmpp_parsers::Element,
    type_: &'static str,
}
impl IqRequestHandler for IqRequestUnknown {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        warn!(
            "Unsupported IQ {} request from {:?}: {}",
            self.type_,
            from,
            String::from(&self.element)
        );
        stanzas::make_iq_unsupported_error(id, conn.state.client.jid.clone(), from)
    }
}
struct IqSetRoster {}
impl IqRequestHandler for IqSetRoster {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got roster push {} from {:?}", id, from);
        stanzas::make_roster_push_answer(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetPing {}
impl IqRequestHandler for IqGetPing {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got ping {} from {:?}", id, from);
        stanzas::make_pong(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetVersion {}
impl IqRequestHandler for IqGetVersion {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got version query {} from {:?}", id, from);
        stanzas::make_version(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoInfo {}
impl IqRequestHandler for IqGetDiscoInfo {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco query {} from {:?}", id, from);
        stanzas::make_disco_info_result(id, conn.state.client.jid.clone(), from)
    }
}
struct IqGetDiscoItems {}
impl IqRequestHandler for IqGetDiscoItems {
    fn process(
        self: Box<Self>,
        conn: &mut XmppConnection,
        id: String,
        from: Option<xmpp_parsers::Jid>,
    ) -> xmpp_parsers::iq::Iq {
        info!("Got disco items query {} from {:?}", id, from);
        stanzas::make_disco_items_result(id, conn.state.client.jid.clone(), from)
    }
}
lazy_static! {
    static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {}", String::from(&e));
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        incoming.register(&XmppConnection::incoming_presence_processing);
        incoming.register(&XmppConnection::incoming_message_processing);
        incoming
    };
    static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_set =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "set",
                }) as Box<dyn IqRequestHandler>
            });
        iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
        iq_set
    };
    static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
        let mut iq_get =
            element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
                Box::new(IqRequestUnknown {
                    element,
                    type_: "get",
                }) as Box<dyn IqRequestHandler>
            });
        iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
        iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
        iq_get
    };
}
pub struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            state: Some(from.state),
        }
    }
}
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: std::rc::Rc::new(from),
            state: None,
        }
    }
}
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from,
            state: None,
        }
    }
}
impl MaybeXmppConnection {
    /// connects if nothing connected
    /// don't connect only if stop_future resolved
    pub fn connect<F>(
        self,
        stop_future: F,
    ) -> impl Future<Item = XmppConnection, Error = failure::Error>
    where
        F: future::Future + Clone + 'static,
        <F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
    {
        info!("xmpp connection...");
        let MaybeXmppConnection { account, state } = self;
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
        } else {
            Box::new(
                stop_future
                    .clone()
                    .select2(
                        future::loop_fn(account, move |account| {
                            info!("xmpp initialization...");
                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
                            // future to wait for online
                            Box::new(
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        data: std::default::Default::default(),
                                    },
                                    account,
                                }
                                .processing(XmppConnection::online, stop_future.clone())
                                .map_err(|(acc, _)| acc)
                                .and_then(|(conn, r)| match r {
                                    Ok(Either::A(_)) => future::ok(conn),
                                    Ok(Either::B(_)) => future::err(conn.account),
                                    Err(_e) => future::err(conn.account),
                                })
                                .and_then(|conn| conn.initial_roster(stop_future2))
                                .and_then(|conn| conn.self_presence(stop_future3))
                                .and_then(|conn| conn.enter_mucs(stop_future4))
                                .then(|r| match r {
                                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                                }),
                            )
                        })
                        .map_err(|_: ()| ()),
                    )
                    .then(|r| match r {
                        Ok(Either::A((_x, _b))) => future::err(format_err!("Stop XMMP connection")),
                        Ok(Either::B((x, _a))) => future::ok(x),
                        Err(Either::A((e, _b))) => future::err(e.into()),
                        Err(Either::B((_, _a))) => {
                            future::err(format_err!("Cann't initiate XMPP connection"))
                        }
                    }),
            )
        }
    }
}
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => INCOMING.process(self, stanza.clone()),
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    /// Process roster push
    /// see RFC 6212 2.1.6. Roster Push
    fn incoming_iq_processing_set_roster(
        &mut self,
        roster: xmpp_parsers::roster::Roster,
    ) -> Box<dyn IqRequestHandler> {
        for i in roster.items {
            if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                info!("Update {} in roster", i.jid);
                rdata.0 = i.subscription;
                rdata.1 = i.ask;
            } else {
                info!("Add {} to roster", i.jid);
                self.state
                    .data
                    .roster
                    .insert(i.jid.clone(), (i.subscription, i.ask));
            }
            self.process_jid(&i.jid);
        }
        Box::new(IqSetRoster {})
    }
    /// Enforce to answer to IQ "set"
    fn incoming_iq_processing_set(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_SET
            .process(self, element)
            .process(self, id, from)
    }
    /// Process ping request
    /// see XEP-0199: XMPP Ping
    fn incoming_iq_processing_get_ping(
        &mut self,
        _ping: xmpp_parsers::ping::Ping,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetPing {})
    }
    /// Process disco query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_info(
        &mut self,
        disco: xmpp_parsers::disco::DiscoInfoQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoInfo {})
        }
    }
    /// Process disco items query
    /// see XEP-0030: Service Discovery
    fn incoming_iq_processing_get_disco_items(
        &mut self,
        disco: xmpp_parsers::disco::DiscoItemsQuery,
    ) -> Box<dyn IqRequestHandler> {
        if let Some(ref node) = disco.node {
            warn!("Unsupported node {}", node);
            Box::new(IqRequestUnknown {
                element: disco.into(),
                type_: "get",
            })
        } else {
            Box::new(IqGetDiscoItems {})
        }
    }
    /// Process version query
    /// see XEP-0092: Software Version
    fn incoming_iq_processing_get_version(
        &mut self,
        _version: xmpp_parsers::version::VersionQuery,
    ) -> Box<dyn IqRequestHandler> {
        Box::new(IqGetVersion {})
    }
    /// Enforce to answer to IQ "get"
    fn incoming_iq_processing_get(
        &mut self,
        id: String,
        from: Option<xmpp_parsers::Jid>,
        element: minidom::Element,
    ) -> xmpp_parsers::iq::Iq {
        INCOMING_IQ_GET
            .process(self, element)
            .process(self, id, from)
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                let iq_answer = self.incoming_iq_processing_set(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.error(self, e);
                }
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                let iq_answer = self.incoming_iq_processing_get(iq.id, iq.from, element);
                self.state.data.send_queue.push_back(iq_answer.into());
            }
            xmpp_parsers::iq::IqType::Result(opt_element) => {
                if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
                    return handler.1.result(self, opt_element);
                }
                warn!(
                    "Unwanted iq result id {} from {:?}: {:?}",
                    iq.id,
                    iq.from,
                    opt_element.map(|e| String::from(&e))
                );
            }
        }
        true
    }
    fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
        if presence.from.as_ref() == Some(&self.state.client.jid) {
            info!("Self-presence accepted");
            self.state.data.self_presence = true;
        } else {
            warn!("Incoming presence stanza: {:?}", presence);
        }
        true
    }
    fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
        for payload in message.payloads.iter() {
            use std::convert::TryInto;
            if let Some(_delay) =
                payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
            {
                return true; // ignore delayed messages
            }
        }
        warn!("Incoming message stanza: {:?}", message);
        true
    }
    /// process event from xmpp stream
    /// returns from future when condition met
    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future
    pub fn processing<S, F, T, E>(
        self,
        stop_condition: S,
        stop_future: F,
    ) -> impl Future<
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
    >
    where
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                // ToDo: check timeouts if iqs
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {}", String::from(&send_element));
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP sending error: {}", e);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Err(e),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Err(e)))
                                    }
                                })),
                            }),
                    ) as Box<dyn Future<Item = _, Error = _>>
                } else {
                    Box::new(
                        client
                            .into_future()
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A(((event, client), b))) => {
                                    if let Some(event) = event {
                                        let mut xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        if xmpp.xmpp_processing(&event) {
                                            match stop_condition(&mut xmpp, event) {
                                                Ok(true) => future::ok(future::Loop::Break((
                                                    xmpp,
                                                    Ok(Either::A(b)),
                                                ))),
                                                Ok(false) => future::ok(future::Loop::Continue((
                                                    xmpp,
                                                    b,
                                                    stop_condition,
                                                ))),
                                                Err(_e) => {
                                                    future::err((xmpp.account, Ok(Either::A(b))))
                                                }
                                            }
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                    } else {
                                        future::err((account, Ok(Either::A(b))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                    if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    future::err((account, Ok(Either::A(b))))
                                }
                                Err(Either::B((e, a))) => {
                                    if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    }
                                }
                            }),
                    )
                }
            },
        )
    }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {}", String::from(&s));
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(())
            }
        }
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;
        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        let account2 = account.clone();
        info!("Quering roster... {}", String::from(&get_roster));
        data.pending_ids.insert(
            id_init_roster.clone(),
            (
                Instant::now() + Duration::from_secs(60),
                Box::new(InitRosterIqHandler {}),
            ),
        );
        client
            .send(Packet::Stanza(get_roster))
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(move |conn, _| Ok(conn.state.data.roster_init), stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, data },
        } = self;
        use tokio::prelude::Sink;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
        info!("Sending presence... {}", String::from(&presence));
        client
            .send(Packet::Stanza(presence))
            .map_err(|e| {
                error!("Error on send self-presence: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(
                    move |conn, _| Ok(conn.state.data.self_presence),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", xmpp_to);
                    let sub_to = match rdata.0 {
                        xmpp_parsers::roster::Subscription::To => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if sub_to {
                        info!("Subscribed to {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                    let sub_from = match rdata.0 {
                        xmpp_parsers::roster::Subscription::From => true,
                        xmpp_parsers::roster::Subscription::Both => true,
                        _ => false,
                    };
                    if !sub_from {
                        info!("Not subscription from {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_allow_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", xmpp_to);
                    self.state.data.counter += 1;
                    let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
                    let add_roster = stanzas::make_add_roster(&id_add_roster, xmpp_to.clone());
                    info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
                    self.state.data.pending_ids.insert(
                        id_add_roster,
                        (
                            Instant::now() + Duration::from_secs(60),
                            Box::new(AddRosterIqHandler {
                                jid: xmpp_to.clone(),
                            }),
                        ),
                    );
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    pub fn process_command(&mut self, cmd: XmppCommand) {
        info!("Got command");
        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::Ping => {
                self.state.data.counter += 1;
                let id_ping = format!("id_ping{}", self.state.data.counter);
                let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
                self.state.data.send_queue.push_back(ping);
                self.state.data.pending_ids.insert(
                    id_ping,
                    (
                        Instant::now() + Duration::from_secs(30),
                        Box::new(PingIqHandler {}),
                    ),
                );
            }
            XmppCommand::TimeoutCleanup => {
                let now = Instant::now();
                let timeouted: Vec<String> = self
                    .state
                    .data
                    .pending_ids
                    .iter()
                    .filter_map(|(id, (timeout, _))| {
                        if now >= *timeout {
                            Some(id.to_string())
                        } else {
                            None
                        }
                    })
                    .collect();
                let mut correct = true;
                timeouted.into_iter().for_each(|id| {
                    if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
                        correct &= handler.timeout(&mut self);
                    }
                })
            }
        }
    }
    pub fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!(
                "Sending muc leave presence... {}",
                String::from(&muc_presence)
            );
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        let account3 = account.clone();
        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                );
                info!("Sending muc presence... {}", String::from(&muc_presence));
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}

    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()

    let mut get_roster = Iq::from_get(Roster {
        items: vec![],
        ver: None,
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()

    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()

    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            ask: xmpp_parsers::roster::Ask::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()

    let mut ping = Iq::from_get(id, Ping);

    let mut ping = Iq::from_get(Ping);
    ping.id = Some(id.to_string());

}
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
    pong.into()

    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {

    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {

                use std::convert::TryInto;
                if let Some(iq) = stanza.clone().try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some((_, jid)) =
                        self.state.data.pending_add_roster_ids.remove_entry(&iq.id)
                    {
                        if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                            if self.state.data.roster.contains_key(&jid) {
                                info!("Jid {} updated to roster", jid);

                use try_from::TryInto;
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some(id) = iq.id {
                        if let Some((_, jid)) =
                            self.state.data.pending_add_roster_ids.remove_entry(&id)
                        {
                            if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                                if self.state.data.roster.contains_key(&jid) {
                                    info!("Jid {} updated to roster", jid);
                                } else {
                                    info!("Jid {} added in roster", jid);
                                    self.state.data.roster.insert(
                                        jid.clone(),
                                        (
                                            xmpp_parsers::roster::Subscription::None,
                                            xmpp_parsers::roster::Ask::None,
                                        ),
                                    );
                                }
                                self.process_jid(&jid);

                                info!("Jid {} added in roster", jid);
                                self.state.data.roster.insert(
                                    jid.clone(),
                                    (
                                        xmpp_parsers::roster::Subscription::None,
                                        xmpp_parsers::roster::Ask::None,
                                    ),

                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload

                            self.process_jid(&jid);
                        } else {
                            warn!(
                                "Wrong payload when adding {} to roster: {:?}",
                                jid, iq.payload
                            );

                    match iq.payload {
                        xmpp_parsers::iq::IqType::Set(element) => {
                            if let Some(roster) =
                                element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                            {
                                for i in roster.items {
                                    if let Some(ref mut rdata) =
                                        self.state.data.roster.get_mut(&i.jid)
                                    {
                                        info!("Update {} in roster", i.jid);
                                        rdata.0 = i.subscription;
                                        rdata.1 = i.ask;
                                    } else {
                                        info!("Add {} to roster", i.jid);
                                        self.state
                                            .data
                                            .roster
                                            .insert(i.jid.clone(), (i.subscription, i.ask));
                                    }
                                    self.process_jid(&i.jid);

                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    rdata.1 = i.ask;
                                } else {
                                    info!("Add {} to roster", i.jid);
                                    self.state
                                        .data
                                        .roster
                                        .insert(i.jid.clone(), (i.subscription, i.ask));

                            }
                        }
                        xmpp_parsers::iq::IqType::Error(e) => {
                            error!("iq error: {:?}", e);
                            return false;
                        }
                        xmpp_parsers::iq::IqType::Get(element) => {
                            if let Some(_ping) =
                                element.try_into().ok() as Option<xmpp_parsers::ping::Ping>
                            {
                                let pong = stanzas::make_pong(
                                    &iq.id,
                                    self.state.client.jid.clone(),
                                    iq.from,
                                );
                                self.state.data.send_queue.push_back(pong);

                                self.process_jid(&i.jid);

                        _ => (), // ignore

                } else if let Some(_presence) =
                    stanza.try_into().ok() as Option<xmpp_parsers::presence::Presence>
                {
                    // to do something with presence

                true

                future::ok(self)

            Event::Online => true,

            Event::Online => future::ok(self),

                false

                future::err(self.account)

                                        let mut xmpp = XmppConnection {

                                        let xmpp = XmppConnection {

                                        if xmpp.xmpp_processing(&event) {
                                            match stop_condition(&mut xmpp, event) {
                                                Ok(true) => future::ok(future::Loop::Break((
                                                    xmpp,
                                                    Ok(Either::A(b)),
                                                ))),
                                                Ok(false) => future::ok(future::Loop::Continue((
                                                    xmpp,
                                                    b,
                                                    stop_condition,
                                                ))),
                                                Err(_e) => {
                                                    future::err((xmpp.account, Ok(Either::A(b))))

                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),

                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }

                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>

                                        future::err((account, Ok(Either::A(b))))

                                        Box::new(future::err((account, Ok(Either::A(b)))))

                                    if let Some(client) = a.into_inner() {

                                    Box::new(if let Some(client) = a.into_inner() {

                                    }

                                    })

                                    future::err((account, Ok(Either::A(b))))

                                    Box::new(future::err((account, Ok(Either::A(b)))))

                                    if let Some(client) = a.into_inner() {

                                    Box::new(if let Some(client) = a.into_inner() {

                                    }

                                    })

            use std::convert::TryInto;

            use try_from::TryInto;

                    if iq.id == id_init_roster {
                        match iq.payload {
                            xmpp_parsers::iq::IqType::Error(_e) => {
                                error!("Get error instead of roster");
                                Err(())
                            }
                            xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                                    Ok(roster) => {
                                        self.state.data.roster.clear();
                                        info!("Got first roster:");
                                        for i in roster.items {
                                            info!(" >>> {:?}", i);
                                            self.state
                                                .data
                                                .roster
                                                .insert(i.jid, (i.subscription, i.ask));

                    if let Some(id) = iq.id {
                        if id == id_init_roster {
                            match iq.payload {
                                xmpp_parsers::iq::IqType::Error(_e) => {
                                    error!("Get error instead of roster");
                                    Err(())
                                }
                                xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                    match result.try_into()
                                        as Result<xmpp_parsers::roster::Roster, _>
                                    {
                                        Ok(roster) => {
                                            self.state.data.roster.clear();
                                            info!("Got first roster:");
                                            for i in roster.items {
                                                info!(" >>> {:?}", i);
                                                self.state
                                                    .data
                                                    .roster
                                                    .insert(i.jid, (i.subscription, i.ask));
                                            }
                                            Ok(true)
                                        }
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())

                                        Ok(true)

                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }

                                }
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())

                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                            }

                        } else {
                            Ok(false)

                        Ok(false)

                        error!("Iq stanza without id");
                        Err(())

                            use std::convert::TryInto;
                            match s.try_into() as Result<xmpp_parsers::presence::Presence, _> {
                                Ok(presence) => {
                                    Ok(presence.from.as_ref() == Some(&conn.state.client.jid))
                                }
                                Err(e) => {
                                    warn!("Not a self-presence: {}", e);
                                    Ok(false)
                                }

                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)

type Func<S, T, E> = dyn Fn(&mut S, E) -> T;
/// TryFrom based visitor
pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
    processors: Vec<Box<Func<S, Option<T>, E>>>,
    default: &'static Func<S, T, E>,
}
impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
    pub fn new<F>(f: &'static F) -> Processor<S, T, E>
    where
        F: Fn(&mut S, E) -> T + 'static,
    {
        Processor {
            processors: vec![],
            default: f,
        }
    }
    pub fn register<F, A>(&mut self, f: &'static F)
    where
        F: Fn(&mut S, A) -> T + 'static,
        A: std::convert::TryFrom<E>,
    {
        self.processors.push(Box::new(move |s, e: E| {
            use std::convert::TryInto;
            (e.try_into().ok() as Option<A>).map(|a| f(s, a))
        }));
    }
    pub fn process(&self, s: &mut S, e: E) -> T {
        for processor in self.processors.iter() {
            match processor(s, e.clone()) {
                Some(t) => return t,
                None => continue,
            }
        }
        (*self.default)(s, e)
    }
}

type Func<S, T, E> = dyn Fn(&mut S, E) -> T;
/// TryFrom based visitor
pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
    processors: Vec<Box<Func<S, Option<T>, E>>>,
    default: &'static Func<S, T, E>,
}
impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
    pub fn new<F>(f: &'static F) -> Processor<S, T, E>
    where
        F: Fn(&mut S, E) -> T + 'static,
    {
        Processor {
            processors: vec![],
            default: f,
        }
    }
    pub fn register<F, A>(&mut self, f: &'static F)
    where
        F: Fn(&mut S, A) -> T + 'static,
        A: std::convert::TryFrom<E>,
    {
        self.processors.push(Box::new(move |s, e: E| {
            use std::convert::TryInto;
            (e.try_into().ok() as Option<A>).map(|a| f(s, a))
        }));
    }
    pub fn process(&self, s: &mut S, e: E) -> T {
        for processor in self.processors.iter() {
            match processor(s, e.clone()) {
                Some(t) => return t,
                None => continue,
            }
        }
        (*self.default)(s, e)
    }
}

    use hyper::rt::{Future, Stream};

use std::collections::HashMap;

use std::collections::{HashMap, HashSet};

}
#[derive(Debug, Deserialize)]
pub struct CmdArgs {
    pub name: String,
}
/// Allowed sources of command
#[derive(Debug, Deserialize, PartialEq, Eq, Hash)]
pub enum Source {
    /// Direct message
    Message,
    /// Groupchat message
    GroupChat,
    /// Private groupchat message
    PrivateGroupChat,
}
/// Command to execute
#[derive(Debug, Deserialize)]
pub struct Command {
    pub source: HashSet<Source>,
    /// Command arguments
    pub args: Vec<CmdArgs>,

    /// map from command name to command definition
    pub commands: HashMap<String, Command>,

toml = "0.5"

toml = "0.4"

xmpp-parsers = "0.13"

xmpp-parsers = "0.12.2"

try_from = "=0.3.2" # xmpp-parsers

[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]

version = "0.7.3"

version = "0.6.10"

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.3.11"

version = "0.3.7"

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "termion 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.3.15"

version = "0.3.14"

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.7.3"

version = "0.7.0"

 "block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

 "block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.1.4"

version = "0.1.3"

version = "0.4.12"

version = "0.4.11"

version = "1.0.35"

version = "1.0.30"

version = "0.1.7"

version = "0.1.6"

version = "2.33.0"

version = "2.32.0"

 "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",

 "strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.6.4"

version = "0.5.1"

 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.6.2"

version = "0.5.1"

dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.6.1"

version = "0.6.0"

 "regex 1.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "regex 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)",

 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",

 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",

 "backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",

 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",

 "proc-macro2 0.4.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.33 (registry+https://github.com/rust-lang/crates.io-index)",

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.1.26"

version = "0.1.25"

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.1.18"

version = "0.1.16"

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",

 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.1.17"

version = "0.1.16"

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.12.27"

version = "0.12.25"

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

 "h2 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",

 "h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",

 "tokio 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "tokio-threadpool 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",

 "tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.2.53"

version = "0.2.49"

version = "0.5.2"

version = "0.4.2"

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.1.2"

version = "0.1.1"

 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",

 "linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",

 "serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",

 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.2.3"

version = "0.2.2"

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)",

 "openssl 0.10.19 (registry+https://github.com/rust-lang/crates.io-index)",

 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",

 "openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)",

 "security-framework 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

 "security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

name = "numtoa"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]

version = "0.10.20"

version = "0.10.19"

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.9.43"

version = "0.9.42"

 "cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.4.29"

version = "0.4.27"

version = "0.6.12"

version = "0.6.11"

 "proc-macro2 0.4.29 (registry+https://github.com/rust-lang/crates.io-index)",

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.1.3"

version = "0.1.2"

 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",

 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.1.54"

version = "0.1.51"

 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",

 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",

version = "1.1.6"

version = "1.1.2"

 "aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",

 "aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",

 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",

 "regex-syntax 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.6.6"

version = "0.6.5"

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.1.14"

version = "0.1.13"

 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

 "rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.3.1"

version = "0.2.2"

 "core-foundation 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.53 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

 "core-foundation 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

version = "0.3.1"

version = "0.2.3"

 "core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",

 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",