//! This module contains the actual, albeit generic, implementaiton of the `Cow`,
//! and the traits that are available to it.

use alloc::borrow::{Borrow, Cow as StdCow};
use alloc::string::String;
use alloc::vec::Vec;
use core::cmp::Ordering;
use core::fmt;
use core::hash::{Hash, Hasher};
use core::marker::PhantomData;
use core::mem::ManuallyDrop;
use core::ptr::NonNull;

#[cfg(target_pointer_width = "64")]
use crate::lean::internal::Lean;
use crate::traits::{Beef, Capacity};
use crate::wide::internal::Wide;

/// A clone-on-write smart pointer, mostly compatible with [`std::borrow::Cow`](https://doc.rust-lang.org/std/borrow/enum.Cow.html).
///
/// This type is using a generic `U: Capacity`. Use either [`beef::Cow`](../type.Cow.html) or [`beef::lean::Cow`](../lean/type.Cow.html) in your code.
pub struct Cow<'a, T: Beef + ?Sized + 'a, U: Capacity> {
    /// Pointer to data
    ptr: NonNull<T::PointerT>,

    /// This usize contains length, but it may contain other
    /// information pending on impl of `Capacity`, and must therefore
    /// always go through `U::len` or `U::unpack`
    fat: usize,

    /// Capacity field. For `beef::lean::Cow` this is 0-sized!
    cap: U::Field,

    /// Lifetime marker
    marker: PhantomData<&'a T>,
}

impl<T, U> Cow<'_, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    /// Owned data.
    ///
    /// # Example
    ///
    /// ```rust
    /// use beef::Cow;
    ///
    /// let owned: Cow<str> = Cow::owned("I own my content".to_string());
    /// ```
    #[inline]
    pub fn owned(val: T::Owned) -> Self {
        let (ptr, fat, cap) = T::owned_into_parts::<U>(val);

        Cow {
            ptr,
            fat,
            cap,
            marker: PhantomData,
        }
    }
}

impl<'a, T, U> Cow<'a, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    /// Borrowed data.
    ///
    /// # Example
    ///
    /// ```rust
    /// use beef::Cow;
    ///
    /// let borrowed: Cow<str> = Cow::borrowed("I'm just a borrow");
    /// ```
    #[inline]
    pub fn borrowed(val: &'a T) -> Self {
        let (ptr, fat, cap) = T::ref_into_parts::<U>(val);

        Cow {
            ptr,
            fat,
            cap,
            marker: PhantomData,
        }
    }

    /// Extracts the owned data.
    ///
    /// Clones the data if it is not already owned.
    #[inline]
    pub fn into_owned(self) -> T::Owned {
        let cow = ManuallyDrop::new(self);

        match cow.capacity() {
            Some(capacity) => unsafe { T::owned_from_parts::<U>(cow.ptr, cow.fat, capacity) },
            None => unsafe { &*T::ref_from_parts::<U>(cow.ptr, cow.fat) }.to_owned(),
        }
    }

    /// Extracts borrowed data.
    ///
    /// Panics: If the data is owned.
    #[inline]
    pub fn unwrap_borrowed(self) -> &'a T {
        if self.capacity().is_some() {
            panic!("Can not turn owned beef::Cow into a borrowed value")
        }
        unsafe { &*T::ref_from_parts::<U>(self.ptr, self.fat) }
    }

    /// Returns `true` if data is borrowed or had no capacity.
    ///
    /// # Example
    ///
    /// ```rust
    /// use beef::Cow;
    ///
    /// let borrowed: Cow<str> = Cow::borrowed("Borrowed");
    /// let no_capacity: Cow<str> = Cow::owned(String::new());
    /// let owned: Cow<str> = Cow::owned(String::from("Owned"));
    ///
    /// assert_eq!(borrowed.is_borrowed(), true);
    /// assert_eq!(no_capacity.is_borrowed(), true);
    /// assert_eq!(owned.is_borrowed(), false);
    /// ```
    #[inline]
    pub fn is_borrowed(&self) -> bool {
        self.capacity().is_none()
    }

    /// Returns `true` if data is owned and has non-0 capacity.
    ///
    /// # Example
    ///
    /// ```rust
    /// use beef::Cow;
    ///
    /// let borrowed: Cow<str> = Cow::borrowed("Borrowed");
    /// let no_capacity: Cow<str> = Cow::owned(String::new());
    /// let owned: Cow<str> = Cow::owned(String::from("Owned"));
    ///
    /// assert_eq!(borrowed.is_owned(), false);
    /// assert_eq!(no_capacity.is_owned(), false);
    /// assert_eq!(owned.is_owned(), true);
    /// ```
    #[inline]
    pub fn is_owned(&self) -> bool {
        self.capacity().is_some()
    }

    /// Internal convenience method for casting `ptr` into a `&T`
    #[inline]
    fn borrow(&self) -> &T {
        unsafe { &*T::ref_from_parts::<U>(self.ptr, self.fat) }
    }

    #[inline]
    fn capacity(&self) -> Option<U::NonZero> {
        U::maybe(self.fat, self.cap)
    }
}

