flense 0.1.0

use core::marker::PhantomData;

use crate::{
    Field,
    type_lists::{
        ConsSet,
        GetPtr,
        GetStride,
        SculptSlice,
        TupleSet,
    },
};

/// Reified lens into contiguous memory.
#[derive(Debug, PartialEq, Eq)]
pub struct LensSlice<'a, T>
where
    T: TupleSet,
{
    storage: T::ConsSlice,
    len: usize,
    _phantom: PhantomData<&'a ()>,
}

// Manual Clone/Copy: the derive would add `T: Clone + Copy` bounds even
// though `T` is purely a phantom type-set tag.
impl<T> Clone for LensSlice<'_, T>
where
    T: TupleSet,
    T::ConsSlice: Clone,
{
    #[inline]
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            len: self.len,
            _phantom: PhantomData,
        }
    }
}
impl<T> Copy for LensSlice<'_, T>
where
    T: TupleSet,
    T::ConsSlice: Copy,
{
}

impl<'a, T> LensSlice<'a, T>
where
    T: TupleSet,
{
    #[inline]
    pub(crate) const fn new(storage: T::ConsSlice, len: usize) -> Self {
        Self {
            storage,
            len,
            _phantom: PhantomData,
        }
    }

    /// Split `self` into two lenses.
    ///
    /// `Lhs` is the tuple of fields that should appear in the left-hand
    /// returned lens; the right-hand lens contains the remaining fields.
    ///
    /// `Indices` is a single tuple-nested list of shrinking-list positions (one
    /// per element of `Lhs`) and should be inferred; pass `_` at the call site.
    #[expect(clippy::type_complexity, reason = "help")]
    #[inline]
    pub fn split<Lhs, Indices>(
        self,
    ) -> (
        LensSlice<'a, Lhs>,
        LensSlice<
            'a,
            <<T::ConsSlice as SculptSlice<Lhs::ConsSlice, Indices>>::Remainder as ConsSet>::Tuple,
        >,
    )
    where
        Lhs: TupleSet,
        T::ConsSlice: SculptSlice<Lhs::ConsSlice, Indices>,
        <T::ConsSlice as SculptSlice<Lhs::ConsSlice, Indices>>::Remainder: ConsSet<
            Tuple: TupleSet<
                ConsSlice = <T::ConsSlice as SculptSlice<Lhs::ConsSlice, Indices>>::Remainder,
            >,
        >,
    {
        let (lhs_storage, rem_storage) = self.storage.sculpt_slice();
        (
            LensSlice {
                storage: lhs_storage,
                len: self.len,
                _phantom: PhantomData,
            },
            LensSlice {
                storage: rem_storage,
                len: self.len,
                _phantom: PhantomData,
            },
        )
    }

    /// Returns a pointer to the first lensed element of a field.
    #[inline]
    pub fn as_ptr<Elt, Index>(&self) -> *const Elt::Type
    where
        Elt: Field + 'static,
        T::ConsSlice: GetPtr<Elt, Index>,
    {
        self.storage.get_ptr().as_ptr()
    }

    /// Returns a shared reference to the `i`-th lensed element of a field, or
    /// `None` if `i >= self.len()`.
    #[inline]
    #[must_use]
    pub fn get<Elt, Index>(&self, i: usize) -> Option<&'a Elt::Type>
    where
        Elt: Field + 'static,
        T::ConsSlice: GetPtr<Elt, Index> + GetStride<Elt, Index>,
    {
        if i < self.len {
            // SAFETY: `i < self.len` checked above.
            Some(unsafe { self.get_unchecked::<Elt, _>(i) })
        } else {
            None
        }
    }

    /// Returns a shared reference to the `i`-th lensed element of a field,
    /// without bounds checking.
    ///
    /// # Safety
    /// `i` must be `< self.len()`.
    #[inline]
    #[must_use]
    pub unsafe fn get_unchecked<Elt, Index>(&self, i: usize) -> &'a Elt::Type
    where
        Elt: Field + 'static,
        T::ConsSlice: GetPtr<Elt, Index> + GetStride<Elt, Index>,
    {
        let base: *const Elt::Type = self.storage.get_ptr().as_ptr();
        let stride = self.storage.get_stride();
        // SAFETY: By the caller's contract `i < self.len()`, so the offset
        // `stride * i` lands inside the original slice. `Adapter` guarantees
        // the resulting pointer is valid for reads of `Elt::Type` and
        // properly aligned. The lens holds a shared borrow of the source
        // for `'a`.
        unsafe { &*base.cast::<u8>().add(stride * i).cast::<Elt::Type>() }
    }

    /// Returns the number of lensed elements.
    #[inline]
    pub const fn len(&self) -> usize {
        self.len
    }

    /// Returns the number of bytes between lensed elements of a field.
    #[inline]
    pub fn stride<Elt, Index>(&self) -> usize
    where
        Elt: Field + 'static,
        T::ConsSlice: GetStride<Elt, Index>,
    {
        self.storage.get_stride()
    }

    /// Returns `true` if the lens has a length of 0.
    #[inline]
    pub const fn is_empty(&self) -> bool {
        self.len == 0
    }
}