use super::*;

impl<A: AtomicModeParse> Atomic for A {
    fn a_deserialize(inlining: impl Inlining) -> AParseResult<Self> {
        <A::Mode as Mode>::seal(Self::ma_deserialize(inlining))
    }

    fn a_extend(self, tail: &[u8]) -> AParseResult<Self> {
        <A::Mode as Mode>::xseal(Self::ma_extend(self.ma_prepare(), tail))
    }
}

pub type AParseResultM<A, I> = <<A as ParseMode>::Mode as Mode>::ParseResult<A, AParseError<A>, I>;

pub type AExtensionResultM<A> =
    <<A as ParseMode>::Mode as Mode>::ExtensionResult<A, AParseError<A>>;

pub type AExtensionSourceM<A> =
    <<A as ParseMode>::Mode as Mode>::ExtensionSource<A, AParseError<A>>;

pub trait AtomicModeParse: AtomicBase + ParseMode {
    fn ma_deserialize<I: Inlining>(inlining: I) -> AParseResultM<Self, I>;

    fn ma_extend(atomic: AExtensionSourceM<Self>, tail: &[u8]) -> AExtensionResultM<Self>;

    fn ma_prepare(self) -> AExtensionSourceM<Self>;
}

pub trait AtomicModeProxy {
    type A: AtomicBase + ParseMode;

    fn pma_deserialize<I: Inlining>(inlining: I) -> AParseResultM<Self::A, I>;

    fn pma_extend(atomic: AExtensionSourceM<Self::A>, tail: &[u8]) -> AExtensionResultM<Self::A>;

    fn pma_prepare(atomic: Self::A) -> AExtensionSourceM<Self::A>;
}

impl<A: AtomicBase + WithParseMode> AtomicModeParse for A
where
    <A as WithParseMode>::WithMode: AtomicModeProxy<A = A>,
{
    fn ma_deserialize<I: Inlining>(inlining: I) -> AParseResultM<Self, I> {
        <<A as WithParseMode>::WithMode as AtomicModeProxy>::pma_deserialize(inlining)
    }

    fn ma_extend(atomic: AExtensionSourceM<Self>, tail: &[u8]) -> AExtensionResultM<Self> {
        <<A as WithParseMode>::WithMode as AtomicModeProxy>::pma_extend(atomic, tail)
    }

    fn ma_prepare(self) -> AExtensionSourceM<Self> {
        <<A as WithParseMode>::WithMode as AtomicModeProxy>::pma_prepare(self)
    }
}

pub trait RegularAtomic: AtomicBase + ParseMode<Mode = RegularMode> {
    fn ra_deserialize(inlining: impl Inlining) -> AParseResult<Self>;
    fn ra_extend(self, tail: &[u8]) -> AParseResult<Self>;
}

impl<A: RegularAtomic> AtomicModeProxy for WithMode<A, RegularMode> {
    type A = A;

    fn pma_deserialize<I: Inlining>(inlining: I) -> AParseResultM<Self::A, I> {
        A::ra_deserialize(inlining)
    }

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

    fn pma_prepare(atomic: Self::A) -> AExtensionSourceM<Self::A> {
        atomic
    }
}