//! 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,

}

/// Held by every clone here and while OXY_TOKEN is set: the variable is the

/// whole process's, and a clone in another test sent it (oxygenhub#247).

static ENV: std::sync::Mutex<()> = std::sync::Mutex::new(());

fn clone(url: &str, dir: &Path) -> Result<Repo, oxy_core::repo::RepoError> {

    let _env = ENV.lock().unwrap_or_else(|p| p.into_inner());

    Repo::clone(url, dir)

}

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

    hermetic();

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

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

    // The first account's setup code (oxygenhub#245).

    config.registration.setup_code = "test-setup".into();

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

    // Help, filled in for this hub (hub spec §6.3).

    // #294: an address the router matches but cannot read (a project or

    // issue number that is not one) is the not-found page, not a parse error.

    for bad in ["/projects/andy/metalgear2", "/andy/demo/issue/abc", "/andy/demo/proposal/x1"] {

        let (status, body) = get(&h.app, bad).await;

        assert_eq!(status, StatusCode::NOT_FOUND, "{bad}");

        assert!(body.contains("There is nothing at this address.") && !body.contains("Cannot parse"), "{bad}: {body}");

    }

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

    assert!(help.contains(&format!("oxy remote add hub {}/OWNER/REPOSITORY", h.base)), "commands carry this hub's address");

    assert!(help.contains(&format!("oxy clone {}/OWNER/REPOSITORY", h.base)));

    assert!(help.contains(&format!("curl -fsSL {}/.well-known/oxyhub-key -o hub.identity", h.base)), "the delegation recipe");

    assert!(!help.contains("oxyhub-ca.pem"), "no certificate step for a hub without a self-signed certificate");

    for id in ["start", "identity", "push", "clone", "proposals", "delegate", "agents", "flow", "keys", "glossary"] {

        assert!(help.contains(&format!("id=\"{id}\"")) && help.contains(&format!("href=\"#{id}\"")), "section {id}");

    }

    // oxygenhub#287: AI identities, with this hub in the commands.

    assert!(help.contains("oh agent grant claude") && help.contains(&format!("oxy auth grant {}", h.base)), "agent grants");

    assert!(help.contains("oxy policy grant-subject agent:claude@OWNER --issuer hub.identity"), "subject grants");

    assert!(help.contains("via agent:claude@OWNER"), "how agent work shows");

    assert!(help.contains("<strong>bookmark</strong>") && help.contains("<strong>proposal</strong>"), "glossary");

    assert!(home_has_help(&page(&h.app, "/explore").await), "linked from every page");

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

    // Overview: clone popover, contributors, languages, visibility badge.

    assert!(o.contains("class=\"clone-pop\"") && o.contains("value=\"oxy clone "), "clone behind a button");

    // The Code button also offers the default bookmark as a zip.

    assert!(o.contains("&lt;&gt;</span> Code</summary>"), "a Code button");

    assert!(o.contains("href=\"/andy/demo/archive?ref=main&format=zip\" download>"), "a zip download: {o}");

    let (status, zip) = get(&h.app, "/andy/demo/archive?ref=main&format=zip").await;

    assert_eq!(status, StatusCode::OK);

    assert!(zip.starts_with("PK"), "a zip archive");

    assert!(o.contains("<h3>Contributors") && o.contains("<h3>Languages</h3>") && o.contains("<strong>Rust</strong>"), "{o}");

    assert!(o.contains("class=\"vis vis-public\""));

    // Landmarks, skip link, current tab (hub spec §6.13).

    assert!(o.contains("<a class=\"skip\" href=\"#main\">") && o.contains("<main id=\"main\""));

    assert!(o.contains("aria-label=\"Site\"") && o.contains("aria-label=\"Repository\"") && o.contains("aria-label=\"Account\""));

    assert!(o.contains("class=\"on\" aria-current=\"page\">Code</a>"), "the current tab is announced");

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

    // A ref's root is the overview with it chosen, side bar and all (#191).

    assert_eq!(get(&h.app, "/andy/demo/tree/v0.1").await.0, StatusCode::SEE_OTHER);

    let at_tag = page(&h.app, "/andy/demo?at=v0.1").await;

    assert!(at_tag.contains("README.md") && at_tag.contains("class=\"ref-pick\"") && at_tag.contains("side cards"), "{at_tag}");

    assert!(at_tag.contains("href=\"/andy/demo?at=v0.1\" class=\"on\""), "the tag is the one chosen");

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

    // A whole hash shows its two ends, the rest in a tip (#198).

    let at_hash = page(&h.app, &format!("/andy/demo?at={c1}")).await;

    let ends = format!("{}…{}", &c1[..8], &c1[c1.len() - 8..]);

    assert!(at_hash.contains(&format!("data-full=\"{c1}\"")) && at_hash.contains(&format!(">{ends}</span>")), "{at_hash}");

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

    let (hits_before, _, _) = oxygenhub::render::highlight::cache_stats();

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

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

    assert!(oxygenhub::render::highlight::cache_stats().0 > hits_before, "the second view is served from the highlight cache");

    assert_eq!(f.split("<table").nth(1), again.split("<table").nth(1), "and renders the same");

    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("class=\"here\" 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);

    // Pickers, swap and the /compare form (hub spec §6.3).

    assert!(

        cmp.contains("<datalist id=\"compare-refs\">")

            && cmp.contains("<option value=\"feature\">bookmark</option>")

            && cmp.contains("<option value=\"v0.1\">tag</option>")

    );

    assert!(cmp.contains("href=\"/andy/demo/compare/main...feature\""), "swap");

    assert!(!cmp.contains("Propose this"), "anonymous viewers cannot propose");

    let redirect = |path: &'static str| {

        let app = h.app.clone();

        async move {

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

            (res.status(), res.headers().get("location").and_then(|v| v.to_str().ok()).unwrap_or("").to_string())

        }

    };

    let (st, loc) = redirect("/andy/demo/compare").await;

    assert!(st.is_redirection() && loc == "/andy/demo/compare/main...feature", "the newest other bookmark against the default: {loc}");

    let (_, loc) = redirect("/andy/demo/compare?base=v0.1&head=+feature+").await;

    assert_eq!(loc, "/andy/demo/compare/v0.1...feature");

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

    // The bar (#254): Tags is Releases' second view and in the More menu;

    // the less used pages sit in More, the outputs in Artifacts; Projects

    // and Conflicts are off the bar.

    assert!(tags.contains("href=\"/andy/demo/releases\" class=\"on\" aria-current=\"page\">Releases</a>"), "{tags}");

    assert!(tags.contains("href=\"/andy/demo/tags\" class=\"on\" aria-current=\"page\">tags</a>"), "the sub-tab");

    let more = &tags[tags.find(">More</summary>").expect("the More menu")..];

    let more = &more[..more.find("</details>").unwrap()];

    for p in ["bookmarks", "tags", "trust", "pushes", "conflicts"] {

        assert!(more.contains(&format!("href=\"/andy/demo/{p}\"")), "More has {p}: {more}");

    }

    let artifacts = &tags[tags.find(">Artifacts</summary>").expect("the Artifacts menu")..];

    let artifacts = &artifacts[..artifacts.find("</details>").unwrap()];

    for p in ["releases", "artifacts", "images", "terraform"] {

        assert!(artifacts.contains(&format!("href=\"/andy/demo/{p}\"")), "Artifacts has {p}: {artifacts}");

    }

    assert!(!tags.contains("project boards\">Projects</a>"), "Projects is not a repository tab");

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

    assert!(releases.contains("href=\"/andy/demo/tags\">tags</a>"), "{releases}");

    for p in ["artifacts", "images", "terraform"] {

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

        assert!(body.contains("<summary class=\"on\">Artifacts</summary>"), "{p}: {body}");

    }

    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, "/.well-known/oxyhub-ca.pem").await.0, StatusCode::NOT_FOUND, "no self-signed certificate configured");

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

    let ok = {

        let _env = ENV.lock().unwrap_or_else(|p| p.into_inner());

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

        ok

    };

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