fastbit 0.11.1

//! A fixed-size bitset implementation.
//!
//! `BitFixed` provides a memory-efficient, fixed-capacity bit array that stores a sequence of bits
//! using word-sized integers as the underlying storage. Unlike [`crate::BitVec`], `BitFixed` does not
//! support dynamic resizing beyond its initial allocation (though it does have a `resize` method
//! that reallocates).
//!
//! # Examples
//!
//! ```
//! use fastbit::{BitFixed, BitRead, BitWrite};
//!
//! // Create a new BitFixed with 32 bits
//! let mut bf: BitFixed<u16> = BitFixed::new(32);
//!
//! // Set some bits
//! bf.set(10);
//! bf.set(20);
//! bf.set(30);
//!
//! // Test bits
//! assert!(bf.test(10));
//! assert!(!bf.test(11));
//!
//! // Count set bits
//! assert_eq!(bf.count_ones(), 3);
//!
//! // Iterate over set bits
//! let set_bits: Vec<usize> = bf.iter().collect();
//! assert_eq!(set_bits, vec![10, 20, 30]);
//!
//! // Perform bitwise operations
//! let mut bf2: BitFixed<u16> = BitFixed::new(32);
//! bf2.set(10);
//! bf2.set(15);
//!
//! // Bitwise AND
//! let bf_and = bf & &bf2;
//! assert!(bf_and.test(10));
//! assert!(!bf_and.test(20));
//! ```

use std::{
    fmt::Debug,
    hash::Hash,
    ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not},
    ptr::NonNull,
};

use crate::{
    BitRead, BitView, BitViewMut, Iter,
    traits::{BitWord, BitWrite},
    util::{
        bitset_all, bitset_any, bitset_clear, bitset_count_ones, bitset_fill, bitset_flip,
        bitset_free, bitset_new, bitset_new_uninit, bitset_reset, bitset_resize, bitset_set,
        bitset_test_and_set, word_bit, word_bit_mask, word_len,
    },
};

/// A fixed-size bitset.
///
/// `BitFixed<W>` is a memory-efficient, fixed-capacity bit array that stores a sequence of bits
/// using word-sized integers as the underlying storage. The type parameter `W` represents the
/// word type used for storage and must implement the [`BitWord`] trait.
///
/// Unlike [`crate::BitVec`], `BitFixed` does not track capacity separately from length, making it
/// slightly more memory-efficient but less flexible for growing operations.
///
/// # Memory Layout
///
/// `BitFixed` uses a raw pointer to a contiguous array of word-sized integers, where each bit
/// in the words represents a bit in the bitset. The memory is automatically deallocated when
/// the `BitFixed` instance is dropped.
///
/// # Examples
///
/// ```
/// use fastbit::{BitFixed, BitRead, BitWrite};
///
/// // Create a new BitFixed with 100 bits
/// let mut bf: BitFixed<usize> = BitFixed::new(100);
///
/// // Set bits
/// bf.set(10);
/// bf.set(20);
/// bf.set(30);
///
/// // Test bits
/// assert!(bf.test(10));
/// assert!(!bf.test(11));
///
/// // Reset (clear) bits
/// bf.reset(10);
/// assert!(!bf.test(10));
///
/// // Fill all bits
/// bf.fill();
/// assert!(bf.all());
///
/// // Clear all bits
/// bf.clear();
/// assert!(!bf.any());
/// ```
pub struct BitFixed<W: BitWord = usize> {
    /// Raw pointer to the allocated memory
    ptr: NonNull<W>,
    /// Number of bits in the bitset
    len: usize,
}

impl<W: BitWord> BitFixed<W> {
    pub fn new(bit_len: usize) -> Self {
        let (ptr, _cap) = unsafe { bitset_new::<W>(bit_len) };
        Self { ptr, len: bit_len }
    }

    pub fn new_uninit(bit_len: usize) -> Self {
        let (ptr, _cap) = unsafe { bitset_new_uninit::<W>(bit_len) };
        Self { ptr, len: bit_len }
    }

    pub fn resize(&mut self, new_bit_len: usize) {
        let (ptr, _cap) = unsafe { bitset_resize(self.ptr, self.len, new_bit_len) };
        self.ptr = ptr;
        self.len = new_bit_len;
    }

    #[inline]
    pub fn capacity(&self) -> usize {
        word_len::<W>(self.len) * W::BITS
    }

    pub fn iter(&self) -> Iter<W> {
        Iter::new(self.ptr, self.len)
    }

