dbuff 0.1.0

#![allow(private_bounds)]

use std::sync::Arc;

use crate::command::{Command, ControlFlow};
use crate::domain::SharedDomainData;
use crate::task_status::TaskStatus;

#[cfg(feature = "error-stack")]
use crate::error::BoxError;
#[cfg(feature = "error-stack")]
use crate::error::DbuffErr;
#[cfg(feature = "error-stack")]
use crate::error::ErasedError;
#[cfg(feature = "error-stack")]
use error_stack::Report;

#[cfg(feature = "error-stack")]
type ErrorHandler<D> =
    Option<Arc<dyn Fn(error_stack::Report<crate::error::DbuffErr>, &mut D) + Send + Sync>>;
#[cfg(not(feature = "error-stack"))]
type ErrorHandler<D> =
    Option<Arc<dyn Fn(Box<dyn std::error::Error + Send + Sync>, &mut D) + Send + Sync>>;

type ChainError = Arc<dyn std::error::Error + Send + Sync>;

/// Handle to a spawned chain task.
///
/// Returned by [`DomainChain::go`]. Wraps a [`tokio::task::JoinHandle`] and
/// implements [`Future`] so it works with [`tokio::select!`]. All
/// `JoinHandle` methods (`.abort()`, `.is_finished()`, etc.) are available
/// via [`Deref`].
///
/// # Awaiting
///
/// ```ignore
/// let result: Result<ControlFlow, tokio::task::JoinError> = handle.await;
/// ```
pub struct ChainHandle {
    inner: tokio::task::JoinHandle<ControlFlow>,
}

impl std::future::Future for ChainHandle {
    type Output = Result<ControlFlow, tokio::task::JoinError>;

