use crate::mode::*;

use super::*;

/// [`Mode`] for [`InliningFactory`].
pub struct InliningMode;

impl Mode for InliningMode {
    /// Keeps the parser.
    type ParseSuccess<A, I> = (A, I);

    /// Always fails.
    type ExtensionResult<A, E> = E;

    /// Discards the value.
    type ExtensionSource<A> = ();

    fn bind<A0, A1, E, I>(
        s: Self::ParseSuccess<A0, I>,
        f: impl FnOnce(A0) -> Result<A1, E>,
    ) -> ModeResult<Self, A1, E, I> {
        let (a0, i) = s;
        let a1 = f(a0)?;
        Ok((a1, i))
    }

    fn map<A0, A1, I>(
        s: Self::ParseSuccess<A0, I>,
        f: impl FnOnce(A0) -> A1,
    ) -> Self::ParseSuccess<A1, I> {
        (f(s.0), s.1)
    }

    fn seal<A, I>(s: Self::ParseSuccess<A, I>) -> A {
        s.0
    }

    fn xmap_err<A, E0, E1>(
        result: Self::ExtensionResult<A, E0>,
        f: impl FnOnce(E0) -> E1,
    ) -> Self::ExtensionResult<A, E1> {
        f(result)
    }

    fn xbind<A0, A1, E>(
        result: Self::ExtensionResult<A0, E>,
        _f: impl FnOnce(A0) -> Result<A1, E>,
    ) -> Self::ExtensionResult<A1, E> {
        result
    }

    fn xseal<A, E>(result: Self::ExtensionResult<A, E>) -> Result<A, E> {
        Err(result)
    }

    fn smap<A0, A1>(
        source: Self::ExtensionSource<A0>,
        _f: impl FnOnce(A0) -> A1,
    ) -> Self::ExtensionSource<A1> {
        source
    }

    fn prepare<A>(_a: A) -> Self::ExtensionSource<A> {}

    fn xsbind<AB, A, B, E>(
        _ab: Self::ExtensionSource<AB>,
        _t2ab: impl FnOnce(AB) -> (A, B),
        ce: impl FnOnce(Self::ExtensionSource<B>) -> Self::ExtensionResult<B, E>,
        _ab2t: impl FnOnce(A, B) -> Result<AB, E>,
    ) -> Self::ExtensionResult<AB, E> {
        ce(())
    }
}

impl<'a, Ctx: Context<'a>, F: CInliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx>
    for WithMode<F, InliningMode>
{
    type F = F;

    fn pmdeserialize<I: InCtx<'a, Ctx>>(f: &Self::F, inctx: I) -> ModeResultM<'a, Ctx, F, I> {
        f.cideserialize(inctx)
    }

    fn pmextend(
        f: &F,
        _mentionable: ExtensionSourceM<'a, Ctx, F>,
        tail: &[u8],
    ) -> ExtensionResultM<'a, Ctx, F> {
        f.cextension_error(tail)
    }
}

impl<A: CInliningAtomic> AtomicModeProxy for WithMode<A, InliningMode> {
    type A = A;

    fn pma_deserialize<I: Stream>(stream: I) -> AModeResultM<Self::A, I> {
        A::ca_ideserialize(stream)
    }

    fn pma_extend(_atomic: AExtensionSourceM<Self::A>, tail: &[u8]) -> AExtensionResultM<Self::A> {
        A::ca_extension_error(tail)
    }
}