//! The contacts screen, driven through the router against a real database.
//!
//! Same property as the projects tests: no Tauri runtime and no window, because
//! a route is a function from state and params to a description. What is
//! asserted is the description, and the markup only where the markup is the
//! point.

use std::sync::Arc;

use goingson_core::{NewContact, NewContactEmail, NewSocialHandle};
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
}

/// A contact carrying nothing but its name.
///
/// `NewContact` has no `Default`, and giving it one here would be adding a trait
/// to the core crate for the convenience of one test module.
fn blank(name: &str) -> NewContact {
    NewContact {
        display_name: name.to_owned(),
        nickname: None,
        company: None,
        title: None,
        notes: String::new(),
        tags: Vec::new(),
        birthday: None,
        timezone: None,
        is_implicit: false,
    }
}

fn add(state: &AppState, name: &str) -> goingson_core::Contact {
    state.contacts.create(DESKTOP_USER_ID, blank(name)).unwrap()
}

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) -> Response {
    router()
        .handle(state, Request::post(path))
        .expect("the route answers")
}

fn screen_html(response: Response) -> String {
    let Outcome::Screen(screen) = (response).outcome else {
        panic!("the route answers with a screen");
    };
    quasi_webview::Webview::new().screen(&screen)
}

fn fragment_html(response: Response) -> String {
    let Outcome::Fragment { node, .. } = (response).outcome else {
        panic!("the route answers with a fragment");
    };
    quasi_webview::Webview::new().fragment(&node)
}

#[tokio::test]
async fn an_empty_database_says_so_rather_than_rendering_nothing() {
    let state = state().await;
    let html = screen_html(get(&state, "/contacts", Params::new()));
    assert!(html.contains("No contacts yet."));
}

#[tokio::test]
async fn an_empty_result_says_which_filter_emptied_it() {
    // Three different sentences, because "nothing here" after a search means
    // something different from "nothing here" on a fresh install, and the JS
    // screen already distinguishes them.
    let state = state().await;
    add(&state, "Ada");

    let searched = screen_html(get(&state, "/contacts", Params::new().with("q", "zzz")));
    assert!(searched.contains("No contacts match that search."));

    let tagged = screen_html(get(&state, "/contacts", Params::new().with("tag", "zzz")));
    assert!(tagged.contains("No contacts carry that tag."));
}

#[tokio::test]
async fn a_blank_search_is_the_same_as_no_search() {
    // An emptied search box sends the param with nothing in it. Treating that as
    // a search for the empty string is how a screen goes blank when a user
    // deletes what they typed.
    let state = state().await;
    add(&state, "Ada");

    let html = screen_html(get(&state, "/contacts", Params::new().with("q", "   ")));
    assert!(html.contains("Ada"));
    assert!(!html.contains("No contacts match"));
}

#[tokio::test]
async fn search_is_an_address_not_a_piece_of_module_state() {
    let state = state().await;
    add(&state, "Ada Lovelace");
    add(&state, "Grace Hopper");

    let html = fragment_html(get(
        &state,
        "/contacts/list",
        Params::new().with("q", "Ada"),
    ));
    assert!(html.contains("Ada Lovelace"));
    assert!(!html.contains("Grace Hopper"));
}

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

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

    let html = fragment_html(response);
    assert!(html.starts_with("<ul"));
    assert!(!html.contains("<html"));
    assert!(html.contains("Ada"));
}

#[tokio::test]
async fn the_tag_filter_offers_only_tags_that_are_in_use() {
    let state = state().await;
    let contact = add(&state, "Ada");
    state
        .contacts
        .tag_many(&[contact.id], DESKTOP_USER_ID, "friend")
        .unwrap();

    let html = screen_html(get(&state, "/contacts", Params::new()));
    assert!(html.contains("friend"));

    // And a tag nobody carries is not offered, which is the rule that keeps the
    // band from growing a control per tag ever used.
    assert!(!html.contains("colleague"));
}

