//! The cloud stores against real services or emulators, when the

//! environment names them; otherwise each test says so and passes.

//!

//! - `OXY_TEST_S3=s3://BUCKET/PREFIX[?params]`, with `OXY_TEST_S3_PROFILE`

//!   added as `?profile=`;

//! - `OXY_TEST_GCS=gs://BUCKET/PREFIX[?params]`, with

//!   `OXY_TEST_GCS_CREDENTIALS` added as `?credentials=`;

//! - `OXY_TEST_AZURE=az://ACCOUNT/CONTAINER/PREFIX[?params]`, with the

//!   `AZURE_*` variables read from the file `OXY_TEST_AZURE_CREDENTIALS`.

//!

//! Every test works under its own prefix below the one given, and deletes

//! what it wrote.

use oxy_core::repo::Repo;

use oxy_core::strata::{conformance, Store};

use oxy_strata::CloudStore;

use std::path::Path;

fn configured(scheme: &str) -> Option<String> {

    let (var, extra, key) = match scheme {

        "s3" => ("OXY_TEST_S3", "OXY_TEST_S3_PROFILE", "profile"),

        "gs" => ("OXY_TEST_GCS", "OXY_TEST_GCS_CREDENTIALS", "credentials"),

        "az" => ("OXY_TEST_AZURE", "OXY_TEST_AZURE_CREDENTIALS", ""),

        _ => unreachable!(),

    };

    let url = std::env::var(var).ok().filter(|u| !u.is_empty())?;

    let extra_value = std::env::var(extra).ok().filter(|v| !v.is_empty());

    if scheme == "az" {

        if let Some(file) = &extra_value {

            for line in std::fs::read_to_string(file).unwrap_or_default().lines() {

                if let Some((k, v)) = line.split_once('=') {

                    std::env::set_var(k.trim(), v.trim());

                }

            }

        }

        return Some(url);

    }

    Some(match extra_value {

        Some(v) if !url.contains(&format!("{key}=")) => {

            let sep = if url.contains('?') { '&' } else { '?' };

            format!("{url}{sep}{key}={v}")

        }

        _ => url,

    })

}

fn each_store() -> Vec<(String, CloudStore)> {

    oxy_strata::register();

    ["s3", "gs", "az"]

        .into_iter()

        .filter_map(|s| {

            let Some(url) = configured(s) else {

                eprintln!("{s}: not configured, skipped");

                return None;

            };

            let store = CloudStore::open(&url).unwrap_or_else(|e| panic!("{url}: {e}"));

            Some((url, store))

        })

        .collect()

}

fn remove_all(store: &dyn Store, prefix: &str) {

    for e in store.list(prefix).unwrap() {

        store.delete(&e.key).unwrap();

    }

}

/// What earlier runs that failed may have left under the test prefix:

/// other processes' `probe-*` and `repo-*` keys.

fn remove_stale(store: &dyn Store) {

    let mine = format!("-{}", std::process::id());

    for e in store.list("").unwrap() {

        let first = e.key.split('/').next().unwrap_or("");

        if (first.starts_with("probe-") || first.starts_with("repo-")) && !first.ends_with(&mine) {

            store.delete(&e.key).unwrap();

        }

    }

}

#[test]

fn every_configured_store_conforms() {

    for (url, store) in each_store() {

        remove_stale(&store);

        let prefix = format!("probe-{}", std::process::id());

        let passed = conformance(&store, &prefix).unwrap_or_else(|e| {

            remove_all(&store, &prefix);

            panic!("{url}: {e}")

        });

        eprintln!("{url}: {} checks passed", passed.len());

        assert_eq!(passed.len(), 8);

    }

}

/// A small repository pushed to the store, cloned back, and pulled, by

/// URL: what a user does. Then every key the test wrote is removed.

#[test]