    pub fn as_view(&self) -> BitView<'_, W> {
        BitView::new(self.ptr, self.len)
    }

    pub fn as_view_mut(&self) -> BitViewMut<'_, W> {
        BitViewMut::new(self.ptr, self.len)
    }

    pub fn copy_from(&mut self, other: &Self) {
        assert_eq!(self.len, other.len);
        if !std::ptr::eq(self, other) {
            let word_len = word_len::<W>(self.len);
            unsafe {
                self.ptr.copy_from_nonoverlapping(other.ptr, word_len);
            }
        }
    }

    pub fn is_disjoint(&self, other: &Self) -> bool {
        assert_eq!(self.len, other.len);
        let word_len = word_len::<W>(self.len);
        for i in 0..word_len {
            if W::from(0)
                != unsafe { *self.ptr.as_ptr().add(i) } & unsafe { *other.ptr.as_ptr().add(i) }
            {
                return false;
            }
        }
        true
    }

    pub fn intersection_count(&self, other: &Self) -> usize {
        assert_eq!(self.len, other.len);
        let word_len = word_len::<W>(self.len);
        let mut count = 0;
        for i in 0..word_len {
            let w = unsafe { *self.ptr.as_ptr().add(i) } & unsafe { *other.ptr.as_ptr().add(i) };
            count += w.count_ones();
        }
        count
    }

    #[inline(always)]
    fn ptr_and_mask(&self, idx: usize) -> (*mut W, W) {
        let (word, bit) = word_bit::<W>(idx);
        unsafe { (self.ptr.as_ptr().add(word), W::from(1) << bit) }
    }
}

/// Automatically deallocates memory when a `BitFixed` instance is dropped.
impl<W: BitWord> Drop for BitFixed<W> {
    /// Deallocates the memory used by the bitset.
    ///
    /// This method is automatically called when the `BitFixed` instance goes out of scope.
    fn drop(&mut self) {
        unsafe { bitset_free(self.ptr, self.len) };
    }
}

/// Implements the `Clone` trait for `BitFixed`.
///
/// Creates a deep copy of the bitset, allocating new memory and copying all bits.
impl<T: BitWord> Clone for BitFixed<T> {
    /// Creates a clone of the bitset.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut original: BitFixed<u32> = BitFixed::new(10);
    /// original.set(3);
    /// original.set(7);
    ///
    /// let cloned = original.clone();
    /// assert!(cloned.test(3));
    /// assert!(cloned.test(7));
    /// ```
    fn clone(&self) -> Self {
        if self.len != 0 {
            let word_len = word_len::<T>(self.len);
            let layout = std::alloc::Layout::array::<T>(word_len).unwrap();
            let raw_ptr = unsafe { std::alloc::alloc(layout) } as *mut T;
            if let Some(ptr) = NonNull::new(raw_ptr) {
                unsafe {
                    self.ptr.copy_to_nonoverlapping(ptr, word_len);
                }
                return Self { ptr, len: self.len };
            } else {
                std::alloc::handle_alloc_error(layout);
            }
        } else {
            return Self {
                ptr: NonNull::dangling(),
                len: 0,
            };
        }
    }
}

/// Implements equality comparison for `BitFixed`.
///
/// Two bitsets are equal if they have the same length and the same bits set.
impl<T: BitWord> PartialEq for BitFixed<T> {
    /// Returns true if the two bitsets are equal.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut bf1: BitFixed<u8> = BitFixed::new(10);
    /// let mut bf2: BitFixed<u8> = BitFixed::new(10);
    ///
    /// bf1.set(3);
    /// bf1.set(7);
    /// bf2.set(3);
    /// bf2.set(7);
    ///
    /// assert_eq!(bf1, bf2);
    ///
    /// bf2.set(5);
    /// assert_ne!(bf1, bf2);
    /// ```
    fn eq(&self, other: &Self) -> bool {
        let self_store =
            unsafe { std::slice::from_raw_parts(self.ptr.as_ptr(), word_len::<T>(self.len)) };
        let other_store =
            unsafe { std::slice::from_raw_parts(other.ptr.as_ptr(), word_len::<T>(other.len)) };
        self.len == other.len && self_store == other_store
    }
}

/// Implements the `Eq` trait for `BitFixed`.
///
/// This trait is required for using `BitFixed` in collections like `HashSet` and `HashMap`.
impl<T: BitWord> Eq for BitFixed<T> {}

/// Implements the `Hash` trait for `BitFixed`.
///
/// This allows `BitFixed` to be used as a key in hash-based collections.
impl<T: BitWord> Hash for BitFixed<T> {
    /// Hashes the bitset.
    ///
    /// The hash is based on both the bit content and the length.
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        let store =
            unsafe { std::slice::from_raw_parts(self.ptr.as_ptr(), word_len::<T>(self.len)) };
        store.hash(state);
        self.len.hash(state);
    }
}

