//! End to end: a hub in a temporary data directory, a real `oxy` client

//! pushing over the wire protocol, and every milestone 0.1 page fetched.

use axum::body::Body;

use axum::http::{Request, StatusCode};

use http_body_util::BodyExt;

use oxy_core::repo::Repo;

use oxygenhub::config::Config;

use oxygenhub::repos::RepoName;

use oxygenhub::{db, Shared};

use std::path::Path;

use tower::ServiceExt;

/// Point `$OXY_HOME` at a throwaway directory so the client's identity and

/// configuration never touch the developer's.

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

}

struct Hub {

    app: Shared,

    base: String,

    _dir: tempfile::TempDir,

}

async fn hub(push_tokens: Vec<String>) -> Hub {

    hermetic();

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

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

    config.auth.push_tokens = push_tokens;

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

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

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

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

    Hub { app, base: format!("http://127.0.0.1:{port}"), _dir: dir }

}

async fn get(app: &Shared, path: &str) -> (StatusCode, String) {

    let res = oxygenhub::router(app.clone()).oneshot(Request::get(path).body(Body::empty()).unwrap()).await.unwrap();

    let status = res.status();

    let bytes = res.into_body().collect().await.unwrap().to_bytes();

    (status, String::from_utf8_lossy(&bytes).into_owned())

}

async fn page(app: &Shared, path: &str) -> String {

    let (status, body) = get(app, path).await;

    assert_eq!(status, StatusCode::OK, "{path}: {}", body.lines().find(|l| l.contains("lead")).unwrap_or(""));

    body

}

/// Push a small history from a client: two changes on main, a second

/// bookmark, a tag.

fn populate(url: &str, work: &Path) -> (Repo, String, String) {

    // The hosted repository is unbound until the first push, so it cannot

    // be cloned yet: start locally and push, as moving an existing

    // repository to the hub does.

    assert!(Repo::clone(url, &work.join("early")).err().unwrap().to_string().contains("unbound"));

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

    // A signing identity, so changes and the tag travel signed.

    client.create_identity("Test Author", "[email protected]", oxy_core::repo::IdentityScope::User).unwrap();

    client.config.set("remote.origin.url", url).unwrap();

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

    client.config.set("core.sign", "change").unwrap();

    client.save_config().unwrap();

    write(work, "README.md", b"# Demo\n\nSee [docs](docs/guide.md).\n");

    write(work, "src/main.rs", b"fn main() {\n    println!(\"hi\");\n}\n");

    write(work, "docs/guide.md", b"# Guide\n");

    client.snapshot("test").unwrap();

    let c1 = client.commit("Initial import", &[]).unwrap();

    write(work, "src/main.rs", b"fn main() {\n    println!(\"hello\");\n}\n\nfn two() {}\n");

    client.snapshot("test").unwrap();

    let c2 = client.commit("Greet properly\n\nAlso adds two().", &[]).unwrap();

    client.tag_create("v0.1", &[c2], "First tag").unwrap();

    client.bookmark_create("feature", Some(&[c1])).unwrap();

    let results = client.push("origin", false).unwrap();

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

    let results = client.push_bookmark("origin", "feature", false).unwrap();

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

    // Bound now: a clone shares the id.

    let clone = Repo::clone(url, &work.join("clone")).unwrap();

    assert_eq!(clone.id().unwrap(), client.id().unwrap());

    (client, c1.to_hex(), c2.to_hex())

}

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

