use super::*;

type Fwa<'a, A, E0, E1, Fallible> = <<Fallible as MonadFailAny>::T as WeakFunctor>::F<
    'a,
    Result<<<Fallible as MonadFailAny>::W<E0> as WeakFunctor>::F<'a, A>, E1>,
>;

pub trait SpeculativeFail: MonadFailAny {
    fn _speculative_a_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
        a: Result<A, E0>,
        wb: Result<<Self::W<E0> as WeakFunctor>::F<'a, B>, E1>,
    ) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
    where
        Self: 'a,
    {
        match wb {
            Ok(wb) => match a {
                Ok(a) => Self::map_err(<Self::W<E0> as Functor>::fmap(|b| (a, b), wb), Ok),
                Err(e0) => Self::fail(Ok(e0)),
            },
            Err(e1) => Self::fail(Err(e1)),
        }
    }

    fn _speculative_a_fwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
        a: Result<A, E0>,
        fwb: Fwa<'a, B, E0, E1, Self>,
    ) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
    where
        Self: 'a,
    {
        Self::stuff(<Self::T as Monad>::bind(fwb, |wb| {
            Self::unstuff(Self::_speculative_a_wb(a, wb))
        }))
    }

    fn _speculative_fa_wb<'a, A: 'a, B: 'a, E0: 'a>(
        fa: <Self::T as WeakFunctor>::F<'a, Result<A, E0>>,
        wb: <Self::W<E0> as WeakFunctor>::F<'a, B>,
    ) -> <Self::W<E0> as WeakFunctor>::F<'a, (A, B)>
    where
        Self: 'a,
    {
        <Self::W<E0> as ApplicativeTuple>::tuple((Self::stuff(fa), wb))
    }

    fn _speculative_wa_fwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
        wa: <Self::W<E0> as WeakFunctor>::F<'a, A>,
        fwb: Fwa<'a, B, E0, E1, Self>,
    ) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
    where
        Self: 'a,
    {
        Self::stuff(<<Self as MonadFailAny>::T as Monad>::join(
            <<Self as MonadFailAny>::T as Functor>::fmap(
                Self::unstuff,
                <Self::T as ApplicativeSelect>::select(
                    |selected| match selected {
                        Selected::A(a, fwb) => Self::_speculative_a_fwb(a, fwb),
                        Selected::B(fa, Ok(wb)) => {
                            Self::map_err(Self::_speculative_fa_wb(fa, wb), Ok)
                        }
                        Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
                    },
                    Self::unstuff(wa),
                    fwb,
                ),
            ),
        ))
    }

    fn _speculative_fwa_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
        fwa: Fwa<'a, A, E0, E1, Self>,
        wb: <Self::W<E0> as WeakFunctor>::F<'a, B>,
    ) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
    where
        Self: 'a,
    {
        <Self::W<Result<E0, E1>> as Functor>::fmap(
            |(b, a)| (a, b),
            Self::_speculative_wa_fwb(wb, fwa),
        )
    }

    fn speculative<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
        wwa: <Self::W<E1> as WeakFunctor>::F<'a, <Self::W<E0> as WeakFunctor>::F<'a, A>>,
        wwb: <Self::W<E1> as WeakFunctor>::F<'a, <Self::W<E0> as WeakFunctor>::F<'a, B>>,
    ) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
    where
        Self: 'a,
    {
        Self::stuff(<Self::T as Monad>::join(<Self::T as Functor>::fmap(
            Self::unstuff,
            <Self::T as ApplicativeSelect>::select(
                |selected| match selected {
                    Selected::A(Ok(wa), fwb) => Self::_speculative_wa_fwb(wa, fwb),
                    Selected::A(Err(e1), _) => Self::fail(Err(e1)),
                    Selected::B(fwa, Ok(wb)) => Self::_speculative_fwa_wb(fwa, wb),
                    Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
                },
                Self::unstuff(wwa),
                Self::unstuff(wwb),
            ),
        )))
    }
}

impl<Fallible: ?Sized + MonadFailAny> SpeculativeFail for Fallible {}