/// Implements the `Debug` trait for `BitFixed`.
///
/// This provides a human-readable representation of the bitset for debugging.
impl<T: Debug + BitWord> std::fmt::Debug for BitFixed<T> {
    /// Formats the bitset for debugging.
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let store =
            unsafe { std::slice::from_raw_parts(self.ptr.as_ptr(), word_len::<T>(self.len)) };
        f.debug_struct("BitFixed")
            .field("len", &self.len)
            .field("store", &store)
            .finish()
    }
}

/// Implements the `BitRead` trait for `BitFixed`.
///
/// This trait provides methods for reading bits from the bitset.
impl<W: BitWord> BitRead for BitFixed<W> {
    /// The type of iterator returned by the `iter` method.
    type Iter<'a>
        = Iter<'a, W>
    where
        Self: 'a;

    /// Returns the number of bits in the bitset.
    #[inline]
    fn len(&self) -> usize {
        self.len
    }

    /// Returns true if the bitset has zero length.
    #[inline]
    fn is_empty(&self) -> bool {
        self.len == 0
    }

    /// Returns true if the bit at position `idx` is set.
    ///
    /// # Panics
    ///
    /// Panics if `idx` is out of bounds.
    #[inline]
    fn test(&self, idx: usize) -> bool {
        assert!(idx < self.len);
        let (ptr, mask) = self.ptr_and_mask(idx);
        unsafe { (*ptr & mask) != W::from(0) }
    }

    /// Returns the number of set bits in the bitset.
    fn count_ones(&self) -> usize {
        unsafe { bitset_count_ones(self.ptr, self.len) }
    }

    /// Returns true if all bits in the bitset are set.
    fn all(&self) -> bool {
        unsafe { bitset_all(self.ptr, self.len) }
    }

    /// Returns true if any bit in the bitset is set.
    fn any(&self) -> bool {
        unsafe { bitset_any(self.ptr, self.len) }
    }

    /// Returns an iterator over the set bits in the bitset.
    #[inline]
    fn iter(&self) -> Self::Iter<'_> {
        Iter::new(self.ptr, self.len)
    }
}

/// Implements the `BitWrite` trait for `BitFixed`.
///
/// This trait provides methods for modifying bits in the bitset.
impl<W: BitWord> BitWrite for BitFixed<W> {
    /// Sets the bit at position `idx`.
    ///
    /// # Panics
    ///
    /// Panics if `idx` is out of bounds.
    #[inline]
    fn set(&mut self, idx: usize) {
        unsafe { bitset_set(self.ptr, self.len, idx) };
    }

    /// Clears the bit at position `idx`.
    ///
    /// # Panics
    ///
    /// Panics if `idx` is out of bounds.
    #[inline]
    fn reset(&mut self, idx: usize) {
        unsafe { bitset_reset(self.ptr, self.len, idx) };
    }

    /// Flips the bit at position `idx`.
    ///
    /// # Panics
    ///
    /// Panics if `idx` is out of bounds.
    #[inline]
    fn flip(&mut self, idx: usize) {
        unsafe { bitset_flip(self.ptr, self.len, idx) };
    }

    /// Sets the bit at position `idx` and returns the previous value.
    ///
    /// # Panics
    ///
    /// Panics if `idx` is out of bounds.
    #[inline]
    fn test_and_set(&mut self, idx: usize) -> bool {
        unsafe { bitset_test_and_set(self.ptr, self.len, idx) }
    }

    /// Sets all bits to 1.
    #[inline]
    fn fill(&mut self) {
        unsafe { bitset_fill(self.ptr, self.len) };
    }

    /// Clears all bits to 0.
    #[inline]
    fn clear(&mut self) {
        unsafe { bitset_clear(self.ptr, self.len) };
    }
}

/// Implements the bitwise AND assignment operator for `BitFixed`.
///
/// This performs a bitwise AND operation in-place, modifying the left-hand side.
impl<T: BitWord> BitAndAssign<&Self> for BitFixed<T> {
    /// Performs a bitwise AND assignment operation.
    ///
    /// # Panics
    ///
    /// Panics if the two bitsets have different lengths.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut bf1: BitFixed<u8> = BitFixed::new(8);
    /// let mut bf2: BitFixed<u8> = BitFixed::new(8);
    ///
    /// bf1.set(1);
    /// bf1.set(3);
    /// bf1.set(5);
    ///
    /// bf2.set(3);
    /// bf2.set(4);
    ///
    /// bf1 &= &bf2;  // In-place AND
    ///
    /// assert!(!bf1.test(1));
    /// assert!(bf1.test(3));
    /// assert!(!bf1.test(4));
    /// assert!(!bf1.test(5));
    /// ```
    fn bitand_assign(&mut self, rhs: &Self) {
        assert_eq!(self.len, rhs.len);
        for i in 0..word_len::<T>(self.len) {
            unsafe {
                *self.ptr.as_ptr().add(i) &= *rhs.ptr.as_ptr().add(i);
            }
        }
    }
}

