use matrix_sdk::{
    config::SyncSettings,
    ruma::events::room::{
        member::StrippedRoomMemberEvent,
        message::{MessageType, OriginalSyncRoomMessageEvent, RoomMessageEventContent},
    },
    Client, Room, RoomState,
};
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = Client::builder()
        .homeserver_url("http://matrix.internal.jpace121.net:8008")
        .build()
        .await?;

    let token = std::env::var("TOKEN")?;

    // First we need to log in.
    let mut login_data = serde_json::Map::new();
    login_data.insert("token".to_string(), token.into());
    client
        .matrix_auth()
        .login_custom("org.matrix.login.jwt", login_data)?
        .initial_device_display_name("bot")
        .send()
        .await?;

    client.add_event_handler(on_stripped_state_member);
    let sync_token = client
        .sync_once(SyncSettings::default())
        .await
        .unwrap()
        .next_batch;

    client.add_event_handler(on_room_message);

    let settings = SyncSettings::default().token(sync_token);
    client.sync(settings).await?;

    Ok(())
}

// This is going to respond to invites.
async fn on_stripped_state_member(
    room_member: StrippedRoomMemberEvent,
    client: Client,
    room: Room,
) {
    if room_member.state_key != client.user_id().unwrap() {
        return;
    }

    tokio::spawn(async move {
        println!("Autojoining room {}", room.room_id());
        let mut delay = 2;

        while let Err(err) = room.join().await {
            sleep(Duration::from_secs(delay)).await;
            delay *= 2;

            if delay > 3600 {
                eprintln!("Can't join room {} ({err:?})", room.room_id());
                break;
            }
        }
        println!("Successfully joined room {}", room.room_id());
    });
}

async fn on_room_message(event: OriginalSyncRoomMessageEvent, room: Room, client: Client) {
    if room.state() != RoomState::Joined {
        return;
    }
    if event.sender == client.user_id().unwrap() {
        return;
    }
    let MessageType::Text(text_content) = event.content.msgtype else {
        return;
    };

    println!("{:?}", text_content.body);

    let content = RoomMessageEventContent::text_plain("i am groot");
    room.send(content).await.unwrap();
}