//! Integration tests for SqliteTaskRepository focus + scheduling + reporting methods.

mod common;

use chrono::{Duration, TimeZone, Utc};
use goingson_core::{NewTask, Priority, TaskCrud, TaskScheduling};
use goingson_db_sqlite::SqliteTaskRepository;

// ---- Focus ----

#[tokio::test]
async fn test_set_focus_and_list_focused() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let task = repo.create(user_id, NewTask::builder("Focus me").build()).await.unwrap();

    // Not focused initially.
    assert!(repo.list_focused(user_id).await.unwrap().is_empty());

    let focused = repo.set_focus(task.id, user_id, true).await.expect("set focus").unwrap();
    assert!(focused.is_focus);
    assert!(focused.focus_set_at.is_some(), "focus_set_at should be stamped");

    let list = repo.list_focused(user_id).await.unwrap();
    assert_eq!(list.len(), 1);
    assert_eq!(list[0].id, task.id);

    // Clearing focus removes it from the set.
    let unfocused = repo.set_focus(task.id, user_id, false).await.expect("clear focus").unwrap();
    assert!(!unfocused.is_focus);
    assert!(unfocused.focus_set_at.is_none(), "focus_set_at should be nulled");
    assert!(repo.list_focused(user_id).await.unwrap().is_empty());
}

#[tokio::test]
async fn test_clear_all_focus() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let a = repo.create(user_id, NewTask::builder("A").build()).await.unwrap();
    let b = repo.create(user_id, NewTask::builder("B").build()).await.unwrap();
    repo.set_focus(a.id, user_id, true).await.unwrap();
    repo.set_focus(b.id, user_id, true).await.unwrap();
    assert_eq!(repo.list_focused(user_id).await.unwrap().len(), 2);

    let cleared = repo.clear_all_focus(user_id).await.expect("clear all");
    assert_eq!(cleared, 2, "both focused tasks should be cleared");
    assert!(repo.list_focused(user_id).await.unwrap().is_empty());

    // A second call clears nothing.
    assert_eq!(repo.clear_all_focus(user_id).await.unwrap(), 0);
}

#[tokio::test]
async fn test_focus_is_per_user_scoped() {
    let pool = common::setup_test_db().await;
    let user_a = common::create_test_user(&pool).await;
    let user_b = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let task_a = repo.create(user_a, NewTask::builder("A's task").build()).await.unwrap();
    let task_b = repo.create(user_b, NewTask::builder("B's task").build()).await.unwrap();
    repo.set_focus(task_a.id, user_a, true).await.unwrap();
    repo.set_focus(task_b.id, user_b, true).await.unwrap();

    // Each user only sees their own focused task.
    let a_list = repo.list_focused(user_a).await.unwrap();
    assert_eq!(a_list.len(), 1);
    assert_eq!(a_list[0].id, task_a.id);

    // Clearing all focus for A must not touch B.
    repo.clear_all_focus(user_a).await.unwrap();
    assert!(repo.list_focused(user_a).await.unwrap().is_empty());
    let b_list = repo.list_focused(user_b).await.unwrap();
    assert_eq!(b_list.len(), 1, "clearing A's focus must not affect B");
    assert_eq!(b_list[0].id, task_b.id);
}

#[tokio::test]
async fn test_list_available_for_focus_candidate_set() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    // Candidate: pending, not focused, not snoozed, not waiting.
    let candidate = repo.create(user_id, NewTask::builder("Candidate").priority(Priority::High).build()).await.unwrap();

    // Excluded: already focused.
    let focused = repo.create(user_id, NewTask::builder("Focused").build()).await.unwrap();
    repo.set_focus(focused.id, user_id, true).await.unwrap();

    // Excluded: snoozed into the future.
    let snoozed = repo.create(user_id, NewTask::builder("Snoozed").build()).await.unwrap();
    repo.snooze(snoozed.id, user_id, Utc::now() + Duration::hours(2)).await.unwrap();

    // Excluded: waiting for response.
    let waiting = repo.create(user_id, NewTask::builder("Waiting").build()).await.unwrap();
    repo.mark_waiting(waiting.id, user_id, None).await.unwrap();

    // Excluded: completed.
    let done = repo.create(user_id, NewTask::builder("Done").build()).await.unwrap();
    repo.complete(done.id, user_id).await.unwrap();

    let available = repo.list_available_for_focus(user_id, 100).await.expect("list available");
    let ids: Vec<_> = available.iter().map(|t| t.id).collect();
    assert_eq!(ids, vec![candidate.id], "only the pending unfocused task should be a focus candidate");
}