async fn create_push_and_browse() {

    let h = hub(vec!["site-token".into()]).await;

    let name = RepoName::parse("andy/demo").unwrap();

    h.app.repos.create(&name, None).unwrap();

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

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

    let (_client, c1, c2) = populate(&format!("{}/andy/demo", h.base), work.path());

    // Front page and owner page list it.

    let home = page(&h.app, "/").await;

    assert!(home.contains("/andy/demo"), "{home}");

    assert!(page(&h.app, "/andy").await.contains("demo"));

    assert_eq!(get(&h.app, "/nobody").await.0, StatusCode::NOT_FOUND);

    // Overview: tree, README rendered with rebased links, clone URL, counts.

    let o = page(&h.app, "/andy/demo").await;

    assert!(o.contains("src"), "tree entries");

    assert!(o.contains("href=\"/andy/demo/file/main/docs/guide.md\""), "README link rebased: {o}");

    assert!(o.contains(&format!("oxy clone {}/andy/demo", h.base)));

    assert!(o.contains("2 changes"));

    assert!(o.contains("v0.1"));

    assert!(o.contains("feature"));

    // Tree at a bookmark, a tag and a change; file with highlighting; raw; blame.

    let t = page(&h.app, "/andy/demo/tree/main/src").await;

    assert!(t.contains("main.rs"));

    assert!(page(&h.app, "/andy/demo/tree/v0.1").await.contains("README.md"));

    assert!(page(&h.app, &format!("/andy/demo/tree/{}", &c1[..10])).await.contains("README.md"));

    assert_eq!(get(&h.app, "/andy/demo/tree/main/nope").await.0, StatusCode::NOT_FOUND);

    let f = page(&h.app, "/andy/demo/file/main/src/main.rs").await;

    assert!(f.contains("sy-storage sy-type sy-function"), "highlighted: {f}");

    assert!(f.contains("id=\"L5\""));

    assert!(f.contains("Rust"));

    let (status, raw) = get(&h.app, "/andy/demo/file/main/src/main.rs?plain=1").await;

    assert_eq!(status, StatusCode::OK);

    assert_eq!(raw, "fn main() {\n    println!(\"hello\");\n}\n\nfn two() {}\n");

    let b = page(&h.app, "/andy/demo/file/main/src/main.rs?blame=1").await;

    assert!(b.contains(&c1[..8]) && b.contains(&c2[..8]), "both changes blamed: {b}");

    // Sidebar, permalink, blame shading and "blame before this change" (hub spec §6.6).

    assert!(f.contains("class=\"file-side\""), "sidebar");

    assert!(f.contains("href=\"/andy/demo/tree/main/docs\""), "sibling directory listed");

    let here = f.split("aria-current=\"page\">").nth(1).unwrap_or("");

    assert!(here.trim_start().starts_with("<a href=\"/andy/demo/file/main/src/main.rs\""), "the file marked");

    assert!(f.contains(&format!("data-permalink=\"/andy/demo/file/{c2}/src/main.rs\"")), "permalink at the head");

    assert!(b.contains(&format!("data-permalink=\"/andy/demo/file/{c2}/src/main.rs?blame=1\"")));

    assert!(b.contains("blame age-0") && b.contains("blame age-9"), "oldest and newest shaded");

    assert!(b.contains(&format!("href=\"/andy/demo/file/{c1}/src/main.rs?blame=1#L")), "the state before c2 is c1");

    assert_eq!(b.matches("class=\"before\"").count(), b.matches("blame age-9").count(), "c1 has no dependencies, so no link");

    let before = page(&h.app, &format!("/andy/demo/file/{c1}/src/main.rs?blame=1")).await;

    assert!(before.contains(&c1[..8]) && !before.contains(&c2[..8]), "blamed in c1's state");

    // States: heads joined with +, in any order; not a change otherwise.

    let (lo, hi) = if c1 < c2 { (&c1, &c2) } else { (&c2, &c1) };

    assert!(page(&h.app, &format!("/andy/demo/tree/{hi}+{lo}/src"))

        .await

        .contains(&format!("data-permalink=\"/andy/demo/tree/{lo}+{hi}/src\"")));

    assert_ne!(get(&h.app, &format!("/andy/demo/tree/{c1}+{}", &c2[..12])).await.0, StatusCode::OK, "state heads are full hashes");

    let md = page(&h.app, "/andy/demo/file/main/README.md").await;

    assert!(md.contains("<h1>Demo</h1>"), "markdown rendered");

    // Last-change JSON for tree rows.

    let (status, json) = get(&h.app, "/andy/demo/last/main?paths=README.md,src").await;

    assert_eq!(status, StatusCode::OK);

    assert!(json.contains("Initial import") && json.contains("Greet properly"), "{json}");

    // History with graph rows, filtered by path; change page with diff; compare.

    let hist = page(&h.app, "/andy/demo/changes/main").await;

    assert!(hist.contains("Greet properly") && hist.contains("Initial import"));

    assert!(hist.contains("<circle"), "graph drawn");

    assert!(hist.contains("lbl-tag") && hist.contains("v0.1"), "tag label on its head");

    let by_path = page(&h.app, "/andy/demo/changes/main?path=README.md").await;

    assert!(by_path.contains("Initial import") && !by_path.contains("Greet properly"));

    let c = page(&h.app, &format!("/andy/demo/change/{c2}")).await;

    assert!(c.contains("Also adds two()"), "body shown");

    assert!(c.contains("+fn two() {}") || c.contains("fn two() {}"), "diff shown: {c}");

    assert!(c.contains("class=\"add\"") && c.contains("class=\"del\""));

    assert!(c.contains(&c1[..12]), "dependency listed");

    assert!(page(&h.app, &format!("/andy/demo/change/{}", &c2[..8])).await.contains("Greet properly"));

    let cmp = page(&h.app, "/andy/demo/compare/feature...main").await;

    assert!(cmp.contains("1 change") && cmp.contains("Greet properly"));

    assert_eq!(get(&h.app, "/andy/demo/compare/feature").await.0, StatusCode::BAD_REQUEST);

    // Bookmarks, tags, conflicts (none), trust (no policy), pushes.

    let bm = page(&h.app, "/andy/demo/bookmarks").await;

    assert!(bm.contains("feature") && bm.contains("default"));

    let tags = page(&h.app, "/andy/demo/tags").await;

    assert!(tags.contains("v0.1") && tags.contains("First tag"));

    assert!(page(&h.app, "/andy/demo/conflicts").await.contains("No bookmark carries a conflict"));

    let trust = page(&h.app, "/andy/demo/trust").await;

    assert!(trust.contains("No trust policy") && trust.contains(&h.app.hub_key.key.to_hex()));

    assert!(trust.contains("2 signed"), "signed changes verified on the host: {trust}");

    assert!(c.contains("signed by Test Author"), "change page shows the signer");

    let pushes = page(&h.app, "/andy/demo/pushes").await;

    assert!(pushes.contains("accepted") && pushes.contains("main"), "{pushes}");

    assert!(pushes.contains("<td>2</td>") && pushes.contains("<code title="), "two changes imported and the state shown: {pushes}");

    // API and small endpoints.

    let (_, repos) = get(&h.app, "/api/v1/repos").await;

    assert!(repos.contains("\"name\":\"demo\""));

    let (_, bms) = get(&h.app, "/api/v1/repos/andy/demo/bookmarks").await;

    assert!(bms.contains("\"default\":true"));

    let (status, key) = get(&h.app, "/.well-known/oxyhub-key").await;

    assert_eq!(status, StatusCode::OK);

    assert!(!key.is_empty());

    assert!(get(&h.app, "/health").await.1.contains("\"ok\":true"));

    assert_eq!(get(&h.app, "/style.css").await.0, StatusCode::OK);

    assert_eq!(get(&h.app, "/static/fonts/Barlow-400.woff2").await.0, StatusCode::OK);

    assert_eq!(get(&h.app, "/andy/demo/oxy/v1/nothing").await.0, StatusCode::NOT_FOUND);

}

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

