macltok

use std::{sync::Arc, time::Duration};

use macltok::{

    AttachmentUpload, ClientHandle, Command, CommandErrorKind, Engine, EngineConfig, EngineError,

    Event, EventStream, LifecycleCommand, MediaCommand, MediaId, MediaSize, RoomCommand,

    TimelineDiff, TimelineItem, UploadDetails, UploadThumbnail,

};

use matrix_sdk::{

    media::{MediaFormat, MediaRequestParameters},

    ruma::{

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

        event_id,

        events::room::{

            EncryptedFile, MediaSource,

            message::{

                AudioMessageEventContent, FileInfo, FileMessageEventContent,

                ImageMessageEventContent, MessageType, RoomMessageEventContent,

            },

        },

        media::Method,

        mxc_uri, room_id,

    },

    test_utils::mocks::MatrixMockServer,

};

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

use serde_json::{Value, json};

use wiremock::{

    Mock, ResponseTemplate,

    matchers::{method, path_regex},

};

struct MediaHarness {

    server: MatrixMockServer,

    client: matrix_sdk::Client,

    handle: ClientHandle,

    events: EventStream,

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

    media_id: MediaId,

}

#[tokio::test]

async fn full_size_uses_full_source() {

    let mut harness = start(file_with_thumbnail()).await;

    mount_downloads(&harness.server).await;

    let bytes = fetch_ready(&mut harness, MediaSize::Full).await;

    assert_eq!(&*bytes, b"binaryjpegfullimagedata");

    assert!(

        media_paths(&harness.server)

            .await

            .iter()

            .any(|path| path.ends_with("/localhost/full"))

    );

    stop(harness).await;

}

#[tokio::test]

async fn encrypted_media_is_cached_as_plaintext_like_the_sdk_does() {

    use std::io::Read as _;

    let plaintext = b"very secret image".to_vec();

    let mut cursor = std::io::Cursor::new(plaintext.clone());

    let mut encryptor = matrix_sdk_crypto::AttachmentEncryptor::new(&mut cursor);

    let mut ciphertext = Vec::new();

    encryptor.read_to_end(&mut ciphertext).unwrap();

    let keys = encryptor.finish();

    let file = EncryptedFile::new(

        mxc_uri!("mxc://localhost/secret").to_owned(),

        keys.encryption_info,

        keys.hashes,

    );

    let source = MediaSource::Encrypted(Box::new(file.clone()));

    let mut harness = start(RoomMessageEventContent::new(MessageType::Image(

        ImageMessageEventContent::encrypted("secret.png".to_owned(), file),

    )))

    .await;

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

        .and(path_regex("/download/localhost/secret$"))

        .respond_with(ResponseTemplate::new(200).set_body_bytes(ciphertext))

        .mount(harness.server.server())

        .await;

    let from_sdk = harness

        .client

        .media()

        .get_media_content(

            &MediaRequestParameters {

                source,

                format: MediaFormat::File,

            },

            true,

        )

        .await

        .unwrap();

    assert_eq!(from_sdk, plaintext);

    assert_eq!(

        &*fetch_ready(&mut harness, MediaSize::Full).await,

        &plaintext[..]

    );

    assert_eq!(media_paths(&harness.server).await.len(), 1);

    stop(harness).await;

}

#[tokio::test]

async fn simultaneous_fetches_share_one_download() {

    let mut harness = start(plain_image()).await;

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

        .and(path_regex("/download/localhost/image$"))

        .respond_with(

            ResponseTemplate::new(200)

                .set_body_bytes(b"shared image bytes".to_vec())

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

        )

        .mount(harness.server.server())

        .await;

    let mut pending = Vec::new();

    for _ in 0..2 {

        pending.push(

            harness

                .handle

                .send(Command::Media(MediaCommand::Fetch {

                    id: harness.media_id.clone(),

                    size: MediaSize::Full,

                }))

                .await

                .unwrap(),

        );

    }

    let mut ready = false;

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

        loop {

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

                Event::MediaReady {

                    media_id, bytes, ..

                } if media_id == harness.media_id => {

                    assert_eq!(&*bytes, b"shared image bytes");

                    ready = true;

                }

                Event::CommandSucceeded { id, .. } => pending.retain(|waiting| *waiting != id),

                Event::CommandFailed(failure) if pending.contains(&failure.id) => {

                    panic!("fetch failed: {failure:?}");

                }

                _ => {}

            }

            if ready && pending.is_empty() {

                break;

            }

        }

    })

    .await

    .expect("both fetches did not complete");

    let downloads = harness

        .server

        .received_requests()

        .await

        .unwrap()

        .iter()

        .filter(|request| request.url.path().ends_with("/download/localhost/image"))

        .count();

    assert_eq!(downloads, 1, "duplicate in-flight media download");

    stop(harness).await;

}