impl<'a> Cow<'a, str, Wide> {
    /// Borrowed data.
    ///
    /// This is functionally identical to [`borrow`](./generic/struct.Cow.html#method.borrow).
    /// We use impl specialization to allow this function to be `const`.
    ///
    /// # Example
    ///
    /// ```rust
    /// use beef::Cow;
    ///
    /// const HELLO: Cow<str> = Cow::const_str("Hello");
    /// ```
    pub const fn const_str(val: &'a str) -> Self {
        Cow {
            // We are casting *const T to *mut T, however for all borrowed values
            // this raw pointer is only ever dereferenced back to &T.
            ptr: unsafe { NonNull::new_unchecked(val.as_ptr() as *mut u8) },
            fat: val.len(),
            cap: None,
            marker: PhantomData,
        }
    }
}

#[cfg(target_pointer_width = "64")]
impl<'a> Cow<'a, str, Lean> {
    /// Borrowed data.
    ///
    /// This is functionally identical to [`borrow`](./generic/struct.Cow.html#method.borrow).
    /// We use impl specialization to allow this function to be `const`.
    ///
    /// # Example
    ///
    /// ```rust
    /// use beef::lean::Cow;
    ///
    /// const HELLO: Cow<str> = Cow::const_str("Hello");
    /// ```
    pub const fn const_str(val: &'a str) -> Self {
        Cow {
            // We are casting *const T to *mut T, however for all borrowed values
            // this raw pointer is only ever dereferenced back to &T.
            ptr: unsafe { NonNull::new_unchecked(val.as_ptr() as *mut u8) },
            fat: Lean::mask_len(val.len()),
            cap: Lean,
            marker: PhantomData,
        }
    }
}

// This requires nightly:
// https://github.com/rust-lang/rust/issues/57563
#[cfg(feature = "const_fn")]
impl<'a, T> Cow<'a, [T], Wide>
where
    T: Clone,
{
    /// Borrowed data.
    ///
    /// This is functionally identical to [`borrow`](./generic/struct.Cow.html#method.borrow).
    /// We use impl specialization to allow this function to be `const`.
    ///
    /// # Example
    ///
    /// ```rust
    /// use beef::Cow;
    ///
    /// const HELLO: Cow<[u8]> = Cow::const_slice(&[1, 2, 3]);
    /// ```
    pub const fn const_slice(val: &'a [T]) -> Self {
        Cow {
            // We are casting *const T to *mut T, however for all borrowed values
            // this raw pointer is only ever dereferenced back to &T.
            ptr: unsafe { NonNull::new_unchecked(val.as_ptr() as *mut T) },
            fat: val.len(),
            cap: None,
            marker: PhantomData,
        }
    }
}

// This requires nightly:
// https://github.com/rust-lang/rust/issues/57563
#[cfg(all(feature = "const_fn", target_pointer_width = "64"))]
impl<'a, T> Cow<'a, [T], Lean>
where
    T: Clone,
{
    /// Borrowed data.
    ///
    /// This i functionally identical to [`borrow`](./generic/struct.Cow.html#method.borrow).
    /// We use impl specialization to allow this function to be `const`.
    ///
    /// # Example
    ///
    /// ```rust
    /// use beef::lean::Cow;
    ///
    /// const HELLO: Cow<[u8]> = Cow::const_slice(&[1, 2, 3]);
    /// ```
    pub const fn const_slice(val: &'a [T]) -> Self {
        Cow {
            // We are casting *const T to *mut T, however for all borrowed values
            // this raw pointer is only ever dereferenced back to &T.
            ptr: unsafe { NonNull::new_unchecked(val.as_ptr() as *mut T) },
            fat: Lean::mask_len(val.len()),
            cap: Lean,
            marker: PhantomData,
        }
    }
}

impl<T, U> Hash for Cow<'_, T, U>
where
    T: Hash + Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.borrow().hash(state)
    }
}

impl<'a, T, U> Default for Cow<'a, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
    &'a T: Default,
{
    #[inline]
    fn default() -> Self {
        Cow::borrowed(Default::default())
    }
}

impl<T, U> Eq for Cow<'_, T, U>
where
    T: Eq + Beef + ?Sized,
    U: Capacity,
{
}

impl<A, B, U, V> PartialOrd<Cow<'_, B, V>> for Cow<'_, A, U>
where
    A: Beef + ?Sized + PartialOrd<B>,
    B: Beef + ?Sized,
    U: Capacity,
    V: Capacity,
{
    #[inline]
    fn partial_cmp(&self, other: &Cow<'_, B, V>) -> Option<Ordering> {
        PartialOrd::partial_cmp(self.borrow(), other.borrow())
    }
}

impl<T, U> Ord for Cow<'_, T, U>
where
    T: Ord + Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn cmp(&self, other: &Self) -> Ordering {
        Ord::cmp(self.borrow(), other.borrow())
    }
}