async fn private_repositories_and_push_tokens() {

    let h = hub(vec!["s3cret".into()]).await;

    for (name, vis) in [("pub", hub_api::Visibility::Public), ("priv", hub_api::Visibility::Private)] {

        // `priv` is created bound so it can be cloned while still empty.

        let id = if name == "priv" { Some([7u8; 16]) } else { None };

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

        db::repos::create(&h.app.db, "andy", name, "", vis).await.unwrap();

    }

    // The private one is invisible on pages and to anonymous clients.

    assert_eq!(get(&h.app, "/andy/priv").await.0, StatusCode::NOT_FOUND);

    assert!(!page(&h.app, "/").await.contains("priv"));

    assert!(Repo::clone(&format!("{}/andy/priv", h.base), &tempfile::tempdir().unwrap().path().join("x")).is_err());

    // Anonymous push to the public one is refused; with the token it lands.

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

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

    client.config.set("remote.origin.url", &format!("{}/andy/pub", h.base)).unwrap();

    write(work.path(), "a.txt", b"a\n");

    client.snapshot("test").unwrap();

    client.commit("a", &[]).unwrap();

    assert!(client.push("origin", false).is_err());

    client.config.set("remote.origin.token", "s3cret").unwrap();

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

    // With the token, the private repository can be cloned too.

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

    std::env::set_var("OXY_TOKEN", "s3cret");

    let ok = Repo::clone(&format!("{}/andy/priv", h.base), &priv_dir.path().join("p")).is_ok();

    std::env::remove_var("OXY_TOKEN");

    assert!(ok, "a token reads a private repository until accounts exist");

    // The pushes log shows the accepted update; the front page shows activity.

    tokio::time::sleep(std::time::Duration::from_millis(100)).await;

    assert!(page(&h.app, "/andy/pub/pushes").await.contains("accepted"));

    assert!(page(&h.app, "/andy/pub").await.contains("1 change"));

}