use super::piece::Piece;
use tracing::trace;
pub struct PiecedSegment {
piece: Piece,
piece_length: u64,
written_length: u64,
}
impl PiecedSegment {
pub fn new(piece_length: u64, piece: Piece) -> Self {
let initial_written = piece.completed_length();
trace!(
index = piece.index(),
length = piece.length(),
piece_length,
initial_written,
"PiecedSegment: created"
);
PiecedSegment {
piece,
piece_length,
written_length: initial_written,
}
}
pub fn is_complete(&self) -> bool {
self.piece.is_complete()
}
pub fn index(&self) -> usize {
self.piece.index()
}
pub fn position(&self) -> u64 {
self.piece.index() as u64 * self.piece_length
}
pub fn position_to_write(&self) -> u64 {
self.position() + self.written_length
}
pub fn length(&self) -> u64 {
self.piece.length()
}
pub fn segment_length(&self) -> u64 {
self.piece_length
}
pub fn written_length(&self) -> u64 {
self.written_length
}
pub fn update_written_length(&mut self, bytes: u64) {
if bytes == 0 {
return;
}
let old_pos = self.written_length;
let new_pos = self.written_length + bytes;
let block_length = self.piece.block_length() as u64;
if let Some(start_block) = old_pos.checked_div(block_length) {
let start_block = start_block as usize;
let end_block = new_pos.div_ceil(block_length) as usize;
let num_blocks = self.piece.count_blocks();
for block_idx in start_block..std::cmp::min(end_block, num_blocks) {
let block_start = block_idx as u64 * block_length;
let block_end = std::cmp::min(block_start + block_length, self.piece.length());
if new_pos >= block_end {
self.piece.complete_block(block_idx);
}
}
}
self.written_length = new_pos;
trace!(
index = self.piece.index(),
old_written = old_pos,
increment = bytes,
new_written = self.written_length,
"PiecedSegment: updated written length"
);
}
pub fn update_hash(&mut self, begin: u64, data: &[u8]) -> bool {
self.piece.update_hash(begin, data)
}
pub fn is_hash_calculated(&self) -> bool {
self.piece.is_hash_calculated()
}
pub fn digest(&mut self) -> String {
match self.piece.get_digest() {
Some(bytes) => hex::encode(bytes),
None => String::new(),
}
}
pub fn piece(&self) -> &Piece {
&self.piece
}
pub fn piece_mut(&mut self) -> &mut Piece {
&mut self.piece
}
}
impl std::fmt::Debug for PiecedSegment {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PiecedSegment")
.field("index", &self.piece.index())
.field("piece_length", &self.piece_length)
.field("written_length", &self.written_length)
.field("piece", &self.piece)
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_new_with_piece() {
let piece = Piece::new(3, 65536);
let seg = PiecedSegment::new(65536, piece);
assert_eq!(seg.index(), 3);
assert_eq!(seg.position(), 3 * 65536);
assert_eq!(seg.position_to_write(), 3 * 65536);
assert_eq!(seg.length(), 65536);
assert_eq!(seg.segment_length(), 65536);
assert_eq!(seg.written_length(), 0);
assert!(!seg.is_complete());
}
#[test]
fn test_last_piece_shorter_length() {
let piece = Piece::new(1, 34464);
let seg = PiecedSegment::new(65536, piece);
assert_eq!(seg.index(), 1);
assert_eq!(seg.position(), 65536);
assert_eq!(seg.length(), 34464);
assert_eq!(seg.segment_length(), 65536);
}
#[test]
fn test_update_written_length_single_block() {
let piece = Piece::new(0, 65536);
let mut seg = PiecedSegment::new(65536, piece);
assert_eq!(seg.written_length(), 0);
seg.update_written_length(16384);
assert_eq!(seg.written_length(), 16384);
assert!(seg.piece().has_block(0));
}
#[test]
fn test_update_written_length_multiple_blocks() {
let piece = Piece::new(0, 65536);
let mut seg = PiecedSegment::new(65536, piece);
seg.update_written_length(32768);
assert_eq!(seg.written_length(), 32768);
assert!(seg.piece().has_block(0));
assert!(seg.piece().has_block(1));
assert!(!seg.piece().has_block(2));
}
#[test]
fn test_update_written_length_complete() {
let piece = Piece::new(0, 65536);
let mut seg = PiecedSegment::new(65536, piece);
seg.update_written_length(65536);
assert_eq!(seg.written_length(), 65536);
assert!(seg.is_complete());
}
#[test]
fn test_update_written_length_incremental() {
let piece = Piece::new(0, 65536);
let mut seg = PiecedSegment::new(65536, piece);
seg.update_written_length(16384);
assert_eq!(seg.written_length(), 16384);
assert_eq!(seg.position_to_write(), 16384);
seg.update_written_length(16384);
assert_eq!(seg.written_length(), 32768);
assert_eq!(seg.position_to_write(), 32768);
}
#[test]
fn test_update_written_length_zero_is_noop() {
let piece = Piece::new(0, 65536);
let mut seg = PiecedSegment::new(65536, piece);
seg.update_written_length(0);
assert_eq!(seg.written_length(), 0);
}
#[test]
fn test_hash_update_and_digest() {
let piece = Piece::new(0, 4);
let mut seg = PiecedSegment::new(4, piece);
seg.piece_mut().set_hash_type("sha-1");
assert!(seg.update_hash(0, b"test"));
assert!(seg.is_hash_calculated());
let digest = seg.digest();
assert!(!digest.is_empty());
assert_eq!(digest.len(), 40); }
#[test]
fn test_digest_empty_when_no_hash() {
let piece = Piece::new(0, 65536);
let mut seg = PiecedSegment::new(65536, piece);
assert!(seg.digest().is_empty());
}
#[test]
fn test_piece_accessors() {
let piece = Piece::new(5, 32768);
let mut seg = PiecedSegment::new(65536, piece);
assert_eq!(seg.piece().index(), 5);
assert_eq!(seg.piece().length(), 32768);
seg.piece_mut().set_hash_type("sha-256");
assert_eq!(seg.piece().hash_type(), Some("sha-256"));
}
#[test]
fn test_debug_format() {
let piece = Piece::new(2, 65536);
let seg = PiecedSegment::new(65536, piece);
let debug_str = format!("{:?}", seg);
assert!(debug_str.contains("index: 2"));
assert!(debug_str.contains("piece_length: 65536"));
}
#[test]
fn test_position_calculation() {
let piece = Piece::new(5, 1048576);
let seg = PiecedSegment::new(1048576, piece);
assert_eq!(seg.position(), 5 * 1048576);
assert_eq!(seg.position_to_write(), 5 * 1048576); }
#[test]
fn test_update_written_length_partial_block() {
let piece = Piece::new(0, 65536);
let mut seg = PiecedSegment::new(65536, piece);
seg.update_written_length(100);
assert_eq!(seg.written_length(), 100);
assert!(!seg.piece().has_block(0));
}
}