//! The user dashboard's Projects panel, described.
//!
//! Second of the tier-1 batch (wiki `mnw-server-conversion-plan`, "The S4 tab
//! inventory"): 53 lines, four `hx-` attributes, no `data-action`, no
//! `<details>`, no `{% include %}`, and nothing in `static/` or `frontend/src`
//! reaches for any id it writes.
//!
//! It replaces `UserProjectsTabTemplate` and the template, and leaves
//! `routes::pages::dashboard::tabs::user::build_projects` in place answering
//! described markup instead of an Askama render.
//!
//! # A fill, not a mounted screen, and the ETag is why
//!
//! Every conversion before this one took its address off the Askama router and
//! answered it through `super::mount`. This one must not: `dashboard_tab_projects`
//! answers a conditional GET keyed on the user's cache generation
//! (`helpers::check_etag` / `with_etag`), and `mount` has no way to say
//! "304 if the generation has not moved". Mounting it would trade a working
//! conditional GET for a tidier route table.
//!
//! So this follows [`super::project_content`] instead, which stayed on its
//! Askama handler for the same reason (see `project_tabs::project_tab_content`,
//! where the ETag is read before the panel is built). The handler and the route
//! survive; what dies is the template.
//!
//! # It has two callers, which is why there are two entry points
//!
//! Projects is the tab the dashboard opens on, so it is rendered *inline* into
//! the page as well as answering its own address when the strip fetches it.
//! [`fill`] is the inline half and [`fragment`] the addressed half. The strip
//! already draws a region carrying [`REGION`], so the inline markup must not
//! wrap itself in a second one, and a route's answer must.
//!
//! # The empty state moves, and stops being reachable at the same time as the list
//!
//! The template renders the project loop and *then* asks whether the list was
//! empty, so an account with no projects drew an empty `role="list"` followed by
//! a Getting Started box. Described, the two are alternatives: a
//! [`layout::Readiness::Empty`] stand-in carries the same four steps and the
//! same call to action, and the list is simply not there. Nothing a reader can
//! see changes, and the `<div role="list">` with no rows in it does.
//!
//! # What the description says that the markup did not
//!
//! Every project card was an `<article>` holding an `<h3>`, two `<div>`s of
//! metadata, a badge and three controls, and the three controls were an anchor,
//! an anchor and a `<button>` on no shared footing. As a [`Row`] it is a
//! primary, a meta line, a token and three acts, and which of them draw as
//! links is the renderer's business rather than the template's.
//!
//! The delete control keeps its confirm and gains nothing else: it already
//! addressed a real route with a real target, which is rarer in this tree than
//! it sounds (see `super::mount`'s note on the two screens that did not).

use makeover_layout as layout;
use quasi_router::screen::{Act, Row, Tag};
use quasi_router::{Action, Node, RegionKind, Slot};
use quasi_webview::Webview;

use crate::types::ProjectCard;

/// The region the answer replaces, keeping the id the page already used.
///
/// `super::user_tabs::TABS` names this rather than transcribing it, the way
/// `user_analytics` already did.
pub const REGION: &str = "user-projects";

/// Where a reader who cannot create projects is sent to ask.
const APPLY: &str = "/dashboard?tab=settings&section=creator";

/// Where a reader who can create one starts.
const NEW_PROJECT: &str = "/dashboard/new-project";

/// The panel as the route answers it: the region, carrying its own id.
///
/// The wrapper matters for the same reason it does on `project_content`: the
/// strip aims the fetch at `#user-projects` and swaps it, so an answer without
/// the id replaces the panel with markup nothing can target afterwards.
#[must_use]
pub fn fragment(projects: &[ProjectCard], can_create_projects: bool) -> String {
    use quasi_axum::Serves as _;

    let mut slot = Slot::new(REGION, RegionKind::Pane);
    for node in body(projects, can_create_projects) {
        slot = slot.with(node);
    }
    Webview::new().fragment(&Node::Region(slot))
}

/// The panel's contents as the page embeds them, without a region wrapper.
///
/// The strip draws the region; this goes inside it. See the module header.
#[must_use]
pub fn fill(projects: &[ProjectCard], can_create_projects: bool) -> String {
    use quasi_axum::Serves as _;

    let mut out = String::new();
    for node in body(projects, can_create_projects) {
        out.push_str(&Webview::new().fragment(&node));
    }
    out
}

