use bytes::Bytes;
 
fn main() {
    // Bytes is a reference-counted buffer
    // Multiple handles can share the same underlying data
    let data = Bytes::from("hello world");
    
    // Bytes uses Arc internally for shared ownership
    // - Cloning is cheap (increments reference count)
    // - Slicing is cheap (just adjusts offset/length)
    // - Actual data is never copied
    
    let clone = data.clone();  // Reference count: 2
    let view = data.slice(0..5);  // Reference count: still 2, new view
    
    // All three share the same underlying buffer
    println!("Original: {:?}", data);
    println!("Clone: {:?}", clone);
    println!("Slice: {:?}", view);  // "hello"
    
    // When any handle is dropped, reference count decreases
    // Buffer is freed when count reaches 0
}

use bytes::Bytes;
 
fn main() {
    let data = Bytes::from("hello world");
    
    // copy_to_slice requires a mutable destination
    let mut buffer = [0u8; 11];
    
    // Copies bytes from data into buffer
    data.copy_to_slice(&mut buffer);
    
    // Now buffer owns the copied data
    println!("Buffer: {:?}", std::str::from_utf8(&buffer).unwrap());
    
    // The original Bytes is unchanged
    println!("Original: {:?}", data);
    
    // After copy_to_slice:
    // - buffer contains a COPY of the data
    // - data still owns its reference to original buffer
    // - Two separate memory regions now hold the same bytes
    
    // copy_to_slice returns () - it's pure side effect
    // The destination slice must be exactly the right size
}

use bytes::Bytes;
 
fn main() {
    let data = Bytes::from("hello world");
    
    // slice creates a new Bytes referencing the same buffer
    let hello = data.slice(0..5);
    let world = data.slice(6..11);
    
    // No data copying occurred!
    // hello and world share the underlying "hello world" buffer
    // They just have different offset/length views
    
    println!("hello: {:?}", std::str::from_utf8(&hello).unwrap());
    println!("world: {:?}", std::str::from_utf8(&world).unwrap());
    
    // Memory layout:
    // Original buffer: [h, e, l, l, o, ' ', w, o, r, l, d]
    // data:    offset=0, len=11 -> "hello world"
    // hello:   offset=0, len=5  -> "hello"
    // world:   offset=6, len=5  -> "world"
    // All share the same Arc reference
}

use bytes::Bytes;
 
fn main() {
    let original = Bytes::from("important data");
    
    // === copy_to_slice: You own the copy ===
    
    // Destination buffer is YOUR memory
    let mut my_buffer = [0u8; 14];
    original.copy_to_slice(&mut my_buffer);
    
    // my_buffer now contains independent copy
    // Dropping original doesn't affect my_buffer
    
    drop(original);
    println!("Still have: {:?}", std::str::from_utf8(&my_buffer).unwrap());
    // Works because data was copied
    
    // === slice: Shared reference ===
    
    let shared = Bytes::from("shared data");
    let view = shared.slice(0..6);
    
    // view shares buffer with shared
    // Both must be kept alive for data to exist
    
    println!("View: {:?}", std::str::from_utf8(&view).unwrap());
    
    // When shared drops, view keeps buffer alive
    drop(shared);
    println!("View still works: {:?}", std::str::from_utf8(&view).unwrap());
    // Buffer kept alive by reference counting
}

use bytes::Bytes;
 
fn main() {
    // Use case 1: Need mutable data
    let data = Bytes::from("hello");
    let mut buffer = vec![0u8; 5];
    data.copy_to_slice(&mut buffer);
    
    // Now we can modify the copied data
    buffer[0] = b'H';
    println!("Modified: {:?}", std::str::from_utf8(&buffer).unwrap());
    // "Hello" - we modified our copy
    
    // Use case 2: Interop with APIs requiring &[u8] ownership
    fn process_owned_data(data: Vec<u8>) -> String {
        String::from_utf8(data).unwrap()
    }
    
    let bytes = Bytes::from("data to process");
    let mut owned = vec![0u8; bytes.len()];
    bytes.copy_to_slice(&mut owned);
    let result = process_owned_data(owned);
    
    // Use case 3: Fixed-size buffers
    let data = Bytes::from("12345");
    let mut fixed: [u8; 5] = [0; 5];
    data.copy_to_slice(&mut fixed);
    // Data now in fixed-size array
    
    // Use case 4: When original Bytes lifetime is constrained
    fn get_scoped_bytes() -> Bytes {
        Bytes::from("temporary")
    }
    
    let data = get_scoped_bytes();
    let mut owned = [0u8; 9];
    data.copy_to_slice(&mut owned);
    // owned persists even after data is dropped
}

