macltok

use std::time::Duration;

use macltok::{

    ClientHandle, ClientQueryError, Command, CommandErrorKind, CommandId, CommandKind,

    CreateRoomOptions, Engine, EngineConfig, EngineError, Event, EventStream, LifecycleCommand,

    RoomCommand, RoomPreset, RoomVisibility,

};

use matrix_sdk::{

    ruma::{

        api::client::sync::sync_events::v5,

        events::{GlobalAccountDataEventType, RoomAccountDataEventType},

        room_id,

        serde::Raw,

        server_name, user_id,

    },

    test_utils::mocks::MatrixMockServer,

};

use matrix_sdk_test::{InvitedRoomBuilder, JoinedRoomBuilder};

use serde_json::json;

use tokio::task::JoinHandle;

use wiremock::{

    Mock, ResponseTemplate,

    matchers::{body_partial_json, method, path, path_regex, query_param},

};

#[tokio::test]

async fn joining_by_room_id_forwards_via_servers() {

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

    let (server, handle, mut events, running) = start_engine().await;

    Mock::given(method("POST"))

        .and(path(format!("/_matrix/client/v3/join/{room_id}")))

        .and(query_param("via", "relay.example"))

        .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "room_id": room_id })))

        .expect(1)

        .mount(server.server())

        .await;

    let joined_room = handle

        .join_room(

            room_id.to_owned().into(),

            vec![server_name!("relay.example").to_owned()],

        )

        .await

        .unwrap();

    assert_eq!(joined_room, room_id);

    stop_engine(handle, &mut events, running).await;

}

#[tokio::test]

async fn leave_and_forget_report_correlated_success() {

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

    let (server, client) = configured_client().await;

    server.sync_joined_room(&client, room_id).await;

    server.mock_room_leave().ok(room_id).expect(1).mount().await;

    server.mock_room_forget().ok().expect(1).mount().await;

    let (handle, mut events, running) = run_client(client).await;

    let leave_id = handle.leave_room(room_id.to_owned()).await.unwrap();

    receive_room_success(&mut events, leave_id).await;

    let forget_id = handle

        .send(Command::Room(RoomCommand::Forget(room_id.to_owned())))

        .await

        .unwrap();

    receive_room_success(&mut events, forget_id).await;

    assert_ne!(leave_id, forget_id);

    stop_engine(handle, &mut events, running).await;

}

#[tokio::test]

async fn accepting_and_rejecting_invites_use_the_expected_endpoints() {

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

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

    let (server, client) = configured_client().await;

    server

        .sync_room(&client, InvitedRoomBuilder::new(accepted))

        .await;

    server

        .sync_room(&client, InvitedRoomBuilder::new(rejected))

        .await;

    server.mock_room_join(accepted).ok().expect(1).mount().await;

    server

        .mock_room_leave()

        .ok(rejected)

        .expect(1)

        .mount()

        .await;

    let (handle, mut events, running) = run_client(client).await;

    let accept_id = handle.accept_invite(accepted.to_owned()).await.unwrap();

    receive_room_success(&mut events, accept_id).await;

    let reject_id = handle.reject_invite(rejected.to_owned()).await.unwrap();

    receive_room_success(&mut events, reject_id).await;

    stop_engine(handle, &mut events, running).await;

}

#[tokio::test]

async fn creating_a_room_forwards_options() {

    let (server, handle, mut events, running) = start_engine().await;

    Mock::given(method("POST"))

        .and(path("/_matrix/client/v3/createRoom"))

        .and(body_partial_json(json!({

            "name": "Planning",

            "topic": "Next release",

            "room_alias_name": "planning",

            "invite": ["@partner:localhost"],

            "visibility": "public",

            "preset": "public_chat"

        })))

        .respond_with(

            ResponseTemplate::new(200).set_body_json(json!({ "room_id": "!created:localhost" })),

        )

        .expect(1)

        .mount(server.server())

        .await;

    let created_room = handle

        .create_room(CreateRoomOptions {

            name: Some("Planning".to_owned()),

            topic: Some("Next release".to_owned()),

            alias_localpart: Some("planning".to_owned()),

            invite: vec![user_id!("@partner:localhost").to_owned()],

            visibility: RoomVisibility::Public,

            preset: Some(RoomPreset::PublicChat),

            ..Default::default()

        })

        .await

        .unwrap();

    assert_eq!(created_room, room_id!("!created:localhost").to_owned());

    stop_engine(handle, &mut events, running).await;

}

