//! The task overview, driven through the router against a real database.
//!
//! Same standard as the other two screens: no Tauri runtime and no window, the
//! description asserted, and the markup only where the markup is the point.
//! Every workaround this port had to take is asserted here rather than left to
//! be noticed, so closing a finding is a test that has to change.

use std::sync::Arc;

use goingson_core::{NewTask, Priority};
use quasi_http::Serves as _;
use quasi_router::Outcome;
use quasi_router::{Params, Request, Response};

use super::super::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, title: &str) -> goingson_core::Task {
    state
        .tasks
        .create(
            DESKTOP_USER_ID,
            NewTask::builder(title)
                .title(title)
                .priority(Priority::High)
                .build(),
        )
        .unwrap()
}

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

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

fn html(response: Response) -> String {
    match response.outcome {
        Outcome::Screen(screen) => quasi_webview::Webview::new().screen(&screen),
        Outcome::Fragment { node, .. } => quasi_webview::Webview::new().fragment(&node),
        // Deliberately not a wildcard. See the same helper in the dashboard
        // tests: a redirect has no body, and a fallback returning empty markup
        // would read as a screen that rendered nothing.
        Outcome::Goto(action) => panic!("expected content, got a redirect to {action:?}"),
        // Same reasoning one step along: an overlay is a screen, but it is not
        // the screen this route was asked for. Rendering it here would let a
        // route that answered with the command palette pass as the page.
        Outcome::Over(_) => panic!("expected content, got a screen drawn over it"),
        Outcome::Anchored { .. } => {
            panic!("expected content, got a screen drawn at a point on it")
        }
        Outcome::Suggestions { field, .. } => {
            panic!("expected content, got a suggestion list for `{field}`")
        }
        Outcome::File { name, .. } => panic!("expected content, got the file `{name}`"),
        Outcome::Locate(_) => panic!("expected content, got a place on a map"),
        // `cb62a9dc`. Work that runs somewhere else and a region that says so:
        // not content, and not a place either.
        Outcome::Started { region, .. } => {
            panic!("expected content, got work started in `{region}`")
        }
    }
}

#[tokio::test]
async fn the_overview_carries_the_task_and_its_badges() {
    let state = state().await;
    let task = add(&state, "Write the port");

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("Write the port"));
    // Status and priority are tokens, so they keep their tone. `H` is the short
    // form `Priority::as_str` gives, which is what the JS chip shows too.
    assert!(page.contains("Pending"));
    assert!(page.contains(">H<"));
    assert!(page.contains("data-tone=\"danger\""));
}

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

#[tokio::test]
async fn a_task_title_cannot_become_markup() {
    let state = state().await;
    let task = add(&state, "<script>alert(1)</script>");
    let page = html(get(&state, &format!("/tasks/{}", task.id)));
    assert!(!page.contains("<script>alert"));
    assert!(page.contains("&lt;script&gt;"));
}

#[tokio::test]
async fn the_heatmap_is_a_place_and_the_description_says_nothing_about_it() {
    // Decision 4 working rather than a shortfall. A month grid of completion
    // counts is not describable and is not going to become describable; the
    // screen says a thing called `task-heatmap` goes here and stops.
    let state = state().await;
    let task = state
        .tasks
        .create(
            DESKTOP_USER_ID,
            NewTask::builder("Daily")
                .title("Daily")
                .recurrence(goingson_core::Recurrence::Daily)
                .build(),
        )
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("Completion History"));
    assert!(page.contains("data-bespoke=\"task-heatmap\""));
    // A place and nothing else: no cells, no counts, no month.
    assert!(!page.contains("month-heatmap"));
}

#[tokio::test]
async fn a_one_off_task_has_no_completion_history_at_all() {
    // Absent rather than empty. A streak of zero on a task that does not repeat
    // is a section saying nothing four times.
    let state = state().await;
    let task = add(&state, "Once");
    let page = html(get(&state, &format!("/tasks/{}", task.id)));
    assert!(!page.contains("Completion History"));
    assert!(!page.contains("data-bespoke"));
}

