//! Integration tests for SqliteBackupSettingsRepository.

mod common;

use chrono::{Duration, Utc};
use goingson_core::{BackupSettingsRepository, NewBackupSettings};
use goingson_db_sqlite::SqliteBackupSettingsRepository;

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

    let settings = repo.get(user_id).await.expect("get");
    assert!(settings.is_none(), "no row should exist for a fresh user");
}

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

    let created = repo
        .upsert(user_id, NewBackupSettings {
            auto_backup_enabled: true,
            backup_frequency_minutes: 30,
            max_backups_to_keep: 5,
        })
        .await
        .expect("upsert insert");

    assert!(created.auto_backup_enabled);
    assert_eq!(created.backup_frequency_minutes, 30);
    assert_eq!(created.max_backups_to_keep, 5);
    assert!(created.last_backup_at.is_none(), "a new row has no backup timestamp yet");

    let fetched = repo.get(user_id).await.expect("get").expect("row should exist after upsert");
    assert_eq!(fetched.id, created.id, "get must return the same persisted row");
    assert!(fetched.auto_backup_enabled);
    assert_eq!(fetched.backup_frequency_minutes, 30);
    assert_eq!(fetched.max_backups_to_keep, 5);
}

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

    let first = repo
        .upsert(user_id, NewBackupSettings {
            auto_backup_enabled: true,
            backup_frequency_minutes: 15,
            max_backups_to_keep: 1,
        })
        .await
        .expect("first upsert");

    let second = repo
        .upsert(user_id, NewBackupSettings {
            auto_backup_enabled: false,
            backup_frequency_minutes: 120,
            max_backups_to_keep: 10,
        })
        .await
        .expect("second upsert");

    assert_eq!(second.id, first.id, "upsert must update in place, not create a second row");
    assert!(!second.auto_backup_enabled);
    assert_eq!(second.backup_frequency_minutes, 120);
    assert_eq!(second.max_backups_to_keep, 10);

    let fetched = repo.get(user_id).await.expect("get").expect("row exists");
    assert!(!fetched.auto_backup_enabled, "the updated values must persist");
    assert_eq!(fetched.backup_frequency_minutes, 120);
    assert_eq!(fetched.max_backups_to_keep, 10);
}

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

    repo.upsert(user_id, NewBackupSettings {
        auto_backup_enabled: true,
        backup_frequency_minutes: 15,
        max_backups_to_keep: 1,
    })
    .await
    .expect("upsert");

    let ts = Utc::now() - Duration::minutes(3);
    repo.update_last_backup_at(user_id, ts).await.expect("update_last_backup_at");

    let fetched = repo.get(user_id).await.expect("get").expect("row exists");
    let stored = fetched.last_backup_at.expect("last_backup_at must be set");
    assert!((stored - ts).num_seconds().abs() <= 1, "stored backup time must match the value written (within second precision)");
}

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

    // No prior upsert: the update must lazily create default settings.
    assert!(repo.get(user_id).await.expect("get").is_none());

    let ts = Utc::now();
    repo.update_last_backup_at(user_id, ts).await.expect("update_last_backup_at");

    let fetched = repo.get(user_id).await.expect("get").expect("defaults should have been created");
    assert!(fetched.auto_backup_enabled, "lazy default enables auto backup");
    assert_eq!(fetched.backup_frequency_minutes, 15, "lazy default frequency");
    assert_eq!(fetched.max_backups_to_keep, 1, "lazy default retention");
    assert!(fetched.last_backup_at.is_some(), "the backup timestamp must be recorded");
}