/// Implements the bitwise OR assignment operator for `BitFixed`.
///
/// This performs a bitwise OR operation in-place, modifying the left-hand side.
impl<T: BitWord> BitOrAssign<&Self> for BitFixed<T> {
    /// Performs a bitwise OR assignment operation.
    ///
    /// # Panics
    ///
    /// Panics if the two bitsets have different lengths.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut bf1: BitFixed<u8> = BitFixed::new(8);
    /// let mut bf2: BitFixed<u8> = BitFixed::new(8);
    ///
    /// bf1.set(1);
    /// bf1.set(3);
    ///
    /// bf2.set(3);
    /// bf2.set(5);
    ///
    /// bf1 |= &bf2;  // In-place OR
    ///
    /// assert!(bf1.test(1));
    /// assert!(bf1.test(3));
    /// assert!(bf1.test(5));
    /// ```
    fn bitor_assign(&mut self, rhs: &Self) {
        assert_eq!(self.len, rhs.len);
        for i in 0..word_len::<T>(self.len) {
            unsafe {
                *self.ptr.as_ptr().add(i) |= *rhs.ptr.as_ptr().add(i);
            }
        }
    }
}

/// Implements the bitwise XOR assignment operator for `BitFixed`.
///
/// This performs a bitwise XOR operation in-place, modifying the left-hand side.
impl<T: BitWord> BitXorAssign<&Self> for BitFixed<T> {
    /// Performs a bitwise XOR assignment operation.
    ///
    /// # Panics
    ///
    /// Panics if the two bitsets have different lengths.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut bf1: BitFixed<u8> = BitFixed::new(8);
    /// let mut bf2: BitFixed<u8> = BitFixed::new(8);
    ///
    /// bf1.set(1);
    /// bf1.set(3);
    /// bf1.set(5);
    ///
    /// bf2.set(3);
    /// bf2.set(5);
    /// bf2.set(7);
    ///
    /// bf1 ^= &bf2;  // In-place XOR
    ///
    /// assert!(bf1.test(1));
    /// assert!(!bf1.test(3));  // Both had bit 3 set, so it's cleared
    /// assert!(!bf1.test(5));  // Both had bit 5 set, so it's cleared
    /// assert!(bf1.test(7));
    /// ```
    fn bitxor_assign(&mut self, rhs: &Self) {
        assert_eq!(self.len, rhs.len);
        for i in 0..word_len::<T>(self.len) {
            unsafe {
                (*self.ptr.as_ptr().add(i)) ^= *rhs.ptr.as_ptr().add(i);
            }
        }
    }
}

/// Implements the bitwise AND operator for `BitFixed`.
///
/// This creates a new bitset that is the result of a bitwise AND operation.
impl<T: BitWord> BitAnd<&Self> for BitFixed<T> {
    /// The resulting type of the bitwise AND operation.
    type Output = BitFixed<T>;

    /// Performs a bitwise AND operation.
    ///
    /// # Panics
    ///
    /// Panics if the two bitsets have different lengths.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut bf1: BitFixed<u8> = BitFixed::new(8);
    /// let mut bf2: BitFixed<u8> = BitFixed::new(8);
    ///
    /// bf1.set(1);
    /// bf1.set(3);
    /// bf1.set(5);
    ///
    /// bf2.set(3);
    /// bf2.set(4);
    ///
    /// let result = bf1 & &bf2;
    ///
    /// assert!(!result.test(1));
    /// assert!(result.test(3));
    /// assert!(!result.test(4));
    /// assert!(!result.test(5));
    /// ```
    fn bitand(self, rhs: &Self) -> Self::Output {
        assert_eq!(self.len, rhs.len);
        let output = Self::Output::new_uninit(self.len);
        let words = word_len::<T>(self.len);
        for i in 0..words {
            unsafe {
                output
                    .ptr
                    .as_ptr()
                    .add(i)
                    .write(self.ptr.as_ptr().add(i).read() & rhs.ptr.as_ptr().add(i).read());
            }
        }
        output
    }
}

/// Implements the bitwise OR operator for `BitFixed`.
///
/// This creates a new bitset that is the result of a bitwise OR operation.
impl<T: BitWord> BitOr<&Self> for BitFixed<T> {
    /// The resulting type of the bitwise OR operation.
    type Output = BitFixed<T>;

