use super::*;

/// [Inlining] context.
pub trait InCtx<'a, Ctx: Context<'a>>: Inlining {
    /// Read the next [Address].
    fn icnext_address<E>(self, err: impl FnOnce(&[u8]) -> E) -> Result<(Address, Self), E>;

    /// Read the next [Point].
    fn icnext_point<'b, A: Mentionable<'a, Ctx>, E>(
        self,
        factory: A::Fctr,
        err: impl FnOnce(&[u8]) -> E,
    ) -> Result<(Point<'a, Ctx, A>, Self), E> {
        let (point, inctx) = self.icnext_address(err)?;
        Ok((
            Point::from_address(point, factory, inctx.iresolver()),
            inctx,
        ))
    }

    /// Clone the reference to the current [Resolver].
    fn iresolver(&self) -> Rc<dyn Resolver<'a, Ctx>>;
}

impl<'a: 'c, 'c, Ctx: Context<'a>> Inlining for &'c mut dyn DeCtx<'a, Ctx> {
    fn iread_n<A, E>(
        self,
        n: usize,
        ok: impl FnOnce(&[u8]) -> A,
        err: impl FnOnce(&[u8]) -> E,
    ) -> Result<(A, Self), E> {
        match self.deserializer().iread_n(n, ok, err) {
            Ok((a, _)) => Ok((a, self)),
            Err(e) => Err(e),
        }
    }

    fn iread_all<A>(self, ok: impl FnOnce(&[u8]) -> A) -> A {
        self.deserializer().iread_all(ok)
    }

    fn itell(&self) -> usize {
        self.tell()
    }
}

impl<'a: 'c, 'c, Ctx: Context<'a>> InCtx<'a, Ctx> for &'c mut dyn DeCtx<'a, Ctx> {
    fn icnext_address<E>(self, err: impl FnOnce(&[u8]) -> E) -> Result<(Address, Self), E> {
        let (addresses, deserialiser) = self.ad();
        match deserialiser.inext_address(addresses, err) {
            Ok((address, _)) => Ok((address, self)),
            Err(e) => Err(e),
        }
    }

    fn iresolver(&self) -> Rc<dyn Resolver<'a, Ctx>> {
        self.resolver()
    }
}