//! Integration tests for event repository operations.

use chrono::{Duration, Utc};
use goingson_core::{NewEvent, Recurrence, UpdateEvent};

use crate::test_utils::{create_test_project, setup_test_state};

#[tokio::test]
async fn create_and_list_event() {
    let (state, user_id) = setup_test_state().await;

    let start = Utc::now() + Duration::days(1);
    let end = start + Duration::hours(1);

    let new_event = NewEvent::builder("Team Meeting", start)
        .end_time(end)
        .description("Weekly sync")
        .location("Room A")
        .build();

    let event = state.events.create(user_id, new_event).await.unwrap();
    assert_eq!(event.title, "Team Meeting");
    assert_eq!(event.description, "Weekly sync");
    assert_eq!(event.location, Some("Room A".to_string()));

    let events = state.events.list_all(user_id).await.unwrap();
    assert_eq!(events.len(), 1);
    assert_eq!(events[0].title, "Team Meeting");
}

#[tokio::test]
async fn create_event_with_project() {
    let (state, user_id) = setup_test_state().await;
    let project_id = create_test_project(&state, user_id).await;

    let start = Utc::now() + Duration::days(2);

    let new_event = NewEvent::builder("Project Review", start)
        .project_id(project_id)
        .build();

    let event = state.events.create(user_id, new_event).await.unwrap();
    assert_eq!(event.project_id, Some(project_id));

    // List for project
    let project_events = state
        .events
        .list_by_project(user_id, project_id)
        .await
        .unwrap();
    assert_eq!(project_events.len(), 1);
    assert_eq!(project_events[0].title, "Project Review");
}

#[tokio::test]
async fn update_event() {
    let (state, user_id) = setup_test_state().await;

    let start = Utc::now() + Duration::days(1);
    let new_event = NewEvent::builder("Original Title", start).build();

    let event = state.events.create(user_id, new_event).await.unwrap();

    let new_start = Utc::now() + Duration::days(3);
    let update = UpdateEvent {
        project_id: None,
        contact_id: None,
        title: "Updated Title".to_string(),
        description: "Added description".to_string(),
        start_time: new_start,
        end_time: Some(new_start + Duration::hours(2)),
        location: Some("New Location".to_string()),
        linked_task_id: None,
        recurrence: Recurrence::None,
        recurrence_rule: None,
        block_type: None,
        reminder_offsets_seconds: Vec::new(),
    };

    let updated = state
        .events
        .update(event.id, user_id, update)
        .await
        .unwrap()
        .unwrap();
    assert_eq!(updated.title, "Updated Title");
    assert_eq!(updated.description, "Added description");
    assert_eq!(updated.location, Some("New Location".to_string()));
}

#[tokio::test]
async fn list_upcoming_events() {
    let (state, user_id) = setup_test_state().await;

    // Create a future event (within 7 days)
    let soon = Utc::now() + Duration::days(2);
    let future_event = NewEvent::builder("Soon Event", soon).build();
    state.events.create(user_id, future_event).await.unwrap();

    // Create a far-future event (beyond 7 days)
    let far = Utc::now() + Duration::days(30);
    let far_event = NewEvent::builder("Far Event", far).build();
    state.events.create(user_id, far_event).await.unwrap();

    // List upcoming (next 7 days)
    let upcoming = state.events.get_upcoming(user_id, 7).await.unwrap();
    assert_eq!(upcoming.len(), 1);
    assert_eq!(upcoming[0].title, "Soon Event");
}

#[tokio::test]
async fn delete_event() {
    let (state, user_id) = setup_test_state().await;

    let start = Utc::now() + Duration::days(1);
    let new_event = NewEvent::builder("Event to Delete", start).build();

    let event = state.events.create(user_id, new_event).await.unwrap();

    let deleted = state.events.delete(event.id, user_id).await.unwrap();
    assert!(deleted);

    let fetched = state.events.get_by_id(event.id, user_id).await.unwrap();
    assert!(fetched.is_none());
}