macltok

use macltok::{

    Command, CommandKind, EngineConfig, Event, LifecycleCommand, PasswordLogin, RoomCommand,

    RoomMembership, Session, StoreConfig, TimelineCommand,

};

#[tokio::main]

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

    let homeserver = required("MATRIX_HOMESERVER")?;

    let username = required("MATRIX_USERNAME")?;

    let password = required("MATRIX_PASSWORD")?;

    let store_path = required("MATRIX_STORE_PATH")?;

    let store_passphrase = required("MATRIX_STORE_PASSPHRASE")?;

    let session = Session::login_password(

        PasswordLogin {

            homeserver,

            username,

            password,

            device_display_name: Some("macltok headless example".into()),

            device_id: None,

        },

        StoreConfig::new(store_path, store_passphrase),

    )

    .await?;

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

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

    let mut room_open_id = None;

    let mut resync_id = None;

    let mut timeline_items = Vec::new();

    loop {

        tokio::select! {

            event = events.recv() => {

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

                match event {

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

                        if let Some(room) = handle

                            .rooms()

                            .await

                            .into_iter()

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

                        {

                            room_open_id = Some(handle

                                .send(Command::Room(RoomCommand::Open(room.room_id)))

                                .await?);

                        }

                    }

                    Event::TimelineReset { items, .. } => {

                        timeline_items = items;

                        resync_id = None;

                    }

                    Event::TimelineChanged { timeline_id, diffs } if resync_id.is_none() => {

                        for diff in diffs {

                            if diff.try_apply(&mut timeline_items).is_err() {

                                resync_id = Some(handle.send(Command::Timeline(

                                    TimelineCommand::Resync { timeline_id },

                                )).await?);

                                break;

                            }

                        }

                        if resync_id.is_none() {

                            for item in &timeline_items {

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

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

                                }

                            }

                        }

                    }

                    Event::CommandSucceeded { id, command: CommandKind::Room }

                        if room_open_id == Some(id) => println!("room ready"),

                    Event::CommandFailed(error) if room_open_id == Some(error.id)

                        || resync_id == Some(error.id) => return Err(error.message.into()),

                    Event::CommandFailed(error) => {

                        eprintln!("{:?}  {}", error.command, error.message);

                    }

                    Event::Stopped => break,

                    _ => {}

                }

            }

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

                result?;

                handle

                    .send(Command::Lifecycle(LifecycleCommand::Shutdown))

                    .await?;

            }

        }

    }

    running.await??;

    Ok(())

}

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

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

}