use async_channel::Receiver;
use tokio::runtime::Runtime;
use xmpp::{BareJid, ClientBuilder, ClientFeature, Event};

use std::sync::OnceLock;

#[derive(Clone, Debug)]
pub struct ContactReceived(pub BareJid);

fn tokio_runtime() -> &'static Runtime {
    static RUNTIME: OnceLock<Runtime> = OnceLock::new();
    RUNTIME.get_or_init(|| Runtime::new().expect("Setting up tokio runtime needs to succeed."))
}

pub(crate) fn client(jid: &str, password: &str) -> Receiver<ContactReceived> {
    let (event_sender, event_receiver) = async_channel::bounded::<ContactReceived>(1);

    let jid = jid.to_string();
    let password = password.to_string();

    tokio_runtime().spawn(async move {
        let mut client = ClientBuilder::new(BareJid::new(&jid).unwrap(), &password)
            .set_default_nick("xmpp-client")
            .enable_feature(ClientFeature::ContactList)
            .build();

        while let Some(events) = client.wait_for_events().await {
            for event in events {
                match event {
                    Event::ContactAdded(contact) => {
                        event_sender
                            .send(ContactReceived(contact.jid))
                            .await
                            .expect("BOOOOOOHOOOO");
                    }
                    _ => {
                        continue;
                    }
                }
            }
        }
    });

    event_receiver
}