use uuid::Uuid;
 
fn main() {
    // The idiomatic way to get the nil UUID
    let nil = Uuid::nil();
    
    println!("Nil UUID: {}", nil);  // 00000000-0000-0000-0000-000000000000
    
    // Check it's actually all zeros
    let bytes = nil.as_bytes();
    println!("All zeros: {}", bytes.iter().all(|&b| b == 0));  // true
}

use uuid::Uuid;
 
fn main() {
    // Manual construction: from bytes
    let manual_bytes = Uuid::from_bytes([0; 16]);
    println!("From bytes: {}", manual_bytes);
    
    // Manual construction: from slice
    let manual_slice = Uuid::from_slice(&[0u8; 16]).unwrap();
    println!("From slice: {}", manual_slice);
    
    // Manual construction: parse from string
    let manual_parse = "00000000-0000-0000-0000-000000000000".parse::<Uuid>().unwrap();
    println!("From string: {}", manual_parse);
    
    // All produce the same value
    assert_eq!(manual_bytes, Uuid::nil());
    assert_eq!(manual_slice, Uuid::nil());
    assert_eq!(manual_parse, Uuid::nil());
}

use uuid::Uuid;
 
fn main() {
    let nil = Uuid::nil();
    let manual = Uuid::from_bytes([0; 16]);
    
    // They are exactly equal
    assert_eq!(nil, manual);
    
    // Same bytes
    assert_eq!(nil.as_bytes(), manual.as_bytes());
    
    // Same string representation
    assert_eq!(nil.to_string(), manual.to_string());
    
    // Same hyphenated representation
    assert_eq!(nil.hyphenated().to_string(), manual.hyphenated().to_string());
    
    println!("Nil and manual are identical");
}

use uuid::Uuid;
 
// Using nil() makes intent clear: this is the RFC-defined nil UUID
fn find_by_id(id: Uuid) -> Option<String> {
    if id == Uuid::nil() {
        // nil UUID has special meaning: "no ID" or "not specified"
        println!("Searching for nil UUID - may have special handling");
    }
    Some("found".to_string())
}
 
// Manual construction leaves intent ambiguous
fn find_by_id_ambiguous(id: Uuid) -> Option<String> {
    if id == Uuid::from_bytes([0; 16]) {
        // Reader must know this is the nil UUID, not arbitrary zeros
        println!("Is this a special nil check or checking for zero?");
    }
    Some("found".to_string())
}

use uuid::Uuid;
 
fn main() {
    // RFC 4122 defines the nil UUID as:
    // "The nil UUID is special form of UUID that is specified to have all
    // 128 bits set to zero."
    
    let nil = Uuid::nil();
    
    // It's defined in the standard, not just a convention
    // UUID: 00000000-0000-0000-0000-000000000000
    
    // Version and variant fields are all zero
    println!("Version field: {}", nil.get_version());  // None (all zeros)
    println!("Variant: {:?}", nil.get_variant());      // Reserved (NCS)
    
    // The nil UUID is guaranteed to never be assigned to any object
    // It exists solely to represent "no UUID"
}

use uuid::Uuid;
 
#[derive(Debug)]
struct Entity {
    id: Uuid,
    name: String,
}
 
impl Default for Entity {
    fn default() -> Self {
        Entity {
            id: Uuid::nil(),  // Clear: "no ID assigned yet"
            name: String::new(),
        }
    }
}
 
fn main() {
    let entity = Entity::default();
    println!("Entity: {:?}", entity);
    
    // Check if ID has been assigned
    if entity.id == Uuid::nil() {
        println!("Entity has no ID yet");
    }
}

use uuid::Uuid;
 
// Nil UUID can serve as a "none" sentinel in APIs that require Uuid
fn get_parent_id(entity_id: Uuid) -> Uuid {
    // For root entities, return nil to indicate "no parent"
    if is_root(entity_id) {
        Uuid::nil()  // Clear semantic: no parent
    } else {
        find_parent(entity_id)
    }
}
 
fn is_root(_id: Uuid) -> bool {
    // Simplified logic
    true
}
 
fn find_parent(_id: Uuid) -> Uuid {
    Uuid::new_v4()
}
 
fn main() {
    let parent = get_parent_id(Uuid::new_v4());
    
    // Check for "none" using nil()
    if parent == Uuid::nil() {
        println!("This is a root entity");
    }
}

use uuid::Uuid;
 
fn main() {
    // Database queries may use nil UUIDs for nullable columns
    let nil = Uuid::nil();
    
    // SQL: SELECT * FROM entities WHERE parent_id = '00000000-0000-0000-0000-000000000000'
    // Finds root entities (no parent)
    println!("Finding root entities with parent_id = {}", nil);
    
    // Idiomatic check
    let id = Uuid::nil();
    if id.is_nil() {
        println!("This is the nil UUID");
    }
}