    fn poll(
        self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Self::Output> {
        let inner = unsafe { self.map_unchecked_mut(|s| &mut s.inner) };
        inner.poll(cx)
    }
}

impl std::ops::Deref for ChainHandle {
    type Target = tokio::task::JoinHandle<ControlFlow>;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

#[cfg(feature = "error-stack")]
#[allow(private_bounds)]
pub(crate) trait CmdError:
    std::fmt::Debug + std::fmt::Display + Send + Sync + 'static
{
}
#[cfg(feature = "error-stack")]
impl<T> CmdError for T
where
    T: std::fmt::Debug + std::fmt::Display + Send + Sync + 'static,
{}

#[cfg(not(feature = "error-stack"))]
#[allow(private_bounds)]
pub(crate) trait CmdError: std::error::Error + Send + Sync + 'static {}
#[cfg(not(feature = "error-stack"))]
impl<T> CmdError for T
where
    T: std::error::Error + Send + Sync + 'static,
{}

#[cfg(not(feature = "error-stack"))]
struct ArcErrorWrapper(Arc<dyn std::error::Error + Send + Sync>);

#[cfg(not(feature = "error-stack"))]
impl std::fmt::Display for ArcErrorWrapper {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

#[cfg(not(feature = "error-stack"))]
impl std::fmt::Debug for ArcErrorWrapper {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

#[cfg(not(feature = "error-stack"))]
impl std::error::Error for ArcErrorWrapper {}

#[cfg(feature = "error-stack")]
struct DebugDisplayAdapter(Arc<dyn ErasedError>);

#[cfg(feature = "error-stack")]
impl std::fmt::Display for DebugDisplayAdapter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

#[cfg(feature = "error-stack")]
impl std::fmt::Debug for DebugDisplayAdapter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

#[cfg(feature = "error-stack")]
impl std::error::Error for DebugDisplayAdapter {}

/// A domain-bound executor for chaining commands with ergonomic setters.
///
/// Created via [`SharedDomainData::bind`]. Add commands with [`exec`](DomainExecutor::exec)
/// or [`exec_discard`](DomainExecutor::exec_discard) to produce a [`DomainChain`], then
/// extend it with more [`exec`](DomainChain::exec), [`then`](DomainChain::then), or
/// [`exec_discard`](DomainChain::exec_discard) calls. Finish with [`go`](DomainChain::go)
/// to spawn the entire chain as a single sequential task.
///
/// # Execution model
///
/// All commands in a chain execute **sequentially** — each command completes fully
/// before the next one begins. The chain is composed into a single async future,
/// so there is no parallelism between commands within the same chain.
///
/// # Building chains
///
/// ```
/// use dbuff::*;
/// use std::time::Duration;
///
/// # #[derive(Clone, Default)]
/// # struct Data { user_id: i32, post_count: usize }
/// # #[derive(Debug, Clone, wherror::Error)]
/// # #[error(debug)]
/// # struct E;
/// # struct FetchUser(i32);
/// # #[async_trait::async_trait]
/// # impl Command<()> for FetchUser {
/// #     type Output = i32;
/// #     type Error = E;
/// #     async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> { Ok(self.0) }
/// # }
/// # struct FetchPosts(i32);
/// # #[async_trait::async_trait]
/// # impl Command<()> for FetchPosts {
/// #     type Output = usize;
/// #     type Error = E;
/// #     async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> {
/// #         Ok(self.0 as usize * 10)
/// #     }
/// # }
/// # struct Log(String);
/// # #[async_trait::async_trait]
/// # impl Command<()> for Log {
/// #     type Output = String;
/// #     type Error = E;
/// #     async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> { Ok(self.0) }
/// # }
/// # async fn example() {
/// # let (domain, wh) = SharedDomainData::with_coalesce(Data::default(), Duration::from_millis(1));
/// # tokio::spawn(wh.run());
/// # let rt = tokio::runtime::Handle::current();
///
/// // Start a chain
/// domain.bind((), rt)
///     .exec(FetchUser(42), |d, id: &i32| d.user_id = *id)
///     .then(|id: &i32| FetchPosts(*id), |d, count: &usize| d.post_count = *count)
///     .exec_discard(Log("done".into()))
///     .go();
///
/// tokio::time::sleep(Duration::from_millis(10)).await;
/// assert_eq!(domain.read().user_id, 42);
/// assert_eq!(domain.read().post_count, 420);
/// # }
/// ```
///
/// # Type parameters
///
/// - `D`: The domain data type.
/// - `S`: The services type.
pub struct DomainExecutor<D, S> {
    pub(crate) domain: SharedDomainData<D>,
    pub(crate) services: S,
    pub(crate) rt: tokio::runtime::Handle,
    pub(crate) error_handler: ErrorHandler<D>,
}

impl<D, S> DomainExecutor<D, S>
where
    D: Clone + Send + Sync + 'static,
    S: Clone + Send + 'static,
{
    /// Set a chain-level error callback.
    ///
    /// When any command in the chain returns `Err`, this callback is invoked
    /// with the error report and a mutable reference to the domain data.
    /// The callback runs on the write task via [`SharedDomainData::modify`].
    #[cfg(feature = "error-stack")]
    #[must_use = "the error handler must be consumed as part of the chain"]
    pub fn on_error(
        mut self,
        f: impl Fn(Report<DbuffErr>, &mut D) + Send + Sync + 'static,
    ) -> Self {
        self.error_handler = Some(Arc::new(f));
        self
    }

    /// Set a chain-level error callback.
    ///
    /// When any command in the chain returns `Err`, this callback is invoked
    /// with the boxed error and a mutable reference to the domain data.
    /// The callback runs on the write task via [`SharedDomainData::modify`].
    #[cfg(not(feature = "error-stack"))]
    #[must_use = "the error handler must be consumed as part of the chain"]
    pub fn on_error(
        mut self,
        f: impl Fn(Box<dyn std::error::Error + Send + Sync>, &mut D) + Send + Sync + 'static,
    ) -> Self {
        self.error_handler = Some(Arc::new(f));
        self
    }

    /// Execute a command and apply its output to domain state.
    ///
    /// This command runs **after** the previous command in the chain completes.
    /// The previous command's output is **dropped** — this command runs independently.
    /// If you need the previous output, use [`then`](DomainChain::then) instead.
    ///
    /// The `setter` receives `&C::Output` (by reference) and is called on success
    /// to update domain state. On error, the [`on_error`](Self::on_error) callback
    /// is invoked (if set) and the chain short-circuits (remaining commands are skipped).
    ///
    /// Returns a [`DomainChain`] that can be extended with more commands.
    pub fn exec<C>(
        self,
        cmd: C,
        setter: impl Fn(&mut D, &C::Output) + Send + Sync + 'static,
    ) -> DomainChain<D, C::Output, S>
    where
        C: Command<S> + 'static,
        C::Output: Clone + Send + 'static,
        C::Error: CmdError,
    {
        let domain = self.domain.clone();
        let services = self.services.clone();
        let err_handler = self.error_handler.clone();
        let setter = Arc::new(setter);

        let future: std::pin::Pin<
            Box<dyn std::future::Future<Output = Result<C::Output, ChainError>> + Send + 'static>,
        > = Box::pin(async move {
            match cmd.execute(services).await {
                Ok(output) => {
                    let setter = setter;
                    let output_for_setter = output.clone();
                    domain.modify(move |d| setter(d, &output_for_setter));
                    Ok(output)
                }
                Err(e) => {
                    #[cfg(feature = "error-stack")]
                    let shared: Arc<dyn ErasedError> = Arc::new(e);
                    #[cfg(feature = "error-stack")]
                    let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                    #[cfg(not(feature = "error-stack"))]
                    let err: ChainError = Arc::new(e);

                    if let Some(h) = &err_handler {
                        let h = h.clone();
                        #[cfg(feature = "error-stack")]
                        domain.modify(move |d| {
                            h(
                                Report::new(BoxError(Box::new(DebugDisplayAdapter(shared))))
                                    .change_context(DbuffErr),
                                d,
                            );
                        });
                        #[cfg(not(feature = "error-stack"))]
                        {
                            let err = err.clone();
                            domain.modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                        }
                    }
                    Err(err)
                }
            }
        });

        DomainChain {
            future,
            domain: self.domain.clone(),
            services: self.services.clone(),
            rt: self.rt.clone(),
            error_handler: self.error_handler,
        }
    }

    /// Execute a command and discard its output.
    ///
    /// This command runs **after** the previous command in the chain completes.
    /// The output is thrown away — no setter is needed. Useful for fire-and-forget
    /// side effects (logging, notifications).
    ///
    /// Returns a [`DomainChain`] with output type `()` that can still be extended
    /// with more commands.
    pub fn exec_discard<C>(self, cmd: C) -> DomainChain<D, (), S>
    where
        C: Command<S> + 'static,
        C::Error: CmdError,
    {
        let services = self.services.clone();
        let err_handler = self.error_handler.clone();
        let domain = self.domain.clone();

        let future: std::pin::Pin<
            Box<dyn std::future::Future<Output = Result<(), ChainError>> + Send + 'static>,
        > = Box::pin(async move {
            match cmd.execute(services).await {
                Ok(_) => Ok(()),
                Err(e) => {
                    #[cfg(feature = "error-stack")]
                    let shared: Arc<dyn ErasedError> = Arc::new(e);
                    #[cfg(feature = "error-stack")]
                    let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                    #[cfg(not(feature = "error-stack"))]
                    let err: ChainError = Arc::new(e);

                    if let Some(h) = &err_handler {
                        let h = h.clone();
                        #[cfg(feature = "error-stack")]
                        domain.modify(move |d| {
                            h(
                                Report::new(BoxError(Box::new(DebugDisplayAdapter(shared))))
                                    .change_context(DbuffErr),
                                d,
                            );
                        });
                        #[cfg(not(feature = "error-stack"))]
                        {
                            let err = err.clone();
                            domain.modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                        }
                    }
                    Err(err)
                }
            }
        });

        DomainChain {
            future,
            domain: self.domain.clone(),
            services: self.services.clone(),
            rt: self.rt.clone(),
            error_handler: self.error_handler,
        }
    }
}

/// A typed chain of sequential async command executions bound to a domain.
///
/// Created by [`DomainExecutor::exec`] or [`DomainExecutor::exec_discard`].
/// Extend the chain with [`exec`](DomainChain::exec), [`then`](DomainChain::then),
/// or [`exec_discard`](DomainChain::exec_discard). Finish with [`go`](DomainChain::go)
/// to spawn the entire chain.
///
/// Generic over `T` — the output type of the last executed command — which
/// enables type-safe inter-command data passing via [`then`](DomainChain::then).
///
/// # Execution model
///
/// All commands run **sequentially**: each completes fully before the next begins.
/// The chain is a single composed future — there is no parallelism within a chain.
/// If any command fails, the [`on_error`](DomainExecutor::on_error) callback is
/// invoked and remaining commands are skipped (short-circuit).
///
/// # Type parameters
///
/// - `D`: The domain data type.
/// - `T`: The output type of the last command in the chain.
/// - `S`: The services type.
pub struct DomainChain<D, T, S> {
    future: std::pin::Pin<
        Box<dyn std::future::Future<Output = Result<T, ChainError>> + Send + 'static>,
    >,
    domain: SharedDomainData<D>,
    services: S,
    rt: tokio::runtime::Handle,
    error_handler: ErrorHandler<D>,
}

impl<D, T, S> DomainChain<D, T, S>
where
    D: Clone + Send + Sync + 'static,
    T: Send + 'static,
    S: Clone + Send + 'static,
{
    /// Execute a command independently, ignoring the previous output.
    ///
    /// This command runs **after** the previous command completes. The previous
    /// output is **dropped** — use [`then`](DomainChain::then) instead if you
    /// need to pass data forward.
    ///
    /// If the chain has already short-circuited (previous error), this command
    /// is skipped.
    pub fn exec<C>(
        self,
        cmd: C,
        setter: impl Fn(&mut D, &C::Output) + Send + Sync + 'static,
    ) -> DomainChain<D, C::Output, S>
    where
        C: Command<S> + 'static,
        C::Output: Clone + Send + 'static,
        C::Error: CmdError,
    {
        let domain = self.domain.clone();
        let services = self.services.clone();
        let err_handler = self.error_handler.clone();
        let setter = Arc::new(setter);

        let future: std::pin::Pin<
            Box<dyn std::future::Future<Output = Result<C::Output, ChainError>> + Send + 'static>,
        > = Box::pin(async move {
            self.future.await?;
            match cmd.execute(services).await {
                Ok(output) => {
                    let setter = setter;
                    let output_for_setter = output.clone();
                    domain.modify(move |d| setter(d, &output_for_setter));
                    Ok(output)
                }
                Err(e) => {
                    #[cfg(feature = "error-stack")]
                    let shared: Arc<dyn ErasedError> = Arc::new(e);
                    #[cfg(feature = "error-stack")]
                    let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                    #[cfg(not(feature = "error-stack"))]
                    let err: ChainError = Arc::new(e);

                    if let Some(h) = &err_handler {
                        let h = h.clone();
                        #[cfg(feature = "error-stack")]
                        domain.modify(move |d| {
                            h(
                                Report::new(BoxError(Box::new(DebugDisplayAdapter(shared))))
                                    .change_context(DbuffErr),
                                d,
                            );
                        });
                        #[cfg(not(feature = "error-stack"))]
                        {
                            let err = err.clone();
                            domain.modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                        }
                    }
                    Err(err)
                }
            }
        });

        DomainChain {
            future,
            domain: self.domain.clone(),
            services: self.services.clone(),
            rt: self.rt.clone(),
            error_handler: self.error_handler,
        }
    }

    /// Execute a command and discard its output, ignoring the previous output.
    ///
    /// This command runs **after** the previous command completes. The output
    /// is thrown away — no setter is needed.
    ///
    /// Returns a chain with output type `()`.
    pub fn exec_discard<C>(self, cmd: C) -> DomainChain<D, (), S>
    where
        C: Command<S> + 'static,
        C::Error: CmdError,
    {
        let services = self.services.clone();
        let err_handler = self.error_handler.clone();
        let domain = self.domain.clone();

        let future: std::pin::Pin<
            Box<dyn std::future::Future<Output = Result<(), ChainError>> + Send + 'static>,
        > = Box::pin(async move {
            self.future.await?;
            match cmd.execute(services).await {
                Ok(_) => Ok(()),
                Err(e) => {
                    #[cfg(feature = "error-stack")]
                    let shared: Arc<dyn ErasedError> = Arc::new(e);
                    #[cfg(feature = "error-stack")]
                    let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                    #[cfg(not(feature = "error-stack"))]
                    let err: ChainError = Arc::new(e);

                    if let Some(h) = &err_handler {
                        let h = h.clone();
                        #[cfg(feature = "error-stack")]
                        domain.modify(move |d| {
                            h(
                                Report::new(BoxError(Box::new(DebugDisplayAdapter(shared))))
                                    .change_context(DbuffErr),
                                d,
                            );
                        });
                        #[cfg(not(feature = "error-stack"))]
                        {
                            let err = err.clone();
                            domain.modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                        }
                    }
                    Err(err)
                }
            }
        });

        DomainChain {
            future,
            domain: self.domain.clone(),
            services: self.services.clone(),
            rt: self.rt.clone(),
            error_handler: self.error_handler,
        }
    }

    /// Execute a command whose input depends on the previous command's output.
    ///
    /// This command runs **after** the previous command completes. The `factory`
    /// closure receives `&T` (the previous output) and returns the next command,
    /// enabling multi-step pipelines where each step feeds the next:
    ///
    /// ```
    /// use dbuff::*;
    /// use std::time::Duration;
    /// #[derive(Clone, Default)]
    /// struct Data { total: i32 }
    /// # #[derive(Debug, Clone, wherror::Error)]
    /// # #[error(debug)]
    /// # struct E;
    /// # struct Add(i32);
    /// # #[async_trait::async_trait]
    /// # impl Command<()> for Add {
    /// #     type Output = i32;
    /// #     type Error = E;
    /// #     async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> { Ok(self.0) }
    /// # }
    /// # struct Mul(i32);
    /// # #[async_trait::async_trait]
    /// # impl Command<()> for Mul {
    /// #     type Output = i32;
    /// #     type Error = E;
    /// #     async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> {
    /// #         Ok(self.0)
    /// #     }
    /// # }
    /// # async fn example() {
    /// # let (domain, wh) = SharedDomainData::with_coalesce(Data::default(), Duration::from_millis(1));
    /// # tokio::spawn(wh.run());
    /// # let rt = tokio::runtime::Handle::current();
    ///
    /// // Add(10) outputs 10, then Mul(3) receives 10 and outputs 30
    /// domain.bind((), rt)
    ///     .exec(Add(10), |d, val: &i32| d.total = *val)
    ///     .then(|val: &i32| Mul(*val * 3), |d, val: &i32| d.total = *val)
    ///     .go();
    ///
    /// tokio::time::sleep(Duration::from_millis(10)).await;
    /// assert_eq!(domain.read().total, 30);
    /// # }
    /// ```
    ///
    /// If you don't need the previous output, use [`exec`](DomainChain::exec) instead.
    ///
    /// If the chain has already short-circuited (previous error), the factory
    /// is not called and the chain remains short-circuited.
    pub fn then<C, F>(
        self,
        factory: F,
        setter: impl Fn(&mut D, &C::Output) + Send + Sync + 'static,
    ) -> DomainChain<D, C::Output, S>
    where
        C: Command<S> + 'static,
        C::Output: Clone + Send + 'static,
        C::Error: CmdError,
        F: FnOnce(&T) -> C + Send + 'static,
    {
        let domain = self.domain.clone();
        let services = self.services.clone();
        let err_handler = self.error_handler.clone();
        let setter = Arc::new(setter);

        let future: std::pin::Pin<
            Box<dyn std::future::Future<Output = Result<C::Output, ChainError>> + Send + 'static>,
        > = Box::pin(async move {
            let prev = self.future.await?;
            let cmd = factory(&prev);
            match cmd.execute(services).await {
                Ok(output) => {
                    let setter = setter;
                    let output_for_setter = output.clone();
                    domain.modify(move |d| setter(d, &output_for_setter));
                    Ok(output)
                }
                Err(e) => {
                    #[cfg(feature = "error-stack")]
                    let shared: Arc<dyn ErasedError> = Arc::new(e);
                    #[cfg(feature = "error-stack")]
                    let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                    #[cfg(not(feature = "error-stack"))]
                    let err: ChainError = Arc::new(e);

                    if let Some(h) = &err_handler {
                        let h = h.clone();
                        #[cfg(feature = "error-stack")]
                        domain.modify(move |d| {
                            h(
                                Report::new(BoxError(Box::new(DebugDisplayAdapter(shared))))
                                    .change_context(DbuffErr),
                                d,
                            );
                        });
                        #[cfg(not(feature = "error-stack"))]
                        {
                            let err = err.clone();
                            domain.modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                        }
                    }
                    Err(err)
                }
            }
        });

        DomainChain {
            future,
            domain: self.domain.clone(),
            services: self.services.clone(),
            rt: self.rt.clone(),
            error_handler: self.error_handler,
        }
    }

    /// Add lifecycle status tracking to the last command in the chain.
    ///
    /// Wraps the chain's composed future with status transitions:
    /// - [`TaskStatus::Pending`] before the chain segment runs
    /// - [`TaskStatus::Resolved`] with the output value on success
    /// - [`TaskStatus::Error`] if the chain short-circuits (previous error)
    ///
    /// The `status_setter` is called via [`SharedDomainData::modify`] at each
    /// transition, writing the current [`TaskStatus`] into domain state. This
    /// enables a render loop to poll status via `domain.read()`:
    ///
    /// ```
    /// use dbuff::*;
    /// use std::time::Duration;
    ///
    /// # #[derive(Clone, Default)]
    /// # struct Data { status: TaskStatus<i32> }
    /// # #[derive(Debug, Clone, wherror::Error)]
    /// # #[error(debug)]
    /// # struct E;
    /// # struct Fetch(i32);
    /// # #[async_trait::async_trait]
    /// # impl Command<()> for Fetch {
    /// #     type Output = i32;
    /// #     type Error = E;
    /// #     async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> { Ok(self.0) }
    /// # }
    /// # async fn example() {
    /// # let (domain, wh) = SharedDomainData::with_coalesce(Data::default(), Duration::from_millis(1));
    /// # tokio::spawn(wh.run());
    /// # let rt = tokio::runtime::Handle::current();
    ///
    /// domain.bind((), rt)
    ///     .exec(Fetch(42), |_, _: &i32| {})
    ///     .tracked(|d, status: TaskStatus<i32>| d.status = status)
    ///     .go();
    ///
    /// // Later, in a render loop:
    /// // match &domain.read().status {
    /// //     TaskStatus::Pending => render_spinner(),
    /// //     TaskStatus::Resolved(v) => render_value(v),
    /// //     _ => {}
    /// // }
    /// # }
    /// ```
    ///
    /// Multiple `.tracked()` calls can be chained to track different steps:
    ///
    /// ```
    /// use dbuff::*;
    /// use std::time::Duration;
    ///
    /// # #[derive(Clone, Default)]
    /// # struct Data { step1: TaskStatus<i32>, step2: TaskStatus<i32> }
    /// # #[derive(Debug, Clone, wherror::Error)]
    /// # #[error(debug)]
    /// # struct E;
    /// # struct Step(i32);
    /// # #[async_trait::async_trait]
    /// # impl Command<()> for Step {
    /// #     type Output = i32;
    /// #     type Error = E;
    /// #     async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> { Ok(self.0) }
    /// # }
    /// # async fn example() {
    /// # let (domain, wh) = SharedDomainData::with_coalesce(Data::default(), Duration::from_millis(1));
    /// # tokio::spawn(wh.run());
    /// # let rt = tokio::runtime::Handle::current();
    ///
    /// domain.bind((), rt)
    ///     .exec(Step(1), |_, _: &i32| {})
    ///     .tracked(|d, status: TaskStatus<i32>| d.step1 = status)
    ///     .then(|v: &i32| Step(*v + 1), |_, _: &i32| {})
    ///     .tracked(|d, status: TaskStatus<i32>| d.step2 = status)
    ///     .go();
    /// # }
    /// ```
    ///
    /// Note: `.tracked()` tracks the entire chain segment up to that point,
    /// including all previous commands. If a previous command in the chain
    /// fails, the status will transition to [`TaskStatus::Error`].
    #[must_use = "the tracked builder must be consumed to take effect"]
    pub fn tracked(
        self,
        status_setter: impl Fn(&mut D, TaskStatus<T>) + Send + Sync + 'static,
    ) -> Self
    where
        T: Clone + Send + 'static,
    {
        let domain = self.domain.clone();
        let setter = Arc::new(status_setter);

        let future: std::pin::Pin<
            Box<dyn std::future::Future<Output = Result<T, ChainError>> + Send + 'static>,
        > = Box::pin(async move {
            {
                let setter = setter.clone();
                domain.modify(move |d| setter(d, TaskStatus::Pending));
            }
            match self.future.await {
                Ok(output) => {
                    let output_for_status = output.clone();
                    let setter = setter.clone();
                    domain.modify(move |d| setter(d, TaskStatus::Resolved(output_for_status)));
                    Ok(output)
                }
                Err(e) => {
                    let setter = setter.clone();
                    let e_for_status = e.clone();
                    domain.modify(move |d| setter(d, TaskStatus::Error(e_for_status)));
                    Err(e)
                }
            }
        });

        DomainChain {
            future,
            domain: self.domain,
            services: self.services,
            rt: self.rt,
            error_handler: self.error_handler,
        }
    }

    /// Spawn the entire chain as a single sequential task on the tokio runtime.
    ///
    /// Commands execute one at a time — each completes before the next begins.
    /// Returns a [`ChainHandle`] that resolves to
    /// [`ControlFlow::Continue`] if all commands succeeded, or
    /// [`ControlFlow::Break`] if any command failed (short-circuit).
    #[must_use = "the chain must be consumed with `.go()` to spawn execution"]
    pub fn go(self) -> ChainHandle {
        ChainHandle {
            inner: self.rt.spawn(async move {
                if self.future.await.is_ok() {
                    ControlFlow::Continue
                } else {
                    ControlFlow::Break
                }
            }),
        }
    }

    /// Spawn the chain as a fire-and-forget task.
    ///
    /// Identical to [`Self::go`] but returns `()` instead of a [`ChainHandle`],
    /// so no `#[must_use]` warning is emitted when the handle is not needed.
    pub fn go_detach(self) {
        self.rt.spawn(async move {
            if self.future.await.is_ok() {
                ControlFlow::Continue
            } else {
                ControlFlow::Break
            }
        });
    }
}

macro_rules! impl_parallel {
    ($n:tt; $($cmd:ident, $setter:ident, $idx:tt),+ $(,)?) => {
        paste::paste! {
            #[allow(non_snake_case)]
            impl<D, S> DomainExecutor<D, S>
            where
                D: Clone + Send + Sync + 'static,
                S: Clone + Send + 'static,
            {
                pub fn [<exec_parallel_ $n>]<$($cmd, $setter),+>(
                    self,
                    $($cmd: ($cmd, $setter)),+
                ) -> DomainChain<D, (), S>
                where
                    $($cmd: Command<S> + 'static,)+
                    $($cmd::Output: Clone + Send + 'static,)+
                    $($cmd::Error: CmdError,)+
                    $($setter: Fn(&mut D, &$cmd::Output) + Send + Sync + 'static,)+
                {
                    let domain = self.domain.clone();
                    let services = self.services.clone();
                    let rt = self.rt.clone();
                    let err_handler = self.error_handler.clone();

                    $(
                        let ($cmd, $setter) = $cmd;
                        let $setter = Arc::new($setter);
                        let [<domain_ $idx>] = domain.clone();
                        let [<services_ $idx>] = services.clone();
                        let _ = rt.clone();
                        let [<err_handler_ $idx>] = err_handler.clone();
                    )+

                    let future: std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), ChainError>> + Send + 'static>> =
                        Box::pin(async move {
                            let results = tokio::join!(
                                $(
                                    async move {
                                        match $cmd.execute([<services_ $idx>]).await {
                                            Ok(output) => {
                                                let o = output.clone();
                                                [<domain_ $idx>].modify(move |d| $setter(d, &o));
                                                Ok(true)
                                            }
                                            Err(e) => {
                                                #[cfg(feature = "error-stack")]
                                                let shared: Arc<dyn ErasedError> = Arc::new(e);
                                                #[cfg(feature = "error-stack")]
                                                let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                                                #[cfg(not(feature = "error-stack"))]
                                                let err: ChainError = Arc::new(e);

                                                if let Some(h) = &[<err_handler_ $idx>] {
                                                    let h = h.clone();
                                                    #[cfg(feature = "error-stack")]
                                                    [<domain_ $idx>].modify(move |d| h(Report::new(BoxError(Box::new(DebugDisplayAdapter(shared)))).change_context(DbuffErr), d));
                                                    #[cfg(not(feature = "error-stack"))]
                                                    {
                                                        let err = err.clone();
                                                        [<domain_ $idx>].modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                                                    }
                                                }
                                                Err(err)
                                            }
                                        }
                                    },
                                )+
                            );
                            let mut first_error: Option<ChainError> = None;
                            $(
                                if let Err(e) = &results.$idx {
                                    if first_error.is_none() {
                                        first_error = Some(e.clone());
                                    }
                                }
                            )+
                            match first_error {
                                Some(e) => Err(e),
                                None => Ok(()),
                            }
                        });

                    DomainChain {
                        future,
                        domain: self.domain.clone(),
                        services: self.services.clone(),
                        rt: self.rt.clone(),
                        error_handler: self.error_handler,
                    }
                }
            }

            #[allow(non_snake_case)]
            impl<D, T, S> DomainChain<D, T, S>
            where
                D: Clone + Send + Sync + 'static,
                T: Send + 'static,
                S: Clone + Send + 'static,
            {
                pub fn [<exec_parallel_ $n>]<$($cmd, $setter),+>(
                    self,
                    $($cmd: ($cmd, $setter)),+
                ) -> DomainChain<D, (), S>
                where
                    $($cmd: Command<S> + 'static,)+
                    $($cmd::Output: Clone + Send + 'static,)+
                    $($cmd::Error: CmdError,)+
                    $($setter: Fn(&mut D, &$cmd::Output) + Send + Sync + 'static,)+
                {
                    let domain = self.domain.clone();
                    let services = self.services.clone();
                    let rt = self.rt.clone();
                    let err_handler = self.error_handler.clone();
                    let prev = self.future;

                    $(
                        let ($cmd, $setter) = $cmd;
                        let $setter = Arc::new($setter);
                        let [<domain_ $idx>] = domain.clone();
                        let [<services_ $idx>] = services.clone();
                        let _ = rt.clone();
                        let [<err_handler_ $idx>] = err_handler.clone();
                    )+

                    let future: std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), ChainError>> + Send + 'static>> =
                        Box::pin(async move {
                            prev.await?;
                            let results = tokio::join!(
                                $(
                                    async move {
                                        match $cmd.execute([<services_ $idx>]).await {
                                            Ok(output) => {
                                                let o = output.clone();
                                                [<domain_ $idx>].modify(move |d| $setter(d, &o));
                                                Ok(true)
                                            }
                                            Err(e) => {
                                                #[cfg(feature = "error-stack")]
                                                let shared: Arc<dyn ErasedError> = Arc::new(e);
                                                #[cfg(feature = "error-stack")]
                                                let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                                                #[cfg(not(feature = "error-stack"))]
                                                let err: ChainError = Arc::new(e);

                                                if let Some(h) = &[<err_handler_ $idx>] {
                                                    let h = h.clone();
                                                    #[cfg(feature = "error-stack")]
                                                    [<domain_ $idx>].modify(move |d| h(Report::new(BoxError(Box::new(DebugDisplayAdapter(shared)))).change_context(DbuffErr), d));
                                                    #[cfg(not(feature = "error-stack"))]
                                                    {
                                                        let err = err.clone();
                                                        [<domain_ $idx>].modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                                                    }
                                                }
                                                Err(err)
                                            }
                                        }
                                    },
                                )+
                            );
                            let mut first_error: Option<ChainError> = None;
                            $(
                                if let Err(e) = &results.$idx {
                                    if first_error.is_none() {
                                        first_error = Some(e.clone());
                                    }
                                }
                            )+
                            match first_error {
                                Some(e) => Err(e),
                                None => Ok(()),
                            }
                        });

                    DomainChain {
                        future,
                        domain: self.domain.clone(),
                        services: self.services.clone(),
                        rt: self.rt.clone(),
                        error_handler: self.error_handler,
                    }
                }
            }

            #[allow(non_snake_case)]
            impl<D, S> DomainExecutor<D, S>
            where
                D: Clone + Send + Sync + 'static,
                S: Clone + Send + 'static,
            {
                pub fn [<exec_parallel_discard_ $n>]<$($cmd),+>(
                    self,
                    $($cmd: $cmd),+
                ) -> DomainChain<D, (), S>
                where
                    $($cmd: Command<S> + 'static,)+
                    $($cmd::Error: CmdError,)+
                {
                    let domain = self.domain.clone();
                    let services = self.services.clone();
                    let rt = self.rt.clone();
                    let err_handler = self.error_handler.clone();

                    $(
                        let [<domain_ $idx>] = domain.clone();
                        let [<services_ $idx>] = services.clone();
                        let _ = rt.clone();
                        let [<err_handler_ $idx>] = err_handler.clone();
                    )+

                    let future: std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), ChainError>> + Send + 'static>> =
                        Box::pin(async move {
                            let results = tokio::join!(
                                $(
                                    async move {
                                        match $cmd.execute([<services_ $idx>]).await {
                                            Ok(_) => Ok(true),
                                            Err(e) => {
                                                #[cfg(feature = "error-stack")]
                                                let shared: Arc<dyn ErasedError> = Arc::new(e);
                                                #[cfg(feature = "error-stack")]
                                                let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                                                #[cfg(not(feature = "error-stack"))]
                                                let err: ChainError = Arc::new(e);

                                                if let Some(h) = &[<err_handler_ $idx>] {
                                                    let h = h.clone();
                                                    #[cfg(feature = "error-stack")]
                                                    [<domain_ $idx>].modify(move |d| h(Report::new(BoxError(Box::new(DebugDisplayAdapter(shared)))).change_context(DbuffErr), d));
                                                    #[cfg(not(feature = "error-stack"))]
                                                    {
                                                        let err = err.clone();
                                                        [<domain_ $idx>].modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                                                    }
                                                }
                                                Err(err)
                                            }
                                        }
                                    },
                                )+
                            );
                            let mut first_error: Option<ChainError> = None;
                            $(
                                if let Err(e) = &results.$idx {
                                    if first_error.is_none() {
                                        first_error = Some(e.clone());
                                    }
                                }
                            )+
                            match first_error {
                                Some(e) => Err(e),
                                None => Ok(()),
                            }
                        });

                    DomainChain {
                        future,
                        domain: self.domain.clone(),
                        services: self.services.clone(),
                        rt: self.rt.clone(),
                        error_handler: self.error_handler,
                    }
                }
            }

            #[allow(non_snake_case)]
            impl<D, T, S> DomainChain<D, T, S>
            where
                D: Clone + Send + Sync + 'static,
                T: Send + 'static,
                S: Clone + Send + 'static,
            {
                pub fn [<exec_parallel_discard_ $n>]<$($cmd),+>(
                    self,
                    $($cmd: $cmd),+
                ) -> DomainChain<D, (), S>
                where
                    $($cmd: Command<S> + 'static,)+
                    $($cmd::Error: CmdError,)+
                {
                    let domain = self.domain.clone();
                    let services = self.services.clone();
                    let rt = self.rt.clone();
                    let err_handler = self.error_handler.clone();
                    let prev = self.future;

                    $(
                        let [<domain_ $idx>] = domain.clone();
                        let [<services_ $idx>] = services.clone();
                        let _ = rt.clone();
                        let [<err_handler_ $idx>] = err_handler.clone();
                    )+

                    let future: std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), ChainError>> + Send + 'static>> =
                        Box::pin(async move {
                            prev.await?;
                            let results = tokio::join!(
                                $(
                                    async move {
                                        match $cmd.execute([<services_ $idx>]).await {
                                            Ok(_) => Ok(true),
                                            Err(e) => {
                                                #[cfg(feature = "error-stack")]
                                                let shared: Arc<dyn ErasedError> = Arc::new(e);
                                                #[cfg(feature = "error-stack")]
                                                let err: ChainError = Arc::new(DebugDisplayAdapter(shared.clone()));

                                                #[cfg(not(feature = "error-stack"))]
                                                let err: ChainError = Arc::new(e);

                                                if let Some(h) = &[<err_handler_ $idx>] {
                                                    let h = h.clone();
                                                    #[cfg(feature = "error-stack")]
                                                    [<domain_ $idx>].modify(move |d| h(Report::new(BoxError(Box::new(DebugDisplayAdapter(shared)))).change_context(DbuffErr), d));
                                                    #[cfg(not(feature = "error-stack"))]
                                                    {
                                                        let err = err.clone();
                                                        [<domain_ $idx>].modify(move |d| h(Box::new(ArcErrorWrapper(err)), d));
                                                    }
                                                }
                                                Err(err)
                                            }
                                        }
                                    },
                                )+
                            );
                            let mut first_error: Option<ChainError> = None;
                            $(
                                if let Err(e) = &results.$idx {
                                    if first_error.is_none() {
                                        first_error = Some(e.clone());
                                    }
                                }
                            )+
                            match first_error {
                                Some(e) => Err(e),
                                None => Ok(()),
                            }
                        });

                    DomainChain {
                        future,
                        domain: self.domain.clone(),
                        services: self.services.clone(),
                        rt: self.rt.clone(),
                        error_handler: self.error_handler,
                    }
                }
            }
        }
    };
}

impl_parallel!(2; C0, S0, 0, C1, S1, 1);
impl_parallel!(3; C0, S0, 0, C1, S1, 1, C2, S2, 2);
impl_parallel!(4; C0, S0, 0, C1, S1, 1, C2, S2, 2, C3, S3, 3);
impl_parallel!(5; C0, S0, 0, C1, S1, 1, C2, S2, 2, C3, S3, 3, C4, S4, 4);