    /// Performs a bitwise OR operation.
    ///
    /// # Panics
    ///
    /// Panics if the two bitsets have different lengths.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut bf1: BitFixed<u8> = BitFixed::new(8);
    /// let mut bf2: BitFixed<u8> = BitFixed::new(8);
    ///
    /// bf1.set(1);
    /// bf1.set(3);
    ///
    /// bf2.set(3);
    /// bf2.set(5);
    ///
    /// let result = bf1 | &bf2;
    ///
    /// assert!(result.test(1));
    /// assert!(result.test(3));
    /// assert!(result.test(5));
    /// ```
    fn bitor(self, rhs: &Self) -> Self::Output {
        assert_eq!(self.len, rhs.len);
        let output = Self::Output::new_uninit(self.len);
        let words = word_len::<T>(self.len);
        for i in 0..words {
            unsafe {
                output
                    .ptr
                    .as_ptr()
                    .add(i)
                    .write(self.ptr.as_ptr().add(i).read() | rhs.ptr.as_ptr().add(i).read());
            }
        }
        output
    }
}

/// Implements the bitwise XOR operator for `BitFixed`.
///
/// This creates a new bitset that is the result of a bitwise XOR operation.
impl<T: BitWord> BitXor<&Self> for BitFixed<T> {
    /// The resulting type of the bitwise XOR operation.
    type Output = BitFixed<T>;

    /// Performs a bitwise XOR operation.
    ///
    /// # Panics
    ///
    /// Panics if the two bitsets have different lengths.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut bf1: BitFixed<u8> = BitFixed::new(8);
    /// let mut bf2: BitFixed<u8> = BitFixed::new(8);
    ///
    /// bf1.set(1);
    /// bf1.set(3);
    /// bf1.set(5);
    ///
    /// bf2.set(3);
    /// bf2.set(5);
    /// bf2.set(7);
    ///
    /// let result = bf1 ^ &bf2;
    ///
    /// assert!(result.test(1));
    /// assert!(!result.test(3));  // Both had bit 3 set, so it's cleared
    /// assert!(!result.test(5));  // Both had bit 5 set, so it's cleared
    /// assert!(result.test(7));
    /// ```
    fn bitxor(self, rhs: &Self) -> Self::Output {
        assert_eq!(self.len, rhs.len);
        let output = Self::Output::new_uninit(self.len);
        let words = word_len::<T>(self.len);
        for i in 0..words {
            unsafe {
                output
                    .ptr
                    .as_ptr()
                    .add(i)
                    .write(self.ptr.as_ptr().add(i).read() ^ rhs.ptr.as_ptr().add(i).read());
            }
        }
        output
    }
}

/// Implements the bitwise NOT operator for `BitFixed`.
///
/// This creates a new bitset that is the result of a bitwise NOT operation (complement).
/// Each bit in the result is the inverse of the corresponding bit in the original bitset.
impl<T: BitWord> Not for &BitFixed<T> {
    /// The resulting type of the bitwise NOT operation.
    type Output = BitFixed<T>;

    /// Performs a bitwise NOT operation.
    ///
    /// # Examples
    ///
    /// ```
    /// use fastbit::{BitFixed, BitRead, BitWrite};
    ///
    /// let mut bf: BitFixed<u8> = BitFixed::new(8);
    /// bf.set(1);
    /// bf.set(3);
    ///
    /// let result = !&bf;
    ///
    /// assert!(!result.test(1));  // Was set, now cleared
    /// assert!(!result.test(3));  // Was set, now cleared
    /// assert!(result.test(0));   // Was cleared, now set
    /// assert!(result.test(2));   // Was cleared, now set
    /// assert!(result.test(4));   // Was cleared, now set
    /// assert!(result.test(5));   // Was cleared, now set
    /// assert!(result.test(6));   // Was cleared, now set
    /// assert!(result.test(7));   // Was cleared, now set
    /// ```
    fn not(self) -> Self::Output {
        let output = Self::Output::new(self.len);
        let (word, bit, mask) = word_bit_mask::<T>(self.len);
        for i in 0..word {
            unsafe {
                output.ptr.as_ptr().add(i).write(!*self.ptr.as_ptr().add(i));
            }
        }
        if bit != 0 {
            unsafe {
                output
                    .ptr
                    .as_ptr()
                    .add(word)
                    .write((!*self.ptr.as_ptr().add(word)) & mask);
            }
        }
        output
    }
}

/// Implements conversion from a reference to `BitFixed` to `BitView`.
///
/// This allows creating a read-only view of a `BitFixed` instance without copying the data.
///
/// # Examples
///
/// ```
/// use fastbit::{BitFixed, BitView, BitWrite, BitRead};
///
/// let mut bf: BitFixed<u8> = BitFixed::new(8);
/// bf.set(1);
/// bf.set(3);
///
/// // Create a BitView from a reference to BitFixed
/// let view: BitView<u8> = BitView::from(&bf);
///
/// // The view reflects the same bit values
/// assert!(view.test(1));
/// assert!(view.test(3));
/// assert!(!view.test(0));
/// ```
impl<'a, T: BitWord> From<&'a BitFixed<T>> for BitView<'a, T> {
    /// Converts a reference to `BitFixed` into a `BitView`.
    fn from(value: &'a BitFixed<T>) -> Self {
        BitView::new(value.ptr, value.len)
    }
}

