//! Milestone 0.4 end to end: issues with labels, assignees and
//! milestones, cross references, closing keywords on landing, the inbox,
//! watching, mentions and search.

use axum::body::Body;
use axum::http::{header, Request, StatusCode};
use http_body_util::BodyExt;
use oxy_core::repo::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 Hub {
    app: Shared,
    base: String,
    _dir: tempfile::TempDir,
}

async fn hub() -> Hub {
    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() });
    Hub { app, base: format!("http://127.0.0.1:{port}"), _dir: dir }
}

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 }
}

async fn get(app: &Shared, path: &str, cookie: Option<&str>) -> Res {
    send(app, "GET", path, cookie, None).await
}

async fn post(app: &Shared, path: &str, cookie: Option<&str>, form: &str) -> Res {
    send(app, "POST", path, cookie, Some(form)).await
}

async fn register(app: &Shared, user: &str) -> String {
    let r = post(app, "/register", None, &format!("username={user}&email={user}%40example.com&password=correct-horse-battery")).await;
    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);
    r.cookie.unwrap()
}

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

#[tokio::test(flavor = "multi_thread")]
async fn issues_notifications_and_search() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let bob = register(app, "bob").await;
    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();

    // Labels and a milestone, by the owner.
    let labels_page = get(app, "/andy/demo/labels", Some(&andy)).await;
    let csrf_a = csrf_of(&labels_page.body);
    assert!(post(app, "/andy/demo/labels", Some(&andy), &format!("_csrf={csrf_a}&name=bug&colour=%23ff0000&description=Something+broke"))
        .await
        .body
        .contains("Saved bug"));
    assert!(post(app, "/andy/demo/milestones", Some(&andy), &format!("_csrf={csrf_a}&title=v1&description=First&due=2027-01-01"))
        .await
        .body
        .contains("v1"));
    assert_eq!(get(app, "/andy/demo/labels", Some(&bob)).await.status, StatusCode::OK, "readers see labels");
    assert!(!get(app, "/andy/demo/labels", Some(&bob)).await.body.contains("Add or change"), "but cannot edit them");

    // Bob watches the repository, then Andy opens an issue mentioning @bob: Bob is told twice at most once.
    let overview = get(app, "/andy/demo", Some(&bob)).await;
    let csrf_b = csrf_of(&overview.body);
    assert_eq!(post(app, "/andy/demo/watch", Some(&bob), &format!("_csrf={csrf_b}")).await.status, StatusCode::SEE_OTHER);
    assert!(get(app, "/andy/demo", Some(&bob)).await.body.contains("UNWATCH"));
    let new_page = get(app, "/andy/demo/issues/new", Some(&andy)).await;
    let csrf_a = csrf_of(&new_page.body);
    let r = post(
        app,
        "/andy/demo/issues/new",
        Some(&andy),
        &format!("_csrf={csrf_a}&title=Crash+on+start&body=cc+%40bob+see+%23999+and+deadbeefcafe1234"),
    )
    .await;
    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);
    assert_eq!(r.location.as_deref(), Some("/andy/demo/issue/1"));
    let page = get(app, "/andy/demo/issue/1", Some(&bob)).await;
    assert!(page.body.contains("Crash on start"));
    assert!(page.body.contains("href=\"/bob\""), "mention linked: {}", page.body);
    assert!(page.body.contains("/andy/demo/change/deadbeefcafe1234"), "hash linked: {}", page.body);
    assert!(page.body.contains("#999") && !page.body.contains("issue/999"), "unknown numbers are not linked");
    let unread = db::notify::unread(&app.db, db::accounts::account_by_name(&app.db, "bob").await.unwrap().unwrap().id).await.unwrap();
    assert_eq!(unread, 1, "one notification, not one per reason");
    let inbox = get(app, "/notifications", Some(&bob)).await;
    assert!(inbox.body.contains("andy/demo#1: Crash on start"), "{}", inbox.body);
    assert!(get(app, "/andy/demo", Some(&bob)).await.body.contains("class=\"count\">1<"), "bell shows the count");

    // Triage: labels, assignee, milestone, pin, lock.
    let page = get(app, "/andy/demo/issue/1", Some(&andy)).await;
    let csrf_a = csrf_of(&page.body);
    let label_id: i64 = sqlx::query_scalar("SELECT id FROM labels WHERE name = 'bug'").fetch_one(&app.db).await.unwrap();
    let r = post(app, "/andy/demo/issue/1/labels", Some(&andy), &format!("_csrf={csrf_a}&label={label_id}")).await;
    assert!(r.body.contains(">bug<"), "{}", r.body);
    let r = post(app, "/andy/demo/issue/1/assign", Some(&andy), &format!("_csrf={csrf_a}&username=bob&action=add")).await;
    assert!(r.body.contains("href=\"/bob\">bob</a>"), "{}", r.body);
    let ms_id: i64 = sqlx::query_scalar("SELECT id FROM milestones WHERE title = 'v1'").fetch_one(&app.db).await.unwrap();
    let r = post(app, "/andy/demo/issue/1/milestone", Some(&andy), &format!("_csrf={csrf_a}&milestone={ms_id}")).await;
    assert!(r.body.contains(">v1<"), "{}", r.body);
    assert!(post(app, "/andy/demo/issue/1/state", Some(&andy), &format!("_csrf={csrf_a}&action=pin")).await.body.contains("UNPIN"));
    assert_eq!(
        post(
            app,
            "/andy/demo/issue/1/state",
            Some(&bob),
            &format!("_csrf={}&action=lock", csrf_of(&get(app, "/andy/demo/issue/1", Some(&bob)).await.body))
        )
        .await
        .status,
        StatusCode::NOT_FOUND,
        "bob cannot lock"
    );
    // Filters on the list.
    let list = get(app, "/andy/demo/issues?q=label:bug+assignee:bob+milestone:v1", None).await;
    assert!(list.body.contains("Crash on start"), "{}", list.body);
    assert!(!get(app, "/andy/demo/issues?q=label:feature", None).await.body.contains("Crash on start"));
    assert!(get(app, "/andy/demo/milestones", None).await.body.contains("1 open, 0 closed"));

    // Bob comments and closes; the author is told; search finds the comment.
    let csrf_b = csrf_of(&get(app, "/andy/demo/issue/1", Some(&bob)).await.body);
    let r = post(app, "/andy/demo/issue/1/comment", Some(&bob), &format!("_csrf={csrf_b}&body=Reproduced+with+the+flux+capacitor")).await;
    assert!(r.body.contains("flux capacitor"), "{}", r.body);
    assert!(get(app, "/notifications", Some(&andy)).await.body.contains("andy/demo#1"));
    let s = get(app, "/search?q=capacitor", None).await;
    assert!(s.body.contains("Crash on start") && s.body.contains("<mark>capacitor</mark>"), "{}", s.body);
    let s = get(app, "/search?q=demo", None).await;
    assert!(s.body.contains("/andy/demo\""), "repository hit: {}", s.body);
    // Bob is not triage, but as an assignee of an open issue he can comment-and-close? No: only the author or triage.
    let r = post(app, "/andy/demo/issue/1/comment", Some(&bob), &format!("_csrf={csrf_b}&body=closing&close=completed")).await;
    assert!(r.body.contains(">open<") || r.body.contains("head\">open"), "still open: {}", r.body);
    let r = post(app, "/andy/demo/issue/1/comment", Some(&andy), &format!("_csrf={csrf_a}&body=fixed&close=completed")).await;
    assert!(r.body.contains("closed"), "{}", r.body);
    assert!(get(app, "/andy/demo/issues?state=closed", None).await.body.contains("Crash on start"));

    // A second issue closed by a change message pushed to the default bookmark.
    let csrf_a = csrf_of(&get(app, "/andy/demo/issues/new", Some(&andy)).await.body);
    assert_eq!(
        post(app, "/andy/demo/issues/new", Some(&andy), &format!("_csrf={csrf_a}&title=Typo&body=")).await.location.as_deref(),
        Some("/andy/demo/issue/2")
    );
    let work = tempfile::tempdir().unwrap();
    let mut client = Repo::init(work.path()).unwrap();
    client.config.set("remote.origin.url", &format!("{}/andy/demo", h.base)).unwrap();
    client.config.set("remote.origin.token", "site").unwrap();
    client.save_config().unwrap();
    write(work.path(), "a.txt", b"a\n");
    client.snapshot("t").unwrap();
    client.commit("Fix the typo\n\nCloses #2", &[]).unwrap();
    assert!(client.push("origin", false).unwrap().iter().all(|r| r.ok));
    tokio::time::sleep(std::time::Duration::from_millis(300)).await;
    let issue2 = db::issues::get(&app.db, db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap().id, 2).await.unwrap().unwrap();
    assert_eq!(issue2.state, "closed", "closed by the landed change");
    assert!(get(app, "/andy/demo/issue/2", None).await.body.contains("closed by change"));

    // Numbers are shared: the next proposal is #3, and /issue/3 redirects to it.
    client.bookmark_create("feat", None).unwrap();
    client.bookmark_switch("feat", false).unwrap();
    write(work.path(), "b.txt", b"b\n");
    client.snapshot("t").unwrap();
    client.commit("feat", &[]).unwrap();
    assert!(client.push_bookmark("origin", "feat", false).unwrap().iter().all(|r| r.ok));
    let csrf_a = csrf_of(&get(app, "/andy/demo/proposals/new?source=feat&target=main", Some(&andy)).await.body);
    let r = post(app, "/andy/demo/proposals/new", Some(&andy), &format!("_csrf={csrf_a}&title=Feat&target=main&source=feat")).await;
    assert_eq!(r.location.as_deref(), Some("/andy/demo/proposal/3"), "{}", r.body);
    assert_eq!(get(app, "/andy/demo/issue/3", None).await.location.as_deref(), Some("/andy/demo/proposal/3"));
    // A comment on the issue referencing #3 links to the proposal.
    let r = post(app, "/andy/demo/issue/2/comment", Some(&andy), &format!("_csrf={csrf_a}&body=see+%233")).await;
    assert!(r.body.contains("href=\"/andy/demo/proposal/3\""), "{}", r.body);
    // Bob takes part in #1 (mentioned, assigned, commented) and only watches #3.
    let part = get(app, "/notifications?reason=participating", Some(&bob)).await.body;
    assert!(part.contains("andy/demo#1") && !part.contains("andy/demo#3: Feat"), "{part}");
    let watch = get(app, "/notifications?reason=watching", Some(&bob)).await.body;
    assert!(watch.contains("andy/demo#3: Feat") && !watch.contains("Crash on start"), "{watch}");
    let props = get(app, "/notifications?kind=proposal", Some(&bob)).await.body;
    assert!(props.contains("andy/demo#3: Feat") && !props.contains("andy/demo#1"), "kind filter");
    assert!(get(app, "/notifications?repo=andy/demo", Some(&bob)).await.body.contains("andy/demo#3: Feat"));
    assert!(get(app, "/notifications?repo=nobody/none", Some(&bob)).await.body.contains("Nothing matches these filters"));
    // One row per thread, however many events it had.
    let inbox = get(app, "/notifications", Some(&bob)).await.body;
    assert_eq!(inbox.matches("data-row-thread=\"/andy/demo/issue/1\"").count(), 1, "{inbox}");
    assert!(inbox.contains(" updates"), "the count of a busy thread");
    // Opening a thread marks it read and goes there.
    let bob_id = db::accounts::account_by_name(&app.db, "bob").await.unwrap().unwrap().id;
    let newest: i64 = sqlx::query_scalar(
        "SELECT id FROM notifications WHERE account_id = ? AND thread = '/andy/demo/proposal/3' ORDER BY id DESC LIMIT 1",
    )
    .bind(bob_id)
    .fetch_one(&app.db)
    .await
    .unwrap();
    let before = db::notify::unread(&app.db, bob_id).await.unwrap();
    let r = get(app, &format!("/notifications/open/{newest}"), Some(&bob)).await;
    assert_eq!(r.location.as_deref(), Some("/andy/demo/proposal/3"));
    assert!(db::notify::unread(&app.db, bob_id).await.unwrap() < before);
    assert_eq!(get(app, &format!("/notifications/open/{newest}"), Some(&andy)).await.status, StatusCode::NOT_FOUND, "only your own");
    // Done sets a thread aside until something new happens in it.
    let csrf_b = csrf_of(&get(app, "/notifications", Some(&bob)).await.body);
    let r = post(
        app,
        "/notifications/thread",
        Some(&bob),
        &format!("_csrf={csrf_b}&thread=%2Fandy%2Fdemo%2Fissue%2F1&action=done&back=%2Fnotifications"),
    )
    .await;
    assert_eq!(r.location.as_deref(), Some("/notifications"));
    assert!(!get(app, "/notifications", Some(&bob)).await.body.contains("Crash on start"));
    assert!(get(app, "/notifications?view=done", Some(&bob)).await.body.contains("Crash on start"));
    post(app, "/andy/demo/issue/1/comment", Some(&andy), &format!("_csrf={csrf_a}&body=one+more+thing")).await;
    assert!(get(app, "/notifications", Some(&bob)).await.body.contains("Crash on start"), "back with the new comment");
    let r = post(
        app,
        "/notifications/thread",
        Some(&bob),
        &format!("_csrf={csrf_b}&thread=%2Fandy%2Fdemo%2Fissue%2F1&action=read&back=https%3A%2F%2Fevil.example"),
    )
    .await;
    assert_eq!(r.location.as_deref(), Some("/notifications"), "only back to the inbox");

    // Bob (watcher) heard about the proposal; the inbox marks all read.
    assert!(get(app, "/notifications", Some(&bob)).await.body.contains("andy/demo#3: Feat"));
    let csrf_b = csrf_of(&get(app, "/notifications", Some(&bob)).await.body);
    let r = post(app, "/notifications/read", Some(&bob), &format!("_csrf={csrf_b}")).await;
    assert!(r.body.contains("0 unread"), "{}", r.body);
    // Email preference and the unsubscribe link.
    let r = post(app, "/settings/notifications", Some(&bob), &format!("_csrf={csrf_b}&email=1")).await;
    assert!(r.body.contains("Email notifications are on"));
    let key: String = sqlx::query_scalar("SELECT unsubscribe_key FROM accounts WHERE username = 'bob'").fetch_one(&app.db).await.unwrap();
    assert_eq!(get(app, &format!("/settings/notifications?unsubscribe={key}"), None).await.status, StatusCode::OK);
    let on: bool = sqlx::query_scalar("SELECT email_notifications FROM accounts WHERE username = 'bob'").fetch_one(&app.db).await.unwrap();
    assert!(!on);
}

