macltok

use macltok::{

    EncryptedSessionStore, EngineConfig, Event, PasswordLogin, Retain, RoomMembership, Session,

    SessionStore, StoreConfig, TimelineContent, TimelineDiff, TimelineId, TimelineItem,

    imbl::Vector,

};

#[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")?;

    let sessions = EncryptedSessionStore::file(

        store_path.with_extension("session"),

        StoreConfig::sqlite(&store_path, &passphrase),

    );

    let session = match Session::restore(&sessions).await? {

        Some(session) => session,

        None => {

            Session::login_password(

                PasswordLogin::new(

                    required("MATRIX_HOMESERVER")?,

                    required("MATRIX_USERNAME")?,

                    required("MATRIX_PASSWORD")?,

                )

                .with_device_display_name("macltok headless example"),

                &sessions,

            )

            .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 = Vector::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 TimelineDiff::try_apply_all(diffs, &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 => {

                        sessions.save(&handle.session_record()?).await?;

                    }

                    Event::Stopped => break,

                    _ => {}

                }

            }

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

                result?;

                let handle = handle.clone();

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

            }

        }

    }

    let termination = running.await??;

    drop((handle, events));

    match termination.retain() {

        Retain::RecordAndStore => {}

        Retain::Store => sessions.forget().await?,

        Retain::Nothing => sessions.discard().await?,

    }

    Ok(())

}

fn print_messages(items: &Vector<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())

}