#[tokio::test]

async fn downloaded_media_over_limit_is_rejected() {

    let mut harness = start_with_config(

        plain_image(),

        EngineConfig::default()

            .with_initial_history_limit(0)

            .with_max_media_bytes(4),

    )

    .await;

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

        .and(path_regex("/download/localhost/image$"))

        .respond_with(ResponseTemplate::new(200).set_body_bytes(b"too large".to_vec()))

        .mount(harness.server.server())

        .await;

    let id = harness

        .handle

        .send(Command::Media(MediaCommand::Fetch {

            id: harness.media_id.clone(),

            size: MediaSize::Full,

        }))

        .await

        .unwrap();

    receive_until(&mut harness.events, |event| {

        matches!(event, Event::CommandFailed(failure) if failure.id == id && failure.kind == CommandErrorKind::MediaTooLarge)

    })

    .await;

    stop(harness).await;

}

#[tokio::test]

async fn thumbnail_size_prefers_explicit_thumbnail() {

    let mut harness = start(file_with_thumbnail()).await;

    mount_downloads(&harness.server).await;

    let bytes = fetch_ready(&mut harness, MediaSize::Thumbnail).await;

    assert_eq!(&*bytes, b"binaryjpegfullimagedata");

    let paths = media_paths(&harness.server).await;

    assert!(

        paths

            .iter()

            .any(|path| path.ends_with("/localhost/explicit-thumbnail"))

    );

    assert!(!paths.iter().any(|path| path.ends_with("/localhost/full")));

    stop(harness).await;

}

#[tokio::test]

async fn plain_image_thumbnail_uses_thumbnail_endpoint() {

    let mut harness = start(plain_image()).await;

    harness

        .server

        .mock_media_thumbnail(Method::Scale, 800, 800, false)

        .ok()

        .mount()

        .await;

    harness

        .server

        .mock_authed_media_thumbnail(Method::Scale, 800, 800, false)

        .ok()

        .mount()

        .await;

    let bytes = fetch_ready(&mut harness, MediaSize::Thumbnail).await;

    assert_eq!(&*bytes, b"binaryjpegthumbnaildata");

    assert!(

        media_paths(&harness.server)

            .await

            .iter()

            .any(|path| path.contains("/thumbnail/localhost/image"))

    );

    stop(harness).await;

}

#[tokio::test]

async fn unavailable_thumbnail_reports_returned_command_id() {

    let mut harness = start(plain_audio()).await;

    let command_id = harness

        .handle

        .send(Command::Media(MediaCommand::Fetch {

            id: harness.media_id.clone(),

            size: MediaSize::Thumbnail,

        }))

        .await

        .unwrap();

    let event = receive_until(&mut harness.events, |event| {

        matches!(

            event,

            Event::CommandFailed(failure)

                if failure.id == command_id && failure.kind == CommandErrorKind::MediaUnavailable

        )

    })

    .await;

    assert!(matches!(

        event,

        Event::CommandFailed(failure)

            if failure.id == command_id && failure.kind == CommandErrorKind::MediaUnavailable

    ));

    stop(harness).await;

}

#[tokio::test]

async fn media_upload_is_queued_and_sent() {

    let mut harness = start(plain_image()).await;

    harness

        .server

        .mock_authenticated_media_config()

        .ok_default()

        .mount()

        .await;

    harness

        .server

        .mock_upload()

        .expect_mime_type("image/jpeg")

        .ok(mxc_uri!("mxc://localhost/uploaded"))

        .expect(1)

        .mount()

        .await;

    harness

        .server

        .mock_room_send()

        .ok(event_id!("$uploaded:localhost"))

        .expect(1)

        .mount()

        .await;

    let id = harness

        .handle

        .upload_media(

            room_id!("!media:localhost").to_owned().into(),

            "photo.jpg".to_owned(),

            "image/jpeg".to_owned(),

            b"photo data".to_vec(),

            Some("holiday".to_owned()),

        )

        .await

        .unwrap();

    receive_until(

        &mut harness.events,

        |event| matches!(event, Event::CommandSucceeded { id: completed, .. } if *completed == id),

    )

    .await;

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

        loop {

            let requests = harness.server.received_requests().await.unwrap();

            if requests.iter().any(|request| {

                request.url.path().contains("/send/m.room.message/")

                    && String::from_utf8_lossy(&request.body).contains("mxc://localhost/uploaded")

            }) {

                break;

            }

            tokio::task::yield_now().await;

        }

    })

    .await

    .expect("queued media was not sent");

    stop(harness).await;

}

#[tokio::test]