/// The panel's contents, in order.
fn body(projects: &[ProjectCard], can_create_projects: bool) -> Vec<Node> {
    let mut out = vec![
        Node::Link {
            text: "Docs: Projects".into(),
            action: Action::get("/docs/projects").navigating(),
        },
        Node::section("Your Projects"),
        start_act(can_create_projects),
    ];

    if projects.is_empty() {
        out.push(getting_started(can_create_projects));
        return out;
    }

    out.push(Node::list(projects.iter().map(card)));
    out
}

/// The one control at the top, which is a different offer per reader.
///
/// Two spellings in the template and one idea: a creator starts a project, and
/// everyone else asks to become one.
fn start_act(can_create_projects: bool) -> Node {
    if can_create_projects {
        // `external` because it is a whole page rather than a fragment, so it
        // leaves. `super::project_content`'s New Item says it the same way and
        // for the same reason: an internal `Action::get` would fetch the wizard
        // into this panel.
        Node::act("New Project", Action::external(NEW_PROJECT))
    } else {
        Node::act("Apply for Creator Access", Action::external(APPLY))
    }
}

/// One project.
fn card(project: &ProjectCard) -> Row {
    let mut meta = format!(
        "{} · Created {}",
        project.project_type, project.created_date
    );
    if let Some(updated) = &project.updated_date {
        meta.push_str(" · Last updated ");
        meta.push_str(updated);
    }

    let mut row = Row::new(project.title.clone()).meta(meta);

    // The template puts `stats` and the badge on one line separated by a
    // middot, and hides the middot when stats is empty. Said as two parts, the
    // renderer decides the separator and the empty case stops being a
    // conditional in the markup.
    if !project.stats.is_empty() {
        row = row.meta(project.stats.clone());
    }

    let mut badge = Tag::badge(project.status.clone());
    badge.tone = tone(project.status_tone);

    row.token(badge)
        .act(Act::new(
            "View",
            Action::external(format!("/p/{}", project.slug)),
        ))
        .act(Act::new(
            "Edit",
            Action::external(format!("/dashboard/project/{}", project.slug)),
        ))
        .act(
            Act::new(
                "Delete",
                Action::delete(format!("/api/projects/{}", project.id)),
            )
            .tone(layout::Tone::Danger)
            .confirm("Delete this project? This cannot be undone."),
        )
}

/// The badge tone, from the string `ProjectCard::from_db` picked.
///
/// A `&'static str` on the type rather than a tone, because the template fed it
/// straight to `data-tone`. Mapped here rather than changed there: making
/// `ProjectCard::status_tone` a `layout::Tone` would put a description type on a
/// view struct four Askama templates still read.
fn tone(status_tone: &str) -> layout::Tone {
    match status_tone {
        "success" => layout::Tone::Success,
        "warning" => layout::Tone::Warning,
        "danger" => layout::Tone::Danger,
        "info" => layout::Tone::Info,
        _ => layout::Tone::Neutral,
    }
}

