macltok

use std::time::Duration;

use macltok::{

    ClientHandle, Command, CommandErrorKind, CommandId, CommandKind, Engine, EngineConfig,

    EngineError, Event, EventStream, LifecycleCommand, MessageContent, MessageEditContent,

    RichText, RoomCommand, TimelineCommand,

};

use matrix_sdk::{

    ruma::{RoomId, api::client::sync::sync_events::v5, event_id, room_id},

    test_utils::mocks::MatrixMockServer,

};

use tokio::task::JoinHandle;

#[tokio::test]

async fn empty_message_bodies_report_their_command_ids() {

    let room_id = room_id!("!empty-bodies:localhost");

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

    open_room(&handle, &mut events, room_id).await;

    let commands = [

        TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::text(String::new()),

        },

        TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::emote(RichText::plain("   "), Default::default()),

        },

        TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::reply(

                event_id!("$reply:localhost").to_owned(),

                RichText::plain("\n"),

                Default::default(),

            ),

        },

        TimelineCommand::Edit {

            timeline_id: room_id.to_owned().into(),

            event_id: event_id!("$edit:localhost").to_owned(),

            content: MessageEditContent::text("\t"),

        },

    ];

    for command in commands {

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

        let failure = receive_command_failure(&mut events, id).await;

        assert_eq!(failure.id, id);

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

        assert_eq!(failure.kind, CommandErrorKind::EmptyBody);

    }

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

    drop(server);

}

#[tokio::test]

async fn open_resets_the_timeline_before_succeeding() {

    let room_id = room_id!("!open-order:localhost");

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

    open_room(&handle, &mut events, room_id).await;

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

    drop(server);

}

#[tokio::test]

async fn same_room_sends_complete_in_submission_order() {

    let room_id = room_id!("!send-order:localhost");

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

    open_room(&handle, &mut events, room_id).await;

    let first_id = handle

        .send(Command::Timeline(TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::text("first"),

        }))

        .await

        .unwrap();

    let second_id = handle

        .send(Command::Timeline(TimelineCommand::Send {

            timeline_id: room_id.to_owned().into(),

            content: MessageContent::text("second"),

        }))

        .await

        .unwrap();

    assert_eq!(

        receive_timeline_completion(&mut events, &[first_id, second_id]).await,

        vec![first_id, second_id]

    );

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

    drop(server);

}

async fn start_engine(

    room_id: &RoomId,

) -> (

    MatrixMockServer,

    ClientHandle,

    EventStream,

    JoinHandle<Result<(), EngineError>>,

) {

    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.sync_joined_room(&client, room_id).await;

    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());

    (server, handle, events, running)

}

async fn open_room(handle: &ClientHandle, events: &mut EventStream, room_id: &RoomId) -> CommandId {

    let id = handle

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

        .await

        .unwrap();

    let mut reset_received = false;

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

        loop {

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

                Event::TimelineReset {

                    timeline_id: reset_timeline,

                    ..

                } if reset_timeline.room_id() == room_id => reset_received = true,

                Event::CommandSucceeded {

                    id: succeeded_id,

                    command: CommandKind::Room,

                } if succeeded_id == id => {

                    assert!(reset_received);

                    break;

                }

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

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

                }

                _ => {}

            }

        }

    })

    .await

    .expect("room did not open");

    id

}

async fn receive_command_failure(

    events: &mut EventStream,

    expected_id: CommandId,

) -> macltok::CommandFailure {

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

        loop {

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

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

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

                    panic!("command unexpectedly succeeded")

                }

                _ => {}

            }

        }

    })

    .await

    .expect("command failure did not arrive")

}

async fn receive_timeline_completion(

    events: &mut EventStream,

    expected_ids: &[CommandId],

) -> Vec<CommandId> {

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

        let mut completed = Vec::new();

        while completed.len() < expected_ids.len() {

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

                Event::CommandSucceeded {

                    id,

                    command: CommandKind::Timeline,

                } if expected_ids.contains(&id) => completed.push(id),

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

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

                }

                _ => {}

            }

        }

        completed

    })

    .await

    .expect("timeline commands did not complete")

}

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(2), async {

        let mut succeeded = false;

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

            match event {

                Event::CommandSucceeded {

                    id: succeeded_id,

                    command: CommandKind::Lifecycle,

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

                Event::Stopped => {

                    assert!(succeeded);

                    break;

                }

                _ => {}

            }

        }

    })

    .await

    .expect("engine did not stop");

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

}