#[tokio::test]
async fn a_latched_tag_offers_the_way_back_out_of_itself() {
    let state = state().await;
    let contact = add(&state, "Ada");
    state
        .contacts
        .tag_many(&[contact.id], DESKTOP_USER_ID, "friend")
        .unwrap();

    let html = screen_html(get(
        &state,
        "/contacts",
        Params::new().with("tag", "friend"),
    ));
    // Still on screen while it is the active filter, and its action drops the
    // tag rather than re-applying it.
    assert!(html.contains("friend"));
    assert!(html.contains("hx-get=\"/contacts/list\""));
}

#[tokio::test]
async fn a_row_carries_its_tags_as_tokens_and_its_email_as_the_plain_fact() {
    // Was `a_row_carries_the_email_and_the_tags_as_one_trailing_fact`, which
    // asserted the workaround: both joined into `meta` as
    // "ada@example.com · friend". makeover-layout 0.9.0 gave a row somewhere to
    // put tokens, so the two facts are now the two different kinds of thing they
    // always were.
    let state = state().await;
    let contact = add(&state, "Ada");
    state
        .contacts
        .add_email(
            contact.id,
            DESKTOP_USER_ID,
            NewContactEmail {
                address: "ada@example.com".to_owned(),
                label: "work".to_owned(),
                is_primary: true,
            },
        )
        .unwrap();
    state
        .contacts
        .tag_many(&[contact.id], DESKTOP_USER_ID, "friend")
        .unwrap();

    let html = fragment_html(get(&state, "/contacts/list", Params::new()));

    // The email is a plain trailing fact and stays one.
    assert!(html.contains("class=\"row-meta\">ada@example.com</span>"));
    // The tag is a token, in the token strip, and clicking it filters the grid.
    assert!(html.contains("class=\"row-tokens\""));
    assert!(html.contains("friend"));
    assert!(html.contains("hx-get=\"/contacts/list?tag=friend\""));
    // And no longer joined into one string.
    assert!(!html.contains("ada@example.com · friend"));
}

#[tokio::test]
async fn a_contact_row_can_be_ticked_without_being_the_current_one() {
    // The other closed gap. `Row::selected` used to mean "the detail pane is
    // showing this", so a bulk checkbox had no way to be described. It is now
    // the user's tick, and `current` is the app's pointer.
    let state = state().await;
    add(&state, "Ada");

    let html = fragment_html(get(&state, "/contacts/list", Params::new()));
    assert!(html.contains("type=\"checkbox\""));
    // Selectable but not ticked, and not the current row either.
    assert!(!html.contains(" checked"));
    assert!(!html.contains("aria-current"));
}

#[tokio::test]
async fn a_nickname_joins_the_name_because_a_row_has_nowhere_else_to_put_it() {
    let state = state().await;
    state
        .contacts
        .create(
            DESKTOP_USER_ID,
            NewContact {
                nickname: Some("Countess".to_owned()),
                ..blank("Ada Lovelace")
            },
        )
        .unwrap();

    let html = fragment_html(get(&state, "/contacts/list", Params::new()));
    assert!(html.contains("Ada Lovelace &quot;Countess&quot;"));
}

