//! The day view, driven through the router against a real database.
//!
//! Same property as its siblings: no Tauri runtime and no window. What is new
//! here is that the assertions are about *placement*, which is the thing the
//! vocabulary could not carry until `makeover-layout` 0.24.0.

use std::sync::Arc;

use chrono::{Duration, Local, NaiveDate, TimeZone, Utc};
use goingson_core::NewEvent;
use quasi_http::Serves as _;
use quasi_router::{Outcome, 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 = 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
}

/// The day every test in this file draws.
///
/// Fixed rather than "today", because a test whose fixtures are relative to the
/// clock passes at 09:00 and fails at 23:50 when the local day rolls over
/// between building the event and reading the screen.
const DAY: &str = "2026-03-04";

fn day() -> NaiveDate {
    NaiveDate::parse_from_str(DAY, "%Y-%m-%d").unwrap()
}

/// An event on the test day, at a local wall-clock time.
///
/// Local rather than UTC because the screen's whole job is placing things on a
/// *local* day, and a fixture written in UTC would silently test a different
/// hour on any machine not on UTC.
fn event(state: &AppState, title: &str, from: (u32, u32), minutes: i64) {
    let start = Local
        .from_local_datetime(&day().and_hms_opt(from.0, from.1, 0).unwrap())
        .unwrap()
        .with_timezone(&Utc);
    state
        .events
        .create(
            DESKTOP_USER_ID,
            NewEvent::builder(title, start)
                .end_time(start + Duration::minutes(minutes))
                .build(),
        )
        .unwrap();
}

