use core::convert::Infallible;
use core_ext::convert::TryTo;

// wrapper type
struct W<T>(pub T);
impl TryTo<Infallible> for W<u8> {}

struct A(u8);
impl TryFrom<W<u8>> for A {
    type Error = Infallible;

    fn try_from(value: W<u8>) -> Result<Self, Self::Error> {
        Ok(Self(value.0))
    }
}

struct B(u8);
impl TryFrom<A> for B {
    type Error = Infallible;

    fn try_from(value: A) -> Result<Self, Self::Error> {
        Ok(B(value.0 + 1))
    }
}

struct C(u8);
impl TryFrom<B> for C {
    type Error = Infallible;

    fn try_from(value: B) -> Result<Self, Self::Error> {
        Ok(Self(value.0 + 1))
    }
}

#[cfg(test)]
mod snapshots {
    use crate::*;

    #[test]
    fn test_try_to() -> Result<(), Infallible> {
        struct Type(u8);

        impl TryFrom<W<u8>> for Type {
            type Error = Infallible;

            fn try_from(value: W<u8>) -> Result<Self, Self::Error> {
                Ok(Type(value.0))
            }
        }
        insta::assert_yaml_snapshot!(W(2_u8).try_to::<Type>()?.0);
        Ok(())
    }

    #[test]
    fn test_try_to_chain() -> Result<(), Infallible> {
        impl TryTo<Infallible> for A {}
        impl TryTo<Infallible> for B {}
        insta::assert_yaml_snapshot!(W(0_u8).try_to::<A>()?.0);
        insta::assert_yaml_snapshot!(
            W(1_u8)
                .try_to::<A>()?
                .try_to::<B>()?
                .try_to::<C>()?
                .0
        );
        Ok(())
    }
}