use super::*;

pub trait AtomicProxy {
    type A: AtomicBase + ParseMode;

    fn pa_deserialize(inlining: impl Inlining) -> AParseResult<Self::A>;
    fn pa_extend(a: Self::A, tail: &[u8]) -> AParseResult<Self::A>;
}

impl<A: AtomicBase + WithParseMode> Atomic for A
where
    A::WithMode: AtomicProxy<A = Self>,
{
    fn a_deserialize(inlining: impl Inlining) -> AParseResult<Self> {
        <A::WithMode as AtomicProxy>::pa_deserialize(inlining)
    }

    fn a_extend(self, tail: &[u8]) -> AParseResult<Self> {
        <A::WithMode as AtomicProxy>::pa_extend(self, 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 + ImplMode<Mode = RegularMode> {
    fn ra_deserialize(inlining: impl Inlining) -> AParseResult<Self>;
    fn ra_extend(self, tail: &[u8]) -> AParseResult<Self>;
}

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

    fn pa_deserialize(inlining: impl Inlining) -> AParseResult<Self::A> {
        A::ra_deserialize(inlining)
    }

    fn pa_extend(a: Self::A, tail: &[u8]) -> AParseResult<Self::A> {
        a.ra_extend(tail)
    }
}