use sqlx::sqlite::SqlitePoolOptions;

async fn fresh_pool() -> sqlx::SqlitePool {
    SqlitePoolOptions::new()
        .max_connections(1)
        .connect("sqlite::memory:")
        .await
        .unwrap()
}

async fn column_names(pool: &sqlx::SqlitePool, table: &str) -> Vec<String> {
    let rows: Vec<(String,)> = sqlx::query_as("SELECT name FROM pragma_table_info(?) ORDER BY cid")
        .bind(table)
        .fetch_all(pool)
        .await
        .unwrap();
    rows.into_iter().map(|row| row.0).collect()
}

async fn applied_count(pool: &sqlx::SqlitePool) -> i64 {
    let row: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM schema_migrations")
        .fetch_one(pool)
        .await
        .unwrap();
    row.0
}

#[tokio::test]
async fn every_migration_applies_exactly_once_however_often_the_server_restarts() {
    let pool = fresh_pool().await;

    sqlite::run_migrations(&pool).await.unwrap();
    let after_first_boot = applied_count(&pool).await;

    sqlite::run_migrations(&pool).await.unwrap();
    sqlite::run_migrations(&pool).await.unwrap();
    let after_further_boots = applied_count(&pool).await;

    assert!(after_first_boot > 0, "no migrations were applied at all");
    assert_eq!(after_first_boot, after_further_boots);
}

#[tokio::test]
async fn mood_entries_no_longer_carries_content() {
    let pool = fresh_pool().await;
    sqlite::run_migrations(&pool).await.unwrap();

    assert_eq!(
        column_names(&pool, "mood_entries").await,
        [
            "id",
            "user_id",
            "mood",
            "logged_at",
            "created_at",
            "updated_at"
        ]
    );
    assert_eq!(
        column_names(&pool, "entry_content").await,
        ["entry_id", "content"]
    );
}

fn a_shared_file() -> String {
    let name = format!("k-mood-migrating-{}.sqlite", uuid::Uuid::new_v4());

    std::env::temp_dir()
        .join(name)
        .to_string_lossy()
        .to_string()
}

fn forget(path: &str) {
    let _ = std::fs::remove_file(path);
    let _ = std::fs::remove_file(format!("{path}-wal"));
    let _ = std::fs::remove_file(format!("{path}-shm"));
}

#[tokio::test]
async fn two_processes_starting_together_both_migrate_successfully() {
    let path = a_shared_file();
    let url = format!("sqlite://{path}");

    let server = sqlite::create_pool(&url).await.unwrap();
    let worker = sqlite::create_pool(&url).await.unwrap();

    let (migrating_server, migrating_worker) = tokio::join!(
        tokio::spawn({
            let pool = server.clone();
            async move { sqlite::run_migrations(&pool).await }
        }),
        tokio::spawn({
            let pool = worker.clone();
            async move { sqlite::run_migrations(&pool).await }
        }),
    );

    let by_the_server = migrating_server.unwrap();
    let by_the_worker = migrating_worker.unwrap();

    assert!(
        by_the_server.is_ok(),
        "the server could not start alongside the worker: {by_the_server:?}"
    );
    assert!(
        by_the_worker.is_ok(),
        "the worker could not start alongside the server: {by_the_worker:?}"
    );

    let applied = applied_count(&server).await;
    let names: Vec<(String,)> = sqlx::query_as("SELECT name FROM schema_migrations")
        .fetch_all(&server)
        .await
        .unwrap();

    assert_eq!(
        applied as usize,
        names.len(),
        "no migration is recorded twice"
    );
    assert!(applied > 0);

    forget(&path);
}

#[tokio::test]
async fn a_process_joining_a_migrated_database_applies_nothing() {
    let path = a_shared_file();
    let url = format!("sqlite://{path}");

    let first = sqlite::create_pool(&url).await.unwrap();
    sqlite::run_migrations(&first).await.unwrap();
    let already_applied = applied_count(&first).await;

    let second = sqlite::create_pool(&url).await.unwrap();
    sqlite::run_migrations(&second).await.unwrap();

    assert_eq!(applied_count(&second).await, already_applied);

    forget(&path);
}