#[tokio::test]
async fn selecting_a_row_addresses_the_detail_pane() {
    let state = state().await;
    let contact = add(&state, "Ada");

    let html = fragment_html(get(&state, "/contacts/list", Params::new()));
    assert!(html.contains(&format!("hx-get=\"/contacts/{}\"", contact.id)));

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

#[tokio::test]
async fn an_empty_sub_collection_says_so_rather_than_rendering_a_bare_heading() {
    let state = state().await;
    let contact = add(&state, "Ada");

    let html = fragment_html(get(
        &state,
        &format!("/contacts/{}", contact.id),
        Params::new(),
    ));
    assert!(html.contains("No email addresses"));
    assert!(html.contains("No phone numbers"));
    assert!(html.contains("No social handles"));
    assert!(html.contains("No custom fields"));
}

#[tokio::test]
async fn a_social_handles_url_is_a_real_link_that_leaves_the_app() {
    // Was `a_social_handles_url_is_text_because_a_row_cannot_carry_a_link`.
    // Worth noting how that test would have survived this change: it asserted
    // `!html.contains("<a href=\"...")`, and the renderer emits
    // `<a class="act" href=...`, so it passed for the wrong reason. Asserting
    // the absence of a literal string is only as good as the string.
    let state = state().await;
    let contact = add(&state, "Ada");
    state
        .contacts
        .add_social_handle(
            contact.id,
            DESKTOP_USER_ID,
            NewSocialHandle {
                platform: "Mastodon".to_owned(),
                handle: "@ada".to_owned(),
                url: Some("https://example.com/@ada".to_owned()),
            },
        )
        .unwrap();

    let html = fragment_html(get(
        &state,
        &format!("/contacts/{}", contact.id),
        Params::new(),
    ));
    assert!(html.contains("Mastodon: @ada"));

    // An anchor, not a button, and not htmx's business: nothing swaps and no
    // route is called.
    assert!(html.contains("href=\"https://example.com/@ada\""));
    assert!(html.contains("rel=\"noopener noreferrer\""));
    assert!(!html.contains("hx-get=\"https://example.com/@ada\""));

    // The removal beside it is still a route, so both kinds coexist in one row.
    assert!(html.contains(&format!("hx-post=\"/contacts/{}/social/", contact.id)));
}

#[tokio::test]
async fn removing_an_email_answers_with_the_pane_it_happened_in() {
    let state = state().await;
    let contact = add(&state, "Ada");
    let email = state
        .contacts
        .add_email(
            contact.id,
            DESKTOP_USER_ID,
            NewContactEmail {
                address: "ada@example.com".to_owned(),
                label: String::new(),
                is_primary: true,
            },
        )
        .unwrap();

    let before = fragment_html(get(
        &state,
        &format!("/contacts/{}", contact.id),
        Params::new(),
    ));
    assert!(before.contains("ada@example.com"));

    let response = post(
        &state,
        &format!("/contacts/{}/email/{}/delete", contact.id, email.id),
    );
    assert_eq!(response.target(), Some("contacts-detail"));

    let after = fragment_html(response);
    assert!(!after.contains("ada@example.com"));
    assert!(after.contains("No email addresses"));
}

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

#[tokio::test]
async fn an_id_that_is_not_a_uuid_is_a_not_found_rather_than_a_panic() {
    let state = state().await;
    let error = router()
        .handle(&state, Request::get("/contacts/nonsense"))
        .expect_err("not an id");
    assert_eq!(error.class.http_status(), 404);
}

#[tokio::test]
async fn a_contact_name_cannot_become_markup() {
    // The reason the description carries text and the renderer owns escaping.
    // This is the whole point of the port: 57 `esc()` calls across the three
    // contacts files exist to do by hand what this asserts is done by type.
    let state = state().await;
    add(&state, "<script>alert(1)</script>");

    let html = screen_html(get(&state, "/contacts", Params::new()));
    assert!(!html.contains("<script>alert"));
    assert!(html.contains("&lt;script&gt;"));
}

#[tokio::test]
async fn a_social_url_cannot_become_markup_either() {
    // `contacts-render.js` runs the URL through `safeUrl` and then `escAttr`
    // before it reaches an href. Here it is text like everything else, so the
    // only question is whether the renderer escapes it.
    let state = state().await;
    let contact = add(&state, "Ada");
    state
        .contacts
        .add_social_handle(
            contact.id,
            DESKTOP_USER_ID,
            NewSocialHandle {
                platform: "X".to_owned(),
                handle: "@ada".to_owned(),
                url: Some("\"><script>alert(1)</script>".to_owned()),
            },
        )
        .unwrap();

    let html = fragment_html(get(
        &state,
        &format!("/contacts/{}", contact.id),
        Params::new(),
    ));
    assert!(!html.contains("<script>alert"));
}