macltok

use macltok::{

    EngineConfig, Event, PasswordLogin, RoomMembership, Session, StoreConfig, TimelineId,

    TimelineItem,

};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {

    let session = Session::login_password(

        PasswordLogin::new(

            required("MATRIX_HOMESERVER")?,

            required("MATRIX_USERNAME")?,

            required("MATRIX_PASSWORD")?,

        )

        .with_device_display_name("macltok headless example"),

        StoreConfig::new(

            required("MATRIX_STORE_PATH")?,

            required("MATRIX_STORE_PASSPHRASE")?,

        ),

    )

    .await?;

    let (engine, handle, mut events) = session.build(EngineConfig::default()).await?;

    let running = tokio::spawn(engine.run());

    let mut opened: Option<TimelineId> = None;

    let mut items = Vec::new();

    let mut stale = false;

    loop {

        tokio::select! {

            event = events.recv() => {

                let Some(event) = event else { break };

                match event {

                    Event::RoomsChanged if opened.is_none() => {

                        let Some(room) = handle

                            .rooms()

                            .await

                            .into_iter()

                            .find(|room| room.membership == RoomMembership::Joined)

                        else {

                            continue;

                        };

                        opened = Some(room.room_id.clone().into());

                        // answers arrive on their own, the event loop keeps draining meanwhile

                        let handle = handle.clone();

                        tokio::spawn(async move {

                            if let Err(error) = handle.open_room(room.room_id).await {

                                eprintln!("could not open {error}");

                            }

                        });

                    }

                    Event::TimelineReset { timeline_id, items: snapshot }

                        if opened.as_ref() == Some(&timeline_id) =>

                    {

                        items = snapshot;

                        stale = false;

                        print_messages(&items);

                    }

                    Event::TimelineChanged { timeline_id, diffs }

                        if !stale && opened.as_ref() == Some(&timeline_id) =>

                    {

                        if diffs.into_iter().any(|diff| diff.try_apply(&mut items).is_err()) {

                            stale = true;

                            let handle = handle.clone();

                            tokio::spawn(async move { handle.resync(timeline_id).await });

                            continue;

                        }

                        print_messages(&items);

                    }

                    Event::Stopped => break,

                    _ => {}

                }

            }

            result = tokio::signal::ctrl_c() => {

                result?;

                let handle = handle.clone();

                tokio::spawn(async move { handle.shutdown().await });

            }

        }

    }

    running.await??;

    Ok(())

}

fn print_messages(items: &[TimelineItem]) {

    for item in items {

        if let TimelineItem::Message(message) = item {

            println!("{}  {}", message.sender_name, message.body);

        }

    }

}

fn required(name: &str) -> Result<String, Box<dyn std::error::Error>> {

    std::env::var(name).map_err(|_| format!("{name} is required").into())

}