//! Import, export and backups, driven through the router against a real
//! database and real files on disk.
//!
//! Same standard as the screens before it: no Tauri runtime and no window, the
//! description asserted, and the markup only where the markup is the point.
//! Every finding this port recorded is asserted here rather than left to be
//! noticed, so closing one is a test that has to change.
//!
//! Files are real because the writes are: every route on this screen reads a
//! path off disk, and a test that faked the read would be testing a different
//! function than the one that runs.

use std::sync::Arc;

use quasi_http::Serves as _;
use quasi_router::{Outcome, Params, Request, Response};
use tempfile::TempDir;

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

/// A state whose data directory is this test's own, so the backups one test
/// writes are invisible to the next.
///
/// `test_utils` hands out `/tmp/goingson-test` for every test at once, which is
/// fine for a path nothing reads and wrong for this screen: the backups list is
/// a directory walk.
async fn state() -> (Arc<AppState>, TempDir) {
    let (mut state, _) = crate::test_utils::setup_test_state().await;
    let dir = tempfile::tempdir().unwrap();

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

    Arc::get_mut(&mut state).expect("sole owner").data_dir = dir.path().to_path_buf();
    (state, dir)
}

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),
        Outcome::Goto(action) => panic!("expected content, got a redirect to {action:?}"),
        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}`")
        }
    }
}

/// The file an answer handed over, or a panic naming what it did instead.
fn handed(response: Response) -> (String, quasi_router::Accepted, Vec<u8>) {
    match response.outcome {
        Outcome::File { name, kind, bytes } => (name, kind, bytes),
        other => panic!("expected a file, got {other:?}"),
    }
}

/// What the response says in a toast, if it says anything.
fn said(response: &Response) -> String {
    response
        .notice
        .as_ref()
        .map(|notice| notice.text.clone())
        .unwrap_or_default()
}

/// Write a file into this test's directory and answer its path.
fn file(dir: &TempDir, name: &str, content: &str) -> String {
    let path = dir.path().join(name);
    std::fs::write(&path, content).unwrap();
    path.to_string_lossy().into_owned()
}

/// A picked file, as the `FieldKind::File` control submits one.
fn picked(path: &str) -> Params {
    Params::new().with("file", path)
}

const TASKS_CSV: &str = "description,priority,project\n\
                         Describe the import screens,High,GoingsOn\n\
                         Write the tests,Medium,GoingsOn\n";

const ONE_CARD: &str = "BEGIN:VCARD\r\n\
                        VERSION:3.0\r\n\
                        FN:Jane Smith\r\n\
                        EMAIL;TYPE=WORK:jane@example.com\r\n\
                        ORG:Acme Corp\r\n\
                        END:VCARD\r\n";

const ONE_EVENT: &str = "BEGIN:VCALENDAR\r\n\
                         VERSION:2.0\r\n\
                         BEGIN:VEVENT\r\n\
                         UID:one@example.com\r\n\
                         SUMMARY:Team Meeting\r\n\
                         DTSTART:20260415T100000Z\r\n\
                         DTEND:20260415T110000Z\r\n\
                         LOCATION:Conference Room A\r\n\
                         END:VEVENT\r\n\
                         END:VCALENDAR\r\n";

#[tokio::test]
async fn the_screen_offers_the_three_imports_and_says_nothing_it_cannot_do() {
    let (state, _dir) = state().await;
    let page = html(get(&state, "/data"));

    assert!(page.contains("CSV or TSV file"));
    assert!(page.contains("vCard file"));
    assert!(page.contains("iCalendar file"));
    assert!(page.contains("/data/import/csv/preview"));

    // Nothing is left out of this screen as of 2026-08-29. The three exports
    // came back when `67881a88` was ruled and Create Backup when `dc2f2b46`
    // was, each asserted in a test of its own below rather than left as a hole
    // here: `the_screen_offers_all_three_exports` and
    // `create_hands_the_backup_off_and_answers_that_it_started`.
    assert!(page.contains("Create Backup"));
}

#[tokio::test]
async fn a_csv_preview_says_what_is_in_the_file_and_creates_nothing() {
    let (state, dir) = state().await;
    let path = file(&dir, "tasks.csv", TASKS_CSV);

    let page = html(post(&state, "/data/import/csv/preview", picked(&path)));

    assert!(page.contains("2 tasks"));
    assert!(page.contains("Describe the import screens"));
    assert!(page.contains("Write the tests"));
    // The kind is read off the header, not off the extension, so the confirm
    // control can name what it is about to make.
    assert!(page.contains("Import 2 tasks"));
    // A dry run. Nothing exists yet.
    assert_eq!(state.tasks.list_all(DESKTOP_USER_ID).unwrap().len(), 0);
}

#[tokio::test]
async fn importing_a_csv_creates_the_rows_and_clears_the_preview() {
    let (state, dir) = state().await;
    let path = file(&dir, "tasks.csv", TASKS_CSV);

    let response = post(&state, "/data/import/csv", picked(&path));
    assert!(said(&response).contains("Imported 2"));

    let tasks = state.tasks.list_all(DESKTOP_USER_ID).unwrap();
    assert_eq!(tasks.len(), 2);

    // The preview region is answered emptied: the rows have gone somewhere else,
    // and a preview of a file that has been imported is a stale answer.
    let page = html(response);
    assert!(page.contains("Pick a file above"));
    assert!(!page.contains("Describe the import screens"));
}

#[tokio::test]
async fn a_vcard_preview_offers_the_duplicate_choice_only_when_there_are_duplicates() {
    // Finding 5, asserted from both sides.
    let (state, dir) = state().await;
    let path = file(&dir, "one.vcf", ONE_CARD);

    let page = html(post(&state, "/data/import/contacts/preview", picked(&path)));
    assert!(page.contains("1 contact"));
    assert!(page.contains("Jane Smith"));
    assert!(!page.contains("already here"), "nothing to ask about yet");

    // Import it, then preview the same file again: now every card matches.
    post(&state, "/data/import/contacts", picked(&path));
    let page = html(post(&state, "/data/import/contacts/preview", picked(&path)));

    assert!(page.contains("1 contact is already here"));
    assert!(page.contains("Merge into the existing contact"));
    assert!(page.contains("Skip them"));
    assert!(page.contains("Import them as new contacts"));
    // And it says which contact was matched, which the shipped table hides in a
    // title attribute.
    assert!(page.contains("Matches Jane Smith"));
}

#[tokio::test]
async fn the_duplicate_choice_is_what_the_import_does() {
    let (state, dir) = state().await;
    let path = file(&dir, "one.vcf", ONE_CARD);

    post(&state, "/data/import/contacts", picked(&path));
    assert_eq!(state.contacts.list_all(DESKTOP_USER_ID).unwrap().len(), 1);

    // Skip leaves the contact alone.
    let response = post(
        &state,
        "/data/import/contacts",
        picked(&path).with("duplicates", "skip"),
    );
    assert!(said(&response).contains("1 already here"));
    assert_eq!(state.contacts.list_all(DESKTOP_USER_ID).unwrap().len(), 1);

    // Import as new makes a second one.
    post(
        &state,
        "/data/import/contacts",
        picked(&path).with("duplicates", "importAsNew"),
    );
    assert_eq!(state.contacts.list_all(DESKTOP_USER_ID).unwrap().len(), 2);
}

#[tokio::test]
async fn a_calendar_file_previews_and_imports() {
    let (state, dir) = state().await;
    let path = file(&dir, "one.ics", ONE_EVENT);

    let page = html(post(&state, "/data/import/calendar/preview", picked(&path)));
    assert!(page.contains("1 event"));
    assert!(page.contains("Team Meeting"));
    assert!(page.contains("Conference Room A"));

    let response = post(&state, "/data/import/calendar", picked(&path));
    assert!(said(&response).contains("1 imported"));
    assert_eq!(state.events.list_all(DESKTOP_USER_ID).unwrap().len(), 1);

    // Twice is once: the UID is the dedup key, and the sentence says so rather
    // than claiming another import happened.
    let response = post(&state, "/data/import/calendar", picked(&path));
    assert!(said(&response).contains("1 already here"));
    assert_eq!(state.events.list_all(DESKTOP_USER_ID).unwrap().len(), 1);
}

#[tokio::test]
async fn an_empty_file_says_so_and_offers_no_way_to_import_it() {
    let (state, dir) = state().await;
    let path = file(&dir, "empty.vcf", "");

    let page = html(post(&state, "/data/import/contacts/preview", picked(&path)));
    assert!(page.contains("No contacts in that file."));
    assert!(!page.contains("/data/import/contacts\""));
}

#[tokio::test]
async fn a_csv_the_parser_complains_about_keeps_its_warnings() {
    let (state, dir) = state().await;
    // A row with no description is a row the task importer cannot use.
    let path = file(
        &dir,
        "partial.csv",
        "description,priority\nA real task,High\n,Low\n",
    );

    let page = html(post(&state, "/data/import/csv/preview", picked(&path)));
    assert!(page.contains("A real task"));
    assert!(
        page.contains("Row"),
        "the parser's warning is carried: {page}"
    );
}

#[tokio::test]
async fn a_request_with_no_file_on_it_is_refused() {
    let (state, _dir) = state().await;

    let error = router()
        .handle(
            &state,
            Request::post("/data/import/csv/preview").sending(Params::new().with("file", "  ")),
        )
        .expect_err("an untouched control sends nothing");
    assert_eq!(error.class.http_status(), 404);
}

#[tokio::test]
async fn a_kind_nothing_imports_is_a_not_found() {
    let (state, _dir) = state().await;

    let error = router()
        .handle(
            &state,
            Request::post("/data/import/spreadsheet/preview").sending(picked("/tmp/x")),
        )
        .expect_err("three kinds and no others");
    assert_eq!(error.class.http_status(), 404);
}

#[tokio::test]
async fn a_file_that_is_not_there_is_an_error_rather_than_an_empty_preview() {
    let (state, dir) = state().await;
    let missing = dir.path().join("nothing.csv");

    let error = router()
        .handle(
            &state,
            Request::post("/data/import/csv/preview").sending(picked(&missing.to_string_lossy())),
        )
        .expect_err("the importer cannot open it");
    assert_eq!(error.class.http_status(), 500);
}

#[tokio::test]
async fn with_no_backups_the_list_says_so_rather_than_being_blank() {
    let (state, _dir) = state().await;
    let page = html(get(&state, "/data"));

    assert!(page.contains("No backups yet"));
}

/// Put a file in the backup directory that looks like a backup.
///
/// Enough for the list, the delete and the addressing. The restore test writes a
/// real one, because that is the only route that reads the contents.
fn seed_backup(state: &AppState, name: &str) -> std::path::PathBuf {
    let dir = crate::backup_scheduler::backup_dir(state);
    std::fs::create_dir_all(&dir).unwrap();
    let path = dir.join(name);
    std::fs::write(&path, b"not really gzip").unwrap();
    path
}

#[tokio::test]
async fn a_backup_is_listed_with_what_it_is_and_what_can_be_done_to_it() {
    let (state, _dir) = state().await;
    seed_backup(&state, "goingson-backup-20260816-120000-abcd1234.json.gz");

    let page = html(get(&state, "/data"));

    assert!(page.contains("goingson-backup-20260816-120000-abcd1234.json.gz"));
    assert!(page.contains("bytes"));
    // Both destructive controls carry their question, which is Act::confirm
    // rather than a JS helper at the call site.
    assert!(page.contains("Restore from this backup?"));
    assert!(page.contains("Delete this backup?"));
    // Addressed by name. The absolute path the shipped screen puts on every
    // button is never in the markup.
    assert!(!page.contains(&state.data_dir.to_string_lossy().into_owned()));
}

#[tokio::test]
async fn deleting_a_backup_removes_it_and_answers_with_the_list() {
    let (state, _dir) = state().await;
    let name = "goingson-backup-20260816-120000-abcd1234.json.gz";
    let path = seed_backup(&state, name);

    let response = post(
        &state,
        &format!("/data/backups/{name}/delete"),
        Params::new(),
    );
    assert!(said(&response).contains("Deleted"));
    assert!(!path.exists());

    let page = html(response);
    assert!(page.contains("No backups yet"));
}

#[tokio::test]
async fn a_backup_that_is_already_gone_is_said_rather_than_claimed() {
    let (state, _dir) = state().await;
    let name = "goingson-backup-20260816-120000-abcd1234.json.gz";

    let response = post(
        &state,
        &format!("/data/backups/{name}/delete"),
        Params::new(),
    );
    assert!(said(&response).contains("already gone"));
}

#[tokio::test]
async fn a_name_that_is_not_a_backup_in_the_backup_directory_is_refused() {
    let (state, _dir) = state().await;
    // A neighbour of the backup directory, reached the way a hand-typed request
    // would reach it. Both halves of safe_name: the traversal and the suffix.
    let outside = state.data_dir.join("goingson.db");
    std::fs::write(&outside, b"the database").unwrap();

    for name in [
        "../goingson.db",
        "..%2Fgoingson.db",
        "goingson.db",
        "notes.txt",
    ] {
        let error = router()
            .handle(
                &state,
                Request::post(format!("/data/backups/{name}/delete")),
            )
            .expect_err("only backups, only in the backup directory");
        assert_eq!(error.class.http_status(), 404, "should refuse {name}");
    }

    assert!(
        outside.exists(),
        "nothing outside the directory was touched"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn a_real_backup_restores_and_says_how_much_came_back() {
    // Multi-thread because the writer bridges the fetches onto the blocking
    // pool, which is the same reason the scheduler's own round-trip test does.
    let (state, _dir) = state().await;
    let project = state
        .projects
        .create(
            DESKTOP_USER_ID,
            goingson_core::NewProject {
                name: "Restored project".into(),
                description: String::new(),
                project_type: goingson_core::ProjectType::SideProject,
                status: goingson_core::ProjectStatus::Active,
            },
        )
        .unwrap();

    let dir = crate::backup_scheduler::backup_dir(&state);
    let name = "goingson-backup-20260816-130000-beefcafe.json.gz";
    crate::backup_scheduler::write_streaming_backup(
        &state,
        DESKTOP_USER_ID,
        dir.clone(),
        dir.join(name),
        chrono::Utc::now(),
    )
    .await
    .expect("the backup writes");

    // Take the project away, so the restore has something to put back.
    state.projects.delete(project.id, DESKTOP_USER_ID).unwrap();
    assert!(
        state
            .projects
            .get_by_id(project.id, DESKTOP_USER_ID)
            .unwrap()
            .is_none()
    );

    let response = post(
        &state,
        &format!("/data/backups/{name}/restore"),
        Params::new(),
    );
    assert!(said(&response).contains("Restored"), "{}", said(&response));
    assert!(
        state
            .projects
            .get_by_id(project.id, DESKTOP_USER_ID)
            .unwrap()
            .is_some()
    );
}

#[tokio::test]
async fn restoring_a_backup_that_is_not_there_is_a_not_found() {
    let (state, _dir) = state().await;

    let error = router()
        .handle(
            &state,
            Request::post("/data/backups/goingson-backup-nope.json.gz/restore"),
        )
        .expect_err("no such backup");
    assert_eq!(error.class.http_status(), 404);
}

#[tokio::test]
async fn the_automatic_settings_show_what_is_in_force_and_write_what_is_chosen() {
    let (state, _dir) = state().await;
    let page = html(get(&state, "/data"));

    // The defaults the app falls back to when nobody has chosen: on, every 15
    // minutes, keep one.
    assert!(page.contains("Take backups automatically"));
    assert!(page.contains("Every 15 minutes (recommended)"));
    assert!(page.contains("No backups yet."));

    let response = post(
        &state,
        "/data/backups/automatic",
        Params::new()
            .with("enabled", "on")
            .with("frequency", "60")
            .with("retention", "7"),
    );
    assert!(said(&response).contains("saved"));

    let saved = state
        .backup_settings
        .get(DESKTOP_USER_ID)
        .unwrap()
        .expect("written");
    assert!(saved.auto_backup_enabled);
    assert_eq!(saved.backup_frequency_minutes, 60);
    assert_eq!(saved.max_backups_to_keep, 7);
}

#[tokio::test]
async fn an_unticked_checkbox_is_how_automatic_backups_are_turned_off() {
    // A checkbox submits nothing when it is not ticked, on every host and in the
    // vocabulary, so absence is the whole of how "off" arrives. Asserted because
    // reading it as "unchanged" would make the switch one-way.
    let (state, _dir) = state().await;

    post(
        &state,
        "/data/backups/automatic",
        Params::new()
            .with("enabled", "on")
            .with("frequency", "15")
            .with("retention", "1"),
    );
    post(
        &state,
        "/data/backups/automatic",
        Params::new().with("frequency", "15").with("retention", "1"),
    );

    let saved = state
        .backup_settings
        .get(DESKTOP_USER_ID)
        .unwrap()
        .expect("written");
    assert!(!saved.auto_backup_enabled);
}

#[tokio::test]
async fn the_floor_the_command_enforces_is_still_enforced_through_the_screen() {
    // The clamping lives in the write path rather than in the screen, so a value
    // the controls cannot offer is still refused. Same arrangement the settings
    // screen has with its closed key set.
    let (state, _dir) = state().await;

    post(
        &state,
        "/data/backups/automatic",
        Params::new()
            .with("enabled", "on")
            .with("frequency", "0")
            .with("retention", "-4"),
    );

    let saved = state
        .backup_settings
        .get(DESKTOP_USER_ID)
        .unwrap()
        .expect("written");
    assert_eq!(saved.backup_frequency_minutes, 1);
    assert_eq!(saved.max_backups_to_keep, 0);
}

#[tokio::test]
async fn nothing_in_a_file_someone_else_wrote_can_become_markup() {
    // Every string on this screen came off disk: a contact's name, an event's
    // title, a CSV cell, a backup's file name. None of it is seen by anything
    // that validates, and the renderer is what makes it safe.
    let (state, dir) = state().await;
    let path = file(
        &dir,
        "hostile.vcf",
        "BEGIN:VCARD\r\nVERSION:3.0\r\nFN:<script>alert(1)</script>\r\nEND:VCARD\r\n",
    );

    let page = html(post(&state, "/data/import/contacts/preview", picked(&path)));

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

// The three exports. `67881a88`, ruled 2026-08-21.

#[tokio::test]
async fn every_export_answers_with_a_file_and_leaves_the_screen_alone() {
    // The ruling's whole shape, asserted three times: the route answers with the
    // file, the description names no path, and nothing on screen is replaced.
    let (state, _dir) = state().await;

    for (slug, suffix, media_type) in [
        ("json", ".json", "application/json"),
        ("tasks", ".csv", "text/csv"),
        ("calendar", ".ics", "text/calendar"),
    ] {
        let answer = post(&state, &format!("/data/export/{slug}"), Params::new());
        // Not a fragment and not a place: what the user was looking at stays.
        assert_eq!(answer.target(), None, "{slug}");
        assert_eq!(answer.destination(), None, "{slug}");

        let (name, kind, _bytes) = handed(answer);
        assert!(name.starts_with("goingson-"), "{slug}: {name}");
        assert!(name.ends_with(suffix), "{slug}: {name}");
        // Dated, the way `export.js` dated it.
        assert!(
            name.contains(&chrono::Local::now().format("%Y-%m-%d").to_string()),
            "{slug}: {name}"
        );
        assert_eq!(
            kind,
            quasi_router::Accepted::Type(media_type.to_owned()),
            "{slug}"
        );
    }
}

#[tokio::test]
async fn the_json_export_is_the_whole_document_the_command_writes() {
    // The described route and the Tauri command share one body, so this is the
    // assertion that the lift did not change what comes out: valid JSON with
    // the top-level keys a restore reads back.
    let (state, _dir) = state().await;

    let (_name, _kind, bytes) = handed(post(&state, "/data/export/json", Params::new()));
    let parsed: serde_json::Value =
        serde_json::from_slice(&bytes).expect("the export is valid JSON");
    assert!(parsed.get("tasks").is_some());
    assert!(parsed.get("projects").is_some());
}

#[tokio::test]
async fn an_export_says_how_many_things_it_holds() {
    // The shipped toast, kept: `export.js` said "Exported N items to JSON" from
    // the command's `itemCount`, and the sentence is the description's now.
    let (state, _dir) = state().await;

    let answer = post(&state, "/data/export/json", Params::new());
    assert!(said(&answer).starts_with("Exported "), "{}", said(&answer));
    assert!(said(&answer).ends_with(" to JSON"), "{}", said(&answer));
}

#[tokio::test]
async fn a_format_nothing_exports_is_a_404_rather_than_an_empty_file() {
    let (state, _dir) = state().await;
    let refused = router()
        .handle(&state, Request::post("/data/export/pdf"))
        .expect_err("nothing exports that");
    assert_eq!(refused.class, quasi_router::Class::NotFound);
}

#[tokio::test]
async fn the_screen_offers_all_three_exports() {
    // Finding 1 said these were absent because a destination could not be
    // described. It can now, so their absence would be a regression rather than
    // a limit -- which is what this asserts.
    let (state, _dir) = state().await;
    let page = html(get(&state, "/data"));

    for label in [
        "Export All (JSON)",
        "Export Tasks (CSV)",
        "Export Calendar (ICS)",
    ] {
        assert!(page.contains(label), "{label} is not on the screen");
    }
    // And Create Backup beside them since `dc2f2b46`, which answered finding 2
    // separately: the handler is still synchronous and hands the gzip off.
    assert!(page.contains("Create Backup"));
}

/// Picking a file is the host's, and the control says so.
///
/// This was a `FieldKind::File` inside a form until 2026-08-22, and it could not
/// work: the field renders `<input type="file">`, htmx submits urlencoded, and a
/// browser reports a masked filename rather than a path — while
/// `quasi_http::is_form` refuses multipart outright, on the grounds that a
/// description has no word for a byte stream. So the handler, which reads
/// `payload["file"]` as a path, could never receive one. The tests did not see
/// it because they hand the handler a real path, which is a value the renderer
/// would never send.
#[tokio::test]
async fn picking_a_file_is_the_hosts_call_and_carries_no_transport() {
    let (state, _dir) = state().await;
    let markup = html(get(&state, "/data"));

    // No file input anywhere: the control is an act the host performs.
    assert!(!markup.contains("type=\"file\""), "{markup}");

    // `data-sends` and no verb, which is what `Action::by_host` emits: the
    // address is the half the description knows, and how the file gets there is
    // the host's.
    assert!(
        markup.contains("data-sends=\"/data/import/csv/preview\""),
        "{markup}"
    );

    // The accept list travels with it, because a native dialog needs to know
    // what it is asking for and the description is what says.
    assert!(markup.contains("csv,tsv"), "{markup}");
    assert!(markup.contains("vcf,vcard"), "{markup}");
    assert!(markup.contains("ics,ical"), "{markup}");
}

/// The host half is loaded, or none of the above does anything.
///
/// `data-sends` carries no transport by design, so a document without
/// `host.js` draws three buttons that look pressable and are not. That is the
/// exact failure this whole change is fixing, so it is worth its own assertion
/// against the shell the app actually serves.
#[tokio::test]
async fn the_document_loads_the_host_half() {
    let (state, _dir) = state().await;
    let response = get(&state, "/data");
    let quasi_router::Outcome::Screen(screen) = &response.outcome else {
        panic!("the data screen answers a screen");
    };
    let markup = quasi_webview::Webview::new()
        .with_shell(crate::quasi::document_shell())
        .screen(screen);
    assert!(markup.contains("/static/host.js"), "{markup}");
}

// -- Create Backup, and the started answer it hands back ---------------------
//
// quasicoherent `dc2f2b46`. Finding 2 in this module's header was open until
// there was a word for handing work off; these are what closed it.

/// The region a started answer aims at has to be re-asking already, because the
/// started answer deliberately sends no cadence of its own. If this stops being
/// true, "Creating backup…" stands on the screen forever.
#[tokio::test]
async fn the_backups_region_re_asks_on_its_own_so_a_started_backup_can_report() {
    let (state, _dir) = state().await;
    let response = get(&state, "/data");
    let quasi_router::Outcome::Screen(screen) = &response.outcome else {
        panic!("the data screen answers a screen");
    };
    let region = screen
        .slots
        .iter()
        .find(|slot| slot.id == "data-backups")
        .expect("the backups region is on the screen");

    assert!(region.live, "the backups list changes without the reader");
    assert!(
        region.fed_by.is_some(),
        "and a live region with nowhere to ask re-asks nothing"
    );
}

/// The whole of it: press the button, get told it started, and find the file
/// afterwards -- with the handler still synchronous the entire time.
#[tokio::test]
async fn create_hands_the_backup_off_and_answers_that_it_started() {
    let (state, _dir) = state().await;
    AppState::install_offload(&state, tokio::runtime::Handle::current());

    let response = post(&state, "/data/backups/create", Params::default());

    let quasi_router::Outcome::Started { region, message } = &response.outcome else {
        panic!("expected work started, got {:?}", response.outcome);
    };
    assert_eq!(region, "data-backups");
    assert_eq!(message, "Creating backup…");

    // The answer came back before the work did, which is the point.
    let finished = settle(&state).await;
    assert!(finished.0, "the backup worked: {}", finished.1);
    assert!(
        finished.1.contains("goingson-backup-"),
        "it names the file it wrote: {}",
        finished.1
    );
}

/// Wait for the handed-off run to land, and answer what it said.
///
/// Polled rather than awaited on a handle: the route keeps no handle, which is
/// the arrangement being tested. A described screen learns the same way, on its
/// own cadence.
async fn settle(state: &AppState) -> (bool, String) {
    for _ in 0..200 {
        if let Some(outcome) = state.take_finished_backup() {
            return outcome;
        }
        tokio::time::sleep(std::time::Duration::from_millis(25)).await;
    }
    panic!("the backup never finished");
}

/// A finished run is reported to whoever asks next, and reported once.
#[tokio::test]
async fn a_finished_run_is_said_once_and_then_the_region_settles() {
    let (state, _dir) = state().await;
    state.set_backup_run(crate::state::BackupRun::Finished {
        ok: true,
        said: "Backup created: goingson-backup-20260829-120000-abcd1234.json.gz.".into(),
    });

    let first = get(&state, "/data/backups");
    assert!(said(&first).contains("Backup created"), "{}", said(&first));

    // The next poll is a plain list. A success notice redrawn every cadence is
    // a screen that never stops congratulating itself.
    let second = get(&state, "/data/backups");
    assert_eq!(said(&second), "");
}

/// A failure is reported rather than looking like an idle screen, which is the
/// one thing a fire-and-forget offload could plausibly get wrong.
#[tokio::test]
async fn a_failed_run_is_reported_rather_than_going_quiet() {
    let (state, _dir) = state().await;
    state.set_backup_run(crate::state::BackupRun::Finished {
        ok: false,
        said: "Backup failed: the disk is full".into(),
    });

    let response = get(&state, "/data/backups");
    assert!(
        said(&response).contains("Backup failed"),
        "{}",
        said(&response)
    );
    assert_eq!(
        response.notice.as_ref().map(|notice| notice.tone),
        Some(makeover_layout::Tone::Danger)
    );
}

/// Two full gzip streams over one database buys nothing, and the filename is
/// collision-safe rather than idempotent, so the second would land as its own
/// file. Refused, and said.
#[tokio::test]
async fn a_second_create_while_one_is_running_is_refused_and_said() {
    let (state, _dir) = state().await;
    AppState::install_offload(&state, tokio::runtime::Handle::current());
    state.set_backup_run(crate::state::BackupRun::Running);

    let response = post(&state, "/data/backups/create", Params::default());

    assert!(
        matches!(response.outcome, Outcome::Fragment { .. }),
        "a refusal is the region back, not a second start"
    );
    assert!(
        said(&response).contains("already being written"),
        "{}",
        said(&response)
    );
}

/// While one is running the region says so, so a reader who reloads the screen
/// mid-backup is not shown a list that looks finished.
#[tokio::test]
async fn while_a_backup_runs_the_region_says_so() {
    let (state, _dir) = state().await;
    state.set_backup_run(crate::state::BackupRun::Running);

    let page = html(get(&state, "/data/backups"));
    assert!(page.contains("Creating backup…"), "{page}");
}

/// A host that installed no runtime gets an error, not a button that reports
/// success and does nothing.
#[tokio::test]
async fn without_a_runtime_to_hand_the_work_to_the_button_refuses() {
    let (state, _dir) = state().await;

    let error = router()
        .handle(&state, Request::post("/data/backups/create"))
        .expect_err("no runtime was installed");

    assert!(
        format!("{error:?}").contains("background"),
        "it says what is missing: {error:?}"
    );
}