//! 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", "test@example.com", 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());

    // Help, filled in for this hub (hub spec §6.3).
    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", "flow", "keys", "glossary"] {
        assert!(help.contains(&format!("id=\"{id}\"")) && help.contains(&format!("href=\"#{id}\"")), "section {id}");
    }
    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&amp;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"));
    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 (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"));
    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!(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"));
}

fn home_has_help(page: &str) -> bool {
    page.contains("<a href=\"/help\">Help</a>")
}