//! Smart pointer owning its pointee and trait which allows conversion into
//! owned type
//!
//! `deref_owned` provides a smart pointer [`Owned`], which points to an owned
//! value. It's similar to [`Cow`], except that it's always owning its pointee.
//! Moreover, a trait [`IntoOwned`] is provided, which allows conversion of
//! certain pointers into an owned value though an
//! [`.into_owned()`](IntoOwned::into_owned) method. The trait `IntoOwned` is
//! implemented for:
//!
//! * `&'a T where T: ?Sized + ToOwned`
//! * `Cow<'a, T> where T: ?Sized + ToOwned`
//! * `Owned<T>`
//! * `OwnedRef<T>` (also provided by `deref_owned`)

use std::borrow::{Borrow, BorrowMut, Cow};
use std::fmt;
use std::ops::{Deref, DerefMut};

/// Smart pointer to owned inner value
#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Owned<T>(pub T);

impl<T> Deref for Owned<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> DerefMut for Owned<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T, U> AsRef<U> for Owned<T>
where
    T: AsRef<U>,
    U: ?Sized,
{
    fn as_ref(&self) -> &U {
        self.0.as_ref()
    }
}

impl<T, U> AsMut<U> for Owned<T>
where
    T: AsMut<U>,
    U: ?Sized,
{
    fn as_mut(&mut self) -> &mut U {
        self.0.as_mut()
    }
}

impl<B> Borrow<B> for Owned<<B as ToOwned>::Owned>
where
    B: ?Sized + ToOwned,
{
    fn borrow(&self) -> &B {
        self.0.borrow()
    }
}

impl<B> BorrowMut<B> for Owned<<B as ToOwned>::Owned>
where
    B: ?Sized + ToOwned,
    <B as ToOwned>::Owned: BorrowMut<B>,
{
    fn borrow_mut(&mut self) -> &mut B {
        self.0.borrow_mut()
    }
}

impl<T: fmt::Display> fmt::Display for Owned<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.0, f)
    }
}

impl<T: fmt::Debug> fmt::Debug for Owned<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self.0, f)
    }
}

/// Smart pointer to value pointed-to by owned inner value
#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct OwnedRef<T>(pub T);

impl<T> Deref for OwnedRef<T>
where
    T: Deref,
{
    type Target = <T as Deref>::Target;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> DerefMut for OwnedRef<T>
where
    T: DerefMut,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T, U> AsRef<U> for OwnedRef<T>
where
    T: AsRef<U>,
    U: ?Sized,
{
    fn as_ref(&self) -> &U {
        self.0.as_ref()
    }
}

impl<T, U> AsMut<U> for OwnedRef<T>
where
    T: AsMut<U>,
    U: ?Sized,
{
    fn as_mut(&mut self) -> &mut U {
        self.0.as_mut()
    }
}

impl<B> Borrow<B> for OwnedRef<<B as ToOwned>::Owned>
where
    B: ?Sized + ToOwned,
{
    fn borrow(&self) -> &B {
        self.0.borrow()
    }
}

impl<B> BorrowMut<B> for OwnedRef<<B as ToOwned>::Owned>
where
    B: ?Sized + ToOwned,
    <B as ToOwned>::Owned: BorrowMut<B>,
{
    fn borrow_mut(&mut self) -> &mut B {
        self.0.borrow_mut()
    }
}

impl<T: fmt::Display> fmt::Display for OwnedRef<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.0, f)
    }
}

impl<T: fmt::Debug> fmt::Debug for OwnedRef<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self.0, f)
    }
}

/// Pointer types that can be converted into an owned type
pub trait IntoOwned: Sized + Deref {
    /// The type the pointer can be converted into
    type Owned: Borrow<<Self as Deref>::Target>;
    /// Convert into owned type
    fn into_owned(self) -> Self::Owned;
}

impl<'a, T> IntoOwned for &'a T
where
    T: ?Sized + ToOwned,
{
    type Owned = <T as ToOwned>::Owned;
    fn into_owned(self) -> Self::Owned {
        self.to_owned()
    }
}

impl<'a, T> IntoOwned for Cow<'a, T>
where
    T: ?Sized + ToOwned,
{
    type Owned = <T as ToOwned>::Owned;
    fn into_owned(self) -> <Self as IntoOwned>::Owned {
        Cow::into_owned(self)
    }
}

impl<T> IntoOwned for Owned<T> {
    type Owned = T;
    fn into_owned(self) -> Self::Owned {
        self.0
    }
}

impl<T> IntoOwned for OwnedRef<T>
where
    T: Deref + Borrow<<T as Deref>::Target>,
{
    type Owned = T;
    fn into_owned(self) -> Self::Owned {
        self.0
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::borrow::Cow;
    #[test]
    fn test_owned() {
        let smart = Owned("Alpha".to_string());
        let reference: &String = &*smart;
        assert_eq!(reference, &"Alpha".to_string());
        let owned: String = smart.into_owned();
        assert_eq!(owned, "Alpha".to_string());
    }
    #[test]
    fn test_cow() {
        let cow_owned: Cow<'static, str> = Cow::Owned("Bravo".to_string());
        assert_eq!(IntoOwned::into_owned(cow_owned), "Bravo".to_string());
        let cow_borrowed: Cow<'static, str> = Cow::Borrowed("Charlie");
        assert_eq!(IntoOwned::into_owned(cow_borrowed), "Charlie".to_string());
    }
    #[test]
    fn test_ref() {
        let reference: &str = "Delta";
        assert_eq!(IntoOwned::into_owned(reference), "Delta".to_string());
    }
    #[test]
    fn test_slice() {
        let owned_ref: OwnedRef<Vec<i32>> = OwnedRef(vec![1, 2, 3]);
        assert_eq!(&*owned_ref, &[1, 2, 3] as &[i32]);
        assert_eq!(IntoOwned::into_owned(owned_ref), vec![1, 2, 3]);
    }
    #[test]
    fn test_generic_fn() {
        fn generic_fn(arg: impl IntoOwned<Owned = String> + Borrow<str>) {
            let borrowed: &str = arg.borrow();
            assert_eq!(borrowed, "Echo");
            let owned: String = arg.into_owned();
            assert_eq!(owned, "Echo".to_string());
        }
        generic_fn(Owned("Echo".to_string()));
        generic_fn(Cow::Owned("Echo".to_string()));
        generic_fn(Cow::Borrowed("Echo"));
        generic_fn("Echo");
    }
}