//! The projects screen, driven through the router against a real database.
//!
//! No Tauri runtime and no window: a route is a function from state and params
//! to a description, which is the property that makes the router testable at
//! all. What is asserted here is the description, and the markup only where the
//! markup is the point.

use std::sync::Arc;

use goingson_core::{NewProject, ProjectStatus, ProjectType};
use quasi_http::Serves as _;
use quasi_router::Outcome;
use quasi_router::{Params, Request, Response};

use super::super::{protocol, router};
use crate::state::{AppState, DESKTOP_USER_ID};

/// State with the desktop user in place, which is who the handlers read as.
async fn state() -> Arc<AppState> {
    let (state, _) = crate::test_utils::setup_test_state().await;
    let now = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S").to_string();
    state
        .db
        .conn()
        .unwrap()
        .execute(
            "INSERT OR IGNORE INTO users (id, email, password_hash, display_name, created_at) \
             VALUES (?, ?, ?, ?, ?)",
            rusqlite::params![
                DESKTOP_USER_ID.to_string(),
                "desktop@localhost",
                "x",
                "Desktop User",
                &now,
            ],
        )
        .unwrap();
    state
}

fn add(state: &AppState, name: &str, status: ProjectStatus) -> goingson_core::Project {
    state
        .projects
        .create(
            DESKTOP_USER_ID,
            NewProject {
                name: name.to_owned(),
                description: String::new(),
                project_type: ProjectType::SideProject,
                status,
            },
        )
        .unwrap()
}

fn answer(state: &AppState, path: &str, params: Params) -> Response {
    router()
        .handle(state, Request::get(path).carrying(params))
        .expect("the route answers")
}

/// A write, which is the shape every action on this screen arrives in.
fn post(state: &AppState, path: &str, params: Params) -> Response {
    router()
        .handle(state, Request::post(path).sending(params))
        .expect("the route answers")
}

/// A write made from a filtered view: what the control sent, and where it was
/// sent from. The two never merge, which is why a screen may filter on the same
/// name it writes.
fn viewing_post(state: &AppState, path: &str, carried: Params) -> Response {
    router()
        .handle(state, Request::post(path).carrying(carried))
        .expect("the route answers")
}

/// The four the create form asks for.
///
/// Every value spelled out at each call site rather than overridden on top of a
/// valid default: `Params::get` answers with the *first* value under a name, so
/// a `.with("status", ...)` after a valid one is silently ignored and the test
/// passes for the wrong reason.
fn a_project(name: &str, project_type: &str, status: &str) -> Params {
    Params::new()
        .with("name", name)
        .with("description", "")
        .with("project_type", project_type)
        .with("status", status)
}

/// A valid submission.
fn valid(name: &str) -> Params {
    a_project(name, "SideProject", "Active")
}