fn get(state: &AppState, path: &str) -> Response {
    router()
        .handle(state, Request::get(path).carrying(Params::new()))
        .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}`")
        }
    }
}

fn screen(state: &AppState) -> String {
    html(get(state, &format!("/day/{DAY}")))
}

#[tokio::test]
async fn an_item_is_placed_at_the_hour_it_starts() {
    let state = state().await;
    event(&state, "Standup", (9, 0), 60);

    let markup = screen(&state);

    // 09:00 on a midnight-to-midnight axis is 540/1440 = 37.5%, and an hour is
    // 60/1440 = 4.1667%. This is the assertion the whole vocabulary change
    // exists for: before Track there was no way to say either number.
    assert!(markup.contains("--track-at:37.5000%"), "{markup}");
    assert!(markup.contains("--track-for:4.1667%"), "{markup}");
    assert!(markup.contains("Standup"), "{markup}");
}

#[tokio::test]
async fn two_things_at_once_take_lanes_and_say_they_clash() {
    let state = state().await;
    event(&state, "Standup", (9, 0), 60);
    event(&state, "Interview", (9, 30), 60);

    let markup = screen(&state);

    // The geometry: two lanes, so neither is drawn on top of the other.
    assert!(markup.contains("--track-lane:0"), "{markup}");
    assert!(markup.contains("--track-lane:1"), "{markup}");
    assert!(markup.contains("--track-lanes:2"), "{markup}");

    // And the judgment, which is a different thing from the geometry and comes
    // from the backend's own `detect_conflicts` rather than from the overlap.
    assert!(markup.contains("clashes"), "{markup}");
}

#[tokio::test]
async fn back_to_back_items_are_not_a_clash() {
    let state = state().await;
    event(&state, "First", (9, 0), 60);
    event(&state, "Second", (10, 0), 60);

    let markup = screen(&state);

    // The off-by-one this guards is the classic day-view bug: every appointment
    // on the hour reading as a conflict with the one before it.
    assert!(markup.contains("--track-lanes:1"), "{markup}");
    assert!(!markup.contains("clashes"), "{markup}");
}

#[tokio::test]
async fn the_axis_carries_an_hourly_ruler() {
    let state = state().await;
    let markup = screen(&state);

    // 96 quarter-hour slots, labelled every fourth. Matches
    // `day-planning-render.js:56`'s `for (let hour = 0; hour < 24; hour++)`.
    assert!(markup.contains(">00:00<"), "{markup}");
    assert!(markup.contains(">09:00<"), "{markup}");
    assert!(markup.contains(">23:00<"), "{markup}");
    assert!(!markup.contains(">09:15<"), "labelled hourly, not per slot");
}

#[tokio::test]
async fn the_interesting_hour_travels_as_a_moment() {
    let state = state().await;
    let markup = screen(&state);

    // What replaces `day-planning-render.js:321`'s `const targetHour = 9`. The
    // app says which hour matters; the host decides how to get there.
    assert!(markup.contains("data-focus=\"540\""), "{markup}");
}

#[tokio::test]
async fn an_events_title_cannot_become_markup() {
    let state = state().await;
    event(&state, "<script>alert('x')</script>", (9, 0), 60);

    let markup = screen(&state);

    // The property this whole port exists for. Being placed on an axis is not a
    // way around the renderer's escaping.
    assert!(!markup.contains("<script>"), "{markup}");
    assert!(markup.contains("&lt;script&gt;"), "{markup}");
}

#[tokio::test]
async fn a_day_with_nothing_on_it_still_draws_its_axis() {
    let state = state().await;
    let markup = screen(&state);

    // An empty day is a day, not an empty state. The ruler is what makes it
    // legible as one, and the JS draws it the same way.
    assert!(markup.contains(">12:00<"), "{markup}");
    assert!(markup.contains("Nothing else due today."), "{markup}");
}

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

    // `/day/yesterday` addresses nothing. Answering it with today's plan would
    // be the screen deciding it knows better than the URL, which is the failure
    // an address exists to prevent.
    let answered = router().handle(
        &state,
        Request::get("/day/yesterday").carrying(Params::new()),
    );
    assert!(answered.is_err(), "an unparseable date should not resolve");
}

#[tokio::test]
async fn stepping_a_day_answers_the_axis_alone() {
    let state = state().await;
    event(&state, "Standup", (9, 0), 60);

    let response = get(&state, &format!("/day/{DAY}/timeline"));
    let Outcome::Fragment { region, .. } = &response.outcome else {
        panic!("stepping a day replaces one region, not the screen");
    };
    assert_eq!(region, "day-timeline");

    let markup = html(response);
    assert!(markup.contains("Standup"), "{markup}");
}

/// A task due on the test day and not on the axis, which is what the pool holds.
fn due_task(state: &AppState, title: &str) -> goingson_core::TaskId {
    let due = Local
        .from_local_datetime(&day().and_hms_opt(12, 0, 0).unwrap())
        .unwrap()
        .with_timezone(&Utc);
    state
        .tasks
        .create(
            DESKTOP_USER_ID,
            goingson_core::NewTask::builder(title).due(due).build(),
        )
        .unwrap()
        .id
}

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

    let markup = screen(&state);

    // The frees-work half only, which is `0df3488`'s reading and the pool's
    // own: the gate already refuses to offer a blocked task until its blockers
    // are in the day, so a "Blocked" badge here would contradict the plan.
    assert!(markup.contains("Unblocks 1"), "{markup}");
    assert!(!markup.contains("Blocked"), "{markup}");
}

/// A task scheduled onto the test day at a local wall-clock time.
///
/// Written through the same function the described route writes through, so the
/// fixture and the thing under test agree about what "scheduled" means -- a task
/// row with a start, and a linked event carrying the block.
fn scheduled_task(state: &AppState, title: &str, at: (u32, u32)) -> goingson_core::TaskId {
    let id = due_task(state, title);
    let start = Local
        .from_local_datetime(&day().and_hms_opt(at.0, at.1, 0).unwrap())
        .unwrap()
        .with_timezone(&Utc);
    crate::commands::day_planning::schedule_task_now(state, id, start, Some(30)).unwrap();
    id
}

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

fn started_at(state: &AppState, id: goingson_core::TaskId) -> chrono::DateTime<Utc> {
    state
        .tasks
        .get_by_id(id, DESKTOP_USER_ID)
        .unwrap()
        .unwrap()
        .scheduled_start
        .expect("still scheduled")
}

#[tokio::test]
async fn a_scheduled_row_carries_the_writes_it_used_to_have_none_of() {
    let state = state().await;
    let id = scheduled_task(&state, "Write the thing", (10, 0));

    let page = screen(&state);
    assert!(
        page.contains(&format!("/day/{DAY}/schedule/{id}/move")),
        "{page}"
    );
    assert!(
        page.contains(&format!("/day/{DAY}/schedule/{id}/unschedule")),
        "{page}"
    );
}

#[tokio::test]
async fn moving_a_task_later_moves_it_by_the_step_it_was_sent() {
    let state = state().await;
    let id = scheduled_task(&state, "Write the thing", (10, 0));
    let before = started_at(&state, id);

    post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/move"),
        Params::new().with("by", "15"),
    );

    assert_eq!(started_at(&state, id) - before, Duration::minutes(15));
}

#[tokio::test]
async fn moving_a_task_earlier_takes_a_negative_step() {
    let state = state().await;
    let id = scheduled_task(&state, "Write the thing", (10, 0));
    let before = started_at(&state, id);

    post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/move"),
        Params::new().with("by", "-15"),
    );

    assert_eq!(started_at(&state, id) - before, Duration::minutes(-15));
}

#[tokio::test]
async fn a_move_that_would_leave_the_day_is_a_no_op_rather_than_an_error() {
    // `moveScheduledTask` refuses to cross midnight and so does this. The
    // control that sent it is on screen either way, so the answer is a fresh
    // axis rather than a 404.
    let state = state().await;
    let id = scheduled_task(&state, "Late one", (23, 45));
    let before = started_at(&state, id);

    let page = html(post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/move"),
        Params::new().with("by", "30"),
    ));

    assert_eq!(started_at(&state, id), before);
    assert!(page.contains("Late one"), "{page}");
}

#[tokio::test]
async fn moving_a_task_keeps_its_linked_block_in_step() {
    // The reason the route calls the command's own body rather than writing the
    // task row itself: the linked event has to move with it, and a second copy
    // of that would drift.
    let state = state().await;
    let id = scheduled_task(&state, "Write the thing", (10, 0));

    post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/move"),
        Params::new().with("by", "60"),
    );

    let block = state
        .events
        .get_by_linked_task(DESKTOP_USER_ID, id)
        .unwrap()
        .expect("the block is still there");
    assert_eq!(block.start_time, started_at(&state, id));
}

#[tokio::test]
async fn unscheduling_takes_the_task_off_the_axis_and_deletes_its_block() {
    let state = state().await;
    let id = scheduled_task(&state, "Not today", (10, 0));

    post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/unschedule"),
        Params::new(),
    );

    let task = state.tasks.get_by_id(id, DESKTOP_USER_ID).unwrap().unwrap();
    assert!(task.scheduled_start.is_none());
    assert!(
        state
            .events
            .get_by_linked_task(DESKTOP_USER_ID, id)
            .unwrap()
            .is_none()
    );
}

#[tokio::test]
async fn moving_a_task_that_is_not_on_the_day_is_a_not_found() {
    let state = state().await;
    let id = due_task(&state, "Never scheduled");

    let error = router()
        .handle(
            &state,
            Request::post(format!("/day/{DAY}/schedule/{id}/move"))
                .sending(Params::new().with("by", "15")),
        )
        .expect_err("that task is not on the day");
    assert_eq!(error.class.http_status(), 404);
}

/// A task due on the test day, carrying an estimate.
///
/// The estimate is what gives the block its size, so a fixture without one is
/// testing the other half of `fa9fe9ed`'s ruling.
fn estimated_task(state: &AppState, title: &str, minutes: i32) -> goingson_core::TaskId {
    let due = Local
        .from_local_datetime(&day().and_hms_opt(12, 0, 0).unwrap())
        .unwrap()
        .with_timezone(&Utc);
    state
        .tasks
        .create(
            DESKTOP_USER_ID,
            goingson_core::NewTask::builder(title)
                .due(due)
                .estimated_minutes(minutes)
                .build(),
        )
        .unwrap()
        .id
}

fn task(state: &AppState, id: goingson_core::TaskId) -> goingson_core::Task {
    state.tasks.get_by_id(id, DESKTOP_USER_ID).unwrap().unwrap()
}

#[tokio::test]
async fn a_pool_row_carries_the_control_that_places_it() {
    let state = state().await;
    let id = estimated_task(&state, "Write the thing", 45);

    let page = screen(&state);

    assert!(
        page.contains(&format!("/day/{DAY}/schedule/{id}/place")),
        "{page}"
    );
    // The argument is which slot, offered as the day's own 96, not typed.
    assert!(page.contains(">09:00<"), "{page}");
    assert!(page.contains(">23:45<"), "{page}");
}

#[tokio::test]
async fn a_task_that_carries_an_estimate_is_not_asked_for_one() {
    let state = state().await;
    estimated_task(&state, "Write the thing", 45);

    let page = screen(&state);

    // Asking would be asking the user to confirm what the task already says.
    assert!(!page.contains("How long it takes"), "{page}");
}

#[tokio::test]
async fn a_task_with_no_estimate_is_asked_how_long_it_takes() {
    let state = state().await;
    due_task(&state, "Never estimated");

    let page = screen(&state);

    // Placeable, and placing it is what fills the missing data in: `fa9fe9ed`
    // ruled (d) over refusing the placement outright.
    assert!(page.contains("How long it takes"), "{page}");
    assert!(page.contains("Placing it records this"), "{page}");
}

#[tokio::test]
async fn placing_a_task_gives_it_a_block_the_size_of_its_estimate() {
    let state = state().await;
    let id = estimated_task(&state, "Write the thing", 45);

    post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/place"),
        Params::new().with("at", "540"),
    );

    let placed = task(&state, id);
    assert_eq!(placed.scheduled_duration, Some(45));
    // 540 is 09:00 local on the day the address names, not on any other day.
    assert_eq!(
        placed.scheduled_start.unwrap(),
        Local
            .from_local_datetime(&day().and_hms_opt(9, 0, 0).unwrap())
            .unwrap()
            .with_timezone(&Utc)
    );
}

#[tokio::test]
async fn placing_a_task_hangs_its_block_off_the_task() {
    let state = state().await;
    let id = estimated_task(&state, "Write the thing", 45);

    post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/place"),
        Params::new().with("at", "540"),
    );

    let block = state
        .events
        .get_by_linked_task(DESKTOP_USER_ID, id)
        .unwrap()
        .expect("placing writes the linked block too");
    assert_eq!(block.start_time, started_at(&state, id));
}

#[tokio::test]
async fn placing_an_unestimated_task_is_what_estimates_it() {
    // The whole of `fa9fe9ed`'s ruling: the missing data gets filled rather
    // than defaulted around.
    let state = state().await;
    let id = due_task(&state, "Never estimated");

    post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/place"),
        Params::new().with("at", "600").with("minutes", "45"),
    );

    let placed = task(&state, id);
    assert_eq!(placed.estimated_minutes, Some(45));
    assert_eq!(placed.scheduled_duration, Some(45));
}

#[tokio::test]
async fn placing_an_unestimated_task_keeps_everything_else_it_had() {
    // The estimate write is a whole-task update, so the risk it carries is
    // clearing a field nobody meant to touch.
    let state = state().await;
    let id = due_task(&state, "Never estimated");
    let before = task(&state, id);

    post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/place"),
        Params::new().with("at", "600").with("minutes", "45"),
    );

    let after = task(&state, id);
    assert_eq!(after.title, before.title);
    assert_eq!(after.due, before.due);
    assert_eq!(after.tags, before.tags);
    assert_eq!(after.priority, before.priority);
}

#[tokio::test]
async fn a_dismissed_ask_places_nothing_and_writes_nothing() {
    // The distinction between (d) and the silent default it beat, and the
    // half that is easy to lose: no answer means no placement, not 15 minutes.
    let state = state().await;
    let id = due_task(&state, "Never estimated");

    let refused = router().handle(
        &state,
        Request::post(format!("/day/{DAY}/schedule/{id}/place"))
            .sending(Params::new().with("at", "540")),
    );

    assert!(refused.is_err(), "an unanswered length should not place");
    let untouched = task(&state, id);
    assert!(untouched.scheduled_start.is_none());
    assert!(untouched.estimated_minutes.is_none());
}

#[tokio::test]
async fn a_slot_outside_the_day_is_refused() {
    let state = state().await;
    let id = estimated_task(&state, "Write the thing", 45);

    let refused = router().handle(
        &state,
        Request::post(format!("/day/{DAY}/schedule/{id}/place"))
            .sending(Params::new().with("at", "1440")),
    );

    assert!(refused.is_err(), "1440 is tomorrow's midnight");
    assert!(task(&state, id).scheduled_start.is_none());
}

#[tokio::test]
async fn placing_answers_with_the_axis_and_the_pool_it_emptied() {
    let state = state().await;
    let id = estimated_task(&state, "Write the thing", 45);

    let response = post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/place"),
        Params::new().with("at", "540"),
    );

    let Outcome::Fragment { region, .. } = &response.outcome else {
        panic!("a placement replaces regions, not the screen");
    };
    assert_eq!(region, "day-timeline");

    // The pool just lost the row, and a fragment that refreshed only the axis
    // would leave it showing a task that is now on the day.
    let pool = response
        .invalidates
        .iter()
        .find(|stale| stale.region == "day-pool")
        .expect("the pool is stale too");
    let markup = quasi_webview::Webview::new().fragment(&pool.node);
    assert!(markup.contains("Nothing else due today."), "{markup}");
}

#[tokio::test]
async fn unscheduling_puts_the_task_back_in_the_pool_it_answers_with() {
    let state = state().await;
    let id = scheduled_task(&state, "Not today", (10, 0));

    let response = post(
        &state,
        &format!("/day/{DAY}/schedule/{id}/unschedule"),
        Params::new(),
    );

    let pool = response
        .invalidates
        .iter()
        .find(|stale| stale.region == "day-pool")
        .expect("the pool is stale too");
    let markup = quasi_webview::Webview::new().fragment(&pool.node);
    assert!(markup.contains("Not today"), "{markup}");
}