impl<'a, T, U> From<&'a T> for Cow<'a, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn from(val: &'a T) -> Self {
        Cow::borrowed(val)
    }
}

impl<U> From<String> for Cow<'_, str, U>
where
    U: Capacity,
{
    #[inline]
    fn from(s: String) -> Self {
        Cow::owned(s)
    }
}

impl<T, U> From<Vec<T>> for Cow<'_, [T], U>
where
    T: Clone,
    U: Capacity,
{
    #[inline]
    fn from(v: Vec<T>) -> Self {
        Cow::owned(v)
    }
}

impl<T, U> Drop for Cow<'_, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn drop(&mut self) {
        if let Some(capacity) = self.capacity() {
            unsafe { T::owned_from_parts::<U>(self.ptr, self.fat, capacity) };
        }
    }
}

impl<'a, T, U> Clone for Cow<'a, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn clone(&self) -> Self {
        match self.capacity() {
            Some(_) => Cow::owned(self.borrow().to_owned()),
            None => Cow { ..*self },
        }
    }
}

impl<T, U> core::ops::Deref for Cow<'_, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    type Target = T;

    #[inline]
    fn deref(&self) -> &T {
        self.borrow()
    }
}

impl<T, U> AsRef<T> for Cow<'_, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn as_ref(&self) -> &T {
        self.borrow()
    }
}

impl<T, U> Borrow<T> for Cow<'_, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn borrow(&self) -> &T {
        self.borrow()
    }
}

impl<'a, T, U> From<StdCow<'a, T>> for Cow<'a, T, U>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn from(stdcow: StdCow<'a, T>) -> Self {
        match stdcow {
            StdCow::Borrowed(v) => Self::borrowed(v),
            StdCow::Owned(v) => Self::owned(v),
        }
    }
}

impl<'a, T, U> From<Cow<'a, T, U>> for StdCow<'a, T>
where
    T: Beef + ?Sized,
    U: Capacity,
{
    #[inline]
    fn from(cow: Cow<'a, T, U>) -> Self {
        let cow = ManuallyDrop::new(cow);

        match cow.capacity() {
            Some(capacity) => {
                StdCow::Owned(unsafe { T::owned_from_parts::<U>(cow.ptr, cow.fat, capacity) })
            }
            None => StdCow::Borrowed(unsafe { &*T::ref_from_parts::<U>(cow.ptr, cow.fat) }),
        }
    }
}

impl<A, B, U, V> PartialEq<Cow<'_, B, V>> for Cow<'_, A, U>
where
    A: Beef + ?Sized,
    B: Beef + ?Sized,
    U: Capacity,
    V: Capacity,
    A: PartialEq<B>,
{
    fn eq(&self, other: &Cow<B, V>) -> bool {
        self.borrow() == other.borrow()
    }
}

macro_rules! impl_eq {
    ($($(@for< $bounds:tt >)? $ptr:ty => $([$($deref:tt)+])? <$with:ty>,)*) => {$(
        impl<U $(, $bounds)*> PartialEq<$with> for Cow<'_, $ptr, U>
        where
            U: Capacity,
            $( $bounds: Clone + PartialEq, )*
        {
            #[inline]
            fn eq(&self, other: &$with) -> bool {
                self.borrow() == $($($deref)*)* other
            }
        }

        impl<U $(, $bounds)*> PartialEq<Cow<'_, $ptr, U>> for $with
        where
            U: Capacity,
            $( $bounds: Clone + PartialEq, )*
        {
            #[inline]
            fn eq(&self, other: &Cow<$ptr, U>) -> bool {
                $($($deref)*)* self == other.borrow()
            }
        }
    )*};
}

impl_eq! {
    str => <str>,
    str => [*]<&str>,
    str => <String>,
    @for<T> [T] => <[T]>,
    @for<T> [T] => [*]<&[T]>,
    @for<T> [T] => [&**]<Vec<T>>,
}

impl<T, U> fmt::Debug for Cow<'_, T, U>
where
    T: Beef + fmt::Debug + ?Sized,
    U: Capacity,
{
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.borrow().fmt(f)
    }
}

impl<T, U> fmt::Display for Cow<'_, T, U>
where
    T: Beef + fmt::Display + ?Sized,
    U: Capacity,
{
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.borrow().fmt(f)
    }
}

// Safety: Same bounds as `std::borrow::Cow`.
unsafe impl<T, U> Sync for Cow<'_, T, U>
where
    U: Capacity,
    T: Beef + Sync + ?Sized,
    T::Owned: Sync,
{
}

unsafe impl<T, U> Send for Cow<'_, T, U>
where
    U: Capacity,
    T: Beef + Sync + ?Sized,
    T::Owned: Send,
{
}

impl<T, U> Unpin for Cow<'_, T, U>
where
    U: Capacity,
    T: Beef + ?Sized,
    T::Owned: Unpin,
{
}