use std::sync::RwLock;
use rand::seq::SliceRandom;
use tracing::trace;
use super::bitfield_util::{byte_at, for_each_set_bit, for_each_set_byte};
pub struct PieceStatMan {
order: Vec<u32>,
counts: RwLock<Vec<u32>>,
}
impl PieceStatMan {
pub fn new(piece_num: usize, random_shuffle: bool) -> Self {
let mut order: Vec<u32> = (0..piece_num)
.map(|index| u32::try_from(index).expect("piece count exceeds u32::MAX"))
.collect();
if random_shuffle {
let mut rng = rand::rng();
order.shuffle(&mut rng);
trace!(
piece_num,
"PieceStatMan created with random shuffle, order randomized"
);
} else {
trace!(piece_num, "PieceStatMan created without shuffle");
}
PieceStatMan {
order,
counts: RwLock::new(vec![0u32; piece_num]),
}
}
pub fn add_piece_stats_index(&self, index: usize) {
let mut counts = self.counts.write().unwrap();
if index < counts.len() {
counts[index] = counts[index].saturating_add(1);
trace!(index, count = counts[index], "add_piece_stats_index");
}
}
pub fn add_piece_stats_bitfield(&self, bitfield: &[u8]) {
let mut counts = self.counts.write().unwrap();
let nbits = counts.len();
for_each_set_bit(bitfield, nbits, |index| {
counts[index] = counts[index].saturating_add(1);
});
trace!(nbits, "add_piece_stats_bitfield completed");
}
pub fn subtract_piece_stats(&self, bitfield: &[u8]) {
let mut counts = self.counts.write().unwrap();
let nbits = counts.len();
for_each_set_bit(bitfield, nbits, |index| {
counts[index] = counts[index].saturating_sub(1);
});
trace!(nbits, "subtract_piece_stats completed");
}
pub fn update_piece_stats(&self, new_bitfield: &[u8], old_bitfield: &[u8]) {
let mut counts = self.counts.write().unwrap();
let nbits = counts.len();
for byte_index in 0..nbits.div_ceil(8) {
let added = byte_at(new_bitfield, byte_index) & !byte_at(old_bitfield, byte_index);
for_each_set_byte(added, byte_index, nbits, &mut |index| {
counts[index] = counts[index].saturating_add(1);
});
let removed = byte_at(old_bitfield, byte_index) & !byte_at(new_bitfield, byte_index);
for_each_set_byte(removed, byte_index, nbits, &mut |index| {
counts[index] = counts[index].saturating_sub(1);
});
}
trace!(nbits, "update_piece_stats completed");
}
pub fn update_piece_stat(&self, index: usize, old: bool, new: bool) {
if old == new {
return;
}
let mut counts = self.counts.write().unwrap();
if let Some(count) = counts.get_mut(index) {
if new {
*count = count.saturating_add(1);
} else {
*count = count.saturating_sub(1);
}
}
}
#[inline]
pub fn order(&self) -> &[u32] {
&self.order
}
pub fn counts_snapshot(&self) -> Vec<u32> {
self.counts.read().unwrap().clone()
}
#[inline]
pub fn counts_ref(&self) -> std::sync::RwLockReadGuard<'_, Vec<u32>> {
self.counts.read().unwrap()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_new_without_shuffle() {
let man = PieceStatMan::new(10, false);
assert_eq!(man.order(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
assert_eq!(*man.counts_ref(), &[0u32; 10]);
}
#[test]
fn test_new_with_shuffle() {
let man = PieceStatMan::new(100, true);
let mut sorted: Vec<u32> = man.order().to_vec();
sorted.sort();
assert_eq!(sorted, (0..100u32).collect::<Vec<_>>());
assert_ne!(man.order(), (0..100u32).collect::<Vec<_>>());
}
#[test]
fn test_new_zero_pieces() {
let man = PieceStatMan::new(0, false);
assert!(man.order().is_empty());
assert!(man.counts_ref().is_empty());
}
#[test]
fn test_add_piece_stats_index() {
let man = PieceStatMan::new(5, false);
man.add_piece_stats_index(2);
man.add_piece_stats_index(2);
man.add_piece_stats_index(4);
assert_eq!(*man.counts_ref(), &[0, 0, 2, 0, 1]);
}
#[test]
fn test_add_piece_stats_index_out_of_bounds() {
let man = PieceStatMan::new(3, false);
man.add_piece_stats_index(99);
assert_eq!(*man.counts_ref(), &[0, 0, 0]);
}
#[test]
fn test_add_piece_stats_bitfield() {
let man = PieceStatMan::new(8, false);
let bitfield: &[u8] = &[0b10110001];
man.add_piece_stats_bitfield(bitfield);
assert_eq!(*man.counts_ref(), &[1, 0, 1, 1, 0, 0, 0, 1]);
}
#[test]
fn test_add_piece_stats_bitfield_multi_byte() {
let man = PieceStatMan::new(16, false);
let bitfield: &[u8] = &[0b11000000, 0b00000011];
man.add_piece_stats_bitfield(bitfield);
let counts = man.counts_ref();
assert_eq!(counts[0], 1);
assert_eq!(counts[1], 1);
assert_eq!(counts[14], 1);
assert_eq!(counts[15], 1);
for i in 2..14 {
assert_eq!(counts[i], 0);
}
}
#[test]
fn test_subtract_piece_stats() {
let man = PieceStatMan::new(8, false);
let bitfield: &[u8] = &[0b11111111];
man.add_piece_stats_bitfield(bitfield);
assert_eq!(*man.counts_ref(), &[1, 1, 1, 1, 1, 1, 1, 1]);
let partial: &[u8] = &[0b10100001];
man.subtract_piece_stats(partial);
assert_eq!(*man.counts_ref(), &[0, 1, 0, 1, 1, 1, 1, 0]);
}
#[test]
fn test_subtract_piece_stats_saturating() {
let man = PieceStatMan::new(4, false);
let bitfield: &[u8] = &[0b11110000]; man.subtract_piece_stats(bitfield);
assert_eq!(*man.counts_ref(), &[0, 0, 0, 0]);
let set_bits: &[u8] = &[0b10100000];
man.subtract_piece_stats(set_bits);
assert_eq!(*man.counts_ref(), &[0, 0, 0, 0]);
}
#[test]
fn test_update_piece_stats() {
let man = PieceStatMan::new(8, false);
let old_bf: &[u8] = &[0b11000000];
man.add_piece_stats_bitfield(old_bf);
assert_eq!(*man.counts_ref(), &[1, 1, 0, 0, 0, 0, 0, 0]);
let new_bf: &[u8] = &[0b10100000];
man.update_piece_stats(new_bf, old_bf);
assert_eq!(*man.counts_ref(), &[1, 0, 1, 0, 0, 0, 0, 0]);
}
#[test]
fn test_update_piece_stats_no_change() {
let man = PieceStatMan::new(8, false);
let bf: &[u8] = &[0b10101010]; man.add_piece_stats_bitfield(bf);
let counts_before = man.counts_snapshot();
man.update_piece_stats(bf, bf);
assert_eq!(*man.counts_ref(), counts_before.as_slice());
}
#[test]
fn test_saturating_add_at_max() {
let man = PieceStatMan::new(3, false);
{
let mut counts = man.counts.write().unwrap();
counts[1] = u32::MAX;
}
man.add_piece_stats_index(1);
assert_eq!(man.counts_ref()[1], u32::MAX, "should saturate at u32::MAX");
}
#[test]
fn test_saturating_sub_at_zero() {
let man = PieceStatMan::new(3, false);
assert_eq!(man.counts_ref()[0], 0);
man.subtract_piece_stats(&[0b10000000]); assert_eq!(man.counts_ref()[0], 0, "should saturate at 0");
}
#[test]
fn test_order_unchanged_after_operations() {
let man = PieceStatMan::new(5, false);
let original_order = man.order().to_vec();
man.add_piece_stats_index(0);
man.add_piece_stats_bitfield(&[0b11111000]); man.subtract_piece_stats(&[0b10000000]);
man.update_piece_stats(&[0b11000000], &[0b10100000]);
assert_eq!(
man.order(),
original_order.as_slice(),
"order should never change after construction"
);
}
#[test]
fn test_empty_bitfield() {
let man = PieceStatMan::new(8, false);
let empty: &[u8] = &[0b00000000];
man.add_piece_stats_bitfield(empty);
assert_eq!(*man.counts_ref(), &[0u32; 8]);
man.subtract_piece_stats(empty);
assert_eq!(*man.counts_ref(), &[0u32; 8]);
}
#[test]
fn test_all_bits_set() {
let man = PieceStatMan::new(8, false);
let all_set: &[u8] = &[0b11111111];
man.add_piece_stats_bitfield(all_set);
assert_eq!(*man.counts_ref(), &[1u32; 8]);
man.subtract_piece_stats(all_set);
assert_eq!(*man.counts_ref(), &[0u32; 8]);
}
#[test]
fn test_all_bits_set_multi_byte() {
let man = PieceStatMan::new(16, false);
let all_set: &[u8] = &[0xFF, 0xFF];
man.add_piece_stats_bitfield(all_set);
assert_eq!(*man.counts_ref(), &[1u32; 16]);
}
#[test]
fn test_arc_shared_mutation() {
use std::sync::Arc;
let man = Arc::new(PieceStatMan::new(4, false));
man.add_piece_stats_index(0);
man.add_piece_stats_index(1);
man.add_piece_stats_bitfield(&[0b11110000]); assert_eq!(*man.counts_ref(), &[2, 2, 1, 1]);
}
}