macltok

use std::time::Duration;

use macltok::{Engine, EngineConfig};

use matrix_sdk::{

    ruma::{api::client::sync::sync_events::v5, room_id, user_id},

    test_utils::mocks::MatrixMockServer,

};

use matrix_sdk_test::{JoinedRoomBuilder, event_factory::EventFactory};

use wiremock::ResponseTemplate;

async fn prepare_twice(encrypted: bool, member_syncs: u64) {

    let server = MatrixMockServer::new().await;

    server

        .mock_sliding_sync()

        .ok(v5::Response::new("1".to_owned()))

        .mount()

        .await;

    let client = server.client_builder().build().await;

    let room_id = room_id!("!prepare:localhost");

    let factory = EventFactory::new().room(room_id);

    let mut room = JoinedRoomBuilder::new(room_id).add_state_event(

        factory

            .member(user_id!("@example:localhost"))

            .into_raw_sync_state(),

    );

    if encrypted {

        room = room.add_state_event(

            factory

                .room_encryption()

                .sender(user_id!("@example:localhost"))

                .into_raw_sync_state(),

        );

    }

    server.sync_room(&client, room).await;

    let member: matrix_sdk::ruma::serde::Raw<

        matrix_sdk::ruma::events::room::member::RoomMemberEvent,

    > = factory.member(user_id!("@example:localhost")).into_raw();

    server

        .mock_get_members()

        .respond_with(

            ResponseTemplate::new(200)

                .set_body_json(serde_json::json!({ "chunk": [member] }))

                .set_delay(Duration::from_millis(300)),

        )

        .expect(member_syncs)

        .mount()

        .await;

    let encryption = server.mock_room_state_encryption();

    if encrypted {

        encryption.encrypted().mount().await;

    } else {

        encryption.plain().mount().await;

    }

    server.mock_query_keys().ok().mount().await;

    let config = EngineConfig::default()

        .with_initial_history_limit(0)

        .with_prepare_to_send(false);

    let (engine, handle, mut events) = Engine::from_client(client, config).await.unwrap();

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

    let draining = tokio::spawn(async move { while events.recv().await.is_some() {} });

    let (first, second) = tokio::join!(

        handle.prepare_to_send(room_id.to_owned()),

        handle.prepare_to_send(room_id.to_owned()),

    );

    first.unwrap();

    second.unwrap();

    handle.shutdown().await.unwrap();

    running.await.unwrap().unwrap();

    draining.await.unwrap();

    server.server().verify().await;

}

#[tokio::test]

async fn two_prepares_at_once_sync_members_once() {

    prepare_twice(true, 1).await;

}

#[tokio::test]

async fn a_plain_room_needs_no_preparing() {

    prepare_twice(false, 0).await;

}