pub struct XmppConnection {
    jid: String,
    password: String,
    inner: Option<()>,
}
impl XmppConnection {
    fn new(jid: &str, password: &str) -> XmppConnection {
        XmppConnection {
            jid: jid.to_owned(),
            password: password.to_owned(),
            inner: None,
        }
    }

    /// connects if nothing connected
    /// Error shoud be !
    fn connect<E>(self) -> impl Future<Item = Self, Error = E> {
        let inner = self.inner.unwrap_or_else(|| ());
        future::ok(XmppConnection {
            jid: self.jid,
            password: self.password,
            inner: Some(inner),
        })
    }
}

    conn: XmppConnection,

    fn new(cmd_recv: Receiver<XmppCommand>, signal: F) -> XmppState<F> {
        XmppState { cmd_recv, signal }

    fn new(cmd_recv: Receiver<XmppCommand>, signal: F, conn: XmppConnection) -> XmppState<F> {
        XmppState {
            cmd_recv,
            signal,
            conn,
        }

pub fn xmpp_process<F>(

pub fn xmpp_process<F: 'static>(

    jid: &str,
    password: &str,

    future::loop_fn(XmppState::new(cmd_recv, signal), |s| {
        s.signal.select2(s.cmd_recv.into_future()).then(|r| {
            match r {
                Ok(Either::A((_x, b))) => {
                    // got signal, breaks
                    future::ok(future::Loop::Break(b.into_inner()))
                }
                Ok(Either::B((x, a))) => {
                    // got cmd, continue
                    future::ok(future::Loop::Continue(XmppState::new(x.1, a)))
                }
                Err(Either::A((e, b))) => {
                    // got signal error, breaks
                    error!("Signal error: {}", e);
                    future::ok(future::Loop::Break(b.into_inner()))
                }
                Err(Either::B((_e, _a))) => {
                    // got cmd error, its bad
                    future::err(tokio::io::Error::new(
                        tokio::io::ErrorKind::Other,
                        "Cmd error",
                    ))

    let conn = XmppConnection::new(jid, password);
    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {
            cmd_recv,
            signal,
            conn,
        } = s;
        signal
            .select2(conn.connect().and_then(|conn| {
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                        tokio::io::Error::new(tokio::io::ErrorKind::Other, "Receive cmd error")
                    }).map(|f| (f, conn))
            })).then(|r| {
                match r {
                    Ok(Either::A((_x, b))) => {
                        // got signal, breaks
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Ok(Either::B((x, a))) => {
                        // got cmd, continue
                        Box::new(future::ok(future::Loop::Continue(XmppState::new(
                            (x.0).1,
                            a,
                            x.1,
                        )))) as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::A((e, b))) => {
                        // got signal error, breaks
                        error!("Signal error: {}", e);
                        Box::new(b.map(|b| future::Loop::Break((Some((b.0).1), b.1))))
                            as Box<Future<Item = _, Error = _>>
                    }
                    Err(Either::B((_e, _a))) => {
                        // got cmd error, its bad
                        Box::new(future::err(tokio::io::Error::new(
                            tokio::io::ErrorKind::Other,
                            "Cmd error",
                        ))) as Box<Future<Item = _, Error = _>>
                    }

            })
    }).and_then(
        |(opt_cmd_recv, _conn): (Option<Receiver<XmppCommand>>, XmppConnection)| {
            if let Some(mut cmd_recv) = opt_cmd_recv {
                // process left commands
                info!("Stop accepting commands");
                cmd_recv.close();
                Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
                    tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
                })) as Box<Future<Item = (), Error = tokio::io::Error>>
            } else {
                Box::new(future::err(tokio::io::Error::new(
                    tokio::io::ErrorKind::Other,
                    "cmd receiver gone",
                )))

        })
    }).and_then(|opt_cmd_recv: Option<Receiver<XmppCommand>>| {
        if let Some(mut cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            cmd_recv.close();
            Box::new(cmd_recv.for_each(|_cmd| future::ok(())).map_err(|_| {
                tokio::io::Error::new(tokio::io::ErrorKind::Other, "cmd receiver last error")
            })) as Box<Future<Item = (), Error = tokio::io::Error>>
        } else {
            Box::new(future::err(tokio::io::Error::new(
                tokio::io::ErrorKind::Other,
                "cmd receiver gone",
            )))
        }
    })

        },
    )

        ctrt.block_on(xmpp_process(ctrl_c.clone().map(|_| ()), cmd_recv))

        ctrt.block_on(xmpp_process(
            ctrl_c.clone().map(|_| ()),
            cmd_recv,
            &config.account.jid,
            &config.account.password,
        ))