// ---- Scheduling ----

#[tokio::test]
async fn test_update_schedule_persists_and_clears() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let task = repo.create(user_id, NewTask::builder("Schedule me").build()).await.unwrap();
    assert!(task.scheduled_start.is_none());
    assert!(task.scheduled_duration.is_none());

    let start = Utc.with_ymd_and_hms(2026, 8, 15, 14, 0, 0).unwrap();
    let updated = repo.update_schedule(task.id, user_id, Some(start), Some(90)).await.expect("schedule").unwrap();
    assert_eq!(updated.scheduled_start, Some(start));
    assert_eq!(updated.scheduled_duration, Some(90));

    // Re-fetch to confirm persistence.
    let fetched = repo.get_by_id(task.id, user_id).await.unwrap().unwrap();
    assert_eq!(fetched.scheduled_start, Some(start));
    assert_eq!(fetched.scheduled_duration, Some(90));

    // Passing None clears the schedule.
    let cleared = repo.update_schedule(task.id, user_id, None, None).await.expect("clear schedule").unwrap();
    assert!(cleared.scheduled_start.is_none());
    assert!(cleared.scheduled_duration.is_none());
    let refetched = repo.get_by_id(task.id, user_id).await.unwrap().unwrap();
    assert!(refetched.scheduled_start.is_none());
    assert!(refetched.scheduled_duration.is_none());
}

#[tokio::test]
async fn test_list_scheduled_for_date() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let on_date = repo.create(user_id, NewTask::builder("On date").build()).await.unwrap();
    let off_date = repo.create(user_id, NewTask::builder("Off date").build()).await.unwrap();
    let _unscheduled = repo.create(user_id, NewTask::builder("Unscheduled").build()).await.unwrap();

    let target = Utc.with_ymd_and_hms(2026, 8, 15, 9, 30, 0).unwrap();
    let other = Utc.with_ymd_and_hms(2026, 8, 16, 9, 30, 0).unwrap();
    repo.update_schedule(on_date.id, user_id, Some(target), Some(60)).await.unwrap();
    repo.update_schedule(off_date.id, user_id, Some(other), Some(60)).await.unwrap();

    let date = chrono::NaiveDate::from_ymd_opt(2026, 8, 15).unwrap();
    let scheduled = repo.list_scheduled_for_date(user_id, date).await.expect("list scheduled");
    let ids: Vec<_> = scheduled.iter().map(|t| t.id).collect();
    assert_eq!(ids, vec![on_date.id], "only the task scheduled on the target date should match");
}

#[tokio::test]
async fn test_list_scheduled_for_date_excludes_completed() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let task = repo.create(user_id, NewTask::builder("Scheduled then done").build()).await.unwrap();
    let start = Utc.with_ymd_and_hms(2026, 8, 15, 9, 30, 0).unwrap();
    repo.update_schedule(task.id, user_id, Some(start), Some(60)).await.unwrap();

    let date = chrono::NaiveDate::from_ymd_opt(2026, 8, 15).unwrap();
    assert_eq!(repo.list_scheduled_for_date(user_id, date).await.unwrap().len(), 1);

    repo.complete(task.id, user_id).await.unwrap();
    assert!(
        repo.list_scheduled_for_date(user_id, date).await.unwrap().is_empty(),
        "completed tasks should not appear in the scheduled-for-date list"
    );
}

// ---- Reporting windows ----