/// Implements conversion from a mutable reference to `BitFixed` to `BitViewMut`.
///
/// This allows creating a mutable view of a `BitFixed` instance without copying the data.
/// Changes made through the view will affect the original `BitFixed` instance.
///
/// # Examples
///
/// ```
/// use fastbit::{BitFixed, BitViewMut, BitWrite, BitRead};
///
/// let mut bf: BitFixed<u8> = BitFixed::new(8);
/// bf.set(1);
///
/// // Create a BitViewMut from a mutable reference to BitFixed
/// let mut view: BitViewMut<u8> = BitViewMut::from(&mut bf);
///
/// // Modify bits through the view
/// view.set(3);
/// view.reset(1);
///
/// // Changes are reflected in the original BitFixed
/// assert!(!bf.test(1));
/// assert!(bf.test(3));
/// ```
impl<'a, T: BitWord> From<&'a mut BitFixed<T>> for BitViewMut<'a, T> {
    /// Converts a mutable reference to `BitFixed` into a `BitViewMut`.
    fn from(value: &'a mut BitFixed<T>) -> Self {
        BitViewMut::new(value.ptr, value.len)
    }
}

#[cfg(test)]
mod tests {
    use std::collections::HashSet;

    use super::*;

    #[test]
    fn test_new_and_len() {
        let bv: BitFixed<u8> = BitFixed::new(10);
        assert_eq!(bv.len(), 10);
        assert!(bv.is_empty() == false);
        let bv0: BitFixed<u16> = BitFixed::new(0);
        assert_eq!(bv0.len(), 0);
        assert!(bv0.is_empty());
        let mut iter = bv.iter();
        assert!(iter.next().is_none());
    }

    #[test]
    fn test_set_and_test() {
        let mut bv: BitFixed<u32> = BitFixed::new(8);
        for i in 0..8 {
            assert!(!bv.test(i));
            bv.set(i);
            assert!(bv.test(i));
        }
    }

    #[test]
    fn test_reset() {
        let mut bv: BitFixed<u64> = BitFixed::new(8);
        for i in 0..8 {
            bv.set(i);
        }
        for i in 0..8 {
            bv.reset(i);
            assert!(!bv.test(i));
        }
    }

    #[test]
    fn test_test_and_set() {
        let mut bv: BitFixed<usize> = BitFixed::new(4);
        assert!(!bv.test_and_set(2));
        assert!(bv.test_and_set(2));
        assert!(bv.test(2));
    }

    #[test]
    fn test_fill_and_clear() {
        let mut bv: BitFixed<u8> = BitFixed::new(10);
        bv.fill();
        for i in 0..10 {
            assert!(bv.test(i));
        }
        bv.clear();
        for i in 0..10 {
            assert!(!bv.test(i));
        }
    }

    #[test]
    fn test_count_ones() {
        let mut bv: BitFixed<u16> = BitFixed::new(16);
        assert_eq!(bv.count_ones(), 0);
        bv.set(0);
        bv.set(3);
        bv.set(15);
        assert_eq!(bv.count_ones(), 3);
        bv.fill();
        assert_eq!(bv.count_ones(), 16);
        bv.clear();
        assert_eq!(bv.count_ones(), 0);
    }

    #[test]
    fn test_all_and_any() {
        let mut bv: BitFixed<u32> = BitFixed::new(5);
        assert!(!bv.all());
        assert!(!bv.any());
        bv.set(0);
        assert!(!bv.all());
        assert!(bv.any());
        bv.fill();
        assert!(bv.all());
        bv.reset(2);
        assert!(!bv.all());
        assert!(bv.any());
        bv.clear();
        assert!(!bv.any());
    }

    #[test]
    fn test_resize_grow_and_shrink() {
        let mut bv: BitFixed<u64> = BitFixed::new(4);
        bv.set(1);
        bv.resize(8);
        assert!(bv.test(1));
        bv.set(7);
        assert!(bv.test(7));
        bv.resize(2);
        assert_eq!(bv.len(), 2);
        assert!(bv.test(1));
    }

    #[test]
    fn test_zero_len() {
        let mut bv: BitFixed<usize> = BitFixed::new(0);
        assert_eq!(bv.len(), 0);
        assert!(bv.is_empty());
        bv.resize(0);
        assert_eq!(bv.len(), 0);
    }

    #[test]
    fn test_iterator_empty() {
        let bv: BitFixed<u32> = BitFixed::new(0);
        let mut iter = bv.iter();
        assert_eq!(iter.next(), None);
    }

