macltok

use std::future::Future;

use futures_util::{StreamExt, stream::FuturesUnordered};

use matrix_sdk::SendOutsideWasm;

pub(super) use matrix_sdk::executor::{AbortHandle, JoinError, JoinHandle, spawn};

#[cfg(not(target_family = "wasm"))]

pub(super) type EngineBoxFuture<'a, T> = futures_util::future::BoxFuture<'a, T>;

#[cfg(target_family = "wasm")]

pub(super) type EngineBoxFuture<'a, T> = futures_util::future::LocalBoxFuture<'a, T>;

#[cfg(not(target_family = "wasm"))]

pub(super) fn is_panic(error: &JoinError) -> bool {

    error.is_panic()

}

/// the sdk's wasm join error has no payload, though a panic there aborts the instance anyway

#[cfg(target_family = "wasm")]

pub(super) fn is_panic(error: &JoinError) -> bool {

    !error.is_cancelled()

}

#[cfg(not(target_family = "wasm"))]

pub(super) fn resume_unwind(error: JoinError) -> ! {

    std::panic::resume_unwind(error.into_panic())

}

#[cfg(target_family = "wasm")]

pub(super) fn resume_unwind(error: JoinError) -> ! {

    panic!("{error}")

}

/// a `JoinSet` that runs on wasm too, and like it aborts whatever's left when dropped

pub(super) struct TaskSet<T: 'static> {

    handles: FuturesUnordered<JoinHandle<T>>,

}

impl<T: 'static> TaskSet<T> {

    pub(super) fn new() -> Self {

        Self {

            handles: FuturesUnordered::new(),

        }

    }

    pub(super) fn spawn(

        &mut self,

        task: impl Future<Output = T> + SendOutsideWasm + 'static,

    ) -> AbortHandle

    where

        T: SendOutsideWasm,

    {

        let handle = spawn(task);

        let abort = handle.abort_handle();

        self.handles.push(handle);

        abort

    }

    pub(super) fn is_empty(&self) -> bool {

        self.handles.is_empty()

    }

    pub(super) async fn join_next(&mut self) -> Option<Result<T, JoinError>> {

        self.handles.next().await

    }

    fn abort_all(&self) {

        for handle in &self.handles {

            handle.abort();

        }

    }

    pub(super) async fn shutdown(&mut self) {

        self.abort_all();

        while self.handles.next().await.is_some() {}

    }

}

impl<T: 'static> Drop for TaskSet<T> {

    fn drop(&mut self) {

        self.abort_all();

    }

}