use bytes::Bytes;
 
fn main() {
    // Use case 1: Parsing without copying
    let data = Bytes::from("GET /path HTTP/1.1\r\nHost: example.com\r\n\r\n");
    
    // Extract method without copying
    let method = data.slice(0..3);  // "GET"
    let path = data.slice(4..9);    // "/path"
    
    // Zero-copy parsing
    println!("Method: {:?}", std::str::from_utf8(&method).unwrap());
    
    // Use case 2: Framing protocols
    fn parse_frame(data: &Bytes) -> Option<(u8, Bytes)> {
        if data.len() < 2 {
            return None;
        }
        
        let frame_type = data[0];
        let payload = data.slice(1..data.len());
        Some((frame_type, payload))
    }
    
    let frame = Bytes::from("\x01payload_data");
    let (ftype, payload) = parse_frame(&frame).unwrap();
    println!("Type: {}, Payload len: {}", ftype, payload.len());
    
    // Use case 3: Large data sections
    let large = Bytes::from(vec![0u8; 1_000_000]);
    
    // Slice to get region - no copy!
    let region = large.slice(100..200);
    println!("Region: {} bytes", region.len());  // 100 bytes
    
    // Would be expensive to copy 100MB, but slice is free
    
    // Use case 4: Shared read-only access
    fn process_header(bytes: &Bytes) -> Bytes {
        bytes.slice(0..10)  // Return view into same buffer
    }
    
    fn process_body(bytes: &Bytes) -> Bytes {
        bytes.slice(10..bytes.len())
    }
    
    let message = Bytes::from("headerdata payload here");
    let header = process_header(&message);
    let body = process_body(&message);
    // All three share the same underlying buffer
}

use bytes::Bytes;
 
fn main() {
    let size = 1_000_000;
    let large_data = Bytes::from(vec![0u8; size]);
    
    // === slice: O(1) ===
    // Creates new handle with adjusted offset/length
    let start = std::time::Instant::now();
    let view = large_data.slice(100..10000);
    let slice_time = start.elapsed();
    println!("slice took {:?}", slice_time);
    // Nearly instant - just pointer arithmetic
    
    // === copy_to_slice: O(n) ===
    // Actually copies bytes
    let mut buffer = vec![0u8; 9900];
    let start = std::time::Instant::now();
    large_data.copy_to_slice(&mut buffer);
    let copy_time = start.elapsed();
    println!("copy_to_slice took {:?}", copy_time);
    // Proportional to data size
    
    // Memory usage:
    // slice: +8 bytes for the handle (pointer + length)
    // copy_to_slice: +n bytes for the copied data
    
    // For large data, slice is dramatically cheaper
    println!("Memory overhead - slice: ~8 bytes");
    println!("Memory overhead - copy: {} bytes", buffer.len());
}

use bytes::Bytes;
 
fn main() {
    let data = Bytes::from("hello world from rust");
    
    // First slice to focus on region, then copy if needed
    let region = data.slice(6..16);  // "world from"
    
    // If you need mutable copy of this region:
    let mut buffer = [0u8; 10];
    region.copy_to_slice(&mut buffer);
    
    // Or directly from original with offset
    let mut direct_buffer = [0u8; 10];
    data.slice(6..16).copy_to_slice(&mut direct_buffer);
    
    // Common pattern: slice for viewing, copy_to_slice for processing
    fn parse_and_process(data: &Bytes) -> Vec<u8> {
        // Slice to find the relevant portion
        let header = data.slice(0..4);
        let body = data.slice(4..data.len());
        
        // Copy body for processing
        let mut owned_body = vec![0u8; body.len()];
        body.copy_to_slice(&mut owned_body);
        
        // Now owned_body can be modified
        for byte in &mut owned_body {
            *byte = byte.to_ascii_uppercase();
        }
        
        owned_body
    }
}

