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

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

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

    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&setup=test-setup"),

    )

    .await;

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

    r.cookie.unwrap()

}

/// A repository settings form's answer (#278): a redirect to the page that

/// holds the form, followed.

async fn settled(app: &Shared, r: Res, cookie: Option<&str>, page: &str) -> Res {

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

    let to = r.location.expect("a redirect");

    assert!(to.starts_with(&format!("{page}?")), "{to} is not {page}");

    get(app, &to, cookie).await

}

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

    // The inbox's thread counts it unread (the SQL is portable now:

    // oxygenhub#211).

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

    let filter = db::notify::Filter { done: false, unread_only: false, reason: None, kind: None, repo_id: None };

    let t = db::notify::threads(&app.db, bob_id, &filter, 10).await.unwrap();

    assert_eq!((t[0].count, t[0].unread), (1, 1));

    let unread_only = db::notify::Filter { unread_only: true, ..filter.clone() };

    assert_eq!(db::notify::threads(&app.db, bob_id, &unread_only, 10).await.unwrap().len(), 1);

    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("<li><a href=\"/bob\"><img class=\"avatar xs\""), "{}", r.body);

    // oxygenhub#82: the sidebar's menu sets the whole list at once.

    assert!(r.body.contains("Assign people to this issue") && r.body.contains("data-menu-filter"), "the assignees menu");

    let r = post(app, "/andy/demo/issue/1/assign", Some(&andy), &format!("_csrf={csrf_a}&action=set&username=andy&username=bob")).await;

    let assigned = |db: oxygenhub::db::Pool| async move {

        let id: i64 = sqlx::query_scalar("SELECT id FROM issues WHERE number = 1").fetch_one(&db).await.unwrap();

        let mut a = db::issues::assignees(&db, id).await.unwrap();

        a.sort();

        a

    };

    assert_eq!(assigned(app.db.clone()).await, ["andy", "bob"], "{}", r.status);

    post(app, "/andy/demo/issue/1/assign", Some(&andy), &format!("_csrf={csrf_a}&action=set&username=bob")).await;

    assert_eq!(assigned(app.db.clone()).await, ["bob"], "set takes off who is not listed");

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

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

    // The push hook closes it after the push answers: wait, up to ten seconds (#121).

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

    let mut issue2 = db::issues::get(&app.db, repo_id, 2).await.unwrap().unwrap();

    for _ in 0..200 {

        if issue2.state == "closed" {

            break;

        }

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

        issue2 = db::issues::get(&app.db, repo_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);

    // `#N` in a pushed change's message lands on those timelines (hub spec §8).

    client.bookmark_switch("main", false).unwrap();

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

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

    let r = client.commit("Tidy up (refs #1, see #3)", &[]).unwrap();

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

    let short = &r.to_hex()[..12];

    // The push hook records the references after the push answers: wait, up

    // to ten seconds (#121).

    let mut one = get(app, "/andy/demo/issue/1", None).await.body;

    for _ in 0..200 {

        if one.contains("referenced by change") {

            break;

        }

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

        one = get(app, "/andy/demo/issue/1", None).await.body;

    }

    assert!(

        one.contains("referenced by change") && one.contains(&format!("href=\"/andy/demo/change/{short}\"")) && one.contains(" on main"),

        "{one}"

    );

    let three = get(app, "/andy/demo/proposal/3", Some(&andy)).await.body;

    assert!(three.contains("referenced by change") && three.contains(short), "proposals too");

    assert!(!get(app, "/andy/demo/issue/2", None).await.body.contains("referenced by change"), "a closing change records only that");

    // #318: the same change pushed on another bookmark is no new reference.

    client.bookmark_create("again", None).unwrap();

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

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

    let recorded: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM issue_events WHERE event = 'referenced by change' AND detail LIKE $1")

        .bind(format!("{short} %"))

        .fetch_one(&app.db)

        .await

        .unwrap();

    assert_eq!(recorded, 1, "once per change, whichever bookmarks it is on");

    // #292: many references on one day are one box, wrapping, the newest

    // day's open; a lone one stays a line.

    let issue1 = db::issues::get(&app.db, repo_id, 1).await.unwrap().unwrap();

    let day = 1_792_540_800_000i64; // 21 Oct 2026, 00:00 UTC

    for (i, at) in [day + 1_000, day + 2_000, day + 3_000, day - 86_400_000].into_iter().enumerate() {

        sqlx::query("INSERT INTO issue_events (issue_id, at_ms, actor, event, detail) VALUES ($1, $2, 'andy', 'referenced by change', $3)")

            .bind(issue1.id)

            .bind(at)

            .bind(format!("{:012x} on main", 0xabc000 + i))

            .execute(&app.db)

            .await

            .unwrap();

    }

    // One recorded again for another bookmark before #318: shown once.

    sqlx::query("INSERT INTO issue_events (issue_id, at_ms, actor, event, detail) VALUES ($1, $2, 'andy', 'referenced by change', $3)")

        .bind(issue1.id)

        .bind(day + 4_000)

        .bind(format!("{:012x} on develop", 0xabc000))

        .execute(&app.db)

        .await

        .unwrap();

    let one = get(app, "/andy/demo/issue/1", None).await.body;

    assert!(one.contains("referenced by 3 changes on 21 Oct 2026"), "{one}");

    assert_eq!(one.matches(&format!("change/{:012x}\"", 0xabc000)).count(), 1, "each change once");

    assert!(!one.contains("mute timeline"), "the events have no rule of their own (#318)");

    assert!(one.contains("refs-day\" open><summary>referenced by 3 changes"), "the newest box is open: {one}");

    assert!(!one.contains("changes on 20 Oct 2026"), "a lone reference is a line");

    assert!(one.contains(&format!("href=\"/andy/demo/change/{short}\"")), "today's own stays");

    // 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 = $1 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;