#[tokio::test]
async fn a_stat_is_a_figure_with_a_caption_and_not_a_row_read_backwards() {
    // The first finding, closed. It asserted the workaround until 2026-08-09:
    // `Row` is a list item, so the caption landed in the primary slot and the
    // figure in the trailing one, the opposite of the tile the JS draws.
    // `93c6a174`.
    let state = state().await;
    let task = state
        .tasks
        .create(
            DESKTOP_USER_ID,
            NewTask::builder("Daily")
                .title("Daily")
                .recurrence(goingson_core::Recurrence::Daily)
                .build(),
        )
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("Current Streak"));
    // A strip of figures, not a list of rows read backwards.
    assert!(page.contains(r#"<div class="figures">"#));
    assert!(page.contains(r#"aria-label="Current Streak: 0d""#));
    // Four of them, which is the arrangement a renderer could not have inferred
    // from four separate nodes.
    assert_eq!(page.matches(r#"class="figure""#).count(), 4);
}

#[tokio::test]
async fn a_subtask_tick_is_the_write_rather_than_a_button_beside_it() {
    // The third finding, closed. It asserted the workaround until 2026-08-09 —
    // a tick drawn inert with the route on a button next to it — and
    // `Row::toggle` is what changed. `14612ed8`.
    let state = state().await;
    let task = add(&state, "Has subtasks");
    state
        .tasks
        .add_subtask(task.id, DESKTOP_USER_ID, "First step")
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("type=\"checkbox\""));
    assert!(page.contains("/subtasks/"));
    assert!(page.contains("/toggle"));
    // The route is on the tick itself, and it fires on the value changing
    // rather than on the row being activated.
    assert!(page.contains("hx-trigger=\"change\""));
    // The button the workaround needed is gone, so there is one affordance for
    // one write rather than two for one.
    assert!(!page.contains(">Done<"));
}

#[tokio::test]
async fn a_linked_subtask_says_it_cannot_be_toggled() {
    // Not a workaround: `Act::disabled` says exactly what the JS's `disabled`
    // attribute says, so this one is described rather than approximated.
    let state = state().await;
    let task = add(&state, "Parent");
    let linked = add(&state, "Child");
    state
        .tasks
        .add_subtask_link(task.id, DESKTOP_USER_ID, linked.id)
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", task.id)));
    assert!(page.contains("Linked"));
    assert!(page.contains("disabled"));
}

#[tokio::test]
async fn a_proportion_is_drawn_as_a_bar_and_not_only_counted() {
    // The fourth finding, closed by makeover-layout 0.10.0's `Meter`. This
    // asserted the loss until then: the bar and its tone were gone and only the
    // concatenated heading survived. Both are back, and the heading keeps its
    // count because that half was a separate gap and stays open.
    let state = state().await;
    let task = add(&state, "Has subtasks");
    state
        .tasks
        .add_subtask(task.id, DESKTOP_USER_ID, "First step")
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("Subtasks 0/1"));
    assert!(page.contains("progress-fill"));
    assert!(page.contains(r#"data-tone="success""#));
    // The ratio reaches a reader that cannot see the bar, which is the whole
    // reason the description carries both numbers instead of a percentage.
    assert!(page.contains(r#"aria-label="0 of 1 subtasks""#));
}

#[tokio::test]
async fn an_over_run_estimate_is_toned_and_says_it_ran_over() {
    // The site that decided `Meter`'s shape. `Task::time_progress` would report
    // this as exactly 100%, because it clamps; the description carries 45 and
    // 30, so the bar is full AND the over-run survives in two places a
    // percentage could not have kept it.
    let state = state().await;
    let task = state
        .tasks
        .create(
            DESKTOP_USER_ID,
            NewTask::builder("Ran long")
                .title("Ran long")
                .priority(Priority::High)
                .estimated_minutes(30)
                .build(),
        )
        .unwrap();
    // `actual_minutes` is a cache the timer maintains, so there is no setter to
    // call; a test that wanted one through the front door would have to let
    // wall-clock time pass.
    state
        .db
        .conn()
        .unwrap()
        .execute(
            "UPDATE tasks SET actual_minutes = 45 WHERE id = ?",
            rusqlite::params![task.id.to_string()],
        )
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("width: 100%"));
    assert!(page.contains(r#"data-over="true""#));
    assert!(page.contains(r#"data-tone="danger""#));
    assert!(page.contains(r#"aria-label="45 of 30 minutes""#));
}

#[tokio::test]
async fn adding_a_subtask_answers_with_the_screen_it_happened_on() {
    let state = state().await;
    let task = add(&state, "Empty");

    let response = post(
        &state,
        &format!("/tasks/{}/subtasks", task.id),
        Params::new().with("text", "Added here"),
    );
    let Outcome::Screen(_) = &response.outcome else {
        panic!("a write answers with the whole screen");
    };
    let page = html(response);

    assert!(page.contains("Added here"));
    assert!(page.contains("Subtasks 0/1"));
}

#[tokio::test]
async fn an_empty_add_changes_nothing_rather_than_failing() {
    // The JS returns early on an empty box. A 400 here would be the described
    // screen inventing an error the shipped one does not have.
    let state = state().await;
    let task = add(&state, "Empty");

    let page = html(post(
        &state,
        &format!("/tasks/{}/subtasks", task.id),
        Params::new().with("text", "   "),
    ));
    assert!(page.contains("Subtasks 0/0"));
}

#[tokio::test]
async fn toggling_a_subtask_ticks_it_and_the_tick_is_the_way_back() {
    let state = state().await;
    let task = add(&state, "Has subtasks");
    let subtask = state
        .tasks
        .add_subtask(task.id, DESKTOP_USER_ID, "First step")
        .unwrap()
        .unwrap();

    let page = html(post(
        &state,
        &format!("/tasks/{}/subtasks/{}/toggle", task.id, subtask.id),
        Params::new(),
    ));

    assert!(page.contains("Subtasks 1/1"));
    assert!(page.contains(" checked"));
    // The way back was an "Undo" button until `14612ed8` closed. It is the same
    // tick, unticked, which is what the shipped screen has always offered.
    assert!(page.contains("/toggle"));
    assert!(!page.contains(">Undo<"));
}

#[tokio::test]
async fn adding_a_note_puts_it_on_the_screen() {
    let state = state().await;
    let task = add(&state, "Needs a note");

    let page = html(post(
        &state,
        &format!("/tasks/{}/notes", task.id),
        Params::new().with("note", "Remember the thing"),
    ));

    assert!(page.contains("Remember the thing"));
    assert!(page.contains("Notes 1"));
}

#[tokio::test]
async fn completing_a_task_takes_the_complete_control_away() {
    let state = state().await;
    let task = add(&state, "Nearly done");

    let page = html(post(
        &state,
        &format!("/tasks/{}/complete", task.id),
        Params::new(),
    ));

    assert!(page.contains("Completed"));
    // Offering to complete something already complete is a control that does
    // nothing, which is what this whole line of work is about not doing.
    assert!(!page.contains(">Complete<"));
    assert!(page.contains(">Delete<"));
}

#[tokio::test]
async fn deleting_a_task_sends_the_user_to_the_list_and_says_so() {
    // The sixth finding, closed 2026-08-09 (`80afd652`). This asserted the
    // workaround until then: a tombstone screen, addressed by the id of the
    // thing that no longer existed, because every answer was content. The
    // workaround is gone, so the assertion had to change rather than be relaxed.
    let state = state().await;
    let task = add(&state, "Going");

    let answer = post(&state, &format!("/tasks/{}/delete", task.id), Params::new());

    let Outcome::Goto(action) = &answer.outcome else {
        panic!("a delete answers with somewhere to go, not with content");
    };
    assert_eq!(action.destination.route(), Some("/tasks"));

    // And it says what happened, which the redirect alone cannot: the list it
    // lands on looks the same whether a task was deleted or the user navigated.
    let notice = answer.notice.as_ref().expect("a delete says so");
    assert_eq!(notice.text, "Task deleted");
    assert_eq!(notice.kind, quasi_router::layout::Notice::Toast);

    // And it is really gone.
    let error = router()
        .handle(&state, Request::get(format!("/tasks/{}", task.id)))
        .expect_err("deleted");
    assert_eq!(error.class.http_status(), 404);
}

#[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!("/tasks/{}/delete", uuid::Uuid::nil())),
        )
        .expect_err("no such task");
    assert_eq!(error.class.http_status(), 404);
}

#[tokio::test]
async fn a_description_renders_as_markdown_and_still_cannot_become_arbitrary_markup() {
    // The second finding, closed. It asserted the lossy form until 2026-08-09 —
    // the user read `**bold**` rather than bold — and `Node::Rich` is what
    // changed. `25822137`.
    let state = state().await;
    let task = state
        .tasks
        .create(
            DESKTOP_USER_ID,
            NewTask::builder("Documented")
                .title("Documented")
                .description("A **bold** claim\n\n<script>alert(1)</script>")
                .build(),
        )
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("<strong>bold</strong>"));
    // The member carries source, so what a user typed is still the renderer's
    // to decide about. This is the same guarantee `Node::Text` gives, kept.
    // The body of the script rather than the tag: the document shell carries
    // htmx's own `<script>`, so the tag alone is not the question.
    assert!(!page.contains("alert(1)"));
}

#[tokio::test]
async fn edit_is_an_address_rather_than_an_overlay() {
    // The fifth finding, and this assertion is its inverse. It read
    // `!page.contains(">Edit<")` while the control was left out, because
    // `tasks.openEdit` opens a modal form over the drawer and that is a second
    // arrangement this screen would have to describe. The form has its own
    // address now, so the control is a link to a screen rather than an overlay
    // drawn on this one.
    let state = state().await;
    let task = add(&state, "Editable elsewhere");
    let page = html(get(&state, &format!("/tasks/{}", task.id)));
    assert!(page.contains(">Edit<"), "{page}");
    assert!(page.contains(&format!("/tasks/{}/edit", task.id)), "{page}");
}

// The dependencies section. It exists because `338aa9f` added the blocking
// graph to `task-overview.js` after this screen was ported and nothing checked
// the two against each other; these are the assertions that make the drift a
// test failure rather than something noticed a second time by hand.

#[tokio::test]
async fn a_task_with_no_edges_says_so_and_reads_as_ready() {
    let state = state().await;
    let task = add(&state, "Standalone");

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("Dependencies"), "{page}");
    assert!(page.contains("Ready"), "{page}");
    assert!(
        page.contains("Nothing blocks this task and nothing waits on it."),
        "{page}"
    );
}

#[tokio::test]
async fn a_blocked_task_says_how_far_away_it_is_and_names_what_it_waits_on() {
    let state = state().await;
    let blocker = add(&state, "Do this first");
    let blocked = add(&state, "Then this");
    state
        .tasks
        .add_dependency(DESKTOP_USER_ID, blocked.id, blocker.id)
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", blocked.id)));

    // The depth, which is the fact `blockDepth` carries and a bare "Blocked"
    // does not.
    assert!(page.contains("Blocked, 1 step away"), "{page}");
    assert!(page.contains("Blocked by"), "{page}");
    assert!(page.contains("Do this first"), "{page}");

    // And the other end of the same edge, from the other side.
    let upstream = html(get(&state, &format!("/tasks/{}", blocker.id)));
    assert!(upstream.contains("Blocks"), "{upstream}");
    assert!(upstream.contains("unblocks 1 task"), "{upstream}");
}

#[tokio::test]
async fn a_satisfied_edge_is_drawn_rather_than_hidden() {
    // A completed blocker is the record of what this task waited for. Dropping
    // it from the view would make a finished chain look like it never existed.
    let state = state().await;
    let blocker = add(&state, "Already done");
    let blocked = add(&state, "Now available");
    state
        .tasks
        .add_dependency(DESKTOP_USER_ID, blocked.id, blocker.id)
        .unwrap();
    state.tasks.complete(blocker.id, DESKTOP_USER_ID).unwrap();

    let page = html(get(&state, &format!("/tasks/{}", blocked.id)));

    assert!(page.contains("Ready"), "{page}");
    assert!(page.contains("Already done"), "{page}");
}

#[tokio::test]
async fn adding_a_blocker_draws_the_edge_and_answers_the_screen() {
    let state = state().await;
    let blocker = add(&state, "Prerequisite");
    let blocked = add(&state, "Dependent work");

    let page = html(post(
        &state,
        &format!("/tasks/{}/blockers", blocked.id),
        Params::new().with("blocker", blocker.id.to_string()),
    ));

    assert!(page.contains("Blocked, 1 step away"), "{page}");
    assert!(page.contains("Prerequisite"), "{page}");
}

#[tokio::test]
async fn an_edge_that_would_close_a_cycle_is_refused_with_the_chain() {
    // The repository is the authority and its message names the chain already
    // in the way, which is the only useful thing to say. The described screen
    // passes it through rather than replacing it with a generic failure.
    let state = state().await;
    let first = add(&state, "First");
    let second = add(&state, "Second");
    state
        .tasks
        .add_dependency(DESKTOP_USER_ID, second.id, first.id)
        .unwrap();

    let error = router()
        .handle(
            &state,
            Request::post(format!("/tasks/{}/blockers", first.id))
                .sending(Params::new().with("blocker", second.id.to_string())),
        )
        .expect_err("a cycle is refused");

    assert_eq!(error.class, quasi_router::error::Class::Conflict);
    assert!(!error.message.is_empty(), "{error}");
}

#[tokio::test]
async fn an_edge_can_be_cut_from_either_side_of_it() {
    let state = state().await;
    let blocker = add(&state, "Upstream");
    let blocked = add(&state, "Downstream");
    state
        .tasks
        .add_dependency(DESKTOP_USER_ID, blocked.id, blocker.id)
        .unwrap();

    // From the blocked task's screen, where the other end is a blocker.
    let page = html(post(
        &state,
        &format!("/tasks/{}/dependencies/{}/remove", blocked.id, blocker.id),
        Params::new().with("role", "blocker"),
    ));
    assert!(page.contains("Ready"), "{page}");

    // And back the other way, cut from the blocker's screen this time, where
    // the same edge reads as a dependent.
    state
        .tasks
        .add_dependency(DESKTOP_USER_ID, blocked.id, blocker.id)
        .unwrap();
    let page = html(post(
        &state,
        &format!("/tasks/{}/dependencies/{}/remove", blocker.id, blocked.id),
        Params::new().with("role", "dependent"),
    ));
    // The blocker's own screen, which is where the user was standing.
    assert!(page.contains("Upstream"), "{page}");
    assert!(
        page.contains("Nothing blocks this task and nothing waits on it."),
        "{page}"
    );
}

#[tokio::test]
async fn a_completed_task_is_not_offered_a_new_blocker() {
    let state = state().await;
    let task = add(&state, "Done with it");
    let _other = add(&state, "Some other task");
    state.tasks.complete(task.id, DESKTOP_USER_ID).unwrap();

    let page = html(get(&state, &format!("/tasks/{}", task.id)));

    assert!(page.contains("Dependencies"), "{page}");
    assert!(!page.contains("Add blocker"), "{page}");
}

#[tokio::test]
async fn a_blockers_title_cannot_become_markup() {
    let state = state().await;
    let blocker = add(&state, "<script>alert('x')</script>");
    let blocked = add(&state, "Ordinary");
    state
        .tasks
        .add_dependency(DESKTOP_USER_ID, blocked.id, blocker.id)
        .unwrap();

    let page = html(get(&state, &format!("/tasks/{}", blocked.id)));

    assert!(!page.contains("<script>"), "{page}");
    assert!(page.contains("&lt;script&gt;"), "{page}");
}

/// What a response said on the way, which is not part of its content.
fn notice(response: &Response) -> String {
    response
        .notice
        .as_ref()
        .map(|message| message.text.clone())
        .unwrap_or_default()
}

fn reread(state: &AppState, id: goingson_core::TaskId) -> goingson_core::Task {
    state
        .tasks
        .get_by_id(id, DESKTOP_USER_ID)
        .unwrap()
        .expect("the task is there")
}

/// Everything the edit form asks for, filled from a task, as a submission.
///
/// Overrides replace rather than append: `Params::get` answers with the first
/// value under a name, so a second entry for a field the form already carries
/// is a value nothing reads.
fn edit_params(task: &goingson_core::Task, overrides: &[(&str, &str)]) -> Params {
    let title = task.title.clone();
    let description = task.description.clone();
    let base: Vec<(&str, &str)> = vec![
        ("title", &title),
        ("description", &description),
        ("project_id", ""),
        ("status", "Pending"),
        ("priority", "High"),
        ("due", ""),
        ("tags", ""),
        ("recurrence", "None"),
        ("estimated_minutes", ""),
        ("contact_id", ""),
        ("milestone_id", ""),
    ];
    base.into_iter()
        .fold(Params::new(), |params, (name, value)| {
            let chosen = overrides
                .iter()
                .find(|(over, _)| *over == name)
                .map_or(value, |(_, over)| *over);
            params.with(name, chosen)
        })
}

#[tokio::test]
async fn the_overview_offers_edit_as_an_address_rather_than_an_overlay() {
    let state = state().await;
    let task = add(&state, "Write the port");

    let page = html(get(&state, &format!("/tasks/{}", task.id)));
    assert!(page.contains(&format!("/tasks/{}/edit", task.id)), "{page}");

    // And the address answers with a form carrying what the task holds.
    let form = html(get(&state, &format!("/tasks/{}/edit", task.id)));
    assert!(form.contains("Write the port"), "{form}");
    assert!(form.contains("Save task"), "{form}");
    // Cancel is the overview's own address; the modal it replaces had nothing
    // to go back to but memory.
    assert!(form.contains("Cancel"), "{form}");
}

#[tokio::test]
async fn saving_writes_every_field_the_form_asked_for() {
    let state = state().await;
    let task = add(&state, "Rough title");

    let response = post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(
            &task,
            &[
                ("title", "Sharper title"),
                ("description", "With detail."),
                ("status", "Started"),
                ("priority", "Low"),
                ("tags", " work , , urgent "),
                ("estimated_minutes", "45"),
                ("due", "2026-12-25"),
            ],
        ),
    );

    assert_eq!(notice(&response), "Task saved");
    let saved = reread(&state, task.id);
    assert_eq!(saved.title, "Sharper title");
    assert_eq!(saved.description, "With detail.");
    assert_eq!(saved.status, goingson_core::TaskStatus::Started);
    assert_eq!(saved.priority, Priority::Low);
    // The blank entry between the commas is dropped, as `normalizeTags` does.
    assert_eq!(saved.tags, vec!["work".to_owned(), "urgent".to_owned()]);
    assert_eq!(saved.estimated_minutes, Some(45));
    assert!(saved.due.is_some());
    // Urgency is recalculated rather than carried, which is what makes an edit
    // that adds a due date move the task up the list.
    assert!(saved.urgency > 0.0);
}

#[tokio::test]
async fn a_refused_edit_hands_back_what_was_typed() {
    let state = state().await;
    let task = add(&state, "Fine as it is");

    let long = "x".repeat(81);
    let page = html(post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(
            &task,
            &[("title", &long), ("description", "Worth keeping.")],
        ),
    ));

    // The complaint, the 81 characters back in the box, and the rest of the
    // submission still there. A form that reports a length and empties the
    // field is how a user retypes to shorten.
    assert!(page.contains("Maximum 80 characters"), "{page}");
    assert!(page.contains(&long), "{page}");
    assert!(page.contains("Worth keeping."), "{page}");
    assert_eq!(reread(&state, task.id).title, "Fine as it is");
}

#[tokio::test]
async fn an_unparseable_due_date_is_refused_rather_than_dropped() {
    let state = state().await;
    let task = add(&state, "Has a deadline");
    post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(&task, &[("due", "friday 3pm")]),
    );
    let due = reread(&state, task.id).due.expect("friday 3pm parsed");

    let page = html(post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(&task, &[("due", "someday")]),
    ));

    assert!(page.contains("Date not recognized"), "{page}");
    // Still the deadline it had. Dropping it would lose a date on an edit that
    // was about something else.
    assert_eq!(reread(&state, task.id).due, Some(due));
}

#[tokio::test]
async fn a_blank_due_date_clears_it() {
    let state = state().await;
    let task = add(&state, "Not urgent after all");
    post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(&task, &[("due", "tomorrow")]),
    );
    assert!(reread(&state, task.id).due.is_some());

    post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(&task, &[]),
    );
    assert!(reread(&state, task.id).due.is_none());
}

#[tokio::test]
async fn the_prefilled_due_date_is_one_the_form_accepts() {
    let state = state().await;
    let task = add(&state, "Round trips");
    post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(&task, &[("due", "2026-12-25 3pm")]),
    );
    let due = reread(&state, task.id).due.expect("parsed");

    // The value the form offers, submitted back unchanged. A prefill the parser
    // would reject is a field that cannot be left alone.
    let prefilled = super::due_value(&reread(&state, task.id));
    let response = post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(&task, &[("due", &prefilled)]),
    );

    assert_eq!(notice(&response), "Task saved");
    assert_eq!(reread(&state, task.id).due, Some(due));
}

