//! The nightly garbage collection (hub spec §17.2), run by hand.

use oxy_core::repo::Repo;

use oxygenhub::config::Config;

use oxygenhub::db;

use oxygenhub::repos::RepoName;

use std::path::Path;

fn hermetic() {

    static ONCE: std::sync::Once = std::sync::Once::new();

    static DIR: std::sync::OnceLock<tempfile::TempDir> = std::sync::OnceLock::new();

    ONCE.call_once(|| {

        let d = tempfile::tempdir().unwrap();

        std::env::set_var("OXY_HOME", d.path());

        DIR.set(d).ok();

    });

}

fn write(root: &Path, rel: &str, content: &[u8]) {

    let p = root.join(rel);

    std::fs::create_dir_all(p.parent().unwrap()).unwrap();

    std::fs::write(p, content).unwrap();

}

#[tokio::test(flavor = "multi_thread")]

async fn every_repository_is_garbage_collected_in_turn() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let mut config = Config::load(dir.path()).unwrap();

    config.auth.push_tokens = vec!["site".into()];

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    config.server.base_url = format!("http://127.0.0.1:{port}");

    assert_eq!(config.retention.gc_hour, 3, "nightly at 03:00 UTC by default");

    let app = oxygenhub::build(config).await.unwrap();

    let router = oxygenhub::router(app.clone());

    tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });

    db::accounts::create_account(&app.db, "andy", "[email protected]", "x", "salt", true).await.unwrap();

    for name in ["one", "two"] {

        app.repos.create(&RepoName::parse(&format!("andy/{name}")).unwrap(), None).unwrap();

        db::repos::create(&app.db, "andy", name, "", hub_api::Visibility::Public).await.unwrap();

    }

    // A gc folds what the pushes stored into one pack.

    let work = tempfile::tempdir().unwrap();

    let mut c = Repo::init(work.path()).unwrap();

    c.config.set("remote.origin.url", &format!("http://127.0.0.1:{port}/andy/one")).unwrap();

    c.config.set("remote.origin.token", "site").unwrap();

    c.save_config().unwrap();

    for i in 0..3 {

        write(work.path(), &format!("f{i}.txt"), format!("{i}\n").as_bytes());

        c.commit(&format!("c{i}"), &[]).unwrap();

    }

    assert!(c.push("origin", false).unwrap().iter().all(|r| r.ok));

    let hosted = app.repos.dir(&RepoName::parse("andy/one").unwrap());

    let before = Repo::open(&hosted).unwrap();

    assert!(before.store().loose_count().unwrap() > 0, "the push left loose objects");

    drop(before);

    let done = oxygenhub::maintenance::gc_all(&app).await;

    assert_eq!(done.len(), 2, "{done:?}");

    assert!(done.iter().all(|d| !d.failed), "{done:?}");

    assert!(done[0].summary.contains("packed"), "{}", done[0]);

    let after = Repo::open(&hosted).unwrap();

    assert_eq!(after.store().loose_count().unwrap(), 0, "everything is in a pack");

    assert_eq!(after.store().pack_count(), 1);

    assert_eq!(after.bookmark_heads().unwrap(), c.bookmark_heads().unwrap(), "and the history is intact");

    // The clone after the gc sees the same repository.

    let again = tempfile::tempdir().unwrap();

    let d = Repo::clone(&format!("http://127.0.0.1:{port}/andy/one"), again.path()).unwrap();

    assert_eq!(std::fs::read(again.path().join("f2.txt")).unwrap(), b"2\n");

    let _ = d;

}