/// What stands where the list would be, for an account with no projects.
fn getting_started(can_create_projects: bool) -> Node {
    // The four steps are prose rather than a described list: they are one
    // explanation of what the product is, not a set of things with addresses.
    // `Node::Rich` carries the markdown source, which is what lets a terminal
    // render the same four steps without being handed markup.
    Node::Region(
        Slot::new("user-projects-getting-started", RegionKind::Pane)
            .with(Node::StandIn {
                state: layout::Readiness::Empty,
                message: "Welcome to Makenotwork. A project groups your work. Think of it as an \
                          album, podcast feed, or product line. Each project contains items: \
                          individual tracks, episodes, downloads, or posts."
                    .into(),
                act: None,
            })
            .with(Node::rich(
                "1. Create a project\n\
                 2. Add items: audio, video, text, or software\n\
                 3. Set prices (or keep them free) and publish\n\
                 4. Connect your payment account, 0% platform fee",
            ))
            .with(if can_create_projects {
                Node::act("Create Your First Project", Action::external(NEW_PROJECT))
            } else {
                Node::act("Apply for Creator Access", Action::external(APPLY))
            }),
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use quasi_axum::Serves;

    fn project(title: &str) -> ProjectCard {
        ProjectCard {
            id: crate::db::ProjectId::from(uuid::Uuid::nil()),
            title: title.into(),
            project_type: "Album".into(),
            created_date: "Aug 1, 2026".into(),
            updated_date: Some("Aug 20, 2026".into()),
            stats: "3 items".into(),
            status: "Published".into(),
            status_tone: "success",
            slug: "an-album".into(),
        }
    }

    fn render(nodes: &[Node]) -> String {
        let mut out = String::new();
        for node in nodes {
            out.push_str(&Webview::new().fragment(node));
        }
        out
    }

    #[test]
    fn the_strip_and_this_panel_agree_about_the_region() {
        // If these drift the panel's answer lands nowhere, and nothing else
        // would notice. `user_analytics` asserts the same thing for its own.
        let strip = include_str!("user_tabs.rs");
        assert!(strip.contains("user_projects::REGION"), "{REGION}");
    }

    #[test]
    fn no_quasi_route_answers_this_address_so_the_strip_must_still_fetch_it() {
        // The other half of the region agreement, and the one that is easy to
        // get wrong later. `screen: Some(..)` tells the strip a described route
        // owns the address and to leave the region alone; this panel is a fill
        // on the Askama handler, which is what keeps the ETag. The two facts
        // have to move together, so if this address is ever mounted, the strip
        // needs `screen: Some(..)` in the same change or the tab goes blank.
        assert!(
            !crate::quasi::PATHS.contains(&"/dashboard/tabs/projects"),
            "mounted now: give the Projects tab `screen: Some(..)` in user_tabs"
        );
    }

    #[test]
    fn a_project_offers_view_edit_and_a_confirmed_delete() {
        let html = render(&[Node::list([card(&project("An Album"))])]);

        assert!(html.contains("An Album"), "{html}");
        assert!(html.contains("href=\"/p/an-album\""), "{html}");
        assert!(
            html.contains("href=\"/dashboard/project/an-album\""),
            "{html}"
        );
        assert!(
            html.contains(&format!(
                "hx-delete=\"/api/projects/{}\"",
                crate::db::ProjectId::from(uuid::Uuid::nil())
            )),
            "{html}"
        );
        assert!(html.contains("This cannot be undone."), "{html}");
    }

    #[test]
    fn the_meta_line_drops_the_stats_part_rather_than_drawing_an_empty_one() {
        let mut bare = project("Bare");
        bare.stats = String::new();

        let with = render(&[Node::list([card(&project("With"))])]);
        let without = render(&[Node::list([card(&bare)])]);

        assert!(with.contains("3 items"), "{with}");
        assert!(!without.contains("3 items"), "{without}");
        // Both still say the rest of the meta line.
        assert!(without.contains("Created Aug 1, 2026"), "{without}");
    }

    #[test]
    fn an_account_with_no_projects_gets_the_guide_and_no_empty_list() {
        let html = render(&body(&[], true));

        assert!(html.contains("Welcome to Makenotwork."), "{html}");
        assert!(html.contains("Create Your First Project"), "{html}");
        // The template drew an empty `role="list"` above the guide. This is the
        // half of the conversion that removes it.
        assert!(!html.contains("role=\"list\""), "{html}");
    }

    #[test]
    fn a_reader_who_cannot_create_projects_is_offered_the_application_instead() {
        let listed = render(&body(&[project("An Album")], false));
        let empty = render(&body(&[], false));

        for html in [&listed, &empty] {
            assert!(html.contains("Apply for Creator Access"), "{html}");
            assert!(!html.contains("New Project"), "{html}");
            assert!(!html.contains("Create Your First Project"), "{html}");
        }
    }

    #[test]
    fn a_project_title_cannot_smuggle_markup() {
        let html = render(&[Node::list([card(&project("<script>x()</script>"))])]);
        assert!(!html.contains("<script>x()"), "{html}");
    }

    #[test]
    fn the_inline_fill_carries_no_region_because_the_strip_draws_one() {
        let inline = fill(&[project("An Album")], true);
        assert!(!inline.contains(&format!("id=\"{REGION}\"")), "{inline}");
        assert!(inline.contains("An Album"), "{inline}");
    }
}