//! Common handling for types backed by byte slices with enforcement of a

//! library-level length limitation i.e. `Length::max()`.

use crate::{

    DecodeValue, DerOrd, EncodeValue, Error, Header, Length, Reader, Result, StrRef, Writer,

};

use core::cmp::Ordering;

#[cfg(feature = "alloc")]

use crate::StrOwned;

/// Byte slice newtype which respects the `Length::max()` limit.

#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]

pub(crate) struct BytesRef<'a> {

    /// Precomputed `Length` (avoids possible panicking conversions)

    pub length: Length,

    /// Inner value

    pub inner: &'a [u8],

}

impl<'a> BytesRef<'a> {

    /// Constant value representing an empty byte slice.

    pub const EMPTY: Self = Self {

        length: Length::ZERO,

        inner: &[],

    };

    /// Create a new [`BytesRef`], ensuring that the provided `slice` value

    /// is shorter than `Length::max()`.

    pub fn new(slice: &'a [u8]) -> Result<Self> {

        Ok(Self {

            length: Length::try_from(slice.len())?,

            inner: slice,

        })

    }

    /// Borrow the inner byte slice

    pub fn as_slice(&self) -> &'a [u8] {

        self.inner

    }

    /// Get the [`Length`] of this [`BytesRef`]

    pub fn len(self) -> Length {

        self.length

    }

    /// Is this [`BytesRef`] empty?

    pub fn is_empty(self) -> bool {

        self.len() == Length::ZERO

    }

}

impl AsRef<[u8]> for BytesRef<'_> {

    fn as_ref(&self) -> &[u8] {

        self.as_slice()

    }

}

impl<'a> DecodeValue<'a> for BytesRef<'a> {

    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> {

        reader.read_slice(header.length).and_then(Self::new)

    }

}

impl EncodeValue for BytesRef<'_> {

    fn value_len(&self) -> Result<Length> {

        Ok(self.length)

    }

    fn encode_value(&self, writer: &mut impl Writer) -> Result<()> {

        writer.write(self.as_ref())

    }

}

impl Default for BytesRef<'_> {

    fn default() -> Self {

        Self {

            length: Length::ZERO,

            inner: &[],

        }

    }

}

impl DerOrd for BytesRef<'_> {

    fn der_cmp(&self, other: &Self) -> Result<Ordering> {

        Ok(self.as_slice().cmp(other.as_slice()))

    }

}

impl<'a> From<StrRef<'a>> for BytesRef<'a> {

    fn from(s: StrRef<'a>) -> BytesRef<'a> {

        let bytes = s.as_bytes();

        debug_assert_eq!(bytes.len(), usize::try_from(s.length).expect("overflow"));

        BytesRef {

            inner: bytes,

            length: s.length,

        }

    }

}

#[cfg(feature = "alloc")]

impl<'a> From<&'a StrOwned> for BytesRef<'a> {

    fn from(s: &'a StrOwned) -> BytesRef<'a> {

        let bytes = s.as_bytes();

        debug_assert_eq!(bytes.len(), usize::try_from(s.length).expect("overflow"));

        BytesRef {

            inner: bytes,

            length: s.length,

        }

    }

}

impl<'a> TryFrom<&'a [u8]> for BytesRef<'a> {

    type Error = Error;

    fn try_from(slice: &'a [u8]) -> Result<Self> {

        Self::new(slice)

    }

}

// Implement by hand because the derive would create invalid values.

// Make sure the length and the inner.len matches.

#[cfg(feature = "arbitrary")]

impl<'a> arbitrary::Arbitrary<'a> for BytesRef<'a> {

    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {

        let length = u.arbitrary()?;

        Ok(Self {

            length,

            inner: u.bytes(u32::from(length) as usize)?,

        })

    }

    fn size_hint(depth: usize) -> (usize, Option<usize>) {

        arbitrary::size_hint::and(Length::size_hint(depth), (0, None))

    }

}

#[cfg(feature = "alloc")]

mod allocating {

    use super::BytesRef;

    use crate::{referenced::RefToOwned, BytesOwned};

    impl<'a> RefToOwned<'a> for BytesRef<'a> {

        type Owned = BytesOwned;

        fn ref_to_owned(&self) -> Self::Owned {

            BytesOwned::from(*self)

        }

    }

}