Quickstart

use bomboni::common::id::Id;

fn main() {
    // Generate a single unique ID
    let id = Id::generate();
    println!("Generated ID: {}", id);
    
    // Generate multiple IDs - they're monotonically increasing
    let ids = Id::generate_multiple(5);
    println!("\nGenerated {} IDs:", ids.len());
    for (i, id) in ids.iter().enumerate() {
        println!("  {}: {}", i + 1, id);
    }
    
    // Parse an ID from a string
    let id_str = "01ARZ3NDEKTSV4RRFFQ69G5FAV";
    match id_str.parse::<Id>() {
        Ok(parsed_id) => println!("\nParsed ID: {}", parsed_id),
        Err(e) => println!("\nFailed to parse ID: {}", e),
    }
}

use bomboni::common::date_time::UtcDateTime;

fn datetime_example() {
    // Get the current time
    let now = UtcDateTime::now();
    println!("Current time: {}", now);
    
    // Create from Unix timestamp
    let dt = UtcDateTime::from_seconds(1609459200).unwrap();
    println!("From timestamp: {}", dt); // 2021-01-01T00:00:00Z
    
    // Parse from string
    let parsed = "2024-03-15T10:30:00Z".parse::<UtcDateTime>().unwrap();
    println!("Parsed datetime: {}", parsed);
    
    // Get timestamp
    let (seconds, nanos) = parsed.timestamp();
    println!("Timestamp: {} seconds, {} nanoseconds", seconds, nanos);
}

fn main() {
    // ... previous ID code ...
    
    println!("\n=== DateTime Examples ===");
    datetime_example();
}

use bomboni::common::id::worker::WorkerIdGenerator;

fn worker_id_example() {
    // Create a generator for worker #1
    let mut generator = WorkerIdGenerator::new(1);
    
    // Generate IDs that are unique to this worker
    let id1 = generator.generate();
    let id2 = generator.generate();
    
    println!("Worker 1 generated: {}", id1);
    println!("Worker 1 generated: {}", id2);
    
    // Generate multiple IDs efficiently
    let batch = generator.generate_multiple(3);
    println!("\nWorker 1 batch:");
    for id in batch {
        println!("  {}", id);
    }
    
    // Create a generator for worker #2
    let mut generator2 = WorkerIdGenerator::new(2);
    let id3 = generator2.generate();
    println!("\nWorker 2 generated: {}", id3);
}

fn main() {
    // ... previous code ...
    
    println!("\n=== Worker-Based ID Generation ===");
    worker_id_example();
}

use bomboni::request::filter::Filter;
use bomboni::request::schema::{SchemaMapped, Schema, FieldMemberSchema, ValueType};
use bomboni::request::value::Value;
use bomboni::macros::btree_map_into;

#[derive(Debug, Clone)]
struct User {
    id: String,
    name: String,
    age: i32,
    email: String,
}

impl SchemaMapped for User {
    fn get_field(&self, name: &str) -> Value {
        match name {
            "id" => self.id.clone().into(),
            "name" => self.name.clone().into(),
            "age" => self.age.into(),
            "email" => self.email.clone().into(),
            _ => Value::Null,
        }
    }
}

impl User {
    fn get_schema() -> Schema {
        Schema {
            members: btree_map_into! {
                "id" => FieldMemberSchema::new_ordered(ValueType::String),
                "name" => FieldMemberSchema::new_ordered(ValueType::String),
                "age" => FieldMemberSchema::new_ordered(ValueType::Integer),
                "email" => FieldMemberSchema::new(ValueType::String),
            },
        }
    }
}

fn filtering_example() {
    // Create sample users
    let users = vec![
        User {
            id: "1".into(),
            name: "Alice".into(),
            age: 30,
            email: "[email protected]".into(),
        },
        User {
            id: "2".into(),
            name: "Bob".into(),
            age: 25,
            email: "[email protected]".into(),
        },
        User {
            id: "3".into(),
            name: "Charlie".into(),
            age: 35,
            email: "[email protected]".into(),
        },
    ];
    
    // Parse a filter expression
    let filter = Filter::parse(r#"age >= 30 AND name = "Alice""#).unwrap();
    println!("Filter: {}", filter);
    
    // Validate the filter against the schema
    let schema = User::get_schema();
    filter.validate(&schema, None).unwrap();
    println!("Filter is valid!");
    
    // Apply filter to users
    println!("\nFiltering users:");
    for user in &users {
        match filter.evaluate(user) {
            Ok(Value::Boolean(true)) => {
                println!("  ✓ {} (age {}) matches", user.name, user.age);
            }
            Ok(Value::Boolean(false)) => {
                println!("  ✗ {} (age {}) doesn't match", user.name, user.age);
            }
            Ok(other) => {
                println!("  ? {} returned unexpected value: {:?}", user.name, other);
            }
            Err(e) => {
                println!("  ! Error evaluating {}: {}", user.name, e);
            }
        }
    }
    
    // Try a more complex filter
    let complex_filter = Filter::parse("age >= 25 AND age <= 35").unwrap();
    println!("\nComplex filter: {}", complex_filter);
    
    let matching_users: Vec<_> = users
        .iter()
        .filter(|user| {
            matches!(complex_filter.evaluate(*user), Ok(Value::Boolean(true)))
        })
        .collect();
    
    println!("Found {} matching users:", matching_users.len());
    for user in matching_users {
        println!("  - {} (age {})", user.name, user.age);
    }
}

fn main() {
    // ... previous code ...
    
    println!("\n=== Filtering Examples ===");
    filtering_example();
}