use uuid::Uuid;
 
fn uuid_structure() {
    let id = Uuid::new_v4();
    println!("{}", id);  // e.g., "550e8400-e29b-41d4-a716-446655440000"
    
    // Structure: xxxxxxxx-xxxx-Vxxx-Nxxx-xxxxxxxxxxxx
    // V = version (4 for v4)
    // N = variant (8, 9, a, or b for RFC 4122)
}

use uuid::Uuid;
 
fn version_and_variant() {
    let id = Uuid::new_v4();
    
    // The version field (bits 48-51 of the 128-bit UUID)
    // For v4, this is always 0100 (4 in binary)
    assert_eq!(id.get_version(), Some(uuid::Version::Random));
    
    // The variant field (bits 64-65)
    // For RFC 4122, this is always 10xx (8, 9, a, or b)
    assert_eq!(id.get_variant(), uuid::Variant::RFC4122);
    
    // In hex representation:
    // The 13th character (after the second hyphen) is always 4
    // The 17th character (after the third hyphen) is always 8, 9, a, or b
    
    let s = id.to_string();
    let chars: Vec<char> = s.chars().collect();
    assert_eq!(chars[14], '4');  // Version indicator
    assert!(matches!(chars[19], '8' | '9' | 'a' | 'b'));  // Variant indicator
}

use uuid::Uuid;
 
fn generation_process() {
    let id = Uuid::new_v4();
    
    // Internally:
    // 1. Get 16 random bytes (128 bits)
    // 2. Set version bits: byte 6 becomes (byte6 & 0x0f) | 0x40
    //    This ensures bits 48-51 are 0100 (version 4)
    // 3. Set variant bits: byte 8 becomes (byte8 & 0x3f) | 0x80
    //    This ensures bits 64-65 are 10 (RFC 4122 variant)
    
    // Result: 122 bits of randomness, 6 bits fixed
}

use uuid::Uuid;
 
// With default features (v4 feature enabled)
fn default_generation() {
    let id = Uuid::new_v4();
    // Uses getrandom crate, which:
    // - Linux: /dev/urandom or getrandom() syscall
    // - macOS: getentropy() or /dev/urandom
    // - Windows: BCryptGenRandom
    // - Web: crypto.getRandomValues()
}

// In Cargo.toml, the default v4 feature uses getrandom:
// [dependencies]
// uuid = { version = "1.0", features = ["v4"] }
 
// Alternative: use a specific RNG
// [dependencies]
// uuid = { version = "1.0", features = ["v4", "fast-rng"] }
 
use uuid::Uuid;
 
// With fast-rng feature:
// Uses a faster but potentially less secure PRNG
// Not recommended for security-sensitive applications
 
// Without v4 feature:
// Uuid::new_v4() won't compile
// You must provide your own randomness

use uuid::Uuid;
use rand::Rng;
 
fn custom_randomness() {
    // Method 1: Create from bytes you generated
    let mut bytes = [0u8; 16];
    rand::thread_rng().fill(&mut bytes);
    let id = Uuid::from_bytes(bytes);
    
    // This doesn't set version/variant bits!
    // You'd need to manually set them for a proper v4 UUID
    
    // Method 2: Use Uuid::new_v4 with a custom RNG (requires rng feature)
    // Uuid::new_v4() with the rng feature uses rand::thread_rng()
}
 
// Manually creating a proper v4 UUID from bytes:
fn v4_from_bytes(mut bytes: [u8; 16]) -> Uuid {
    // Set version to 4 (random)
    bytes[6] = (bytes[6] & 0x0f) | 0x40;
    // Set variant to RFC 4122
    bytes[8] = (bytes[8] & 0x3f) | 0x80;
    Uuid::from_bytes(bytes)
}

use uuid::Uuid;
 
fn security_considerations() {
    // Secure uses (with cryptographically secure RNG):
    // - Session tokens
    // - Authentication nonces
    // - Request IDs for security-sensitive operations
    // - Database primary keys that shouldn't be guessable
    
    // With default getrandom backend, v4 UUIDs are suitable for:
    let session_token = Uuid::new_v4();  // OK for sessions
    let csrf_token = Uuid::new_v4();      // OK for CSRF protection
    
    // NOT suitable without secure RNG:
    // - Password reset tokens (use longer, purpose-built tokens)
    // - Encryption keys (use proper key derivation)
    // - API keys (consider longer, more entropic values)
}

// With 122 random bits, collision probability is extremely low
// Birthday paradox: after generating N UUIDs, collision probability is:
// P ≈ N² / (2 × 2^122)
 
