main.rs

#![allow(unused_imports)]

mod config;
use crate::config::Config;

use matrix_sdk::{
    deserialized_responses::EncryptionInfo,
    room::Room,
    ruma::{
        events::{
            macros::EventContent, push_rules::PushRulesEvent, room::message::MessageEventContent,
            room::topic::TopicEventContent, AnyRoomEvent, AnySyncRoomEvent, StateEvent,
            SyncMessageEvent,
        },
        UserId,
    },
    Client, LoopCtrl, Result, SyncSettings, RoomInfo,
};

use matrix_sdk::ruma::{events::SyncStateEvent, Int, MilliSecondsSinceUnixEpoch};

use std::convert::TryFrom;
use std::path::Path;
use std::{env, process::exit};

#[tokio::main]
async fn main() -> Result<()> {
    if env::args().len() != 2 {
        let default_file = env::args()
            .nth(0)
            .unwrap()
            .split(std::path::MAIN_SEPARATOR)
            .last()
            .unwrap()
            .to_string()
            + ".yml";
        if Path::new(&default_file).exists() {
            panic!(
                "Args count is {}, you need to only specify the config file for the bot",
                env::args().len() - 1
            );
        } else {
            match config::write_default(&default_file) {
                Ok(()) => panic!(
                    "Args count is {}, you need to only specify the config file for the bot. \
                 The default config file was written to '{}'",
                    env::args().len() - 1,
                    default_file
                ),
                Err(e) => panic!(
                    "Args count is {}, you need to only specify the config file for the bot. \
                 The default config file '{}' could not be written: {}",
                    env::args().len() - 1,
                    default_file,
                    e
                ),
            }
        }
    }

    let config_file = env::args().last().unwrap();
    println!("Using config file: {}", config_file);
    return match config::from_file(&config_file) {
        Ok(config) => {
            let alice = UserId::try_from(config.user_name)?;
            let client = Client::new(config.homeserver_url)?;

            // Login
            client
                .login(
                    alice.localpart(),
                    config.user_password.as_str(),
                    None,
                    Some(config.display_name.as_str()),
                )
                .await?;
            println!("Logged as: {}", alice);

            // Don't respond to old messages
            client.sync_once(SyncSettings::default()).await?;

            // https://docs.rs/ruma/0.4.0/ruma/events/enum.AnySyncMessageEvent.html
            client
                .register_event_handler(
                    |ev: SyncMessageEvent<MessageEventContent>,
                     room: Room,
                     encryption_info: Option<EncryptionInfo>| async move {
                        println!(
                            "---\nROOM: {:?}\nENC: {:?}\nSME: {:?}",
                            room, encryption_info, ev
                        );
                    },
                )
                .await;

            println!("Entering sync loop");
            let token = client.sync_token().await.unwrap();
            let settings = SyncSettings::default().token(token);
            client.sync(settings).await;
            Ok(())
        }
        Err(e) => panic!(
            "Failed to read config file '{}' with error: {}",
            config_file, e
        ),
    };
}