use chrono::{Duration, Utc};
use heromodels::db::{Collection, Db};
use heromodels::models::calendar::{Attendee, AttendanceStatus, 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 Attendees ---
    let attendee1 = Attendee::new("user_123".to_string())
        .status(AttendanceStatus::Accepted);
    let attendee2 = Attendee::new("user_456".to_string())
        .status(AttendanceStatus::Tentative);
    let attendee3 = Attendee::new("user_789".to_string()); // Default NoResponse

    // --- Create Events ---
    let now = Utc::now();
    let event1 = Event::new(
        "event_alpha".to_string(),
        "Team Meeting",
        now + Duration::seconds(3600), // Using Duration::seconds for more explicit chrono 0.4 compatibility
        now + Duration::seconds(7200),
    )
    .description("Weekly sync-up meeting.")
    .location("Conference Room A")
    .add_attendee(attendee1.clone())
    .add_attendee(attendee2.clone());

    let event2 = Event::new(
        "event_beta".to_string(),
        "Project Brainstorm",
        now + Duration::days(1),
        now + Duration::days(1) + Duration::seconds(5400), // 90 minutes
    )
    .description("Brainstorming session for new project features.")
    .add_attendee(attendee1.clone())
    .add_attendee(attendee3.clone());

    let event3_for_calendar2 = Event::new(
        "event_gamma".to_string(),
        "Client Call",
        now + Duration::days(2),
        now + Duration::days(2) + Duration::seconds(3600)
    );

    // --- Create Calendars ---
    // Note: Calendar::new directly returns Calendar, no separate .build() step like the user example.

    // Create a calendar with auto-generated ID
    let calendar1 = Calendar::new(None, "Work Calendar")
        .description("Calendar for all work-related events.")
        .add_event(event1.clone())
        .add_event(event2.clone());

    // Create a calendar with auto-generated ID (explicit IDs are no longer supported)
    let calendar2 = Calendar::new(None, "Personal Calendar")
        .add_event(event3_for_calendar2.clone());


    // --- 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].title, "Team Meeting");

    // --- Modify a Calendar (Reschedule an Event) ---
    let event_id_to_reschedule = event1.id.as_str();
    let new_start_time = now + Duration::seconds(10800); // 3 hours from now
    let new_end_time = now + Duration::seconds(14400);   // 4 hours from now

    stored_calendar1 = stored_calendar1.update_event(event_id_to_reschedule, |event_to_update| {
        println!("Rescheduling event '{}'...", event_to_update.title);
        event_to_update.reschedule(new_start_time, new_end_time)
    });

    let rescheduled_event = stored_calendar1.events.iter().find(|e| e.id == event_id_to_reschedule)
        .expect("Rescheduled event should exist");
    assert_eq!(rescheduled_event.start_time, new_start_time);
    assert_eq!(rescheduled_event.end_time, new_end_time);
    println!("Event '{}' rescheduled in stored_calendar1.", rescheduled_event.title);

    // --- Store the modified calendar ---
    let (_, mut stored_calendar1) = cal_collection.set(&stored_calendar1).expect("can set modified calendar1");
    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();
    let re_retrieved_event = re_retrieved_calendar1.events.iter().find(|e| e.id == event_id_to_reschedule)
        .expect("Rescheduled event should exist in re-retrieved calendar");
    assert_eq!(re_retrieved_event.start_time, new_start_time, "Reschedule not persisted correctly");

    println!("\nModified and re-saved calendar1. Rescheduled event start time: {}", re_retrieved_event.start_time);

    // --- Add a new event to an existing calendar ---
    let event4_new = Event::new(
        "event_delta".to_string(),
        "1-on-1",
        now + Duration::days(3),
        now + Duration::days(3) + Duration::seconds(1800) // 30 minutes
    );
    stored_calendar1 = stored_calendar1.add_event(event4_new);
    assert_eq!(stored_calendar1.events.len(), 3);
    let (_, stored_calendar1) = cal_collection.set(&stored_calendar1).expect("can set calendar1 after adding new event");
    println!("Added new event '1-on-1' to stored_calendar1. Total events: {}", stored_calendar1.events.len());

    // --- 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());

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