use super::*;

/// For auto-deriving [`RegularAtomic`] from concrete implementations.
pub trait CRegularAtomic: AtomicBase + ImplMode<Mode = RegularMode> {
    /// Concrete implementation of [`RegularAtomic::ra_deserialize`].
    fn cra_deserialize(stream: impl Stream) -> AParseResult<Self>;
    /// Concrete implementation of [`RegularAtomic::ra_extend`].
    fn cra_extend(self, tail: &[u8]) -> AParseResult<Self>;
}

/// Mostly same as [`AtomicModeParse`] but requires [`Mode`] to be [`RegularMode`].
pub trait RegularAtomic: AtomicBase + ParseMode<Mode = RegularMode> {
    /// Same as [`AtomicModeParse::ma_deserialize`].
    fn ra_deserialize(stream: impl Stream) -> AParseResult<Self>;
    /// Same as [`AtomicModeParse::ma_extend`].
    fn ra_extend(self, tail: &[u8]) -> AParseResult<Self>;
}

impl<A: AtomicModeParse + ParseMode<Mode = RegularMode>> RegularAtomic for A {
    fn ra_deserialize(stream: impl Stream) -> AParseResult<Self> {
        A::ma_deserialize(stream)
    }

    fn ra_extend(self, tail: &[u8]) -> AParseResult<Self> {
        A::ma_extend(self, tail)
    }
}

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

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

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