//! The weekly review, driven through the router against a real database.
//!
//! 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 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, weekly_review};
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()
}

/// A task in a project, due on a day that has already gone.
fn overdue_in_project(state: &AppState, title: &str, project: &str) {
    let project = state
        .projects
        .create(
            DESKTOP_USER_ID,
            goingson_core::NewProject {
                name: project.to_owned(),
                description: String::new(),
                project_type: goingson_core::ProjectType::SideProject,
                status: goingson_core::ProjectStatus::Active,
            },
        )
        .unwrap();
    state
        .tasks
        .create(
            DESKTOP_USER_ID,
            NewTask::builder(title)
                .priority(Priority::High)
                .project_id(project.id)
                .due(chrono::Utc::now() - chrono::Duration::days(3))
                .build(),
        )
        .unwrap();
}

/// The week the tests write into, which is the one anything created now lands
/// in.
fn this_week() -> String {
    weekly_review::current_week_start().to_string()
}

fn get(state: &AppState, path: &str, params: Params) -> Response {
    router()
        .handle(state, Request::get(path).carrying(params))
        .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, for the reason the task tests give: 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}`")
        }
    }
}

/// The review for this week.
fn review(state: &AppState) -> String {
    html(get(state, "/weekly-review", Params::new()))
}

#[tokio::test]
async fn the_review_carries_every_section_it_promises() {
    let state = state().await;
    let page = review(&state);

    for section in [
        "Week at a Glance",
        "Accomplished",
        "Needs Attention",
        "Due This Week",
        // Escaped, because a heading is text and the renderer is the only thing
        // here that ever emits markup.
        "This Week&#39;s Focus",
        "Days Off",
        "Reflection",
    ] {
        assert!(page.contains(section), "missing section: {section}");
    }
}

#[tokio::test]
async fn an_overdue_row_says_its_project_as_well_as_when_it_slipped() {
    // `0c540c6f`. `Row::meta` sets rather than appends, so the project this row
    // placed first was thrown away by the due date placed second and no overdue
    // task ever named the project it belonged to. One joined string is the fix.
    let state = state().await;
    overdue_in_project(&state, "Write the thing", "Ledger");

    let page = review(&state);
    assert!(page.contains("Ledger · 3d ago"), "{page}");
}

#[tokio::test]
async fn a_day_carries_its_counts_as_numbers_rather_than_as_dots() {
    // The first finding. `renderDayDots` caps completed at three dots and the
    // rest at two, which is an encoding running out of room rather than a fact
    // about the week. Seven rows, each saying what it actually holds.
    let state = state().await;
    for index in 0..5 {
        let task = add(&state, &format!("Done {index}"));
        state.tasks.complete(task.id, DESKTOP_USER_ID).unwrap();
    }

    let page = review(&state);

    assert!(page.contains("5 done"), "the fifth completion survives");
    // Seven days, whatever any of them holds.
    for day in ["Mon", "Sun"] {
        assert!(page.contains(day));
    }
}

#[tokio::test]
async fn the_focus_draws_three_named_places_and_the_empty_ones_are_reachable() {
    // The third finding, closed 2026-08-30 (quasicoherent `df57ed16`): three
    // slots always exist in the JS, and a place awaiting content is a region.
    // The meter that stood in for them is gone with the finding.
    let state = state().await;
    let task = add(&state, "The one thing");
    post(
        &state,
        &format!("/weekly-review/focus/{}", task.id),
        Params::new().with("focus", "true"),
    );

    let page = review(&state);

    assert!(page.contains("The one thing"));
    for slot in 1..=3 {
        assert!(
            page.contains(&format!(r#"id="weekly-focus-{slot}""#)),
            "priority {slot} is a place whether or not it is taken"
        );
        assert!(
            page.contains(&format!(r#"aria-label="Priority {slot}""#)),
            "priority {slot} says which one it is"
        );
    }
    // A `section` with a name, which is what makes an empty one reachable
    // rather than a nameless div nothing announces.
    assert!(page.contains(r#"<section id="weekly-focus-2""#));
    // The one that is taken holds the task; the two nobody has filled say so
    // inside their own region rather than as a row standing for nothing.
    let second = page
        .split(r#"id="weekly-focus-2""#)
        .nth(1)
        .expect("the second place is drawn");
    assert!(second[..second.find("weekly-focus-3").unwrap_or(second.len())].contains("Open"));
    // The meter the finding stood in for is gone with it.
    assert!(!page.contains("aria-valuemax"));
}

#[tokio::test]
async fn a_fourth_focused_task_gets_a_fourth_place_rather_than_disappearing() {
    // `tasks.is_focus` is one column and nothing enforces the three, so the
    // count of places is the greater of the two. Three regions and four
    // focused tasks would be a task that stopped existing.
    let state = state().await;
    for index in 1..=4 {
        let task = add(&state, &format!("Priority task {index}"));
        post(
            &state,
            &format!("/weekly-review/focus/{}", task.id),
            Params::new().with("focus", "true"),
        );
    }

    let page = review(&state);

    for index in 1..=4 {
        assert!(page.contains(&format!("Priority task {index}")));
    }
    assert!(page.contains(r#"aria-label="Priority 4""#));
    // And nothing offers a fifth place nobody is standing in.
    assert!(!page.contains(r#"aria-label="Priority 5""#));
}

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

    let focused = html(post(
        &state,
        &format!("/weekly-review/focus/{}", task.id),
        Params::new().with("focus", "true").with("week", &week),
    ));
    assert!(focused.contains("Remove"));
    assert!(focused.contains(r#"aria-label="Priority 1""#));

    let cleared = html(post(
        &state,
        &format!("/weekly-review/focus/{}", task.id),
        Params::new().with("focus", "false").with("week", &week),
    ));
    // Every place is open again, and each still says which one it is.
    assert!(!cleared.contains("Remove"));
    assert!(cleared.contains(r#"aria-label="Priority 3""#));
}

#[tokio::test]
async fn clear_is_an_address_and_never_arrives_as_a_task_id() {
    // A static segment outranks a capture, which is the path matcher's rule
    // and not something the route order here can be relied on to enforce.
    let state = state().await;
    let task = add(&state, "Focused");
    post(
        &state,
        &format!("/weekly-review/focus/{}", task.id),
        Params::new().with("focus", "true"),
    );

    let page = html(post(&state, "/weekly-review/focus/clear", Params::new()));

    assert!(page.contains(r#"aria-label="Priority 1""#));
    // Nothing is holding a slot, so nothing offers to give one up. The task
    // itself comes straight back under Suggested, which is the point of
    // clearing rather than a leak.
    assert!(!page.contains("Remove"));
    assert!(page.contains("Suggested"));
}

#[tokio::test]
async fn a_day_off_is_a_latched_chip_and_clicking_it_twice_puts_it_back() {
    // The one section the vocabulary already had an answer for: seven
    // independently latched things, each answering a click, is a chip. Not a
    // Select, which picks one of a set.
    let state = state().await;

    let plain = review(&state);
    assert!(plain.contains("Wednesday"));
    // `latched`, which is the class makeover styles. This asserted
    // `chip-latched`, a third name that no stylesheet defined, so a latched
    // chip looked exactly like an unlatched one. quasi@f287ac1.
    assert!(!plain.contains("latched"));

    let off = html(post(&state, "/weekly-review/vacation/2", Params::new()));
    assert!(off.contains("latched"));
    assert!(off.contains(r#"aria-pressed="true""#));
    // The day it marks off stops reporting counts and says so.
    assert!(off.contains("Day off"));

    let on_again = html(post(&state, "/weekly-review/vacation/2", Params::new()));
    assert!(!on_again.contains("latched"));
}

#[tokio::test]
async fn an_eighth_weekday_is_a_not_found_rather_than_a_write() {
    let state = state().await;
    let error = router()
        .handle(&state, Request::post("/weekly-review/vacation/7"))
        .expect_err("there is no eighth day");
    assert_eq!(error.class.http_status(), 404);
}

#[tokio::test]
async fn completing_writes_the_notes_the_js_screen_reads_back() {
    // The stored format is `completeWeeklyReview`'s, down to the blank line,
    // because the JS screen still opens these notes.
    let state = state().await;

    let done = post(
        &state,
        "/weekly-review/complete",
        Params::new()
            .with("went-well", "Shipped the fourth screen")
            .with("improve", "Started too late in the day"),
    );
    assert!(done.notice.is_some(), "completing says so");

    let stored = state
        .weekly_reviews
        .get_for_week(DESKTOP_USER_ID, weekly_review::current_week_start())
        .unwrap()
        .expect("the week is written");
    assert_eq!(
        stored.notes,
        "What went well:\nShipped the fourth screen\n\nWhat could be improved:\nStarted too late in the day"
    );

    // And the screen reads them back into the two fields it asked with.
    let page = review(&state);
    assert!(page.contains("Shipped the fourth screen"));
    assert!(page.contains("Started too late in the day"));
    assert!(page.contains("already reviewed"));
    assert!(page.contains("Save notes"));
}

#[tokio::test]
async fn an_unanswered_prompt_is_left_out_rather_than_written_empty() {
    let state = state().await;
    post(
        &state,
        "/weekly-review/complete",
        Params::new()
            .with("went-well", "  ")
            .with("improve", "Less rework"),
    );

    let stored = state
        .weekly_reviews
        .get_for_week(DESKTOP_USER_ID, weekly_review::current_week_start())
        .unwrap()
        .expect("the week is written");
    assert_eq!(stored.notes, "What could be improved:\nLess rework");
}

#[tokio::test]
async fn the_reflection_shows_what_is_stored_and_cannot_say_it_is_a_draft() {
    // The fourth finding, asserted as the loss it is. `weekly-review.js` keeps
    // unsent keystrokes in localStorage against the week and restores them over
    // the stored notes; a Field carries a value and has no way to say the host
    // should be holding one that was never sent.
    let state = state().await;
    post(
        &state,
        "/weekly-review/complete",
        Params::new().with("went-well", "What is stored"),
    );

    let page = review(&state);

    assert!(page.contains("What is stored"));
    assert!(!page.contains("draft"));
}

#[tokio::test]
async fn a_task_title_cannot_become_markup() {
    let state = state().await;
    let task = add(&state, "<script>alert(1)</script>");
    post(
        &state,
        &format!("/weekly-review/focus/{}", task.id),
        Params::new().with("focus", "true"),
    );

    let page = review(&state);

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

#[tokio::test]
async fn a_past_week_is_reachable_by_address_and_holds_none_of_this_weeks_work() {
    // The week is an address rather than a variable, which is the whole reason
    // every action carries it.
    let state = state().await;
    let task = add(&state, "This week only");
    state.tasks.complete(task.id, DESKTOP_USER_ID).unwrap();

    let long_ago = (weekly_review::current_week_start() - chrono::Duration::days(70)).to_string();
    let page = html(get(
        &state,
        "/weekly-review",
        Params::new().with("week", &long_ago),
    ));

    assert!(page.contains("Nothing completed this week"));
    assert!(!page.contains("This week only"));
    // And its arrows still point at weeks either side of the one being read.
    assert!(page.contains("Previous week"));
}

#[tokio::test]
async fn an_unparseable_week_lands_on_this_one_rather_than_erroring() {
    let state = state().await;
    let page = html(get(
        &state,
        "/weekly-review",
        Params::new().with("week", "last tuesday"),
    ));
    assert!(page.contains("Week at a Glance"));
}

#[tokio::test]
async fn a_blocked_candidate_is_offered_and_names_what_it_waits_on() {
    // Decision 143d71b1: a blocked task is a legitimate focus, so the picker
    // marks it rather than filtering it out. The candidate set is unchanged in
    // size, which is the half a filter would have taken.
    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 = review(&state);

    assert!(page.contains("Then this"), "still offered: {page}");
    assert!(page.contains("after Do this first"), "{page}");
    // Naming the blocker is the whole marker. A bare "Blocked" would be the
    // phrasing this deliberately replaced.
    assert!(!page.contains(">Blocked<"), "{page}");
}

#[tokio::test]
async fn a_cycled_candidate_reads_differently_from_a_merely_blocked_one() {
    // A cycle never opens, so doing the named blocker would not help. Same
    // distinction `Availability::marker` draws on every other task surface.
    let state = state().await;
    let first = add(&state, "Round one");
    let second = add(&state, "Round two");
    state
        .tasks
        .add_dependency(DESKTOP_USER_ID, second.id, first.id)
        .unwrap();
    // The write path refuses a cycle, so the closing leg goes in the way a sync
    // pull puts it there: two individually legal edges merged behind the
    // repository. Same setup as `a_cycle_merged_in_behind_the_repository_...`
    // in the dependency repo's own tests.
    state
        .db
        .conn()
        .unwrap()
        .execute(
            "INSERT INTO task_dependencies (id, blocked_id, blocker_id, created_at) \
             VALUES (?, ?, ?, datetime('now'))",
            rusqlite::params![
                uuid::Uuid::new_v4().to_string(),
                first.id.to_string(),
                second.id.to_string(),
            ],
        )
        .unwrap();
    state.tasks.recompute_graph(DESKTOP_USER_ID).unwrap();

    let page = review(&state);

    assert!(page.contains("Cycle"), "{page}");
}