#[tokio::test(flavor = "multi_thread")]
async fn dashboard_shows_what_needs_the_viewer() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let bob = register(app, "bob").await;
    for (name, vis) in [("demo", hub_api::Visibility::Public), ("secret", hub_api::Visibility::Private)] {
        app.repos.create(&RepoName::parse(&format!("andy/{name}")).unwrap(), None).unwrap();
        db::repos::create(&app.db, "andy", name, "", vis).await.unwrap();
    }
    let demo = db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap();
    let secret = db::repos::get(&app.db, "andy", "secret").await.unwrap().unwrap();
    let bob_id = db::accounts::account_by_name(&app.db, "bob").await.unwrap().unwrap().id;
    for (repo, title) in [(demo.id, "Faster startup"), (secret.id, "Hidden work")] {
        let p = db::proposals::create(
            &app.db,
            db::proposals::NewProposal {
                repo_id: repo,
                title,
                body: "",
                author_id: Some(bob_id),
                author: "bob",
                draft: false,
                target: "main",
                source_kind: "bookmark",
                source_repo_id: Some(repo),
                source_bookmark: "fast",
                source_changes: "",
            },
        )
        .await
        .unwrap();
        db::proposals::add_event(&app.db, p.id, "bob", "opened", "").await.unwrap();
    }

    // Signed out, `/` is still the repository list.
    let anon = get(app, "/", None).await;
    assert!(anon.body.contains("andy /") && !anon.body.contains("Dashboard <small>"), "{}", anon.body);

    // Andy owns both repositories: both proposals wait for his review.
    let page = get(app, "/", Some(&andy)).await;
    assert_eq!(page.status, StatusCode::OK);
    assert!(page.body.contains("Waiting for your review <small>2</small>"), "{}", page.body);
    assert!(page.body.contains("/andy/demo/proposal/1") && page.body.contains("/andy/secret/proposal/1"));
    assert!(page.body.contains("Your repositories"));
    assert!(page.body.contains("opened proposal"), "activity feed: {}", page.body);

    // Once he reviews one, it leaves his queue.
    let andy_id = db::accounts::account_by_name(&app.db, "andy").await.unwrap().unwrap().id;
    let p = db::proposals::get(&app.db, demo.id, 1).await.unwrap().unwrap();
    db::proposals::add_review(&app.db, p.id, andy_id, "andy", "approve", "").await.unwrap();
    assert!(get(app, "/", Some(&andy)).await.body.contains("Waiting for your review <small>1</small>"));

    // Bob sees his own proposal on the public repository, never the private one's.
    let page = get(app, "/", Some(&bob)).await;
    assert!(page.body.contains("Your proposals <small>1</small>"), "{}", page.body);
    assert!(!page.body.contains("Hidden work"));
    assert!(page.body.contains("Waiting for your review <small>0</small>"));
    assert!(page.body.contains("Faster startup"));
    let feed = &page.body[page.body.find("Recent activity").unwrap()..];
    assert!(!feed.contains("andy/secret"), "private activity leaked: {feed}");

    // Explore still lists every visible repository.
    assert!(get(app, "/explore", Some(&bob)).await.body.contains("andy /"));
}