#[tokio::test]
async fn an_edit_leaves_the_recurrence_rule_alone() {
    let state = state().await;
    let task = add(&state, "Every other Tuesday");
    let rule = goingson_core::RecurrenceRule {
        pattern: goingson_core::Recurrence::Weekly,
        interval: 2,
        weekdays: vec![1],
        monthly_spec: None,
        until: None,
    };
    let mut with_rule = task.clone();
    with_rule.recurrence = goingson_core::Recurrence::Weekly;
    with_rule.recurrence_rule = Some(rule.clone());
    state
        .tasks
        .update(
            task.id,
            DESKTOP_USER_ID,
            goingson_core::UpdateTask {
                project_id: None,
                milestone_id: None,
                contact_id: None,
                title: with_rule.title.clone(),
                description: with_rule.description.clone(),
                status: goingson_core::TaskStatus::Pending,
                priority: Priority::High,
                due: None,
                tags: Vec::new(),
                recurrence: goingson_core::Recurrence::Weekly,
                recurrence_rule: Some(rule.clone()),
                urgency: 0.0,
                scheduled_start: None,
                scheduled_duration: None,
                estimated_minutes: None,
            },
        )
        .unwrap();

    // A title edit, through a form that cannot ask about weekdays at all.
    post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(
            &task,
            &[
                ("title", "Every other Tuesday, renamed"),
                ("recurrence", "Weekly"),
            ],
        ),
    );

    let saved = reread(&state, task.id);
    assert_eq!(saved.title, "Every other Tuesday, renamed");
    let kept = saved.recurrence_rule.expect("the rule survived the edit");
    assert_eq!(kept.interval, 2);
    assert_eq!(kept.weekdays, vec![1]);
}

