macltok

#![allow(dead_code)]

use std::time::Duration;

use macltok::{ClientHandle, Event, EventStream, TimelineDiff, TimelineItem, TimelineMessage};

pub async fn receive_until(events: &mut EventStream, predicate: impl Fn(&Event) -> bool) -> Event {

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

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

            if predicate(&event) {

                return event;

            }

        }

        panic!("event stream closed before the expected event");

    })

    .await

    .expect("expected event did not arrive")

}

/// asks for a shutdown while still draining, since the engine won't answer until its events are out

pub async fn shut_down(

    handle: &ClientHandle,

    events: &mut EventStream,

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

) {

    let (answer, _) = tokio::join!(handle.shutdown(), async {

        receive_until(events, |event| matches!(event, Event::Stopped)).await

    });

    answer.unwrap();

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

}

pub fn event_messages(event: &Event) -> Vec<&TimelineMessage> {

    let items = match event {

        Event::TimelineReset { items, .. } => items.iter().collect::<Vec<_>>(),

        Event::TimelineChanged { diffs, .. } => diffs.iter().flat_map(diff_items).collect(),

        _ => Vec::new(),

    };

    items

        .into_iter()

        .filter_map(|item| match item {

            TimelineItem::Message(message) => Some(message.as_ref()),

            _ => None,

        })

        .collect()

}

pub fn diff_items(diff: &TimelineDiff) -> Vec<&TimelineItem> {

    match diff {

        TimelineDiff::Append { values } | TimelineDiff::Reset { values } => values.iter().collect(),

        TimelineDiff::PushFront { value }

        | TimelineDiff::PushBack { value }

        | TimelineDiff::Insert { value, .. }

        | TimelineDiff::Set { value, .. } => vec![value],

        _ => Vec::new(),

    }

}