#[tokio::test]

async fn creating_a_direct_room_invites_the_other_user() {

    let (server, handle, mut events, running) = start_engine().await;

    Mock::given(method("POST"))

        .and(path("/_matrix/client/v3/createRoom"))

        .and(body_partial_json(json!({

            "invite": ["@partner:localhost"],

            "is_direct": true,

            "preset": "trusted_private_chat"

        })))

        .respond_with(

            ResponseTemplate::new(200).set_body_json(json!({ "room_id": "!direct:localhost" })),

        )

        .expect(1)

        .mount(server.server())

        .await;

    Mock::given(method("GET"))

        .and(path_regex(

            r"^/_matrix/client/v3/user/.*/account_data/m\.direct$",

        ))

        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))

        .expect(1)

        .mount(server.server())

        .await;

    Mock::given(method("PUT"))

        .and(path_regex(

            r"^/_matrix/client/v3/user/.*/account_data/m\.direct$",

        ))

        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))

        .expect(1)

        .mount(server.server())

        .await;

    let direct_room = handle

        .create_direct(user_id!("@partner:localhost").to_owned())

        .await

        .unwrap();

    assert_eq!(direct_room, room_id!("!direct:localhost").to_owned());

    stop_engine(handle, &mut events, running).await;

}

#[tokio::test]

async fn unknown_rooms_fail_membership_commands_with_their_ids() {

    let (server, handle, mut events, running) = start_engine().await;

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

    for command in [

        RoomCommand::Leave(unknown.to_owned()),

        RoomCommand::Forget(unknown.to_owned()),

        RoomCommand::AcceptInvite(unknown.to_owned()),

        RoomCommand::RejectInvite(unknown.to_owned()),

    ] {

        let id = handle.send(Command::Room(command)).await.unwrap();

        receive_room_failure(&mut events, id, CommandErrorKind::RoomUnknown).await;

    }

    stop_engine(handle, &mut events, running).await;

    drop(server);

}

#[tokio::test]

async fn account_data_reads_synced_values_and_writes_raw_content() {

    let room_id = room_id!("!account-data:localhost");

    let (server, client) = configured_client().await;

    server

        .sync_room(

            &client,

            JoinedRoomBuilder::new(room_id).add_account_data(

                Raw::new(&json!({ "type": "m.fully_read", "content": { "event_id": "$seen:localhost" } }))

                    .unwrap()

                    .cast_unchecked(),

            ),

        )

        .await;

    server

        .mock_sync()

        .ok_and_run(&client, |builder| {

            builder.add_custom_global_account_data(json!({

                "type": "com.example.preferences",

                "content": { "theme": "dark" }

            }));

        })

        .await;

    let (engine, handle, mut events) = Engine::from_client(client, EngineConfig::default())

        .await

        .unwrap();

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

    let global_type = GlobalAccountDataEventType::from("com.example.preferences".to_owned());

    let room_type = RoomAccountDataEventType::FullyRead;

    let global = handle

        .global_account_data(global_type.clone())

        .await

        .unwrap()

        .unwrap();

    assert_eq!(

        global.deserialize_as::<serde_json::Value>().unwrap()["theme"],

        "dark"

    );

    let room = handle

        .room_account_data(room_id, room_type.clone())

        .await

        .unwrap()

        .unwrap();

    assert_eq!(

        room.deserialize_as::<serde_json::Value>().unwrap()["content"]["event_id"],

        "$seen:localhost"

    );

    assert!(matches!(

        handle

            .room_account_data(room_id!("!missing:localhost"), room_type.clone())

            .await,

        Err(ClientQueryError::RoomUnknown(_))

    ));

    Mock::given(method("PUT"))

        .and(path(

            "/_matrix/client/v3/user/@example:localhost/account_data/com.example.preferences",

        ))

        .and(body_partial_json(json!({ "theme": "light" })))

        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))

        .expect(1)

        .mount(server.server())

        .await;

    server

        .mock_set_room_account_data(room_type.clone())

        .ok()

        .expect(1)

        .mount()

        .await;

    handle

        .set_global_account_data(

            global_type,

            Raw::new(&json!({ "theme": "light" }))

                .unwrap()

                .cast_unchecked(),

        )

        .await

        .unwrap();

    handle

        .set_room_account_data(

            room_id,

            room_type,

            Raw::new(&json!({ "event_id": "$later:localhost" }))

                .unwrap()

                .cast_unchecked(),

        )

        .await

        .unwrap();

    assert!(matches!(

        handle

            .set_room_account_data(

                room_id!("!missing:localhost"),

                RoomAccountDataEventType::FullyRead,

                Raw::new(&json!({ "event_id": "$later:localhost" }))

                    .unwrap()

                    .cast_unchecked()

            )

            .await,

        Err(ClientQueryError::RoomUnknown(_))

    ));

    stop_engine(handle, &mut events, running).await;

}

