Como Gerar UUID em Rust

[package]
name = "receita-uuid"
version = "0.1.0"
edition = "2021"

[dependencies]
uuid = { version = "1", features = ["v4", "v7"] }

use uuid::Uuid;

fn main() {
    // =============================================
    // 1. Gerar UUID v4 (aleatório)
    // =============================================
    println!("=== UUID v4 (aleatório) ===");
    let id = Uuid::new_v4();
    println!("UUID v4: {}", id);
    println!("Bytes:   {:?}", id.as_bytes());
    println!("Versão:  {}", id.get_version_num());

    // Gerar vários UUIDs
    println!("\nVários UUIDs v4:");
    for i in 1..=5 {
        println!("  {}: {}", i, Uuid::new_v4());
    }

    // =============================================
    // 2. Gerar UUID v7 (ordenável por tempo)
    // =============================================
    println!("\n=== UUID v7 (ordenável por tempo) ===");
    let id1 = Uuid::now_v7();
    let id2 = Uuid::now_v7();
    let id3 = Uuid::now_v7();

    println!("UUID v7 #1: {}", id1);
    println!("UUID v7 #2: {}", id2);
    println!("UUID v7 #3: {}", id3);
    println!("Ordenados? {} < {} < {}", id1 < id2, id2 < id3, id1 < id3);
    println!("(UUIDs v7 são ordenáveis por tempo de criação)");

    // =============================================
    // 3. Parse de string para UUID
    // =============================================
    println!("\n=== Parse de String ===");

    // Formato padrão com hifens
    let id = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap();
    println!("Parsed: {}", id);

    // Formato sem hifens
    let id = Uuid::parse_str("550e8400e29b41d4a716446655440000").unwrap();
    println!("Sem hifens: {}", id);

    // Formato com chaves (URN)
    let id = Uuid::parse_str("{550e8400-e29b-41d4-a716-446655440000}").unwrap();
    println!("Com chaves: {}", id);

    // Tratando erro de parse
    match Uuid::parse_str("não-é-uuid") {
        Ok(id) => println!("Parsed: {}", id),
        Err(e) => println!("Erro de parse: {}", e),
    }

    // =============================================
    // 4. Formatos de exibição
    // =============================================
    println!("\n=== Formatos de Exibição ===");
    let id = Uuid::new_v4();

    println!("Display (padrão):  {}", id);
    println!("Hyphenated:        {}", id.hyphenated());
    println!("Simple (sem -):    {}", id.simple());
    println!("URN:               {}", id.urn());
    println!("Braced:            {}", id.braced());

    // =============================================
    // 5. UUID nil e max
    // =============================================
    println!("\n=== Valores Especiais ===");
    let nil = Uuid::nil();
    let max = Uuid::max();

    println!("Nil UUID: {}", nil);
    println!("Max UUID: {}", max);
    println!("Nil é nil? {}", nil.is_nil());
    println!("Max é max? {}", max.is_max());

    // =============================================
    // 6. Comparação e ordenação
    // =============================================
    println!("\n=== Comparação e Ordenação ===");
    let mut ids: Vec<Uuid> = (0..5).map(|_| Uuid::new_v4()).collect();
    println!("Desordenados:");
    for id in &ids {
        println!("  {}", id);
    }

    ids.sort();
    println!("Ordenados:");
    for id in &ids {
        println!("  {}", id);
    }

    // Comparação
    let a = Uuid::new_v4();
    let b = Uuid::new_v4();
    println!("\na == b? {}", a == b);
    println!("a != b? {}", a != b);

    // =============================================
    // 7. UUID como chave de HashMap
    // =============================================
    println!("\n=== UUID como Chave de HashMap ===");
    use std::collections::HashMap;

    #[derive(Debug)]
    struct Usuario {
        id: Uuid,
        nome: String,
    }

    let mut usuarios: HashMap<Uuid, Usuario> = HashMap::new();

    let id1 = Uuid::new_v4();
    let id2 = Uuid::new_v4();

    usuarios.insert(id1, Usuario { id: id1, nome: "Ana".into() });
    usuarios.insert(id2, Usuario { id: id2, nome: "Bia".into() });

    // Buscar por UUID
    if let Some(u) = usuarios.get(&id1) {
        println!("Encontrado: {} ({})", u.nome, u.id);
    }

    println!("Total de usuários: {}", usuarios.len());

    // =============================================
    // 8. Exemplo prático: gerador de IDs
    // =============================================
    println!("\n=== Gerador de IDs ===");

    struct IdGenerator {
        prefixo: String,
    }

    impl IdGenerator {
        fn new(prefixo: &str) -> Self {
            IdGenerator { prefixo: prefixo.to_string() }
        }

        fn proximo(&self) -> String {
            format!("{}_{}", self.prefixo, Uuid::new_v4().simple())
        }

        fn proximo_curto(&self) -> String {
            let uuid = Uuid::new_v4();
            let curto = &uuid.simple().to_string()[..8];
            format!("{}_{}", self.prefixo, curto)
        }
    }

    let gen_pedido = IdGenerator::new("PED");
    let gen_nota = IdGenerator::new("NF");

    println!("Pedido: {}", gen_pedido.proximo());
    println!("Pedido: {}", gen_pedido.proximo());
    println!("Nota:   {}", gen_nota.proximo());
    println!("Curto:  {}", gen_pedido.proximo_curto());
    println!("Curto:  {}", gen_pedido.proximo_curto());
}