db/heromodels/examples/calendar_example/main.rs

use chrono::{Duration, Utc};
use heromodels::db::{Collection, Db};
use heromodels::models::User;
use heromodels::models::calendar::{AttendanceStatus, Attendee, Calendar, Event};
use heromodels_core::Model;

fn main() {
    // Create a new DB instance, reset before every run
    let db_path = "/tmp/ourdb_calendar_example";
    let db = heromodels::db::hero::OurDB::new(db_path, true).expect("Can create DB");

    println!("Hero Models - Calendar Usage Example");
    println!("====================================");

    // --- Create Users First ---
    println!("\n--- Creating Users ---");
    let user1 = User::new()
        .username("alice_johnson")
        .email("alice.johnson@company.com")
        .full_name("Alice Johnson")
        .is_active(true)
        .build();

    let user2 = User::new()
        .username("bob_smith")
        .email("bob.smith@company.com")
        .full_name("Bob Smith")
        .is_active(true)
        .build();

    let user3 = User::new()
        .username("carol_davis")
        .email("carol.davis@company.com")
        .full_name("Carol Davis")
        .is_active(true)
        .build();

    // Store users in database and get their IDs
    let user_collection = db.collection::<User>().expect("can open user collection");

    let (user1_id, stored_user1) = user_collection.set(&user1).expect("can set user1");
    let (user2_id, stored_user2) = user_collection.set(&user2).expect("can set user2");
    let (user3_id, stored_user3) = user_collection.set(&user3).expect("can set user3");

    println!("Created users:");
    println!("- User 1 (ID: {}): {}", user1_id, stored_user1.full_name);
    println!("- User 2 (ID: {}): {}", user2_id, stored_user2.full_name);
    println!("- User 3 (ID: {}): {}", user3_id, stored_user3.full_name);

    // --- Create Attendees ---
    println!("\n--- Creating Attendees ---");
    let attendee1 = Attendee::new(user1_id).status(AttendanceStatus::Accepted);
    let attendee2 = Attendee::new(user2_id).status(AttendanceStatus::Tentative);
    let attendee3 = Attendee::new(user3_id); // Default NoResponse

    // Store attendees in database and get their IDs
    let attendee_collection = db
        .collection::<Attendee>()
        .expect("can open attendee collection");

    let (attendee1_id, stored_attendee1) = attendee_collection
        .set(&attendee1)
        .expect("can set attendee1");
    let (attendee2_id, stored_attendee2) = attendee_collection
        .set(&attendee2)
        .expect("can set attendee2");
    let (attendee3_id, stored_attendee3) = attendee_collection
        .set(&attendee3)
        .expect("can set attendee3");

    println!("Created attendees:");
    println!(
        "- Attendee 1 (ID: {}): Contact ID {}, Status: {:?}",
        attendee1_id, stored_attendee1.contact_id, stored_attendee1.status
    );
    println!(
        "- Attendee 2 (ID: {}): Contact ID {}, Status: {:?}",
        attendee2_id, stored_attendee2.contact_id, stored_attendee2.status
    );
    println!(
        "- Attendee 3 (ID: {}): Contact ID {}, Status: {:?}",
        attendee3_id, stored_attendee3.contact_id, stored_attendee3.status
    );

    // --- Create Events with Attendees ---
    println!("\n--- Creating Events with Attendees ---");
    let now = Utc::now();

    let event1 = Event::new(
        "Team Meeting",
        now + Duration::hours(1),
        now + Duration::hours(2),
    )
    .description("Weekly sync-up meeting to discuss project progress.")
    .location("Conference Room A")
    .add_attendee(attendee1_id)
    .add_attendee(attendee2_id);

    let event2 = Event::new(
        "Project Brainstorm",
        now + Duration::days(1),
        now + Duration::days(1) + Duration::minutes(90),
    )
    .description("Brainstorming session for new project features.")
    .location("Innovation Lab")
    .add_attendee(attendee1_id)
    .add_attendee(attendee3_id);

    let event3 = Event::new(
        "Client Call",
        now + Duration::days(2),
        now + Duration::days(2) + Duration::hours(1),
    )
    .description("Quarterly review with key client.")
    .add_attendee(attendee2_id);

    println!("Created events:");
    println!(
        "- Event 1: '{}' at {} with {} attendees",
        event1.title,
        event1.start_time.format("%Y-%m-%d %H:%M"),
        event1.attendees.len()
    );
    println!(
        "  Location: {}",
        event1
            .location
            .as_ref()
            .unwrap_or(&"Not specified".to_string())
    );
    println!("  Attendee IDs: {:?}", event1.attendees);

    println!(
        "- Event 2: '{}' at {} with {} attendees",
        event2.title,
        event2.start_time.format("%Y-%m-%d %H:%M"),
        event2.attendees.len()
    );
    println!(
        "  Location: {}",
        event2
            .location
            .as_ref()
            .unwrap_or(&"Not specified".to_string())
    );
    println!("  Attendee IDs: {:?}", event2.attendees);

    println!(
        "- Event 3: '{}' at {} with {} attendees",
        event3.title,
        event3.start_time.format("%Y-%m-%d %H:%M"),
        event3.attendees.len()
    );
    println!("  Attendee IDs: {:?}", event3.attendees);

    // --- Demonstrate Event Manipulation ---
    println!("\n--- Demonstrating Event Manipulation ---");

    // Reschedule an event
    let new_start = now + Duration::hours(2);
    let new_end = now + Duration::hours(3);
    let mut updated_event1 = event1.clone();
    updated_event1 = updated_event1.reschedule(new_start, new_end);
    println!(
        "Rescheduled '{}' to {}",
        updated_event1.title,
        new_start.format("%Y-%m-%d %H:%M")
    );

    // Remove an attendee
    updated_event1 = updated_event1.remove_attendee(attendee1_id);
    println!(
        "Removed attendee {} from '{}'. Remaining attendee IDs: {:?}",
        attendee1_id, updated_event1.title, updated_event1.attendees
    );

    // Add a new attendee
    updated_event1 = updated_event1.add_attendee(attendee3_id);
    println!(
        "Added attendee {} to '{}'. Current attendee IDs: {:?}",
        attendee3_id, updated_event1.title, updated_event1.attendees
    );

    // --- Store Events in Database ---
    // Now that Event is a proper database model, we need to store events first
    println!("\n--- Storing Events in Database ---");

    let event_collection = db.collection::<Event>().expect("can open event collection");

    // Store events and get their auto-generated IDs
    let (event1_id, stored_event1) = event_collection.set(&event1).expect("can set event1");
    let (event2_id, stored_event2) = event_collection.set(&event2).expect("can set event2");
    let (event3_id, stored_event3) = event_collection.set(&event3).expect("can set event3");

    println!("Stored events in database:");
    println!("- Event ID {}: '{}'", event1_id, stored_event1.title);
    println!("- Event ID {}: '{}'", event2_id, stored_event2.title);
    println!("- Event ID {}: '{}'", event3_id, stored_event3.title);

    // --- Create Calendars ---
    // Now calendars store the actual database IDs of the events
    println!("\n--- Creating Calendars ---");

    // Create a calendar with auto-generated ID and the stored event IDs
    let calendar1 = Calendar::new(None, "Work Calendar")
        .description("Calendar for all work-related events.")
        .add_event(event1_id as i64)
        .add_event(event2_id as i64);

    // Create another calendar with auto-generated ID
    let calendar2 = Calendar::new(None, "Personal Calendar").add_event(event3_id as i64);

    println!("Created calendars with event IDs:");
    println!(
        "- Calendar 1: '{}' with events: {:?}",
        calendar1.name, calendar1.events
    );
    println!(
        "- Calendar 2: '{}' with events: {:?}",
        calendar2.name, calendar2.events
    );

    // --- Store Calendars in DB ---
    let cal_collection = db
        .collection::<Calendar>()
        .expect("can open calendar collection");

    let (_, calendar1) = cal_collection.set(&calendar1).expect("can set calendar1");
    let (_, calendar2) = cal_collection.set(&calendar2).expect("can set calendar2");

    println!(
        "Created calendar1 (ID: {}): Name - '{}'",
        calendar1.get_id(),
        calendar1.name
    );
    println!(
        "Created calendar2 (ID: {}): Name - '{}'",
        calendar2.get_id(),
        calendar2.name
    );

    // --- Retrieve a Calendar by ID ---
    let stored_calendar1_opt = cal_collection
        .get_by_id(calendar1.get_id())
        .expect("can try to load calendar1");
    assert!(
        stored_calendar1_opt.is_some(),
        "Calendar1 should be found in DB"
    );
    let mut stored_calendar1 = stored_calendar1_opt.unwrap();

    println!(
        "\nRetrieved calendar1 from DB: Name - '{}', Events count: {}",
        stored_calendar1.name,
        stored_calendar1.events.len()
    );
    assert_eq!(stored_calendar1.name, "Work Calendar");
    assert_eq!(stored_calendar1.events.len(), 2);
    assert_eq!(stored_calendar1.events[0], event1_id as i64); // Check event ID

    // --- Modify a Calendar (Add/Remove Events) ---
    // Since events are just IDs, we can add and remove them easily
    println!("\n--- Modifying Calendar ---");

    // Create and store a new event
    let new_event = Event::new(
        "1-on-1 Meeting",
        now + Duration::days(3),
        now + Duration::days(3) + Duration::minutes(30),
    )
    .description("One-on-one meeting with team member.")
    .location("Office");

    let (new_event_id, _stored_new_event) =
        event_collection.set(&new_event).expect("can set new event");
    println!("Created new event with ID: {}", new_event_id);

    // Add the new event ID to the calendar
    stored_calendar1 = stored_calendar1.add_event(new_event_id as i64);
    assert_eq!(stored_calendar1.events.len(), 3);
    println!(
        "Added event ID {} to calendar1. Total events: {}",
        new_event_id,
        stored_calendar1.events.len()
    );

    // Remove an event ID from the calendar
    stored_calendar1 = stored_calendar1.remove_event(event2_id as i64); // Remove "Project Brainstorm"
    assert_eq!(stored_calendar1.events.len(), 2);
    println!(
        "Removed event ID {} from calendar1. Total events: {}",
        event2_id,
        stored_calendar1.events.len()
    );

    // --- Store the modified calendar ---
    let (_, _stored_calendar1) = cal_collection
        .set(&stored_calendar1)
        .expect("can set modified calendar1");

    // Verify the changes were persisted
    let re_retrieved_calendar1_opt = cal_collection
        .get_by_id(calendar1.get_id())
        .expect("can try to load modified calendar1");
    let re_retrieved_calendar1 = re_retrieved_calendar1_opt.unwrap();
    assert_eq!(re_retrieved_calendar1.events.len(), 2);
    assert!(re_retrieved_calendar1.events.contains(&(event1_id as i64))); // Team Meeting still there
    assert!(
        re_retrieved_calendar1
            .events
            .contains(&(new_event_id as i64))
    ); // New event added
    assert!(!re_retrieved_calendar1.events.contains(&(event2_id as i64))); // Project Brainstorm removed

    println!(
        "\nModified and re-saved calendar1. Final events: {:?}",
        re_retrieved_calendar1.events
    );

    // --- Delete a Calendar ---
    cal_collection
        .delete_by_id(calendar2.get_id())
        .expect("can delete calendar2");
    let deleted_calendar2_opt = cal_collection
        .get_by_id(calendar2.get_id())
        .expect("can try to load deleted calendar2");
    assert!(
        deleted_calendar2_opt.is_none(),
        "Calendar2 should be deleted from DB"
    );

    println!("\nDeleted calendar2 (ID: {}) from DB.", calendar2.get_id());
    println!("Calendar model DB Prefix: {}", Calendar::db_prefix());

    // --- Demonstrate Event Retrieval ---
    println!("\n--- Retrieving Events from Database ---");

    // Get all events
    let all_events = event_collection.get_all().expect("can list all events");
    println!("All events in database:");
    for event in &all_events {
        println!(
            "- Event ID: {}, Title: '{}', Start: {}, Attendees: {}",
            event.get_id(),
            event.title,
            event.start_time.format("%Y-%m-%d %H:%M"),
            event.attendees.len()
        );
    }
    println!("Total events in DB: {}", all_events.len());

    // Retrieve specific events by ID and show attendee details
    println!("\nRetrieving specific events:");
    if let Some(retrieved_event1) = event_collection
        .get_by_id(event1_id)
        .expect("can try to get event1")
    {
        println!(
            "Retrieved Event 1: '{}' with {} attendees",
            retrieved_event1.title,
            retrieved_event1.attendees.len()
        );

        // Look up attendee details for each attendee ID
        for &attendee_id in &retrieved_event1.attendees {
            if let Some(attendee) = attendee_collection
                .get_by_id(attendee_id)
                .expect("can try to get attendee")
            {
                // Look up user details for the attendee's contact_id
                if let Some(user) = user_collection
                    .get_by_id(attendee.contact_id)
                    .expect("can try to get user")
                {
                    println!(
                        "  - Attendee ID {}: {} (User: {}, Status: {:?})",
                        attendee_id, user.full_name, attendee.contact_id, attendee.status
                    );
                }
            }
        }
    }

    // --- List All Calendars ---
    println!("\n--- Listing All Calendars ---");
    let all_calendars = cal_collection.get_all().expect("can list all calendars");
    for calendar in &all_calendars {
        println!(
            "- Calendar ID: {}, Name: '{}', Events: {:?}",
            calendar.get_id(),
            calendar.name,
            calendar.events
        );

        // Show which events are in this calendar
        for &event_id in &calendar.events {
            if let Some(event) = event_collection
                .get_by_id(event_id as u32)
                .expect("can try to get event")
            {
                println!("    * Event: '{}'", event.title);
            }
        }
    }
    println!("Total calendars in DB: {}", all_calendars.len());

    println!("\nExample finished. DB stored at {}", db_path);
    println!(
        "To clean up, you can manually delete the directory: {}",
        db_path
    );
}