async fn queued_offline_attachment_exposes_fetchable_local_media() {

    let mut harness = start(plain_image()).await;

    harness.client.send_queue().set_enabled(false).await;

    let original = b"offline image bytes".to_vec();

    let mut upload = AttachmentUpload::new(

        room_id!("!media:localhost").to_owned(),

        "pending.png",

        "image/png",

        original.clone(),

    );

    upload.details = Some(UploadDetails::Image {

        width: Some(32),

        height: Some(16),

        blurhash: None,

    });

    harness.handle.upload_attachment(upload).await.unwrap();

    let event = receive_until(&mut harness.events, |event| {

        event_messages(event).any(|message| {

            message.own

                && message.transaction_id.is_some()

                && message

                    .media

                    .as_ref()

                    .is_some_and(|media| media.filename == "pending.png")

        })

    })

    .await;

    let media = event_messages(&event)

        .find(|message| message.own && message.media.is_some())

        .and_then(|message| message.media.as_ref())

        .unwrap();

    assert_eq!((media.width, media.height), (Some(32), Some(16)));

    assert_eq!(media.size_bytes, Some(original.len() as u64));

    let media_id = media.id.clone();

    let fetch_id = harness

        .handle

        .send(Command::Media(MediaCommand::Fetch {

            id: media_id.clone(),

            size: MediaSize::Full,

        }))

        .await

        .unwrap();

    let ready = receive_until(

        &mut harness.events,

        |event| matches!(event, Event::MediaReady { media_id: id, .. } if id == &media_id),

    )

    .await;

    assert!(matches!(ready, Event::MediaReady { bytes, .. } if *bytes == original));

    receive_until(

        &mut harness.events,

        |event| matches!(event, Event::CommandSucceeded { id, .. } if *id == fetch_id),

    )

    .await;

    stop(harness).await;

}

#[tokio::test]

async fn image_upload_uses_caller_supplied_metadata_and_thumbnail() {

    let mut harness = start(plain_image()).await;

    harness

        .server

        .mock_authenticated_media_config()

        .ok_default()

        .mount()

        .await;

    harness

        .server

        .mock_upload()

        .expect_mime_type("image/png")

        .respond_with(|request: &wiremock::Request| {

            let uri = if request.body == b"thumbnail bytes" {

                "mxc://localhost/image-thumb"

            } else {

                "mxc://localhost/image-upload"

            };

            ResponseTemplate::new(200).set_body_json(json!({ "content_uri": uri }))

        })

        .expect(2)

        .mount()

        .await;

    harness

        .server

        .mock_room_send()

        .ok(event_id!("$image-upload:localhost"))

        .expect(1)

        .mount()

        .await;

    let original = b"image bytes".to_vec();

    let thumbnail_bytes = b"thumbnail bytes".to_vec();

    let mut upload = AttachmentUpload::new(

        room_id!("!media:localhost").to_owned(),

        "large.png",

        "image/png",

        original.clone(),

    );

    upload.details = Some(UploadDetails::Image {

        width: Some(900),

        height: Some(450),

        blurhash: None,

    });

    upload.thumbnail = Some(UploadThumbnail {

        bytes: thumbnail_bytes.clone(),

        mimetype: "image/png".to_owned(),

        width: 800,

        height: 400,

    });

    let id = harness.handle.upload_attachment(upload).await.unwrap();

    receive_until(

        &mut harness.events,

        |event| matches!(event, Event::CommandSucceeded { id: completed, .. } if *completed == id),

    )

    .await;

    let content = uploaded_content(&harness.server).await;

    assert_eq!(content["msgtype"], "m.image");

    assert_eq!(content["info"]["w"], 900);

    assert_eq!(content["info"]["h"], 450);

    assert_eq!(content["info"]["size"], original.len());

    assert_eq!(content["info"]["thumbnail_info"]["w"], 800);

    assert_eq!(content["info"]["thumbnail_info"]["h"], 400);

    assert_eq!(content["info"]["thumbnail_info"]["mimetype"], "image/png");

    assert_eq!(

        content["info"]["thumbnail_info"]["size"],

        thumbnail_bytes.len()

    );

    assert_eq!(

        content["info"]["thumbnail_url"],

        "mxc://localhost/image-thumb"

    );

    assert_eq!(content["url"], "mxc://localhost/image-upload");

    let requests = harness.server.received_requests().await.unwrap();

    let uploads = requests

        .iter()

        .filter(|request| request.url.path().ends_with("/_matrix/media/v3/upload"))

        .collect::<Vec<_>>();

    assert_eq!(uploads.len(), 2);

    assert!(uploads.iter().any(|request| request.body == original));

    assert!(

        uploads

            .iter()

            .any(|request| request.body == thumbnail_bytes)

    );

    stop(harness).await;

}

#[tokio::test]

async fn video_upload_preserves_metadata_and_supplied_thumbnail() {

    let mut harness = start(plain_image()).await;

    harness

        .server

        .mock_authenticated_media_config()

        .ok_default()

        .mount()