async fn configured_client() -> (MatrixMockServer, matrix_sdk::Client) {

    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;

    server.mock_room_state_encryption().plain().mount().await;

    (server, client)

}

async fn start_engine() -> (

    MatrixMockServer,

    ClientHandle,

    EventStream,

    JoinHandle<Result<(), EngineError>>,

) {

    let (server, client) = configured_client().await;

    let (handle, events, running) = run_client(client).await;

    (server, handle, events, running)

}

async fn run_client(

    client: matrix_sdk::Client,

) -> (

    ClientHandle,

    EventStream,

    JoinHandle<Result<(), EngineError>>,

) {

    let config = EngineConfig::default().with_initial_history_limit(0);

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

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

    (handle, events, running)

}

async fn receive_room_success(events: &mut EventStream, expected_id: CommandId) {

    tokio::time::timeout(Duration::from_secs(3), async {

        loop {

            match events.recv().await.expect("event stream closed") {

                Event::CommandSucceeded {

                    id,

                    command: CommandKind::Room,

                } if id == expected_id => break,

                Event::CommandFailed(failure) if failure.id == expected_id => {

                    panic!("room command failed {failure:?}")

                }

                _ => {}

            }

        }

    })

    .await

    .expect("room command did not complete");

}

async fn receive_room_failure(

    events: &mut EventStream,

    expected_id: CommandId,

    expected_kind: CommandErrorKind,

) {

    tokio::time::timeout(Duration::from_secs(3), async {

        loop {

            match events.recv().await.expect("event stream closed") {

                Event::CommandFailed(failure) if failure.id == expected_id => {

                    assert_eq!(failure.command, CommandKind::Room);

                    assert_eq!(failure.kind, expected_kind);

                    break;

                }

                Event::CommandSucceeded { id, .. } if id == expected_id => {

                    panic!("room command unexpectedly succeeded")

                }

                _ => {}

            }

        }

    })

    .await

    .expect("room command did not fail");

}

async fn stop_engine(

    handle: ClientHandle,

    events: &mut EventStream,

    running: JoinHandle<Result<(), EngineError>>,

) {

    let id = handle

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

        .await

        .unwrap();

    tokio::time::timeout(Duration::from_secs(3), async {

        let mut succeeded = false;

        while let Some(event) = events.recv().await {

            match event {

                Event::CommandSucceeded {

                    id: completed,

                    command: CommandKind::Lifecycle,

                } if completed == id => succeeded = true,

                Event::Stopped => {

                    assert!(succeeded);

                    break;

                }

                _ => {}

            }

        }

    })

    .await

    .expect("engine did not stop");

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

}