macltok

use macltok::{

    EngineConfig, Event, PasswordLogin, RoomMembership, Session, StoreConfig, TimelineContent,

    TimelineId, TimelineItem,

};

#[tokio::main]

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

    let store_path = std::path::PathBuf::from(required("MATRIX_STORE_PATH")?);

    let passphrase = required("MATRIX_STORE_PASSPHRASE")?;

    // a real client keeps this somewhere safer, it holds the access token

    let record_path = store_path.join("session.json");

    let store = StoreConfig::new(&store_path, &passphrase);

    let session = match std::fs::read(&record_path) {

        Ok(saved) => Session::restore(serde_json::from_slice(&saved)?, store).await?,

        Err(_) => {

            let session = Session::login_password(

                PasswordLogin::new(

                    required("MATRIX_HOMESERVER")?,

                    required("MATRIX_USERNAME")?,

                    required("MATRIX_PASSWORD")?,

                )

                .with_device_display_name("macltok headless example"),

                store,

            )

            .await?;

            std::fs::write(&record_path, serde_json::to_vec(&session.record())?)?;

            session

        }

    };

    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::SessionTokensChanged => {

                        std::fs::write(&record_path, serde_json::to_vec(&handle.session_record()?)?)?;

                    }

                    Event::LoggedOut | Event::SessionAccessRejected { soft_logout: false } => {

                        std::fs::remove_dir_all(&store_path)?;

                    }

                    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::Event(event) = item

            && let TimelineContent::Message(message) = &event.content

        {

            println!("{}  {}", event.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())

}