#[tokio::test]
async fn a_milestone_of_another_project_is_refused() {
    let state = state().await;
    let task = add(&state, "Filed somewhere");
    let project = state
        .projects
        .create(
            DESKTOP_USER_ID,
            goingson_core::NewProject {
                name: "Elsewhere".to_owned(),
                description: String::new(),
                project_type: goingson_core::ProjectType::Other,
                status: goingson_core::ProjectStatus::Active,
            },
        )
        .unwrap();
    let milestone = state
        .milestones
        .create(
            DESKTOP_USER_ID,
            goingson_core::NewMilestone {
                project_id: project.id,
                name: "Phase one".to_owned(),
                description: String::new(),
                position: 0,
                target_date: None,
            },
        )
        .unwrap();

    // Moving the task and filing it under the new project's milestone in one
    // submission, which is the pairing the form never offered.
    let page = html(post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(
            &task,
            &[
                ("project_id", &project.id.to_string()),
                ("milestone_id", &milestone.id.to_string()),
            ],
        ),
    ));

    assert!(page.contains("Move the task first"), "{page}");
    let saved = reread(&state, task.id);
    assert_eq!(saved.project_id, None);
    assert_eq!(saved.milestone_id, None);
}

#[tokio::test]
async fn a_status_control_cannot_delete_a_task() {
    let state = state().await;
    let task = add(&state, "Still here");

    let page = html(post(
        &state,
        &format!("/tasks/{}", task.id),
        edit_params(&task, &[("status", "Deleted")]),
    ));

    assert!(page.contains("Not a status a control can set"), "{page}");
    assert_eq!(
        reread(&state, task.id).status,
        goingson_core::TaskStatus::Pending
    );
}