use uuid::Uuid;
 
fn main() {
    let nil = Uuid::nil();
    let other = Uuid::new_v4();
    
    // Built-in method to check for nil
    assert!(nil.is_nil());
    assert!(!other.is_nil());
    
    // Equivalent to manual check
    assert!(nil == Uuid::from_bytes([0; 16]));
    
    // But is_nil() is clearer
    println!("is_nil() is more readable than == Uuid::from_bytes([0; 16])");
}

use uuid::Uuid;
 
fn main() {
    // These all create the nil UUID:
    
    // From bytes array
    let from_bytes = Uuid::from_bytes([0u8; 16]);
    println!("from_bytes: {}", from_bytes);
    
    // From slice (returns Result)
    let from_slice = Uuid::from_slice(&[0u8; 16]).unwrap();
    println!("from_slice: {}", from_slice);
    
    // From fields (all zeros)
    let from_fields = Uuid::from_fields(0, 0, 0, &[0u8; 8]);
    println!("from_fields: {}", from_fields);
    
    // Parsing string (returns Result)
    let from_str: Uuid = "00000000-0000-0000-0000-000000000000".parse().unwrap();
    println!("from_str: {}", from_str);
    
    // All equal to nil()
    assert_eq!(from_bytes, Uuid::nil());
    assert_eq!(from_slice, Uuid::nil());
    assert_eq!(from_fields, Uuid::nil());
    assert_eq!(from_str, Uuid::nil());
}

use uuid::Uuid;
 
fn main() {
    let nil = Uuid::nil();
    
    // Nil UUID has no version (version field is all zeros)
    println!("Version: {:?}", nil.get_version());
    
    // Variant is Reserved (NCS backward compatibility) due to all zeros
    println!("Variant: {:?}", nil.get_variant());
    
    // It's not a valid v4 UUID or any other version
    // It's its own special case defined by RFC 4122
    
    // Contrast with actual v4 UUID
    let v4 = Uuid::new_v4();
    println!("V4 Version: {:?}", v4.get_version());  // Some(Random)
    println!("V4 Variant: {:?}", v4.get_variant());   // RFC4122
}

use uuid::Uuid;
 
fn main() {
    let nil = Uuid::nil();
    let v4 = Uuid::new_v4();
    
    // Nil is "less than" any non-nil UUID in comparison
    assert!(nil < v4);
    
    // This can be useful for sorting
    let mut uuids = vec![v4, Uuid::new_v4(), Uuid::nil(), Uuid::new_v4()];
    uuids.sort();
    
    // Nil UUID will be first after sorting
    assert!(uuids[0].is_nil());
    println!("Sorted: {:?}", uuids);
}

use uuid::Uuid;
 
fn main() {
    // DON'T: Manual construction when nil() is clearer
    let unclear = Uuid::from_bytes([0; 16]);
    
    // DO: Use nil() for semantic clarity
    let clear = Uuid::nil();
    
    // Both work, but clear is more maintainable
    assert_eq!(unclear, clear);
    
    // DON'T: String parsing for nil
    let parsed: Uuid = "00000000-0000-0000-0000-000000000000".parse().unwrap();
    
    // DO: Use nil() directly
    let direct = Uuid::nil();
    
    assert_eq!(parsed, direct);
}

use uuid::Uuid;
 
// Use case 1: Default/unset state
struct User {
    id: Uuid,
    invited_by: Uuid,  // nil if direct signup
}
 
// Use case 2: Parent references
struct Category {
    id: Uuid,
    parent_id: Uuid,  // nil for root categories
}
 
// Use case 3: Optional foreign keys
struct Order {
    id: Uuid,
    discount_code_id: Uuid,  // nil if no discount
}
 
// Use case 4: Placeholder/pending state
struct Upload {
    id: Uuid,
    processed_by: Uuid,  // nil until processing starts
}
 
fn main() {
    // Nil naturally represents "none" or "not applicable"
    let direct_user = User {
        id: Uuid::new_v4(),
        invited_by: Uuid::nil(),
    };
    
    if direct_user.invited_by.is_nil() {
        println!("Direct signup, no inviter");
    }
}
 
struct User {
    id: Uuid,
    invited_by: Uuid,
}

use uuid::Uuid;
 
fn main() {
    // Rare case: You're explicitly documenting that this is arbitrary zeros
    // not semantically "nil"
    
    // Even then, prefer nil() with a comment
    let placeholder = Uuid::nil();  // Placeholder, not an RFC nil UUID
    println!("Placeholder: {}", placeholder);
    
    // The bytes are identical, so this distinction is purely documentation
}