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(crate) type EngineBoxFuture<'a, T> = futures_util::future::BoxFuture<'a, T>;

#[cfg(target_family = "wasm")]

pub(crate) 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, and a real panic traps before it gets here

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

    }

}

/// a store cipher's pbkdf2 holds its thread for over a second in a debug build, so natively it

/// runs beside the runtime and two stores can derive at once

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

pub(crate) async fn derive<T: Send + 'static>(work: impl FnOnce() -> T + Send + 'static) -> T {

    tokio::task::spawn_blocking(work)

        .await

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

}

#[cfg(target_family = "wasm")]

pub(crate) async fn derive<T>(work: impl FnOnce() -> T) -> T {

    work()

}

/// a command's variant path such as `Room(Open`, cut off before any content reaches a log

pub(crate) fn label(command: &impl std::fmt::Debug) -> String {

    use std::fmt::Write;

    struct Label(String);

    impl Write for Label {

        fn write_str(&mut self, text: &str) -> std::fmt::Result {

            for character in text.chars() {

                if !(character.is_alphanumeric() || character == '_' || character == '(') {

                    return Err(std::fmt::Error);

                }

                self.0.push(character);

            }

            Ok(())

        }

    }

    let mut label = Label(String::new());

    let _ = write!(label, "{command:?}");

    label.0.trim_end_matches('(').to_owned()

}