//! Web edits (hub spec §6.9, §6.10) under a trust policy: refused until

//! the user delegates to the hub key, then edits, new files, proposals

//! landed by the hub as the user's delegate, browser conflict resolution,

//! and closing keywords.

use axum::body::Body;

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

use http_body_util::BodyExt;

use oxy_core::repo::{IdentityScope, Repo};

use oxygenhub::config::Config;

use oxygenhub::db;

use oxygenhub::repos::RepoName;

use oxygenhub::Shared;

use std::path::Path;

use tower::ServiceExt;

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 Res {

    status: StatusCode,

    body: String,

    cookie: Option<String>,

    location: Option<String>,

}

async fn send(app: &Shared, method: &str, path: &str, cookie: Option<&str>, form: Option<&str>) -> Res {

    let mut req = Request::builder().method(method).uri(path);

    if let Some(c) = cookie {

        req = req.header(header::COOKIE, format!("oxyhub={c}"));

    }

    let body = match form {

        Some(f) => {

            req = req.header(header::CONTENT_TYPE, "application/x-www-form-urlencoded");

            Body::from(f.to_string())

        }

        None => Body::empty(),

    };

    let res = oxygenhub::router(app.clone()).oneshot(req.body(body).unwrap()).await.unwrap();

    let status = res.status();

    let cookie = res

        .headers()

        .get(header::SET_COOKIE)

        .and_then(|v| v.to_str().ok())

        .and_then(|v| v.split(';').next())

        .and_then(|kv| kv.split_once('='))

        .map(|(_, v)| v.to_string());

    let location = res.headers().get(header::LOCATION).and_then(|v| v.to_str().ok()).map(String::from);

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

    Res { status, body: String::from_utf8_lossy(&bytes).into_owned(), cookie, location }

}

/// Read server-sent events from `body` until one of `kind` arrives.

async fn next_event(body: &mut Body, kind: &str) -> String {

    let mut buf = String::new();

    loop {

        let frame = tokio::time::timeout(std::time::Duration::from_secs(5), body.frame())

            .await

            .unwrap_or_else(|_| panic!("no {kind} event; got {buf}"))

            .expect("the stream ended")

            .unwrap();

        if let Ok(data) = frame.into_data() {

            buf.push_str(&String::from_utf8_lossy(&data));

        }

        while let Some(end) = buf.find("\n\n") {

            let event: String = buf.drain(..end + 2).collect();

            if event.contains(&format!("event: {kind}\n")) {

                return event;

            }

        }

    }

}

fn csrf_of(page: &str) -> String {

    let i = page.find("name=\"_csrf\" value=\"").expect("csrf field") + "name=\"_csrf\" value=\"".len();

    page[i..].split('"').next().unwrap().to_string()

}

fn enc(s: &str) -> String {

    let mut out = String::new();

    for b in s.bytes() {

        match b {

            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => out.push(b as char),

            _ => out.push_str(&format!("%{b:02X}")),

        }

    }

    out

}

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