fn a_repository_round_trips_through_every_configured_store() {

    for (url, base_store) in each_store() {

        remove_stale(&base_store);

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

        let root = dir.path();

        std::fs::create_dir_all(root.join("home")).unwrap();

        std::env::set_var("OXY_HOME", root.join("home"));

        let (base, query) = match url.split_once('?') {

            Some((b, q)) => (b.to_string(), format!("?{q}")),

            None => (url.clone(), String::new()),

        };

        let remote_url = format!("{base}/repo-{}{query}", std::process::id());

        let plain = format!("{base}/repo-{}", std::process::id());

        let store = CloudStore::open(&remote_url).unwrap();

        let mut a = Repo::init(&root.join("a")).unwrap();

        a.config.set("remote.cloud.url", &remote_url).unwrap();

        a.save_config().unwrap();

        write(root, "a/f.txt", b"hello from a\n");

        let h1 = a.commit("first", &[]).unwrap();

        let r = a.push("cloud", false).unwrap();

        assert!(r.iter().all(|x| x.ok), "{plain}: {r:?}");

        assert!(store.has("oxygen.toml").unwrap());

        assert_eq!(store.list("bundles/").unwrap().len(), 1, "{plain}");

        let b = Repo::clone(&remote_url, &root.join("b"))

            .unwrap_or_else(|e| panic!("{plain}: clone: {e}"));

        assert_eq!(

            std::fs::read(root.join("b/f.txt")).unwrap(),

            b"hello from a\n"

        );

        assert_eq!(b.bookmark_heads().unwrap(), vec![h1]);

        write(root, "b/f.txt", b"hello from a\nand b\n");

        b.commit("second", &[]).unwrap();

        assert!(b.push("origin", false).unwrap()[0].ok);

        let pr = a.pull("cloud").unwrap();

        assert!(pr.changed, "{plain}");

        assert_eq!(

            std::fs::read(root.join("a/f.txt")).unwrap(),

            b"hello from a\nand b\n"

        );

        let total: u64 = store.list("").unwrap().iter().map(|e| e.size).sum();

        eprintln!("{plain}: round trip ok, {total} bytes in the store before cleanup");

        remove_all(&store, "");

        assert!(store.list("").unwrap().is_empty(), "{plain}: cleanup");

    }

}

/// oxygen#68: a small repository kept on each store (`storage.url`), with

/// the local cache in front: commits, a reopen with the cache dropped, and

/// the time each step took. Then every key the test wrote is removed.

#[test]

fn a_repository_runs_on_every_configured_store() {

    for (url, base_store) in each_store() {

        remove_stale(&base_store);

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

        let root = dir.path();

        std::fs::create_dir_all(root.join("home")).unwrap();

        std::env::set_var("OXY_HOME", root.join("home"));

        let (base, query) = match url.split_once('?') {

            Some((b, q)) => (b.to_string(), format!("?{q}")),

            None => (url.clone(), String::new()),

        };

        let store_url = format!("{base}/repo-{}{query}", std::process::id());

        let plain = format!("{base}/repo-{}", std::process::id());

        let store = CloudStore::open(&store_url).unwrap();

        let t = std::time::Instant::now();

        let repo = Repo::init_new(&root.join("w"), false, Some(&store_url))

            .unwrap_or_else(|e| panic!("{plain}: init: {e}"));

        let init_ms = t.elapsed().as_millis();

        let t = std::time::Instant::now();

        let mut last = None;

        for i in 0..5 {

            write(

                root,

                "w/f.txt",

                format!("line {i}\n").repeat(i + 1).as_bytes(),

            );

            last = Some(repo.commit(&format!("commit {i}"), &[]).unwrap());

        }

        let commit_ms = t.elapsed().as_millis() / 5;

        drop(repo);

        std::fs::remove_dir_all(root.join("w/.oxy/cache")).unwrap();

        let t = std::time::Instant::now();

        let repo = Repo::open(&root.join("w")).unwrap();

        let heads = repo.bookmark_heads().unwrap();

        let state = repo.load_state(&heads).unwrap().materialize();

        let cold_ms = t.elapsed().as_millis();

        assert_eq!(heads, vec![last.unwrap()], "{plain}");

        assert_eq!(state.files.len(), 1);

        assert!(

            store.read_ref("ops/head").unwrap().is_some(),

            "{plain}: the head is in the store"

        );

        let keys = store.list("").unwrap();

        let total: u64 = keys.iter().map(|e| e.size).sum();

        eprintln!(

            "{plain}: init {init_ms} ms, commit {commit_ms} ms each, cold open and read {cold_ms} ms; {} keys, {total} bytes",

            keys.len()

        );

        remove_all(&store, "");

        assert!(store.list("").unwrap().is_empty(), "{plain}: cleanup");

    }

}

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();

}