#[tokio::test(flavor = "multi_thread")]
async fn empty_repository_shows_a_quickstart() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let bob = register(app, "bob").await;
    app.repos.create(&RepoName::parse("andy/fresh").unwrap(), None).unwrap();
    db::repos::create(&app.db, "andy", "fresh", "", hub_api::Visibility::Public).await.unwrap();

    let page = get(app, "/andy/fresh", Some(&andy)).await;
    assert!(page.body.contains("This repository is empty"), "{}", page.body);
    let clone_url = format!("{}/andy/fresh", h.base);
    assert!(page.body.contains(&format!("oxy remote add hub {clone_url}")), "{}", page.body);
    assert!(page.body.contains("oxy config remote.hub.token YOUR-TOKEN"));
    assert!(page.body.contains("oxy push hub"));
    assert!(
        page.body.contains("mkdir fresh &amp;&amp; cd fresh") || page.body.contains("mkdir fresh &#38;&#38; cd fresh"),
        "{}",
        page.body
    );
    assert!(page.body.contains("oxy git import --branch main"));
    assert!(!page.body.contains("oxyhub-ca.pem"), "no certificate step without a self-signed certificate");

    // A reader without write access is not told to push.
    let page = get(app, "/andy/fresh", Some(&bob)).await;
    assert!(page.body.contains("Nothing has been pushed yet") && !page.body.contains("oxy push hub"), "{}", page.body);

    // After a first push the quickstart gives way to the tree.
    let work = tempfile::tempdir().unwrap();
    let mut client = Repo::init(work.path()).unwrap();
    client.config.set("remote.hub.url", &clone_url).unwrap();
    client.config.set("remote.hub.token", "site").unwrap();
    client.save_config().unwrap();
    write(work.path(), "README.md", b"# fresh\n");
    client.commit("First change", &[]).unwrap();
    assert!(client.push("hub", false).unwrap().iter().all(|r| r.ok));
    let page = get(app, "/andy/fresh", Some(&andy)).await;
    assert!(!page.body.contains("This repository is empty") && page.body.contains("README.md"), "{}", page.body);
}

