macltok

use std::time::Duration;

use futures_util::StreamExt;

use matrix_sdk::{

    deserialized_responses::TimelineEventKind, event_cache::RedecryptorReport,

    test_utils::mocks::MatrixMockServer,

};

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

use ruma::{RoomVersionId, device_id, event_id, room_id, user_id};

use serde_json::json;

#[tokio::test]

async fn late_key_exposes_a_mention_without_a_ui_timeline() {

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

    server.mock_crypto_endpoints_preset().await;

    let alice_id = user_id!("@alice:localhost");

    let bob_id = user_id!("@bob:localhost");

    let room_id = room_id!("!mentions-encrypted:localhost");

    let event_id = event_id!("$late-mention");

    let alice = server

        .client_builder_for_crypto_end_to_end(alice_id, device_id!("ALICEDEVICE"))

        .build()

        .await;

    let bob = server

        .client_builder_for_crypto_end_to_end(bob_id, device_id!("BOBDEVICE"))

        .build()

        .await;

    bob.event_cache().subscribe().unwrap();

    server.exchange_e2ee_identities(&alice, &bob).await;

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

    let joined = JoinedRoomBuilder::new(room_id)

        .add_state_event(factory.create(alice_id, RoomVersionId::V1))

        .add_state_event(factory.room_encryption())

        .add_state_event(factory.member(alice_id))

        .add_state_event(factory.member(bob_id));

    server.sync_room(&alice, joined.clone()).await;

    server.sync_room(&bob, joined).await;

    let room = alice.get_room(room_id).unwrap();

    let (encrypted_event, send) = server.mock_room_send().ok_with_capture(event_id, alice_id);

    let _send = send.mock_once().mount_as_scoped().await;

    let (_keys, room_key) = server.mock_capture_put_to_device(alice_id).await;

    server

        .mock_get_members()

        .ok(vec![

            factory.member(alice_id).into_raw(),

            factory.member(bob_id).into_raw(),

        ])

        .mock_once()

        .mount()

        .await;

    room.send_raw(

        "m.room.message",

        json!({

            "msgtype": "m.text",

            "body": "a private mention",

            "m.mentions": { "user_ids": [bob_id] }

        }),

    )

    .await

    .unwrap();

    let encrypted_event = encrypted_event.await.unwrap();

    let room_key = room_key.await;

    let mut sync_updates = bob.subscribe_to_all_room_updates();

    let mut cache_updates = bob.event_cache().subscribe_to_room_generic_updates();

    let mut reports = bob.event_cache().subscribe_to_decryption_reports();

    server

        .sync_room(

            &bob,

            JoinedRoomBuilder::new(room_id).add_timeline_event(encrypted_event),

        )

        .await;

    let update = sync_updates.recv().await.unwrap();

    let event = &update.joined[room_id].timeline.events[0];

    assert!(matches!(

        event.kind,

        TimelineEventKind::UnableToDecrypt { .. }

    ));

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

        while cache_updates.recv().await.unwrap().room_id != room_id {}

    })

    .await

    .unwrap();

    server

        .mock_sync()

        .ok_and_run(&bob, |sync| {

            sync.add_to_device_event(room_key.deserialize_as().unwrap());

        })

        .await;

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

        while let Some(report) = reports.next().await {

            if let Ok(RedecryptorReport::ResolvedUtds {

                room_id: resolved,

                events,

            }) = report

            {

                if resolved == room_id && events.contains(event_id) {

                    return;

                }

            }

        }

        panic!("decryption reports ended before the mention was decrypted");

    })

    .await

    .unwrap();

    let room = bob.get_room(room_id).unwrap();

    let (cache, _cache_handles) = room.event_cache().await.unwrap();

    let decrypted = cache.find_event(event_id).await.unwrap().unwrap();

    assert!(matches!(decrypted.kind, TimelineEventKind::Decrypted(_)));

    let content = decrypted

        .raw()

        .get_field::<serde_json::Value>("content")

        .unwrap()

        .unwrap();

    assert_eq!(content["body"], "a private mention");

    assert_eq!(content["m.mentions"]["user_ids"], json!([bob_id]));

    let push_actions = room

        .event_push_actions(decrypted.raw())

        .await

        .unwrap()

        .unwrap();

    assert!(push_actions.iter().any(|action| action.should_notify()));

    assert_eq!(cache.events().await.unwrap().len(), 1);

}