#[tokio::test]
async fn an_empty_database_says_so_as_a_stand_in_with_a_way_out() {
    // `703f4cd2`. This asserted a bare line of text until 2026-08-09, because
    // nothing named an empty state and the description had only `Node::text` to
    // say it with. `Node::StandIn` is what changed.
    let state = state().await;
    let Outcome::Screen(screen) = answer(&state, "/projects", Params::new()).outcome else {
        panic!("the index answers with a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);

    assert!(html.contains("No projects yet."));
    assert!(html.contains(r#"data-state="empty""#));
    // Not a fault: an empty database is the normal state of a new install.
    assert!(!html.contains(r#"role="alert""#));
    // The way out, which is the half `Node::text` could never carry.
    assert!(html.contains("Create your first project"));
    assert!(html.contains("hx-get=\"/projects/new"));
}

#[tokio::test]
async fn deleting_a_project_asks_first() {
    // `524a63fe`. The JS confirms through `confirmDelete` and the described
    // screen did not, so the description was worse than what it replaces on
    // the one path where that matters most.
    let state = state().await;
    let project = add(&state, "Doomed", ProjectStatus::Active);

    let Outcome::Fragment { node, .. } =
        answer(&state, &format!("/projects/{}", project.id), Params::new()).outcome
    else {
        panic!("the detail pane answers with a fragment");
    };
    let html = quasi_webview::Webview::new().fragment(&node);

    assert!(html.contains("Delete project"));
    assert!(html.contains("hx-confirm=\"Are you sure you want to delete this project?"));
}

#[tokio::test]
async fn the_grid_lists_live_projects_and_holds_the_retired_ones_back() {
    let state = state().await;
    add(&state, "Live one", ProjectStatus::Active);
    add(&state, "Paused", ProjectStatus::OnHold);
    add(&state, "Finished", ProjectStatus::Completed);

    let Outcome::Screen(screen) = answer(&state, "/projects", Params::new()).outcome else {
        panic!("a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);

    assert!(html.contains("Live one"));
    assert!(html.contains("Paused"));
    assert!(!html.contains("Finished"));
    // The control that reveals them names how many there are, which is what
    // `projects.js` puts on its retired toggle.
    assert!(html.contains("Show 1 completed or archived"));
}

#[tokio::test]
async fn the_retired_toggle_is_an_address_not_a_piece_of_module_state() {
    let state = state().await;
    add(&state, "Finished", ProjectStatus::Completed);

    let shown = answer(&state, "/projects", Params::new().with("retired", "1"));
    let Outcome::Screen(screen) = shown.outcome else {
        panic!("a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);
    assert!(html.contains("Finished"));
    assert!(html.contains("Hide completed and archived"));
}

#[tokio::test]
async fn a_filter_toggle_swaps_the_grid_alone() {
    let state = state().await;
    add(&state, "Live one", ProjectStatus::Active);

    let response = answer(&state, "/projects/list", Params::new());
    // Decision 7: the response names the region, so the whole document is not
    // reflowed to change one pane.
    assert_eq!(response.target(), Some("projects-grid"));

    let Outcome::Fragment { node, .. } = (response).outcome else {
        panic!("a fragment");
    };
    let html = quasi_webview::Webview::new().fragment(&node);
    assert!(html.starts_with("<ul"));
    assert!(!html.contains("<html"));
    assert!(html.contains("Live one"));
}

#[tokio::test]
async fn the_shared_filter_appears_only_when_sharing_is_in_play() {
    let state = state().await;
    add(&state, "Mine", ProjectStatus::Active);

    let Outcome::Screen(screen) = answer(&state, "/projects", Params::new()).outcome else {
        panic!("a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);
    assert!(!html.contains("Shared only"));

    // Asking for the filtered view surfaces the control even with nothing
    // shared, so the way back is always on screen. Same rule as `projects.js`.
    let Outcome::Screen(screen) =
        answer(&state, "/projects", Params::new().with("shared", "1")).outcome
    else {
        panic!("a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);
    assert!(html.contains("Shared only"));
    assert!(html.contains("No shared projects yet."));
}

#[tokio::test]
async fn a_row_carries_both_badges_as_tokens_and_keeps_the_status_tone() {
    // Was `a_row_carries_both_badges_as_one_trailing_fact`, which asserted the
    // workaround: "Side Project · On Hold" joined into `meta`, and
    // `!html.contains("warning")` pinning down the loss. makeover-layout
    // 0.9.0's `RowPart::Tokens` is what this screen's finding asked for, and
    // this is the assertion inverted.
    let state = state().await;
    add(&state, "Mine", ProjectStatus::OnHold);

    let Outcome::Fragment { node, .. } = answer(&state, "/projects/list", Params::new()).outcome
    else {
        panic!("a fragment");
    };
    let html = quasi_webview::Webview::new().fragment(&node);

    assert!(html.contains("class=\"row-tokens\""));
    assert!(html.contains("Side Project"));
    assert!(html.contains("On Hold"));
    // The thing the join could not keep. `utils.js:statusTone` maps OnHold to
    // warning, and now so does the description.
    // `data-tone`, not a `tone-warning` class. quasi@f287ac1 stopped emitting
    // the class names, because makeover defines none of them: its whole
    // vocabulary keys tone off the attribute, so a toned thing wearing a class
    // rendered untoned.
    assert!(html.contains("data-tone=\"warning\""));
    assert!(!html.contains("Side Project · On Hold"));
}

#[tokio::test]
async fn only_the_status_badge_is_toned() {
    // A type is not news and takes no tone, which is what keeps a row from
    // being a row of colours. Archived is the same case on the status side:
    // `statusTone` returns nothing for it deliberately.
    let state = state().await;
    add(&state, "Done", ProjectStatus::Archived);

    let Outcome::Fragment { node, .. } =
        answer(&state, "/projects/list", Params::new().with("retired", "1")).outcome
    else {
        panic!("a fragment");
    };
    let html = quasi_webview::Webview::new().fragment(&node);

    assert!(html.contains("Archived"));
    assert!(!html.contains("tone-"));
}

#[tokio::test]
async fn selecting_a_row_addresses_the_detail_pane() {
    let state = state().await;
    let project = add(&state, "Mine", ProjectStatus::Active);

    let Outcome::Fragment { node, .. } = answer(&state, "/projects/list", Params::new()).outcome
    else {
        panic!("a fragment");
    };
    let html = quasi_webview::Webview::new().fragment(&node);
    assert!(html.contains(&format!("hx-get=\"/projects/{}\"", project.id)));

    let response = answer(&state, &format!("/projects/{}", project.id), Params::new());
    assert_eq!(response.target(), Some("projects-detail"));
}

#[tokio::test]
async fn a_missing_project_is_a_not_found_rather_than_a_panic() {
    let state = state().await;
    let error = router()
        .handle(
            &state,
            Request::get(format!("/projects/{}", uuid::Uuid::nil())),
        )
        .expect_err("no such project");
    assert_eq!(error.class.http_status(), 404);
}

#[tokio::test]
async fn a_project_name_cannot_become_markup() {
    // The reason the description carries text and the renderer owns escaping.
    // A project name is user input and goes through the same door as everything
    // else.
    let state = state().await;
    add(&state, "<script>alert(1)</script>", ProjectStatus::Active);

    let Outcome::Screen(screen) = answer(&state, "/projects", Params::new()).outcome else {
        panic!("a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);
    assert!(!html.contains("<script>alert"));
    assert!(html.contains("&lt;script&gt;"));
}

#[tokio::test]
async fn the_two_described_writes_reach_a_handler() {
    // The standard the contacts port set, and what this screen was short of:
    // "New project" and "Delete project" were described controls calling routes
    // that were never registered, so the screen said it could do two things it
    // could not.
    let state = state().await;
    let project = add(&state, "Mine", ProjectStatus::Active);

    let Outcome::Screen(screen) = answer(&state, "/projects", Params::new()).outcome else {
        panic!("a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);
    assert!(html.contains("hx-get=\"/projects/new\""));

    let Outcome::Fragment { node, .. } =
        answer(&state, &format!("/projects/{}", project.id), Params::new()).outcome
    else {
        panic!("a fragment");
    };
    let html = quasi_webview::Webview::new().fragment(&node);
    assert!(html.contains(&format!("hx-post=\"/projects/{}/delete\"", project.id)));

    // Both answer rather than 404, which is the whole claim.
    answer(&state, "/projects/new", Params::new());
    post(
        &state,
        &format!("/projects/{}/delete", project.id),
        Params::new(),
    );
}

#[tokio::test]
async fn the_create_form_asks_what_the_modal_asks() {
    let state = state().await;
    let Outcome::Fragment { node, .. } = answer(&state, "/projects/new", Params::new()).outcome
    else {
        panic!("a fragment");
    };
    let html = quasi_webview::Webview::new().fragment(&node);

    assert!(html.contains("hx-post=\"/projects\""));
    for field in ["name", "description", "project_type", "status"] {
        assert!(
            html.contains(&format!("name=\"{field}\"")),
            "{field} is asked"
        );
    }
    // A project cannot be created finished, which is `projects.js` slicing its
    // status list to the first two on create.
    assert!(html.contains("value=\"OnHold\""));
    assert!(!html.contains("value=\"Archived\""));
}

#[tokio::test]
async fn creating_a_project_puts_it_in_the_grid() {
    let state = state().await;
    let Outcome::Screen(screen) = post(&state, "/projects", valid("Made here")).outcome else {
        panic!("a write answers with the whole screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);
    assert!(html.contains("Made here"));
    // The pane the form was in goes back to saying nothing is selected, which is
    // the half a grid-only fragment would have left stale.
    assert!(html.contains("Nothing selected"));
}

#[tokio::test]
async fn a_rejected_form_names_what_is_wrong_and_offers_back_what_was_typed() {
    // The fourth finding, closed. It was asserted here in its broken form until
    // 2026-08-09 — the too-long name was reported and then thrown away, and the
    // user retyped it to shorten it. `Field::refilled` is what changed, and this
    // test changing is what says the finding closed. `1c4a66a4`.
    let state = state().await;
    let long = "x".repeat(101);

    let Outcome::Fragment { node, .. } = post(&state, "/projects", valid(&long)).outcome else {
        panic!("a refusal answers with the form, not the screen");
    };
    let html = quasi_webview::Webview::new().fragment(&node);

    assert!(html.contains("Maximum 100 characters"));
    assert!(html.contains("aria-invalid=\"true\""));
    // What the finding was about: the name comes back in the box it was typed
    // in, so shortening it is an edit rather than a retype.
    assert!(html.contains(&format!("value=\"{long}\"")));
    // The select keeps what was chosen too, which is the same fact in the other
    // control the form offers.
    assert!(html.contains("value=\"SideProject\" selected"));

    // And nothing was written.
    assert!(state.projects.list_all(DESKTOP_USER_ID).unwrap().is_empty());
}

#[tokio::test]
async fn a_nameless_project_is_refused_rather_than_created_blank() {
    let state = state().await;
    let Outcome::Fragment { .. } = post(&state, "/projects", valid("   ")).outcome else {
        panic!("a refusal");
    };
    assert!(state.projects.list_all(DESKTOP_USER_ID).unwrap().is_empty());
}

#[tokio::test]
async fn a_value_no_option_offered_is_refused_rather_than_defaulted() {
    // `from_str_or_default` is what the rest of goingson reads enums with, and
    // it would file this as an `Other` project and say nothing.
    let state = state().await;
    let params = a_project("Mine", "Sculpture", "Active");

    let Outcome::Fragment { node, .. } = post(&state, "/projects", params).outcome else {
        panic!("a refusal");
    };
    let html = quasi_webview::Webview::new().fragment(&node);
    assert!(html.contains("Not one of the options offered."));
    assert!(state.projects.list_all(DESKTOP_USER_ID).unwrap().is_empty());

    // A status that parses but is not on offer is refused on the same grounds.
    let params = a_project("Mine", "SideProject", "Archived");
    let Outcome::Fragment { node, .. } = post(&state, "/projects", params).outcome else {
        panic!("a refusal");
    };
    let html = quasi_webview::Webview::new().fragment(&node);
    assert!(html.contains("Not a status a project starts in."));
    assert!(state.projects.list_all(DESKTOP_USER_ID).unwrap().is_empty());
}

#[tokio::test]
async fn deleting_a_project_takes_it_out_of_the_grid_and_empties_the_pane() {
    let state = state().await;
    let project = add(&state, "Going", ProjectStatus::Active);
    add(&state, "Staying", ProjectStatus::Active);

    let Outcome::Screen(screen) = post(
        &state,
        &format!("/projects/{}/delete", project.id),
        Params::new(),
    )
    .outcome
    else {
        panic!("a write answers with the whole screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);

    assert!(!html.contains("Going"));
    assert!(html.contains("Staying"));
    // The reason a write does not answer with the grid alone: the pane would
    // still be offering to delete something that is gone.
    assert!(html.contains("Nothing selected"));
    assert!(!html.contains(&format!("/projects/{}/delete", project.id)));
}

#[tokio::test]
async fn deleting_something_that_is_not_there_is_a_not_found() {
    let state = state().await;
    let error = router()
        .handle(
            &state,
            Request::post(format!("/projects/{}/delete", uuid::Uuid::nil())),
        )
        .expect_err("no such project");
    assert_eq!(error.class.http_status(), 404);
}

#[tokio::test]
async fn an_action_carries_the_filters_it_was_offered_under() {
    // The filters are the only state this screen has, and they live in the
    // address. A control that dropped them would be a filtered view you fall
    // out of by using it.
    let state = state().await;
    let project = add(&state, "Finished", ProjectStatus::Completed);
    let retired = Params::new().with("retired", "1");

    let Outcome::Screen(screen) = answer(&state, "/projects", retired.clone()).outcome else {
        panic!("a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);
    // On the address, because the filters are the view rather than something a
    // control sends. A write's own values still travel in `hx-vals`, and that
    // separation is what stops a screen reading its own payload back as its
    // filters.
    assert!(html.contains("hx-get=\"/projects/new?retired=1\""));
    assert!(html.contains(&format!("hx-get=\"/projects/{}?retired=1\"", project.id)));

    let Outcome::Fragment { node, .. } =
        answer(&state, &format!("/projects/{}", project.id), retired).outcome
    else {
        panic!("a fragment");
    };
    let html = quasi_webview::Webview::new().fragment(&node);
    assert!(html.contains(&format!(
        "hx-post=\"/projects/{}/delete?retired=1\"",
        project.id
    )));
}

#[tokio::test]
async fn a_write_answers_under_the_filters_it_carried() {
    let state = state().await;
    add(&state, "Finished", ProjectStatus::Completed);
    let doomed = add(&state, "Going", ProjectStatus::Completed);

    let Outcome::Screen(screen) = viewing_post(
        &state,
        &format!("/projects/{}/delete", doomed.id),
        Params::new().with("retired", "1"),
    )
    .outcome
    else {
        panic!("a screen");
    };
    let html = quasi_webview::Webview::new().screen(&screen);

    // Still showing retired projects afterwards. Dropping the filter here is
    // how a delete reads as having emptied the grid.
    assert!(html.contains("Finished"));
    assert!(html.contains("Hide completed and archived"));
}

#[tokio::test]
async fn the_protocol_serves_the_screen_from_its_own_scheme() {
    let state = state().await;
    add(&state, "Mine", ProjectStatus::Active);

    let (served, late) = protocol();
    assert_eq!(served.url().scheme(), "quasi");

    // The state arrives after the builder has already taken the protocol, so
    // the handle is the only way in. See `quasi::protocol`.
    assert!(!late.is_set());
    assert!(late.set(state));
}

#[tokio::test]
async fn a_card_says_what_its_description_says_rather_than_how_it_is_written() {
    // The second finding's tail. A row part holds a string, which the
    // 2026-08-08 ruling settles and this does not reopen; the question is which
    // string, and it used to be the markdown source, so the row showed its
    // syntax and spent its width on a URL it cannot follow.
    let state = state().await;
    state
        .projects
        .create(
            DESKTOP_USER_ID,
            NewProject {
                name: "Atlas".to_owned(),
                description: "**Ships Q3.** See [the brief](https://example.com/very/long/path)."
                    .to_owned(),
                project_type: ProjectType::SideProject,
                status: ProjectStatus::Active,
            },
        )
        .unwrap();

    let Outcome::Screen(screen) = answer(&state, "/projects", Params::new()).outcome else {
        panic!("the index answers with a screen");
    };
    let page = quasi_webview::Webview::new().screen(&screen);

    // The description layer says "this is markdown" and the webview draws it:
    // emphasis kept, the anchor dropped because the row is already the target.
    assert!(page.contains("<strong>Ships Q3.</strong>"));
    assert!(page.contains("See the brief."));
    assert!(!page.contains("**Ships Q3.**"));
    assert!(!page.contains("example.com"));
}

#[tokio::test]
async fn a_cards_description_is_one_line() {
    // A row is one line tall, so block structure is noise here even though it
    // is exactly what a document wants.
    let state = state().await;
    state
        .projects
        .create(
            DESKTOP_USER_ID,
            NewProject {
                name: "Borealis".to_owned(),
                description: "# Goal\n\nShip it.\n\n- one\n- two".to_owned(),
                project_type: ProjectType::SideProject,
                status: ProjectStatus::Active,
            },
        )
        .unwrap();

    let Outcome::Screen(screen) = answer(&state, "/projects", Params::new()).outcome else {
        panic!("the index answers with a screen");
    };
    let page = quasi_webview::Webview::new().screen(&screen);

    let secondary = page
        .split_once(r#"<span class="row-secondary">"#)
        .expect("the card draws its description")
        .1
        .split_once("</span>")
        .expect("the part closes")
        .0;
    for block in ["<h1", "<ul", "<li", "<p"] {
        assert!(!secondary.contains(block), "no {block} in a row: {page}");
    }
    for word in ["Goal", "Ship it.", "one", "two"] {
        assert!(page.contains(word), "{word} survives: {page}");
    }
}

/// A project's scope, stamped the way `set_project_scope` stamps it.
///
/// Written straight rather than through `share_project`: that command awaits the
/// SyncKit client to confirm membership, and what is under test here is the two
/// halves that read and clear the column, neither of which talks to a server.
fn share_into(state: &AppState, project: &goingson_core::Project, group: &str) {
    crate::commands::group::set_project_scope(
        &state.db,
        DESKTOP_USER_ID,
        &project.id.to_string(),
        Some(group),
    )
    .unwrap();
}

fn scope_of(state: &AppState, project: &goingson_core::Project) -> Option<String> {
    state
        .db
        .conn()
        .unwrap()
        .query_row(
            "SELECT group_id FROM projects WHERE id = ?1",
            rusqlite::params![project.id.to_string()],
            |row| row.get(0),
        )
        .unwrap()
}

/// The filter shipped before the mark did, so a "Shared only" view was the only
/// way to tell which rows it would keep.
#[tokio::test]
async fn a_shared_project_says_so_in_the_list() {
    let state = state().await;
    let shared = add(&state, "Shared work", ProjectStatus::Active);
    add(&state, "Mine alone", ProjectStatus::Active);
    share_into(&state, &shared, "11111111-1111-1111-1111-111111111111");

    let Outcome::Screen(screen) = answer(&state, "/projects", Params::new()).outcome else {
        panic!("the index answers with a screen");
    };
    let page = quasi_webview::Webview::new().screen(&screen);
    assert!(page.contains("Shared"), "{page}");
}

#[tokio::test]
async fn a_personal_project_carries_no_shared_badge_and_no_way_out() {
    let state = state().await;
    let personal = add(&state, "Mine alone", ProjectStatus::Active);

    let Outcome::Fragment { node, .. } =
        answer(&state, &format!("/projects/{}", personal.id), Params::new()).outcome
    else {
        panic!("the detail pane answers with a fragment");
    };
    let pane = quasi_webview::Webview::new().fragment(&node);
    assert!(!pane.contains("Move back to personal"), "{pane}");
    assert!(!pane.contains("Shared into a group"), "{pane}");
}

#[tokio::test]
async fn a_shared_project_offers_the_way_back_to_personal() {
    let state = state().await;
    let shared = add(&state, "Shared work", ProjectStatus::Active);
    share_into(&state, &shared, "11111111-1111-1111-1111-111111111111");

    let Outcome::Fragment { node, .. } =
        answer(&state, &format!("/projects/{}", shared.id), Params::new()).outcome
    else {
        panic!("the detail pane answers with a fragment");
    };
    let pane = quasi_webview::Webview::new().fragment(&node);
    assert!(pane.contains("Move back to personal"), "{pane}");
    assert!(
        pane.contains(&format!("/projects/{}/unshare", shared.id)),
        "{pane}"
    );
}

#[tokio::test]
async fn unsharing_clears_the_scope_across_the_subtree() {
    let state = state().await;
    let shared = add(&state, "Shared work", ProjectStatus::Active);
    let group = "11111111-1111-1111-1111-111111111111";
    share_into(&state, &shared, group);

    let task = state
        .tasks
        .create(
            DESKTOP_USER_ID,
            goingson_core::NewTask::builder("Inside it")
                .project_id(shared.id)
                .build(),
        )
        .unwrap();
    // The create path stamps a child from its parent, which is what makes the
    // subtree worth re-checking after the clear.
    assert_eq!(
        scope_of_task(&state, &task).as_deref(),
        Some(group),
        "the child inherited the scope"
    );

    post(
        &state,
        &format!("/projects/{}/unshare", shared.id),
        Params::new(),
    );

    assert!(
        scope_of(&state, &shared).is_none(),
        "the project is personal"
    );
    assert!(
        scope_of_task(&state, &task).is_none(),
        "and so is everything in it"
    );
}

fn scope_of_task(state: &AppState, task: &goingson_core::Task) -> Option<String> {
    state
        .db
        .conn()
        .unwrap()
        .query_row(
            "SELECT group_id FROM tasks WHERE id = ?1",
            rusqlite::params![task.id.to_string()],
            |row| row.get(0),
        )
        .unwrap()
}

/// Put a group in the directory the way the sync loop does, so a described
/// handler can read it. That the loop writes this is synckit's test; what is
/// under test here is a screen reading it.
fn known_group(state: &AppState, id: u128, name: &str) {
    let mut conn = state.db.conn().unwrap();
    // The sync DDL runs when a `SyncStore` is built, which a test state does not
    // do. The directory's own DDL is separable for exactly this reason, so what
    // is under test is a screen reading the table rather than the table's
    // absence, which `a_device_that_knows_no_groups_is_offered_no_picker` covers.
    synckit_client::store::directory::ensure_tables(&conn).unwrap();
    synckit_client::store::directory::add_group(
        &mut conn,
        &synckit_client::store::directory::KnownGroup {
            id: synckit_client::GroupId::new(uuid::Uuid::from_u128(id)),
            name: name.to_owned(),
            gck_version: 1,
            is_admin: true,
        },
    )
    .unwrap();
}

fn pane(state: &AppState, project: &goingson_core::Project) -> String {
    let Outcome::Fragment { node, .. } =
        answer(state, &format!("/projects/{}", project.id), Params::new()).outcome
    else {
        panic!("the detail pane answers with a fragment");
    };
    quasi_webview::Webview::new().fragment(&node)
}

/// An empty directory means this device has not synced since groups existed,
/// not that the user has no groups, so the control is withheld rather than
/// drawn with nothing in it.
#[tokio::test]
async fn a_device_that_knows_no_groups_is_offered_no_picker() {
    let state = state().await;
    let personal = add(&state, "Mine alone", ProjectStatus::Active);
    let shown = pane(&state, &personal);
    assert!(!shown.contains("Share into a group"), "{shown}");
}

#[tokio::test]
async fn a_personal_project_offers_the_groups_this_device_knows() {
    let state = state().await;
    let personal = add(&state, "Mine alone", ProjectStatus::Active);
    known_group(&state, 1, "The Firm");

    let shown = pane(&state, &personal);
    assert!(shown.contains("Share into a group"), "{shown}");
    assert!(shown.contains("The Firm"), "{shown}");
    assert!(
        shown.contains(&format!("/projects/{}/share", personal.id)),
        "{shown}"
    );
}

/// One project is in one scope, so a shared project is offered the way out and
/// not a second way in.
#[tokio::test]
async fn a_shared_project_is_not_offered_the_picker_again() {
    let state = state().await;
    let shared = add(&state, "Shared work", ProjectStatus::Active);
    known_group(&state, 1, "The Firm");
    share_into(&state, &shared, "00000000-0000-0000-0000-000000000001");

    let shown = pane(&state, &shared);
    assert!(!shown.contains("Share into a group"), "{shown}");
    assert!(shown.contains("Move back to personal"), "{shown}");
}

#[tokio::test]
async fn sharing_stamps_the_scope_across_the_subtree() {
    let state = state().await;
    let project = add(&state, "Mine alone", ProjectStatus::Active);
    known_group(&state, 1, "The Firm");
    let group = "00000000-0000-0000-0000-000000000001";

    let task = state
        .tasks
        .create(
            DESKTOP_USER_ID,
            goingson_core::NewTask::builder("Inside it")
                .project_id(project.id)
                .build(),
        )
        .unwrap();

    let mut params = Params::new();
    params.insert("group_id".to_owned(), group.to_owned());
    post(&state, &format!("/projects/{}/share", project.id), params);

    assert_eq!(scope_of(&state, &project).as_deref(), Some(group));
    assert_eq!(
        scope_of_task(&state, &task).as_deref(),
        Some(group),
        "and everything in it went too"
    );
}

/// The check `share_project` used to make against the server, made against the
/// directory. Stamping a scope the engine holds no key for routes the whole
/// subtree into a changelog that goes nowhere.
#[tokio::test]
async fn sharing_into_a_group_this_device_does_not_know_is_refused() {
    let state = state().await;
    let project = add(&state, "Mine alone", ProjectStatus::Active);
    known_group(&state, 1, "The Firm");

    let mut params = Params::new();
    params.insert(
        "group_id".to_owned(),
        "00000000-0000-0000-0000-0000000000ff".to_owned(),
    );
    post(&state, &format!("/projects/{}/share", project.id), params);

    assert!(scope_of(&state, &project).is_none(), "nothing was stamped");
}

/// A stale id stamps zero rows and would otherwise report success, which is
/// `share_project`'s own recorded lesson asked of the way back out.
#[tokio::test]
async fn unsharing_a_project_that_is_not_there_is_refused() {
    let state = state().await;
    let missing = uuid::Uuid::new_v4();
    assert!(
        router()
            .handle(
                &state,
                Request::post(format!("/projects/{missing}/unshare")),
            )
            .is_err(),
        "a stale id is refused rather than answered with success"
    );
}