    #[test]
    fn test_iterator_single_bit() {
        let mut bv: BitFixed<u64> = BitFixed::new(1);
        assert_eq!(bv.iter().collect::<Vec<_>>(), vec![]);
        bv.set(0);
        assert_eq!(bv.iter().collect::<Vec<_>>(), vec![0]);
    }

    #[test]
    fn test_iterator_multiple_bits() {
        let mut bv: BitFixed<u8> = BitFixed::new(10);
        bv.set(2);
        bv.set(5);
        bv.set(9);
        let bits: Vec<_> = bv.iter().collect();
        assert_eq!(bits, vec![2, 5, 9]);
    }

    #[test]
    fn test_iterator_all_bits_set() {
        let mut bv: BitFixed<u16> = BitFixed::new(8);
        bv.fill();
        let bits: Vec<_> = bv.iter().collect();
        assert_eq!(bits, (0..8).collect::<Vec<_>>());
    }

    #[test]
    fn test_iterator_after_clear_and_set() {
        let mut bv: BitFixed<u32> = BitFixed::new(16);
        bv.fill();
        bv.clear();
        assert_eq!(bv.iter().collect::<Vec<_>>(), vec![]);
        bv.set(7);
        bv.set(15);
        assert!(bv.test(7));
        assert!(bv.test(15));
        assert_eq!(bv.iter().collect::<Vec<_>>(), vec![7, 15]);
    }

    #[test]
    fn test_iterator_sparse_bits() {
        let mut bv: BitFixed<u64> = BitFixed::new(64);
        bv.set(0);
        bv.set(31);
        bv.set(32);
        bv.set(63);
        let bits: Vec<_> = bv.iter().collect();
        assert_eq!(bits, vec![0, 31, 32, 63]);
    }

    #[test]
    fn test_iterator_large_bit_map() {
        let mut bv: BitFixed<usize> = BitFixed::new(130);
        for i in (0..130).step_by(13) {
            bv.set(i);
        }
        let expected: Vec<_> = (0..130).step_by(13).collect();
        let actual: Vec<_> = bv.iter().collect();
        assert_eq!(actual, expected);
    }

    #[test]
    fn test_iterator_partial_last_word() {
        let mut bv: BitFixed<u8> = BitFixed::new(70); // 70 bits, not a multiple of 64 (on 64-bit)
        bv.set(0);
        bv.set(63);
        bv.set(64);
        bv.set(69);
        let bits: Vec<_> = bv.iter().collect();
        assert_eq!(bits, vec![0, 63, 64, 69]);
    }

    #[test]
    fn test_eq() {
        let mut bs1: BitFixed<usize> = BitFixed::new(7);
        let mut bs2: BitFixed<usize> = BitFixed::new(7);
        assert_eq!(bs1, bs2);
        bs2.set(3);
        assert_ne!(bs1, bs2);
        bs1.set(3);
        assert_eq!(bs1, bs2);
        let mut x = HashSet::new();
        assert!(x.insert(bs1));
        assert!(!x.insert(bs2));
    }

    #[test]
    fn test_op() {
        let len = 7;
        let mut bset: BitFixed<usize> = BitFixed::new(len);
        assert_eq!((!&bset).count_ones() as usize, len);
        let dup = bset.clone();
        bset ^= &dup;
        assert_eq!(bset.count_ones(), 0);
        bset ^= &!&dup;
        assert_eq!(bset.count_ones() as usize, len);
    }

    #[test]
    fn test_bitwise_operations() {
        // Test with non-empty bitsets
        let mut bf1: BitFixed<u32> = BitFixed::new(32);
        let mut bf2: BitFixed<u32> = BitFixed::new(32);

        // Set some bits in bf1
        bf1.set(1);
        bf1.set(3);
        bf1.set(5);
        bf1.set(7);

        // Set some bits in bf2
        bf2.set(3);
        bf2.set(5);
        bf2.set(9);

        // Test BitAnd
        let bf_and = bf1.clone() & &bf2;
        assert!(!bf_and.test(1));
        assert!(bf_and.test(3));
        assert!(bf_and.test(5));
        assert!(!bf_and.test(7));
        assert!(!bf_and.test(9));
        assert_eq!(bf_and.count_ones(), 2);

        // Test BitOr
        let bf_or = bf1.clone() | &bf2;
        assert!(bf_or.test(1));
        assert!(bf_or.test(3));
        assert!(bf_or.test(5));
        assert!(bf_or.test(7));
        assert!(bf_or.test(9));
        assert_eq!(bf_or.count_ones(), 5);

        // Test BitXor
        let bf_xor = bf1.clone() ^ &bf2;
        assert!(bf_xor.test(1));
        assert!(!bf_xor.test(3)); // Both have bit 3 set
        assert!(!bf_xor.test(5)); // Both have bit 5 set
        assert!(bf_xor.test(7));
        assert!(bf_xor.test(9));
        assert_eq!(bf_xor.count_ones(), 3);

        // Test Not
        let bf_not = !&bf1;
        assert!(!bf_not.test(1));
        assert!(!bf_not.test(3));
        assert!(!bf_not.test(5));
        assert!(!bf_not.test(7));
        assert!(bf_not.test(0));
        assert!(bf_not.test(2));
        assert!(bf_not.test(4));
        assert!(bf_not.test(6));
        assert_eq!(bf_not.count_ones(), 32 - 4);
    }