use bytes::Bytes;
 
fn main() {
    // copy_to_slice requires EXACT size match
    let data = Bytes::from("hello");
    
    // This works - exact size match
    let mut exact = [0u8; 5];
    data.copy_to_slice(&mut exact);
    
    // This would panic - size mismatch
    // let mut too_small = [0u8; 3];
    // data.copy_to_slice(&mut too_small);  // panic!
    
    // let mut too_big = [0u8; 10];
    // data.copy_to_slice(&mut too_big);    // panic!
    
    // Safe approach: check sizes
    fn safe_copy(data: &Bytes, buffer: &mut [u8]) -> Result<(), &'static str> {
        if data.len() != buffer.len() {
            return Err("size mismatch");
        }
        data.copy_to_slice(buffer);
        Ok(())
    }
    
    // Or use copy_to for partial copies
    let mut bigger = [0u8; 10];
    let copied = data.copy_to(&mut bigger);
    println!("Copied {} bytes", copied);  // 5 bytes
    
    // slice doesn't have size constraints (within bounds)
    let partial = data.slice(0..3);  // OK
    let full = data.slice(0..5);     // OK
    // let invalid = data.slice(0..10);  // Would panic - out of bounds
}

use bytes::Bytes;
 
// Common pattern in async/network code
fn process_network_frame(data: Bytes) -> (Bytes, Bytes) {
    // Assume format: [length:4][header:10][body:rest]
    
    // No copies needed to extract parts
    let length_bytes = data.slice(0..4);
    let header = data.slice(4..14);
    let body = data.slice(14..data.len());
    
    // All share the same underlying buffer
    // Zero-copy frame parsing!
    
    (header, body)
}
 
// When mutation is needed
fn process_with_modification(data: Bytes) -> Vec<u8> {
    // Parse without copying
    let header = data.slice(0..4);
    
    // But copy body for modification
    let body = data.slice(4..data.len());
    let mut owned_body = vec![0u8; body.len()];
    body.copy_to_slice(&mut owned_body);
    
    // Process owned_body
    for byte in &mut owned_body {
        *byte = byte.wrapping_add(1);
    }
    
    owned_body
}
 
fn main() {
    let frame = Bytes::from("len\x00\x00header data here");
    let (header, body) = process_network_frame(frame.clone());
    
    println!("Header len: {}", header.len());
    println!("Body len: {}", body.len());
}

use bytes::{Bytes, BytesMut};
 
fn main() {
    // BytesMut is mutable; Bytes is immutable view
    
    let mut buf = BytesMut::from("hello world");
    
    // Can modify BytesMut directly
    buf[0] = b'H';
    
    // Convert to Bytes (shared view)
    let bytes: Bytes = buf.freeze();  // Now immutable
    // buf is consumed, can't modify anymore
    
    // To modify again, you'd need BytesMut
    // Bytes is immutable - that's why copy_to_slice exists
    
    let mut owned = [0u8; 11];
    bytes.copy_to_slice(&mut owned);
    // Now owned is mutable
    
    // The pattern:
    // BytesMut -> modify in place
    // Bytes -> read-only shared
    // copy_to_slice -> get mutable copy from Bytes
}

// | Aspect          | copy_to_slice           | slice                |
// |-----------------|-------------------------|----------------------|
// | Operation       | Memory copy             | Pointer adjustment   |
// | Time complexity | O(n)                    | O(1)                 |
// | Memory          | Allocates new buffer    | Shares existing      |
// | Destination     | Your mutable slice      | New Bytes handle     |
// | Ownership       | You own the copy        | Shared via Arc       |
// | Mutation        | Copy is mutable         | Result is immutable  |
// | Size check      | Must match exactly      | Must be within bounds|
// | Use case        | Need mutable data       | Read-only view       |