async fn web_edits_under_a_policy() {

    hermetic();

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

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

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

    config.registration.mode = "open".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}");

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

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

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

    let base = format!("http://127.0.0.1:{port}");

    let app = &app;

    let r = send(app, "POST", "/register", None, Some("username=andy&email=a%40example.com&password=correct-horse-battery")).await;

    let andy = r.cookie.unwrap();

    let andy_id = db::accounts::account_by_name(&app.db, "andy").await.unwrap().unwrap().id;

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

    app.repos.create(&repo, None).unwrap();

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

    // Andy's client: an identity, a policy naming it, a first push.

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

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

    client.create_identity("Andy McCall", "[email protected]", IdentityScope::Repo).unwrap();

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

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

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

    client.save_config().unwrap();

    client.policy_init().unwrap();

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

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

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

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

    let key = client.config.author_key.unwrap();

    let id = client.identity(&key).unwrap();

    db::accounts::link_identity(&app.db, andy_id, &key.to_hex(), &id.name, &id.email, &id.encode()).await.unwrap();

    // Before delegating: the page explains, and a save is refused.

    let page = send(app, "GET", "/andy/demo/edit/main/a.txt", Some(&andy), None).await;

    assert_eq!(page.status, StatusCode::OK);

    assert!(page.body.contains("not delegated"), "{}", page.body);

    assert!(page.body.contains("textarea class=\"code\""));

    let csrf = csrf_of(&page.body);

    let r = send(

        app,

        "POST",

        "/andy/demo/edit/main",

        Some(&andy),

        Some(&format!("_csrf={csrf}&path=a.txt&original=a.txt&content=x&message=m")),

    )

    .await;

    assert!(r.body.contains("not delegated"), "refused: {}", r.body);

    // Delegate to the hub key (the policy follows the rotation), push it, link the new identity.

    client.delegate_add(app.hub_key.identity.clone(), oxy_core::identity::Scope::CHANGES | oxy_core::identity::Scope::REFS, None).unwrap();

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

    let key2 = client.config.author_key.unwrap();

    let id2 = client.identity(&key2).unwrap();

    assert!(id2.delegate(&app.hub_key.key).is_some());

    // The successor was pushed with a change it authored? Not yet: link it

    // by hand here, as before; the auto-link is checked further down.

    db::accounts::link_identity(&app.db, andy_id, &key2.to_hex(), &id2.name, &id2.email, &id2.encode()).await.unwrap();

    // An edit lands on main, authored by Andy, signed by the hub as his delegate.

    let r = send(

        app,

        "POST",

        "/andy/demo/edit/main",

        Some(&andy),

        Some(&format!(

            "_csrf={csrf}&path=a.txt&original=a.txt&content={}&message={}&mode=commit",

            enc("one\ntwo\nthree\n"),

            enc("Add three")

        )),

    )

    .await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    assert_eq!(r.location.as_deref(), Some("/andy/demo/file/main/a.txt"));

    let raw = send(app, "GET", "/andy/demo/file/main/a.txt?plain=1", None, None).await;

    assert_eq!(raw.body, "one\ntwo\nthree\n");

    let hist = send(app, "GET", "/andy/demo/changes/main", Some(&andy), None).await.body;

    assert!(hist.contains("Add three"));

    assert!(send(app, "GET", "/andy/demo/pushes", None, None).await.body.contains("web edit"));

    let trust = send(app, "GET", "/andy/demo/trust", None, None).await.body;

    assert!(!trust.contains("INVALID"), "every change verifies: {trust}");

    // A new file.

    let r = send(

        app,

        "POST",

        "/andy/demo/edit/main",

        Some(&andy),

        Some(&format!("_csrf={csrf}&path=docs/guide.md&content={}&message=Guide&mode=commit", enc("# Guide\n"))),

    )

    .await;

    assert_eq!(r.location.as_deref(), Some("/andy/demo/file/main/docs/guide.md"), "{}", r.body);

    // An issue closed by a web edit's message.

    let csrf_i = csrf_of(&send(app, "GET", "/andy/demo/issues/new", Some(&andy), None).await.body);

    send(app, "POST", "/andy/demo/issues/new", Some(&andy), Some(&format!("_csrf={csrf_i}&title=Typo&body="))).await;

    let r = send(

        app,

        "POST",

        "/andy/demo/edit/main",

        Some(&andy),

        Some(&format!(

            "_csrf={csrf}&path=docs/guide.md&original=docs/guide.md&content={}&message={}&mode=commit",

            enc("# The guide\n"),

            enc("Fix typo, closes #1")

        )),

    )

    .await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    let row = db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap();

    assert_eq!(db::issues::get(&app.db, row.id, 1).await.unwrap().unwrap().state, "closed");

    // Propose: a new bookmark and a proposal, which the hub lands under the policy as Andy's delegate.

    let r = send(

        app,

        "POST",

        "/andy/demo/edit/main",

        Some(&andy),

        Some(&format!(

            "_csrf={csrf}&path=a.txt&original=a.txt&content={}&message={}&mode=propose&new_bookmark=tweak",

            enc("ONE\ntwo\nthree\n"),

            enc("Shout one")

        )),

    )

    .await;

    assert_eq!(r.location.as_deref(), Some("/andy/demo/proposal/2"), "{}", r.body);

    let page = send(app, "GET", "/andy/demo/proposal/2", Some(&andy), None).await;

    assert!(page.body.contains("ready to land") && page.body.contains(">LAND<"), "{}", page.body);

    // Nobody approved, and the repository requires no approval: the page says so and Land asks first.

    assert!(page.body.contains("settings</a> require none."), "{}", page.body);

    assert!(page.body.contains("without any approval?"), "{}", page.body);

    let r = send(app, "POST", "/andy/demo/proposal/2/land", Some(&andy), Some(&format!("_csrf={}", csrf_of(&page.body)))).await;

    // The action redirects back (so a reload never repeats it), saying so.

    let back = r.location.clone().unwrap_or_default();

    assert!(back.starts_with("/andy/demo/proposal/2?") && back.contains("notice=Landed."), "{back}");

    assert!(send(app, "GET", &back, Some(&andy), None).await.body.contains("Landed."));

    assert_eq!(send(app, "GET", "/andy/demo/file/main/a.txt?plain=1", None, None).await.body, "ONE\ntwo\nthree\n");

    // A conflict: two proposals edit the same line from the same base; landing both conflicts main.

    db::proposals::set_requirements(

        &app.db,

        row.id,

        db::proposals::Requirements { required_approvals: 0, require_owners: false, allow_conflicts: true },

    )

    .await

    .unwrap();

    for (b, text) in [("left", "Left\ntwo\nthree\n"), ("right", "Right\ntwo\nthree\n")] {

        let r = send(

            app,

            "POST",

            "/andy/demo/edit/main",

            Some(&andy),

            Some(&format!("_csrf={csrf}&path=a.txt&original=a.txt&content={}&message={b}&mode=propose&new_bookmark={b}", enc(text))),

        )

        .await;

        assert!(r.location.as_deref().is_some_and(|l| l.contains("/proposal/")), "{}", r.body);

    }

    for n in [3, 4] {

        let page = send(app, "GET", &format!("/andy/demo/proposal/{n}"), Some(&andy), None).await;

        let r =

            send(app, "POST", &format!("/andy/demo/proposal/{n}/land"), Some(&andy), Some(&format!("_csrf={}", csrf_of(&page.body)))).await;

        assert!(r.location.as_deref().is_some_and(|l| l.contains("notice=Landed.")), "#{n}: {:?}", r.location);

    }

    let conflicts = send(app, "GET", "/andy/demo/conflicts", Some(&andy), None).await.body;

    assert!(conflicts.contains("resolve region by region") && conflicts.contains("/andy/demo/resolve/main/a.txt"), "{conflicts}");

    let page = send(app, "GET", "/andy/demo/edit/main/a.txt", Some(&andy), None).await;

    assert!(page.body.contains("Resolve a.txt") && page.body.contains("<<<<<<< oxy conflict"), "{}", page.body);

    // Blame of a conflicted file: its markers are lines no change wrote,

    // so the page has more lines than blame rows, and still renders.

    let blamed = send(app, "GET", "/andy/demo/file/main/a.txt?blame=1", Some(&andy), None).await;

    assert_eq!(blamed.status, 200, "{}", blamed.body);

    assert!(blamed.body.contains("oxy conflict") && blamed.body.contains("class=\"blame\"></td>"), "{}", blamed.body);

    // Leaving markers in is refused; removing them resolves.

    let r = send(

        app,

        "POST",

        "/andy/demo/edit/main",

        Some(&andy),

        Some(&format!(

            "_csrf={csrf}&path=a.txt&original=a.txt&content={}&message=half&mode=commit",

            enc("<<<<<<< oxy conflict 1 of 1, side 1 of 2: change x \"y\"\nLeft\n")

        )),

    )

    .await;

    assert_ne!(r.status, StatusCode::SEE_OTHER);

    // The resolver: region by region, against the state it showed.

    let page = send(app, "GET", "/andy/demo/resolve/main/a.txt", Some(&andy), None).await;

    assert!(

        page.body.contains("id=\"region-1\"") && page.body.contains("keep side 2") && page.body.contains("keep every side"),

        "{}",

        page.body

    );

    assert!(

        page.body.contains("vscode://oxygenhub.oxygen-vscode/resolve?url=") && page.body.contains("&bookmark=main&path=a.txt"),

        "{}",

        page.body

    );

    let state = {

        let i = page.body.find("name=\"state\" value=\"").unwrap() + "name=\"state\" value=\"".len();

        page.body[i..i + 64].to_string()

    };

    // Live: one tab follows the room, another shares a choice (P1b).

    let live_req = Request::builder()

        .uri("/andy/demo/resolve-live/main/a.txt?client=tab-a")

        .header(header::COOKIE, format!("oxyhub={andy}"))

        .body(Body::empty())

        .unwrap();

    let res = oxygenhub::router(app.clone()).oneshot(live_req).await.unwrap();

    assert_eq!(res.status(), StatusCode::OK);

    let mut stream = res.into_body();

    let snapshot = next_event(&mut stream, "snapshot").await;

    assert!(snapshot.contains("\"present\":[\"andy\"]"), "{snapshot}");

    let choose = |region: &str, choice: &str| {

        let body = serde_json::json!({ "_csrf": csrf, "client": "tab-b", "region": region, "choice": choice, "text": "" }).to_string();

        Request::builder()

            .method("POST")

            .uri("/andy/demo/resolve-live/main/a.txt")

            .header(header::COOKIE, format!("oxyhub={andy}"))

            .header(header::CONTENT_TYPE, "application/json")

            .body(Body::from(body))

            .unwrap()

    };

    let r = oxygenhub::router(app.clone()).oneshot(choose("1", "side2")).await.unwrap();

    assert_eq!(r.status(), StatusCode::NO_CONTENT);

    let shared = next_event(&mut stream, "choice").await;

    assert!(shared.contains("\"side2\"") && shared.contains("\"tab-b\""), "{shared}");

    assert_ne!(oxygenhub::router(app.clone()).oneshot(choose("1", "rm -rf")).await.unwrap().status(), StatusCode::NO_CONTENT);

    let stale = send(

        app,

        "POST",

        "/andy/demo/resolve/main/a.txt",

        Some(&andy),

        Some(&format!("_csrf={csrf}&state={}&r1=side2&message=x", "0".repeat(64))),

    )

    .await;

    assert!(stale.body.contains("has moved since this page was loaded"), "{}", stale.body);

    let unchosen =

        send(app, "POST", "/andy/demo/resolve/main/a.txt", Some(&andy), Some(&format!("_csrf={csrf}&state={state}&message=x"))).await;

    assert!(unchosen.body.contains("choose how to resolve conflict 1"), "{}", unchosen.body);

    let r = send(

        app,

        "POST",

        "/andy/demo/resolve/main/a.txt",

        Some(&andy),

        Some(&format!("_csrf={csrf}&state={state}&r1=text&t1={}&message={}", enc("Both"), enc("Resolve a.txt"))),

    )

    .await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    let change = r.location.unwrap();

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

    let landed = next_event(&mut stream, "landed").await;

    assert!(landed.contains(&change), "the other tab hears the resolution land: {landed}");

    drop(stream);

    assert!(send(app, "GET", "/andy/demo/conflicts", None, None).await.body.contains("No bookmark carries a conflict"));

    assert_eq!(send(app, "GET", "/andy/demo/file/main/a.txt?plain=1", None, None).await.body, "Both\ntwo\nthree\n");

    let shown = send(app, "GET", &change, Some(&andy), None).await.body;

    assert!(shown.to_lowercase().contains("resolution"), "a resolution change");

    // A name conflict: two proposals add different files called new.txt.

    for (b, text) in [("first-new", "first\n"), ("second-new", "second\n")] {

        let r = send(

            app,

            "POST",

            "/andy/demo/edit/main",

            Some(&andy),

            Some(&format!("_csrf={csrf}&path=new.txt&content={}&message={b}&mode=propose&new_bookmark={b}", enc(text))),

        )

        .await;

        assert!(r.location.as_deref().is_some_and(|l| l.contains("/proposal/")), "{}", r.body);

    }

    for n in [5, 6] {

        let page = send(app, "GET", &format!("/andy/demo/proposal/{n}"), Some(&andy), None).await;

        let r =

            send(app, "POST", &format!("/andy/demo/proposal/{n}/land"), Some(&andy), Some(&format!("_csrf={}", csrf_of(&page.body)))).await;

        assert!(r.location.as_deref().is_some_and(|l| l.contains("notice=Landed.")), "#{n}: {:?} {}", r.location, r.body);

    }

    let conflicts = send(app, "GET", "/andy/demo/conflicts", Some(&andy), None).await.body;

    assert!(conflicts.contains("choose which to keep") && conflicts.contains("/andy/demo/resolve/main/new.txt"), "{conflicts}");

    let page = send(app, "GET", "/andy/demo/resolve/main/new.txt", Some(&andy), None).await;

    assert!(page.body.contains("new.txt.oxy-conflict-1") && page.body.contains("new.txt.oxy-conflict-2"), "{}", page.body);

    let state = {

        let i = page.body.find("name=\"state\" value=\"").unwrap() + "name=\"state\" value=\"".len();

        page.body[i..i + 64].to_string()

    };

    // Which suffix holds "second" depends on node order; keep that one.

    let preview = |text: &str| page.body.find(&format!("<pre class=\"marked\">{text}")).expect("a candidate's preview");