    #[test]
    fn test_bitwise_operations_edge_cases() {
        // Test with empty bitsets
        let empty1: BitFixed<u16> = BitFixed::new(0);
        let empty2: BitFixed<u16> = BitFixed::new(0);

        let empty_and = empty1.clone() & &empty2;
        let empty_or = empty1.clone() | &empty2;
        let empty_xor = empty1.clone() ^ &empty2;
        let empty_not = !&empty1;

        assert_eq!(empty_and.len(), 0);
        assert_eq!(empty_or.len(), 0);
        assert_eq!(empty_xor.len(), 0);
        assert_eq!(empty_not.len(), 0);

        // Test with single-bit bitsets
        let mut single1: BitFixed<u8> = BitFixed::new(1);
        let single2: BitFixed<u8> = BitFixed::new(1);

        single1.set(0);

        let single_and = single1.clone() & &single2;
        assert!(!single_and.test(0));

        let single_or = single1.clone() | &single2;
        assert!(single_or.test(0));

        let single_xor = single1.clone() ^ &single2;
        assert!(single_xor.test(0));

        let single_not = !&single1;
        assert!(!single_not.test(0));

        // Test with non-standard word size
        let mut odd1: BitFixed<u64> = BitFixed::new(65); // Just over one u64
        let mut odd2: BitFixed<u64> = BitFixed::new(65);

        odd1.set(0);
        odd1.set(63); // Last bit in first word
        odd1.set(64); // First bit in second word

        odd2.set(63);
        odd2.set(64);

        let odd_and = odd1.clone() & &odd2;
        assert!(!odd_and.test(0));
        assert!(odd_and.test(63));
        assert!(odd_and.test(64));

        let odd_or = odd1.clone() | &odd2;
        assert!(odd_or.test(0));
        assert!(odd_or.test(63));
        assert!(odd_or.test(64));

        let odd_xor = odd1.clone() ^ &odd2;
        assert!(odd_xor.test(0));
        assert!(!odd_xor.test(63));
        assert!(!odd_xor.test(64));
    }

    #[test]
    fn test_copy_from() {
        let len = 10;
        let mut bv1: BitFixed<u16> = BitFixed::new(len);
        let mut bv2: BitFixed<u16> = BitFixed::new(len);
        bv1.set(2);
        bv1.set(5);
        bv2.set(7);
        bv2.set(9);
        bv2.copy_from(&bv1);
        for i in 0..len {
            assert_eq!(bv2.test(i), bv1.test(i));
        }
    }

    #[test]
    fn test_is_disjoint() {
        let len = 8;
        let mut bv1: BitFixed<u32> = BitFixed::new(len);
        let mut bv2: BitFixed<u32> = BitFixed::new(len);
        // Both empty, should be disjoint
        assert!(bv1.is_disjoint(&bv2));
        bv1.set(2);
        bv2.set(3);
        assert!(bv1.is_disjoint(&bv2));
        bv2.set(2);
        assert!(!bv1.is_disjoint(&bv2));
        bv1.clear();
        bv2.clear();
        assert!(bv1.is_disjoint(&bv2));
    }

    #[test]
    fn test_intersection_count() {
        let len = 10;
        let mut bv1: BitFixed<u8> = BitFixed::new(len);
        let mut bv2: BitFixed<u8> = BitFixed::new(len);
        assert_eq!(bv1.intersection_count(&bv2), 0);
        bv1.set(1);
        bv1.set(3);
        bv1.set(5);
        bv2.set(3);
        bv2.set(5);
        bv2.set(7);
        assert_eq!(bv1.intersection_count(&bv2), 2);
        bv2.set(1);
        assert_eq!(bv1.intersection_count(&bv2), 3);
        bv1.clear();
        assert_eq!(bv1.intersection_count(&bv2), 0);
    }

    #[test]
    fn test_debug() {
        let mut bset: BitFixed<u8> = BitFixed::new(10);
        bset.set(1);
        bset.set(7);
        bset.set(9);
        assert_eq!(format!("{bset:?}"), "BitFixed { len: 10, store: [130, 2] }");
    }
}