#[tokio::test(flavor = "multi_thread")]
async fn theme_is_chosen_in_settings_and_remembered_in_a_cookie() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let page = get(app, "/settings", Some(&andy)).await;
    assert!(page.body.contains("Appearance"));
    assert!(page.body.contains(r#"value="dark" checked"#), "dark by default: {}", page.body);
    assert!(page.body.contains("data-theme-toggle"), "the header has the switch");
    let csrf = csrf_of(&page.body);
    let r = post(app, "/settings/appearance", Some(&andy), &format!("_csrf={csrf}&theme=light")).await;
    assert_eq!(r.status, StatusCode::SEE_OTHER);
    assert_eq!(r.cookie.as_deref(), Some("light"));
    assert_eq!(r.location.as_deref(), Some("/settings"));
    let page = send_with_theme(app, &andy, "light").await;
    assert!(page.contains(r#"value="light" checked"#), "the form shows the cookie's theme");
    assert_eq!(post(app, "/settings/appearance", Some(&andy), &format!("_csrf={csrf}&theme=purple")).await.status, StatusCode::BAD_REQUEST);
    assert_eq!(post(app, "/settings/appearance", Some(&andy), "_csrf=nope&theme=light").await.status, StatusCode::BAD_REQUEST);
}

async fn send_with_theme(app: &Shared, session: &str, theme: &str) -> String {
    let req =
        Request::builder().uri("/settings").header(header::COOKIE, format!("oxyhub={session}; theme={theme}")).body(Body::empty()).unwrap();
    let res = oxygenhub::router(app.clone()).oneshot(req).await.unwrap();
    String::from_utf8_lossy(&res.into_body().collect().await.unwrap().to_bytes()).into_owned()
}

#[tokio::test(flavor = "multi_thread")]
async fn profile_and_organisation_pages() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let bob = register(app, "bob").await;
    let andy_id = db::accounts::account_by_name(&app.db, "andy").await.unwrap().unwrap().id;
    let bob_id = db::accounts::account_by_name(&app.db, "bob").await.unwrap().unwrap().id;
    app.repos.create(&RepoName::parse("andy/demo").unwrap(), None).unwrap();
    db::repos::create(&app.db, "andy", "demo", "A demo", hub_api::Visibility::Public).await.unwrap();
    app.repos.create(&RepoName::parse("andy/hidden").unwrap(), None).unwrap();
    db::repos::create(&app.db, "andy", "hidden", "", hub_api::Visibility::Private).await.unwrap();

    // Andy fills in his profile; a script URL and markup are refused or escaped.
    let csrf = csrf_of(&get(app, "/settings", Some(&andy)).await.body);
    let r = post(app, "/settings", Some(&andy), &format!("_csrf={csrf}&display_name=Andy+McCall&email=a%40example.com&bio=Builds+%3Cb%3Eoxy%3C%2Fb%3E&website=javascript%3Aalert(1)&location=Earth")).await;
    assert!(r.body.contains("must be an http"), "{}", r.body);
    let r = post(app, "/settings", Some(&andy), &format!("_csrf={csrf}&display_name=Andy+McCall&email=a%40example.com&bio=Builds+%3Cb%3Eoxy%3C%2Fb%3E&website=https%3A%2F%2Fexample.org&location=Earth")).await;
    assert!(r.body.contains("Profile saved"), "{}", r.body);

    let org = db::accounts::create_org(&app.db, "retro", "Retro Club", andy_id).await.unwrap();
    db::accounts::set_org_member(&app.db, org.id, bob_id, "member").await.unwrap();
    let team = db::accounts::create_team(&app.db, org.id, "core").await.unwrap();
    db::accounts::add_team_member(&app.db, team.id, bob_id).await.unwrap();

    let page = get(app, "/andy", Some(&bob)).await;
    assert_eq!(page.status, StatusCode::OK);
    for want in ["Andy McCall", "Earth", r#"href="https://example.org""#, "/avatar/andy", "Signing keys", "/retro", "demo"] {
        assert!(page.body.contains(want), "profile lacks {want}: {}", page.body);
    }
    assert!(!page.body.contains("<b>oxy</b>"), "the bio is escaped");
    assert!(!page.body.contains("a@example.com"), "the email stays private");
    assert!(!page.body.contains("/andy/hidden"), "bob cannot see the private repository");
    assert!(!page.body.contains("edit profile"), "only the owner gets the edit link");
    assert!(get(app, "/andy", Some(&andy)).await.body.contains("/andy/hidden"), "andy sees his own private repository");

    let page = get(app, "/retro", Some(&bob)).await;
    assert_eq!(page.status, StatusCode::OK);
    for want in ["Retro Club", "organisation", "Members <small>2</small>", "core", "1 member"] {
        assert!(page.body.contains(want), "org page lacks {want}: {}", page.body);
    }
    assert!(!page.body.contains("/orgs/retro/settings"), "bob is not an owner");
    assert!(get(app, "/retro", Some(&andy)).await.body.contains("/orgs/retro/settings"));

    let svg = get(app, "/avatar/andy", None).await;
    assert_eq!(svg.status, StatusCode::OK);
    assert!(svg.body.starts_with("<svg"));
    assert_eq!(svg.body, get(app, "/avatar/ANDY", None).await.body);
    assert_eq!(get(app, "/nobody-here", None).await.status, StatusCode::NOT_FOUND);
}

#[tokio::test(flavor = "multi_thread")]
async fn diffs_mark_words_hide_whitespace_and_collapse() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    app.repos.create(&RepoName::parse("andy/demo").unwrap(), None).unwrap();
    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();
    let work = tempfile::tempdir().unwrap();
    let mut client = Repo::init(work.path()).unwrap();
    client.config.set("remote.hub.url", &format!("{}/andy/demo", h.base)).unwrap();
    client.config.set("remote.hub.token", "site").unwrap();
    client.save_config().unwrap();
    write(work.path(), "main.rs", b"fn main() {\n  setup();\n  let answer = 42;\n}\n");
    client.commit("first", &[]).unwrap();
    write(work.path(), "main.rs", b"fn main() {\n    setup();\n  let answer = 43;\n}\n");
    let second = client.commit("reindent and change the answer", &[]).unwrap();
    assert!(client.push("hub", false).unwrap().iter().all(|r| r.ok));

    let url = format!("/andy/demo/change/{}", second.to_hex());
    let page = get(app, &url, Some(&andy)).await;
    assert_eq!(page.status, StatusCode::OK);
    assert!(page.body.contains(r#"<details class="file-diff""#), "files collapse: {}", page.body);
    assert!(page.body.contains(r#"<span class="wx">43</span>"#), "the changed word is marked: {}", page.body);
    assert!(page.body.contains("hide whitespace changes"));
    assert!(page.body.contains("data-diff-mode=\"split\""));
    let adds = |b: &str| b.matches(r#"<tr class="add">"#).count();
    assert_eq!(adds(&page.body), 2, "re-indent and answer both changed");

    let quiet = get(app, &format!("{url}?w=1"), Some(&andy)).await;
    assert_eq!(adds(&quiet.body), 1, "only the answer changed ignoring whitespace: {}", quiet.body);
    assert!(quiet.body.contains("show whitespace changes"));

    assert!(quiet.body.contains("?w=0"), "the toggle leads back");
}

#[tokio::test(flavor = "multi_thread")]
async fn fork_and_propose_upstream() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let bob = register(app, "bob").await;
    app.repos.create(&RepoName::parse("andy/demo").unwrap(), None).unwrap();
    db::repos::create(&app.db, "andy", "demo", "The demo", hub_api::Visibility::Public).await.unwrap();
    let work = tempfile::tempdir().unwrap();
    let mut client = Repo::init(work.path()).unwrap();
    client.config.set("remote.hub.url", &format!("{}/andy/demo", h.base)).unwrap();
    client.config.set("remote.hub.token", "site").unwrap();
    client.save_config().unwrap();
    write(work.path(), "README.md", b"# demo\n");
    client.commit("first", &[]).unwrap();
    assert!(client.push("hub", false).unwrap().iter().all(|r| r.ok));

    // Bob forks it; he cannot fork into Andy's name.
    let page = get(app, "/andy/demo", Some(&bob)).await;
    assert!(page.body.contains("/andy/demo/fork"), "a fork button: {}", page.body);
    let csrf = csrf_of(&get(app, "/andy/demo/fork", Some(&bob)).await.body);
    let r = post(app, "/andy/demo/fork", Some(&bob), &format!("_csrf={csrf}&owner=andy&name=other")).await;
    assert!(r.body.contains("cannot create repositories under that owner"), "{}", r.body);
    let r = post(app, "/andy/demo/fork", Some(&bob), &format!("_csrf={csrf}&owner=bob&name=demo")).await;
    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);
    assert_eq!(r.location.as_deref(), Some("/bob/demo"));
    let forked = get(app, "/bob/demo", Some(&bob)).await;
    assert!(forked.body.contains("README.md") && forked.body.contains("forked from"), "{}", forked.body);
    assert!(forked.body.contains("propose to andy/demo"));
    assert!(get(app, "/andy/demo", None).await.body.contains("1 fork"));
    assert!(get(app, "/andy/demo/forks", None).await.body.contains("/bob/demo"));
    let fork_row = db::repos::get(&app.db, "bob", "demo").await.unwrap().unwrap();
    let up_row = db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap();
    assert_eq!(fork_row.forked_from, Some(up_row.id));
    assert_eq!(fork_row.description, "The demo");
    let fork_repo = app.repos.open(&RepoName::parse("bob/demo").unwrap()).unwrap();
    let up_repo = app.repos.open(&RepoName::parse("andy/demo").unwrap()).unwrap();
    assert_ne!(fork_repo.id().unwrap(), up_repo.id().unwrap(), "a fork is a repository of its own");
    assert_eq!(fork_repo.bookmark_heads().unwrap(), up_repo.bookmark_heads().unwrap());
    assert_eq!(fork_repo.fsck().unwrap().errors(), 0);

    // Bob works in a clone of his fork, pushes a bookmark, and proposes it upstream.
    let bw = tempfile::tempdir().unwrap();
    let mut mine = Repo::clone(&format!("{}/bob/demo", h.base), &bw.path().join("c")).unwrap();
    mine.config.set("remote.origin.token", "site").unwrap();
    mine.save_config().unwrap();
    mine.bookmark_create("feat", None).unwrap();
    mine.bookmark_switch("feat", false).unwrap();
    write(&bw.path().join("c"), "feature.txt", b"new\n");
    mine.commit("Add a feature", &[]).unwrap();
    assert!(mine.push_bookmark("origin", "feat", false).unwrap().iter().all(|r| r.ok));
    let csrf = csrf_of(&get(app, "/andy/demo/proposals/new?source=bob/demo:feat", Some(&bob)).await.body);
    let r =
        post(app, "/andy/demo/proposals/new", Some(&bob), &format!("_csrf={csrf}&title=From+my+fork&target=main&source=bob%2Fdemo%3Afeat"))
            .await;
    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);
    let p = get(app, &r.location.unwrap(), Some(&andy)).await;
    assert!(p.body.contains("From my fork") && p.body.contains("fork bob/demo"), "{}", p.body);
    let files = get(app, "/andy/demo/proposal/1?tab=files", Some(&andy)).await;
    assert!(files.body.contains("feature.txt"), "{}", files.body);
}

#[tokio::test(flavor = "multi_thread")]
async fn stars_topics_and_explore() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let bob = register(app, "bob").await;
    for (name, desc) in [("alpha", "An emulator"), ("beta", "A compiler"), ("gamma", "Retro games")] {
        app.repos.create(&RepoName::parse(&format!("andy/{name}")).unwrap(), None).unwrap();
        db::repos::create(&app.db, "andy", name, desc, hub_api::Visibility::Public).await.unwrap();
    }

    // Topics through settings; bad ones are refused.
    let csrf = csrf_of(&get(app, "/andy/gamma/settings", Some(&andy)).await.body);
    let r = post(
        app,
        "/andy/gamma/settings",
        Some(&andy),
        &format!("_csrf={csrf}&description=Retro+games&default_bookmark=main&visibility=public&topics=c%2B%2B"),
    )
    .await;
    assert!(r.body.contains("is not a topic"), "{}", r.body);
    let r = post(
        app,
        "/andy/gamma/settings",
        Some(&andy),
        &format!("_csrf={csrf}&description=Retro+games&default_bookmark=main&visibility=public&topics=Retro%2C+6502"),
    )
    .await;
    assert!(r.body.contains("Saved"), "{}", r.body);
    assert_eq!(db::repos::get(&app.db, "andy", "gamma").await.unwrap().unwrap().topics, "retro 6502");
    let page = get(app, "/andy/gamma", None).await;
    assert!(page.body.contains(r#"href="/explore?topic=retro""#), "{}", page.body);

    // Stars: bob stars beta and gamma, andy stars gamma; toggling unstars.
    for (who, repo) in [(&bob, "beta"), (&bob, "gamma"), (&andy, "gamma"), (&andy, "alpha")] {
        let csrf = csrf_of(&get(app, &format!("/andy/{repo}"), Some(who)).await.body);
        assert_eq!(post(app, &format!("/andy/{repo}/star"), Some(who), &format!("_csrf={csrf}")).await.status, StatusCode::SEE_OTHER);
    }
    let csrf = csrf_of(&get(app, "/andy/alpha", Some(&andy)).await.body);
    post(app, "/andy/alpha/star", Some(&andy), &format!("_csrf={csrf}")).await;
    assert!(get(app, "/andy/gamma", Some(&bob)).await.body.contains("★ UNSTAR"));
    assert!(get(app, "/andy/gamma", None).await.body.contains("★ 2"));
    assert!(get(app, "/andy/alpha", None).await.body.contains("★ 0"), "unstarred again");

    // Explore: sort by stars, by name, filter by text and by topic.
    let order = |b: &str| {
        ["alpha", "beta", "gamma"]
            .into_iter()
            .map(|n| (b.find(&format!("/andy/{n}\"")).unwrap_or(usize::MAX), n))
            .collect::<std::collections::BTreeMap<_, _>>()
            .into_values()
            .collect::<Vec<_>>()
    };
    assert_eq!(order(&get(app, "/explore?sort=stars", None).await.body)[..2], ["gamma", "beta"]);
    assert_eq!(order(&get(app, "/explore?sort=name", None).await.body), ["alpha", "beta", "gamma"]);
    let filtered = get(app, "/explore?q=compiler", None).await.body;
    assert!(filtered.contains("/andy/beta\"") && !filtered.contains("/andy/alpha\""), "{filtered}");
    let by_topic = get(app, "/explore?topic=6502", None).await.body;
    assert!(by_topic.contains("/andy/gamma\"") && !by_topic.contains("/andy/beta\""), "{by_topic}");
}

#[tokio::test(flavor = "multi_thread")]
async fn lists_filter_sort_page_and_count() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let _bob = register(app, "bob").await;
    app.repos.create(&RepoName::parse("andy/demo").unwrap(), None).unwrap();
    let repo = db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();
    for n in 0..30 {
        let author = if n % 3 == 0 { "bob" } else { "andy" };
        db::issues::create(
            &app.db,
            db::issues::NewIssue { repo_id: repo.id, title: &format!("Issue number {n}"), body: "", author_id: None, author },
        )
        .await
        .unwrap();
    }
    let ui = db::issues::upsert_label(&app.db, repo.id, "ui", "#00f0ff", "").await.unwrap();
    for (title, author, target) in [("Faster menus", "bob", "main"), ("New theme", "andy", "main"), ("Release prep", "andy", "stable")] {
        let p = db::proposals::create(
            &app.db,
            db::proposals::NewProposal {
                repo_id: repo.id,
                title,
                body: "",
                author_id: None,
                author,
                draft: false,
                target,
                source_kind: "changes",
                source_repo_id: None,
                source_bookmark: "",
                source_changes: "",
            },
        )
        .await
        .unwrap();
        if title == "New theme" {
            db::issues::set_proposal_label(&app.db, p.id, ui.id, true).await.unwrap();
        }
    }

    // The tabs count what is open.
    let page = get(app, "/andy/demo/issues", Some(&andy)).await;
    assert!(page.body.contains(r#"Issues <span class="count-chip">30</span>"#), "{}", page.body);
    assert!(page.body.contains(r#"Proposals <span class="count-chip">3</span>"#));

    // Pages of 25, newest first; the second page holds the rest.
    let rows = |b: &str| b.matches("/andy/demo/issue/").count();
    assert_eq!(rows(&page.body), 25);
    assert!(page.body.contains("page 1 of 2") && page.body.contains("page=2"), "a pager");
    let second = get(app, "/andy/demo/issues?page=2", Some(&andy)).await;
    assert_eq!(rows(&second.body), 5);
    assert!(second.body.contains("Issue number 0<"), "the oldest are last");
    let oldest = get(app, "/andy/demo/issues?sort=oldest", Some(&andy)).await;
    assert!(oldest.body.find("Issue number 0<").unwrap() < oldest.body.find("Issue number 1<").unwrap());
    let bobs = get(app, "/andy/demo/issues?q=author:bob", Some(&andy)).await;
    assert_eq!(rows(&bobs.body), 10, "{}", bobs.body);

    // Proposals: by author, label and target.
    let by_bob = get(app, "/andy/demo/proposals?q=author:bob", Some(&andy)).await.body;
    assert!(by_bob.contains("Faster menus") && !by_bob.contains("New theme"));
    let ui_only = get(app, "/andy/demo/proposals?q=label:ui", Some(&andy)).await.body;
    assert!(ui_only.contains("New theme") && !ui_only.contains("Faster menus") && ui_only.contains(r#"class="label""#));
    let stable = get(app, "/andy/demo/proposals?q=target:stable", Some(&andy)).await.body;
    assert!(stable.contains("Release prep") && !stable.contains("New theme"));
}

#[tokio::test(flavor = "multi_thread")]
async fn project_boards() {
    let h = hub().await;
    let app = &h.app;
    let andy = register(app, "andy").await;
    let bob = register(app, "bob").await;
    for (name, vis) in [("demo", hub_api::Visibility::Public), ("secret", hub_api::Visibility::Private)] {
        app.repos.create(&RepoName::parse(&format!("andy/{name}")).unwrap(), None).unwrap();
        let row = db::repos::create(&app.db, "andy", name, "", vis).await.unwrap();
        db::issues::create(
            &app.db,
            db::issues::NewIssue { repo_id: row.id, title: &format!("{name} issue"), body: "", author_id: None, author: "andy" },
        )
        .await
        .unwrap();
    }
    let csrf = csrf_of(&get(app, "/projects/andy", Some(&andy)).await.body);
    let r = post(app, "/projects/andy", Some(&andy), &format!("_csrf={csrf}&title=Roadmap&description=Next+steps")).await;
    assert_eq!(r.location.as_deref(), Some("/projects/andy/1"), "{}", r.body);
    let board = get(app, "/projects/andy/1", Some(&andy)).await.body;
    for col in ["Backlog", "Doing", "Done"] {
        assert!(board.contains(&format!(">{col} <span")), "{col}");
    }
    let cols: Vec<i64> = sqlx::query_scalar("SELECT id FROM project_columns ORDER BY position").fetch_all(&app.db).await.unwrap();
    let act = |form: String| {
        let andy = andy.clone();
        async move { post(app, "/projects/andy/1", Some(&andy), &form).await }
    };
    // Cards: by reference, by repository and number, a note; duplicates and strangers refused.
    assert_eq!(
        act(format!("_csrf={csrf}&action=add&column={}&reference=demo%231", cols[0])).await.location.as_deref(),
        Some("/projects/andy/1")
    );
    act(format!("_csrf={csrf}&action=add&column={}&repo=secret&reference=%231", cols[0])).await;
    act(format!("_csrf={csrf}&action=add&column={}&note=Write+the+docs", cols[1])).await;
    assert!(act(format!("_csrf={csrf}&action=add&column={}&reference=demo%231", cols[1])).await.body.contains("already on this project"));
    assert!(act(format!("_csrf={csrf}&action=add&column={}&reference=demo%2399", cols[0])).await.body.contains("no issue or proposal #99"));
    assert!(act(format!("_csrf={csrf}&action=add&column={}&reference=nothere%231", cols[0])).await.body.contains("no repository nothere"));
    // Move demo#1 to Done.
    let demo_card: i64 =
        sqlx::query_scalar("SELECT c.id FROM project_cards c JOIN repositories r ON r.id = c.repo_id WHERE r.name = 'demo'")
            .fetch_one(&app.db)
            .await
            .unwrap();
    act(format!("_csrf={csrf}&action=move&card={demo_card}&column={}", cols[2])).await;
    let issue = get(app, "/andy/demo/issue/1", None).await.body;
    assert!(issue.contains("href=\"/projects/andy/1\">Roadmap</a> <span class=\"mute\">· Done"), "the issue shows where it is");

    // Readers see public cards, never those of repositories they cannot read.
    let anon = get(app, "/projects/andy/1", None).await.body;
    assert!(anon.contains("demo issue") && anon.contains("Write the docs") && !anon.contains("secret issue"), "{anon}");
    assert!(!anon.contains("name=\"action\""), "and cannot change anything");
    assert!(get(app, "/projects/andy/1", Some(&andy)).await.body.contains("secret issue"));
    // Only the owner changes it; a private project is invisible to others.
    let csrf_b = csrf_of(&get(app, "/settings", Some(&bob)).await.body);
    assert_eq!(
        post(app, "/projects/andy/1", Some(&bob), &format!("_csrf={csrf_b}&action=remove&card={demo_card}")).await.status,
        StatusCode::NOT_FOUND
    );
    act(format!("_csrf={csrf}&action=settings&title=Roadmap&description=&private=1")).await;
    assert_eq!(get(app, "/projects/andy/1", Some(&bob)).await.status, StatusCode::NOT_FOUND);
    assert!(!get(app, "/projects/andy", None).await.body.contains("Roadmap"), "not even listed");
    assert!(!get(app, "/andy/demo/issue/1", None).await.body.contains("Roadmap"), "nor on the issue");

    // Columns: removing one moves its cards to the first column; the last one stays.
    act(format!("_csrf={csrf}&action=remove_column&column={}", cols[1])).await;
    let note_col: i64 = sqlx::query_scalar("SELECT column_id FROM project_cards WHERE kind = 'note'").fetch_one(&app.db).await.unwrap();
    assert_eq!(note_col, cols[0]);
    act(format!("_csrf={csrf}&action=remove_column&column={}", cols[2])).await;
    assert!(act(format!("_csrf={csrf}&action=remove_column&column={}", cols[0])).await.body.contains("at least one column"));
    // Closed projects are read-only until reopened; then deleted, the issues remain.
    act(format!("_csrf={csrf}&action=settings&title=Roadmap&closed=1")).await;
    assert!(act(format!("_csrf={csrf}&action=add&column={}&note=late", cols[0])).await.body.contains("This project is closed"));
    let r = act(format!("_csrf={csrf}&action=delete")).await;
    assert_eq!(r.location.as_deref(), Some("/projects/andy"));
    assert_eq!(get(app, "/projects/andy/1", Some(&andy)).await.status, StatusCode::NOT_FOUND);
    assert_eq!(get(app, "/andy/demo/issue/1", None).await.status, StatusCode::OK);
    assert_eq!(get(app, "/projects/nobody", None).await.status, StatusCode::NOT_FOUND);
}