//! 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"
    );
}