#[tokio::test]
async fn test_list_due_between_inclusive_boundaries() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let start = Utc.with_ymd_and_hms(2026, 9, 1, 0, 0, 0).unwrap();
    let end = Utc.with_ymd_and_hms(2026, 9, 30, 23, 59, 59).unwrap();

    let at_start = repo.create(user_id, NewTask::builder("At start").due(start).build()).await.unwrap();
    let at_end = repo.create(user_id, NewTask::builder("At end").due(end).build()).await.unwrap();
    let inside = repo.create(user_id, NewTask::builder("Inside").due(Utc.with_ymd_and_hms(2026, 9, 15, 12, 0, 0).unwrap()).build()).await.unwrap();
    let _before = repo.create(user_id, NewTask::builder("Before").due(start - Duration::seconds(1)).build()).await.unwrap();
    let _after = repo.create(user_id, NewTask::builder("After").due(end + Duration::seconds(1)).build()).await.unwrap();

    let found = repo.list_due_between(user_id, start, end).await.expect("list due between");
    let ids: Vec<_> = found.iter().map(|t| t.id).collect();
    assert_eq!(ids.len(), 3, "window is inclusive on both bounds and excludes tasks just outside");
    for want in [at_start.id, at_end.id, inside.id] {
        assert!(ids.contains(&want), "expected task {want} in window");
    }
}

#[tokio::test]
async fn test_list_due_between_excludes_completed() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let start = Utc.with_ymd_and_hms(2026, 9, 1, 0, 0, 0).unwrap();
    let end = Utc.with_ymd_and_hms(2026, 9, 30, 23, 59, 59).unwrap();

    let task = repo.create(user_id, NewTask::builder("Due and done").due(Utc.with_ymd_and_hms(2026, 9, 10, 0, 0, 0).unwrap()).build()).await.unwrap();
    assert_eq!(repo.list_due_between(user_id, start, end).await.unwrap().len(), 1);
    repo.complete(task.id, user_id).await.unwrap();
    assert!(repo.list_due_between(user_id, start, end).await.unwrap().is_empty());
}

#[tokio::test]
async fn test_list_became_overdue_between_window() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let start = Utc.with_ymd_and_hms(2026, 9, 1, 0, 0, 0).unwrap();
    let end = Utc.with_ymd_and_hms(2026, 9, 30, 23, 59, 59).unwrap();

    let inside = repo.create(user_id, NewTask::builder("Overdue inside").due(Utc.with_ymd_and_hms(2026, 9, 15, 8, 0, 0).unwrap()).build()).await.unwrap();
    let _outside = repo.create(user_id, NewTask::builder("Overdue outside").due(end + Duration::seconds(1)).build()).await.unwrap();
    // Completed tasks are excluded even if due in range.
    let done = repo.create(user_id, NewTask::builder("Overdue done").due(Utc.with_ymd_and_hms(2026, 9, 20, 8, 0, 0).unwrap()).build()).await.unwrap();
    repo.complete(done.id, user_id).await.unwrap();

    let found = repo.list_became_overdue_between(user_id, start, end).await.expect("list overdue between");
    let ids: Vec<_> = found.iter().map(|t| t.id).collect();
    assert_eq!(ids, vec![inside.id], "only the non-completed task due inside the window should match");
}

#[tokio::test]
async fn test_list_created_between_window() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteTaskRepository::new(pool);

    let a = repo.create(user_id, NewTask::builder("Created one").build()).await.unwrap();
    let b = repo.create(user_id, NewTask::builder("Created two").build()).await.unwrap();

    // A window around now includes both freshly created tasks.
    let start = Utc::now() - Duration::minutes(5);
    let end = Utc::now() + Duration::minutes(5);
    let found = repo.list_created_between(user_id, start, end).await.expect("list created between");
    let ids: Vec<_> = found.iter().map(|t| t.id).collect();
    assert!(ids.contains(&a.id) && ids.contains(&b.id), "both tasks created inside the window should match");

    // A past window matches nothing.
    let old_start = Utc::now() - Duration::days(30);
    let old_end = Utc::now() - Duration::days(29);
    assert!(repo.list_created_between(user_id, old_start, old_end).await.unwrap().is_empty());
}