fn collision_probability() {
    // After generating 1 billion UUIDs (10^9):
    // P ≈ (10^9)² / (2 × 2^122)
    // P ≈ 10^18 / (2 × 5.3 × 10^36)
    // P ≈ 10^-18 (negligible)
    
    // For practical purposes, v4 UUID collisions are essentially impossible
    // if the RNG is functioning correctly
    
    // However: if the RNG is broken or seeded identically:
    // - Same seed = same UUID sequence
    // - Two instances with same seed will generate identical UUIDs
}

use rand::{SeedableRng, rngs::StdRng};
use uuid::Uuid;
 
fn demonstrate_predictability() {
    // Same seed produces same UUID sequence
    let seed = [0u8; 32];
    
    let mut rng1 = StdRng::from_seed(seed);
    let mut rng2 = StdRng::from_seed(seed);
    
    let mut bytes1 = [0u8; 16];
    let mut bytes2 = [0u8; 16];
    
    rng1.fill(&mut bytes1);
    rng2.fill(&mut bytes2);
    
    // Apply v4 bits manually
    bytes1[6] = (bytes1[6] & 0x0f) | 0x40;
    bytes1[8] = (bytes1[8] & 0x3f) | 0x80;
    bytes2[6] = (bytes2[6] & 0x0f) | 0x40;
    bytes2[8] = (bytes2[8] & 0x3f) | 0x80;
    
    let id1 = Uuid::from_bytes(bytes1);
    let id2 = Uuid::from_bytes(bytes2);
    
    assert_eq!(id1, id2);  // Same seed = same UUID
}

use uuid::Uuid;
 
fn when_not_to_use_v4() {
    // Problem 1: Need guaranteed uniqueness across distributed systems
    // Solution: Use v1 (time-based) or v7 (time-ordered) UUIDs
    
    // Problem 2: Need sequential ordering for database performance
    // Solution: Use v1, v6, or v7 (time-ordered)
    
    // Problem 3: Need more than 128 bits of randomness
    // Solution: Use longer tokens
    
    // Problem 4: Need to derive UUID from a name/namespace
    // Solution: Use v3 or v5 (name-based) UUIDs
    
    // Problem 5: Security tokens that must be unguessable
    // Consider: Use 256-bit random tokens instead
    // 128 bits is secure but some applications prefer more margin
}

// UUID v7 (available in uuid crate with v7 feature)
// Structure:
// - 48 bits: Unix timestamp in milliseconds
// - 74 bits: Random data
// - 6 bits: Version/variant
 
// Advantages:
// - Time-ordered (good for database indexes)
// - Still has randomness for uniqueness
// - No MAC address leakage (unlike v1)

use uuid::Uuid;
use std::time::Instant;
 
fn performance_comparison() {
    let start = Instant::now();
    
    // Generating 1 million v4 UUIDs
    for _ in 0..1_000_000 {
        let _ = Uuid::new_v4();
    }
    
    println!("1M v4 UUIDs: {:?}", start.elapsed());
    // Typically: 100-500ms depending on RNG
    
    // The cryptographic RNG has overhead
    // For non-security-critical bulk ID generation,
    // consider if sequential IDs or v7 UUIDs would work
}

use uuid::Uuid;
 
fn entropy_considerations() {
    // On Linux, /dev/urandom doesn't block (good)
    // On some systems, early boot may have limited entropy
    
    // getrandom() syscall on Linux:
    // - With GRND_NONBLOCK: returns immediately or EAGAIN
    // - Without: may block until entropy pool initialized
    
    // The uuid crate's getrandom usage typically:
    // - Blocks until sufficient entropy (safe but may delay startup)
    // - This is correct behavior for security
    
    // For embedded systems or early boot:
    // - Ensure system has entropy source
    // - Consider if v4 UUIDs are appropriate
}

use uuid::Uuid;
 
fn verify_v4() {
    let id = Uuid::new_v4();
    
    // Check version
    assert!(id.get_version() == Some(uuid::Version::Random));
    
    // Check variant
    assert!(id.get_variant() == uuid::Variant::RFC4122);
    
    // Parse from string and verify
    let parsed: Uuid = id.to_string().parse().unwrap();
    assert_eq!(id, parsed);
    
    // Check bytes directly
    let bytes = id.as_bytes();
    assert_eq!(bytes[6] & 0xf0, 0x40);  // Version 4
    assert_eq!(bytes[8] & 0xc0, 0x80);  // RFC 4122 variant
}