//! # Core Convert Extensions
//!
//! Useful extensions to `core::convert` library.
//!

use core::convert::{Into, TryInto};
use core::result::Result;

/// Simple and safe type conversions to `self`. Relies on reciprocals `From` and `Into`, so as a consequence the implementation of at least one of them is required.
///
/// # Examples
///
/// ```
/// use core_ext::convert::To;
///
/// struct A(u8);
/// impl To for A {}
///
/// struct B(u8);
/// impl From<A> for B {
///     fn from(value: A) -> Self {
///         Self(value.0 + 1)
///     }
/// }
/// impl To for B {}
///
/// struct C(u8);
/// impl From<B> for C {
///     fn from(value: B) -> Self {
///         Self(value.0 + 2)
///     }
/// }
/// impl To for C {}
///
/// assert_eq!(5_u8, A(2).to::<B>().to::<C>().0)
/// ```
pub trait To {
    fn to<T>(self) -> T
    where
        Self: Into<T>,
    {
        self.into()
    }
}

/// Simple and safe type conversions to `self` that may fail in a controlled way under some circunstances.
/// Relies on reciprocals `TryFrom` and `TryInto`, so as a consequence the implementation of at least one of them is required.
///
/// # Examples
///
/// ```
/// use core_ext::convert::TryTo;
///
/// #[derive(Debug)]
/// enum Error {}
///
/// struct A(u8);
/// impl TryTo<Error> for A {}
///
/// struct B(u8);
/// impl TryFrom<A> for B {
///     type Error = Error;
///     fn try_from(value: A) -> Result<Self,Error> {
///         Ok(Self(value.0 + 1))
///     }
/// }
/// impl TryTo<Error> for B {}
///
/// struct C(u8);
/// impl TryFrom<B> for C {
///     type Error = Error;
///     fn try_from(value: B) -> Result<Self,Error> {
///         Ok(Self(value.0 + 2))
///     }
/// }
/// impl TryTo<Error> for C {}
///
/// assert_eq!(5_u8, A(2).try_to::<B>().unwrap().try_to::<C>().unwrap().0)
/// ```
pub trait TryTo<E> {
    fn try_to<T>(self) -> Result<T, E>
    where
        Self: TryInto<T, Error = E>,
    {
        self.try_into()
    }
}

#[cfg(test)]
mod tests {
    use core::convert::Infallible;

    use super::*;

    #[test]
    fn test_to() {
        #[derive(PartialEq, Debug)]
        struct Type(u8);
        impl From<u8> for Type {
            fn from(value: u8) -> Self {
                Type(value)
            }
        }
        impl To for u8 {}
        // insta::assert_yaml_snapshot!(2_u8.to::<A>());
        assert_eq!(Type(2), 2_u8.to())
    }

    #[test]
    fn test_to_chain() {
        #[derive(PartialEq, Debug)]
        struct A(u8);
        #[derive(PartialEq, Debug)]
        struct B(u8);
        #[derive(PartialEq, Debug)]
        struct C(u8);
        impl From<u8> for A {
            fn from(value: u8) -> Self {
                A(value + 1)
            }
        }
        impl From<A> for B {
            fn from(value: A) -> Self {
                B(value.0 + 1)
            }
        }
        impl From<B> for C {
            fn from(value: B) -> Self {
                Self(value.0 + 1)
            }
        }
        impl To for A {}
        // impl To for u8 {}
        impl To for B {}
        assert_eq!(A(1), 0_u8.to());
        assert_eq!(
            C(4_u8),
            1_u8.to::<A>() //
                .to::<B>() //
                .to::<C>()
        );
    }

    #[test]
    fn test_try_to() -> Result<(), Infallible> {
        #[derive(PartialEq, Debug)]
        struct Type(u8);
        impl TryFrom<u8> for Type {
            type Error = Infallible;

            fn try_from(value: u8) -> Result<Self, Self::Error> {
                Ok(Type(value))
            }
        }
        impl TryTo<Infallible> for u8 {}
        assert_eq!(Type(2), 2_u8.try_to()?);
        Ok(())
    }

    #[test]
    fn test_try_to_chain() -> Result<(), Infallible> {
        #[derive(PartialEq, Debug)]
        struct A(u8);
        #[derive(PartialEq, Debug)]
        struct B(u8);
        #[derive(PartialEq, Debug)]
        struct C(u8);
        impl TryFrom<u8> for A {
            type Error = Infallible;

            fn try_from(value: u8) -> Result<Self, Self::Error> {
                Ok(A(value + 1))
            }
        }
        impl TryFrom<A> for B {
            type Error = Infallible;

            fn try_from(value: A) -> Result<Self, Self::Error> {
                Ok(B(value.0 + 1))
            }
        }
        impl TryFrom<B> for C {
            type Error = Infallible;

            fn try_from(value: B) -> Result<Self, Self::Error> {
                Ok(Self(value.0 + 1))
            }
        }
        impl TryTo<Infallible> for A {}
        // impl To for u8 {}
        impl TryTo<Infallible> for B {}
        assert_eq!(A(1), 0_u8.try_to()?);
        assert_eq!(
            C(4_u8),
            1_u8.try_to::<A>()? //
                .try_to::<B>()? //
                .try_to::<C>()?
        );
        Ok(())
    }
}