//! The project dashboard's Content panel, described.
//!
//! B4's centrepiece, and the close condition makeover-layout `N12` has been
//! waiting on since 2026-08-18. That task decided two things about this screen
//! and then had nowhere to spend them: the ticks are a payload the renderer
//! assembles rather than something the layer names, and the three filter
//! controls are a **server round trip** rather than a client-side pass over
//! rendered rows. Both are what this module is built out of.
//!
//! Compare `routes::pages::dashboard::project_tabs::build_content`, which
//! answers the same address from Askama when the screen is switched off, and
//! `static/tab-project-content.js`, whose 334 lines are what a described panel
//! replaces.
//!
//! # A view is an address
//!
//! Every narrowing the shipped screen holds in module scope -- the search box,
//! the two selects, the sort column and its direction, which bundles are
//! expanded -- is a query param here, and [`View`] is the whole of that state.
//! `filterContentTable` walked the DOM and toggled a `hidden` class on rows;
//! `sortContentTable` reordered `<tr>` nodes and kept `contentSortState` in a
//! closure. Neither survives a fragment swap, which is why the JS re-applied
//! both after every refresh, and neither is reachable with JS off.
//!
//! The cost is a round trip per keystroke-settle and per press, which is what
//! `N12` weighed and accepted: this is one table in one project, already fetched
//! from Postgres on every tab press, and the count that decided it found no
//! other local filter in the tree to generalise from.
//!
//! # What the selection costs, and what it does not
//!
//! Nothing here counts the ticks. A tick is the host's until something submits
//! it, so "3 selected" and the disabled-until-non-empty bar are the renderer's
//! (quasi ships `quasi-selection.js` for the webview) and no description says
//! them. Select-all is the other half and is an address --
//! [`View::ticked`] -- for goingson's reason: a renderer that ticked its own
//! boxes would need a script per host, and the answer to a filter change is a
//! new set of rows anyway.
//!
//! # The parity harness does not apply to this one
//!
//! Every batch before this asserted the described screen rendered what Askama
//! rendered, normalized. This screen cannot: `N12` decided the filters are a
//! round trip, so the two renderings answer *different sets of rows* for the
//! same address, and the tick column is a gutter rather than a `<th>`. The
//! safety argument is the pressed-controls suite instead
//! (`tests/workflows/project_content_panel.rs`), which is the harness the
//! earlier batches added when they found that an address is not an answer.
//!
//! # Findings
//!
//! **1. Sales and Revenue are zero for every row, and always have been.**
//! `ContentItem::from_db` writes `sales: 0` and `revenue: "$0"`, and nothing on
//! the content path fills them in; only the analytics tab computes real
//! numbers. So two of the table's eight columns have shown the same two
//! constants since they were added, and two of the JS sort modes (`num`,
//! `money`) sorted a column of identical values. Carried forward here rather
//! than fixed, because fixing it is a query this conversion should not be
//! choosing, and filed instead.
//!
//! **2. The status filter could not name every status a row can wear.** The
//! template offers Active and Draft; `ContentItem::from_db` also produces
//! Scheduled, for an item with a `publish_at`. Under the JS the filter compared
//! the badge text exactly, so picking either option hid every scheduled item
//! and nothing offered a way back to them. [`STATUSES`] offers all three.
//!
//! **3. Inline rename survives, as a control that asks for a value.** The JS
//! swapped the title cell for an `<input>` and saved on blur, which no
//! description says. [`Act::asking`] is the shape that does -- the same member
//! "Set Price" uses -- so Rename is a row control that reveals one box and
//! applies it. What is lost is editing in place; what is gained is a rename
//! that works with JS off and in a terminal.
//!
//! **4. Bundle children expand through the address.** `toggleBundleChildren`
//! toggled a class on rows already in the document. There is no disclosure in
//! the vocabulary for a *row group*, and rather than reach for one this carries
//! the open bundles on the view: pressing Expand is a round trip that answers
//! the panel with the children in it. Cheap here (they are already loaded) and
//! it survives a swap, which the class did not.

use makeover_layout as layout;
use quasi_router::screen::{Act, Cell, Cells, Choice, Column, Consult, Field, Tag};
use quasi_router::{Action, Node, RegionKind, Slot};
use quasi_webview::Webview;

use crate::templates::DeletedItemRow;
use crate::types::{BlogPostDashboardRow, ContentItem};

/// The region the answer replaces: the panel the project tab strip targets.
///
/// The same id `quasi::project_tabs` gives the Content tab's bespoke region, so
/// a described answer lands where a pressed tab lands.
pub const REGION: &str = "project-content";

/// The screen's one selection, named once.
///
/// See [`Act::over`] for why a renderer does not match this against the screen:
/// a fragment carries no screen, so the name is what makes a control readable
/// rather than what binds it to a set.
const SELECTION: &str = "chosen";

/// How long the search box waits before asking, and how little it will ask about.
///
/// The shipped box filters on every keystroke because filtering was local and
/// free. It is a query now, so it waits: `page-discover.js`'s numbers, which are
/// the corpus' own for a search box over a catalogue.
const SEARCH_WAIT: std::time::Duration = std::time::Duration::from_millis(200);
const SEARCH_FLOOR: usize = 2;

/// The statuses the filter offers.
///
/// All three a row can wear. See finding 2: the template offered two of them.
const STATUSES: [&str; 3] = ["Active", "Draft", "Scheduled"];

/// What the table can be ordered by.
///
/// The six sortable headings, in column order. `#` is the project's own order
/// and is what the reorder arrows change, so it is not one of these: sorting by
/// it and then pressing an arrow would move a row against an order the reader
/// cannot see.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SortBy {
    Item,
    Kind,
    Price,
    Sales,
    Revenue,
    Status,
}

impl SortBy {
    /// The word it travels as.
    const fn word(self) -> &'static str {
        match self {
            Self::Item => "item",
            Self::Kind => "type",
            Self::Price => "price",
            Self::Sales => "sales",
            Self::Revenue => "revenue",
            Self::Status => "status",
        }
    }

    /// The column it orders, or `None` for a word no heading carries.
    ///
    /// Strict rather than defaulting: an address naming a column that does not
    /// exist is a wiring mistake, and answering it with the default order hides
    /// one.
    fn of(word: &str) -> Option<Self> {
        [
            Self::Item,
            Self::Kind,
            Self::Price,
            Self::Sales,
            Self::Revenue,
            Self::Status,
        ]
        .into_iter()
        .find(|sort| sort.word() == word)
    }
}

/// Which rows, in what order, and which bundles are open.
///
/// Query params rather than module state, per quasi's decision 2 and `N12`'s
/// ruling. Every member here is a fact `tab-project-content.js` held in a
/// closure and re-applied by hand after each swap.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct View {
    /// What the search box holds. Blank is absent.
    pub query: Option<String>,
    /// The status being looked at. `None` is every status.
    pub status: Option<String>,
    /// The item type being looked at. `None` is every type.
    pub kind: Option<String>,
    /// What the table is ordered by. `None` is the project's own order.
    pub sort: Option<SortBy>,
    /// Which way, when there is a sort at all.
    pub descending: bool,
    /// The bundles whose children are showing.
    pub open: Vec<String>,
    /// Whether the rows arrive ticked.
    ///
    /// Select-all, and it is an address for the reason goingson's task list
    /// gives: a webview renderer would need a script to tick its own boxes and a
    /// terminal would need a key it invented, where a server answers it for
    /// every host at once. Only the arriving state; what the reader unticks
    /// afterwards is the host's.
    pub ticked: bool,
}

impl View {
    /// The view a request asked for.
    ///
    /// A blank param is an absent one, which is what the "All statuses" option
    /// sends. An unknown sort column is a 404 rather than a silent default; see
    /// [`SortBy::of`].
    #[must_use]
    pub fn of(
        query: Option<&str>,
        status: Option<&str>,
        kind: Option<&str>,
        sort: Option<&str>,
        direction: Option<&str>,
        open: Option<&str>,
        ticked: Option<&str>,
    ) -> Option<Self> {
        let text = |raw: Option<&str>| {
            raw.map(str::trim)
                .filter(|value| !value.is_empty())
                .map(str::to_owned)
        };

        let sort = match text(sort) {
            None => None,
            Some(word) => Some(SortBy::of(&word)?),
        };

        Some(Self {
            query: text(query),
            status: text(status).filter(|word| STATUSES.contains(&word.as_str())),
            kind: text(kind),
            sort,
            descending: matches!(direction, Some("desc")),
            open: text(open)
                .map(|raw| raw.split(' ').map(str::to_owned).collect())
                .unwrap_or_default(),
            ticked: matches!(ticked, Some("all")),
        })
    }

    /// The address of the panel under this view, aimed at the region it fills.
    fn panel(&self, slug: &str) -> Action {
        self.carry(Action::get(base(slug))).replacing(REGION)
    }

    /// A write under this view, answering the panel it was pressed on.
    ///
    /// Every described write here carries the view for one reason: the answer is
    /// the whole panel, so a bulk publish under a filter has to come back under
    /// that filter or the reader is moved somewhere they did not ask to go.
    fn write(&self, slug: &str, tail: &str) -> Action {
        self.carry(Action::post(format!("{}/{tail}", base(slug))))
            .replacing(REGION)
            .awaiting()
    }

    /// The same action, still pointed at the view it was offered under.
    ///
    /// A default is never written, so two addresses for one view cannot exist.
    fn carry(&self, action: Action) -> Action {
        let mut action = action;
        if let Some(query) = &self.query {
            action = action.carrying("q", query);
        }
        if let Some(status) = &self.status {
            action = action.carrying("status", status);
        }
        if let Some(kind) = &self.kind {
            action = action.carrying("type", kind);
        }
        if let Some(sort) = self.sort {
            action = action.carrying("sort", sort.word());
            if self.descending {
                action = action.carrying("direction", "desc");
            }
        }
        if !self.open.is_empty() {
            action = action.carrying("open", self.open.join(" "));
        }
        if self.ticked {
            action = action.carrying("ticked", "all");
        }
        action
    }

    /// The view ordered by this column: flipped if it is already the sort,
    /// ascending if it is not. `sortContentTable`'s own rule.
    fn sorted_by(&self, sort: SortBy) -> Self {
        Self {
            sort: Some(sort),
            descending: self.sort == Some(sort) && !self.descending,
            ..self.narrowed()
        }
    }

    /// The same view with one bundle's children shown, or hidden if they were.
    fn toggling(&self, bundle: &str) -> Self {
        let mut open = self.open.clone();
        if let Some(at) = open.iter().position(|id| id == bundle) {
            open.remove(at);
        } else {
            open.push(bundle.to_owned());
        }
        Self {
            open,
            ..self.clone()
        }
    }

    /// The same view with the arriving ticks dropped.
    ///
    /// What a narrowing keeps. The ticks a reader made go with the rows they
    /// were on, which is the answer being a new list; `ticked=all` is carried on
    /// the address and would silently come to mean a different everything.
    /// `tab-project-content.js` clears the selection on a filter change by hand
    /// for the same reason.
    fn narrowed(&self) -> Self {
        Self {
            ticked: false,
            ..self.clone()
        }
    }

    /// The same view with one control's own value dropped.
    ///
    /// What a control's address has to leave out. A field sends its value under
    /// its own name, so an address that also carried the value it was offered
    /// under would send the old one beside the new one and the handler would
    /// have to guess which was meant.
    fn without_query(&self) -> Self {
        Self {
            query: None,
            ..self.clone()
        }
    }

    fn without_status(&self) -> Self {
        Self {
            status: None,
            ..self.clone()
        }
    }

    fn without_kind(&self) -> Self {
        Self {
            kind: None,
            ..self.clone()
        }
    }

    /// Whether anything is hidden. What "Clear filters" is offered for, and it
    /// ignores the sort and the open bundles: neither hides a row.
    #[must_use]
    pub fn filtered(&self) -> bool {
        self.query.is_some() || self.status.is_some() || self.kind.is_some()
    }

    /// Whether this is the view an unadorned address asks for.
    ///
    /// Read by the route to decide whether the panel may carry the project's
    /// ETag: the tag is the project's cache generation, which does not move when
    /// a filter does, so a narrowed panel must not be cached under it.
    #[must_use]
    pub fn is_default(&self) -> bool {
        *self == Self::default()
    }

    /// Whether a row survives the narrowing.
    fn keeps(&self, item: &ContentItem) -> bool {
        let matches_query = self.query.as_ref().is_none_or(|query| {
            item.title
                .to_lowercase()
                .contains(&query.trim().to_lowercase())
        });
        let matches_status = self
            .status
            .as_ref()
            .is_none_or(|status| &item.status == status);
        let matches_kind = self
            .kind
            .as_ref()
            .is_none_or(|kind| &item.item_type == kind);
        matches_query && matches_status && matches_kind
    }

    /// The rows this view shows, in the order it shows them.
    fn shown<'a>(&self, items: &'a [ContentItem]) -> Vec<&'a ContentItem> {
        let mut shown: Vec<&ContentItem> = items.iter().filter(|item| self.keeps(item)).collect();
        if let Some(sort) = self.sort {
            // Stable, so rows that tie keep the project's own order rather than
            // a different one each press.
            shown.sort_by(|a, b| {
                let ordering = match sort {
                    SortBy::Item => a.title.to_lowercase().cmp(&b.title.to_lowercase()),
                    SortBy::Kind => a.item_type.to_lowercase().cmp(&b.item_type.to_lowercase()),
                    SortBy::Price => a.price_cents.cmp(&b.price_cents),
                    SortBy::Sales => a.sales.cmp(&b.sales),
                    // Finding 1: every row's revenue is the same string, so this
                    // orders nothing until the numbers are real. Sorted on the
                    // text rather than on a parse of it, which would be a parse
                    // of our own formatting.
                    SortBy::Revenue => a.revenue.cmp(&b.revenue),
                    SortBy::Status => a.status.cmp(&b.status),
                };
                if self.descending {
                    ordering.reverse()
                } else {
                    ordering
                }
            });
        }
        shown
    }
}

/// The address every control on this panel is written against.
fn base(slug: &str) -> String {
    format!("/dashboard/project/{slug}/tabs/content")
}

/// The tone a badge wears, from the tone word the view model already picked.
///
/// The template writes `data-tone="{{ status_tone }}"` and the described badge
/// says the same thing in the vocabulary's words, so the two renderings agree
/// about which item looks live.
fn tone(word: &str) -> layout::Tone {
    match word {
        "success" => layout::Tone::Success,
        "warning" => layout::Tone::Warning,
        "danger" => layout::Tone::Danger,
        _ => layout::Tone::Neutral,
    }
}

/// The ghost text a field shows while it is empty.
///
/// `Field::placeholder` is a public member with no builder beside it, so this is
/// the one line that would otherwise be a `let mut` in three places.
fn ghost(mut field: Field, text: &str) -> Field {
    field.placeholder = Some(text.to_owned());
    field
}

/// Everything inside the Content panel, as the tab strip's fill.
///
/// Without the region wrapper, because the strip already draws one carrying
/// [`REGION`] and the panel goes inside it. [`fragment`] is the same content
/// wrapped, which is what a route answers.
#[must_use]
pub fn fill(
    slug: &str,
    items: &[ContentItem],
    deleted: &[DeletedItemRow],
    posts: &[BlogPostDashboardRow],
    view: &View,
) -> String {
    use quasi_axum::Serves as _;

    let mut out = String::new();
    for node in body(slug, items, deleted, posts, view) {
        out.push_str(&Webview::new().fragment(&node));
    }
    out
}

/// The panel as a route answers it: the region, carrying its own id.
///
/// The wrapper matters. A control here aims its answer with
/// `hx-target="#project-content"` and htmx swaps `outerMorph`, so an answer
/// without the id would replace the panel with markup nothing can target
/// afterwards.
#[must_use]
pub fn fragment(
    slug: &str,
    items: &[ContentItem],
    deleted: &[DeletedItemRow],
    posts: &[BlogPostDashboardRow],
    view: &View,
) -> String {
    use quasi_axum::Serves as _;

    let mut slot = Slot::new(REGION, RegionKind::Pane);
    for node in body(slug, items, deleted, posts, view) {
        slot = slot.with(node);
    }
    Webview::new().fragment(&Node::Region(slot))
}

/// The panel's contents, in order.
fn body(
    slug: &str,
    items: &[ContentItem],
    deleted: &[DeletedItemRow],
    posts: &[BlogPostDashboardRow],
    view: &View,
) -> Vec<Node> {
    let mut out = vec![
        Node::section("Items"),
        Node::act(
            "New Item",
            // A whole page rather than a fragment, so it leaves: see
            // `quasi::forum_memberships` for the same spelling. An internal
            // `Action::get` would fetch the wizard into this panel.
            Action::external(format!("/dashboard/project/{slug}/new-item")),
        ),
    ];

    if items.is_empty() {
        // The project's own empty state, which is a different sentence from a
        // filter matching nothing and is the only one that offers a way to make
        // the first item.
        out.push(
            Node::empty("No items in this project yet. Add your first item to start publishing.")
                .offering(Act::new(
                    "Add First Item",
                    Action::external(format!("/dashboard/project/{slug}/new-item")),
                )),
        );
        out.push(Node::text(
            "After creating an item, set its pricing and publish it to make it available to fans.",
        ));
    } else {
        out.push(Node::Region(filters(slug, items, view)));
        out.push(Node::Region(bulk(slug, view)));

        let shown = view.shown(items);
        if shown.is_empty() {
            out.push(
                Node::empty("No items match these filters.").offering(Act::new(
                    "Clear filters",
                    View {
                        sort: view.sort,
                        descending: view.descending,
                        ..View::default()
                    }
                    .panel(slug),
                )),
            );
        } else {
            out.push(table(slug, view, &shown));
        }
    }

    if !deleted.is_empty() {
        out.push(Node::section(format!(
            "Recently Deleted ({})",
            deleted.len()
        )));
        out.push(Node::text(
            "Deleted items are permanently removed after 7 days.",
        ));
        out.push(deleted_table(slug, view, deleted));
    }

    out.push(Node::section("Blog Posts"));
    out.push(Node::act(
        "New Post",
        Action::external(format!("/dashboard/project/{slug}/blog/new")),
    ));
    if posts.is_empty() {
        out.push(Node::empty(
            "No blog posts yet. Share updates, release notes, or stories with your audience.",
        ));
    } else {
        out.push(posts_table(slug, view, posts));
    }

    out
}

/// The three narrowing controls.
///
/// `N12`'s decision in one function: each is a control with a route, and the
/// answer is the panel under the new view. The search box asks as it is typed
/// ([`Consult`]) and the two pickers write when they settle
/// ([`Field::changes`]) -- which is the difference between a value that is
/// still being written and one that is chosen in a single gesture.
fn filters(slug: &str, items: &[ContentItem], view: &View) -> Slot {
    let narrowed = view.narrowed();

    let search = ghost(
        Field::new(layout::FieldKind::Text, "q", "Search items"),
        "Search items...",
    )
    .value(view.query.clone().unwrap_or_default())
    .consulting(
        Consult::new(narrowed.without_query().panel(slug))
            .after(SEARCH_WAIT)
            .at_least(SEARCH_FLOOR),
    );

    let mut statuses = vec![Choice::new("", "All statuses")];
    statuses.extend(STATUSES.iter().map(|status| Choice::new(*status, *status)));

    // The type options are the types this project actually holds. The template
    // emitted one `<option>` per item and deleted the duplicates in JS on load;
    // counted once here instead.
    let mut kinds: Vec<&str> = items.iter().map(|item| item.item_type.as_str()).collect();
    // The type in force stays on the list even when nothing carries it any
    // more, which happens when the last item of a kind is deleted or renamed
    // under the filter. Without it the picker reads "All types" while the table
    // is narrowed, and the control disagrees with the rows beside it.
    if let Some(kind) = &view.kind {
        kinds.push(kind.as_str());
    }
    kinds.sort_unstable();
    kinds.dedup();
    let mut types = vec![Choice::new("", "All types")];
    types.extend(kinds.iter().map(|kind| Choice::new(*kind, *kind)));

    Slot::new("content-filters", RegionKind::Group)
        .with(Node::field(search))
        .with(Node::field(
            Field::select("status", "Status", statuses)
                .value(view.status.clone().unwrap_or_default())
                .changes(narrowed.without_status().panel(slug)),
        ))
        .with(Node::field(
            Field::select("type", "Type", types)
                .value(view.kind.clone().unwrap_or_default())
                .changes(narrowed.without_kind().panel(slug)),
        ))
}

/// The controls over the selection.
///
/// The shipped bar's five verbs, and its two halves are the two shapes a
/// selection control has: Publish, Unpublish and Delete act on the set, while
/// Set Price and Add Tag apply a value to it. The second pair is
/// [`Act::asking`], which is the member `033ff3ca` grew off this exact bar.
///
/// What is not here is the count and the disabling, for [`Act::over`]'s stated
/// reason: the ticks are the host's until something submits them.
fn bulk(slug: &str, view: &View) -> Slot {
    let mut slot = Slot::new("content-bulk", RegionKind::Group)
        .with(Node::Act(
            Act::new("Publish", view.write(slug, "bulk/publish")).over(SELECTION),
        ))
        .with(Node::Act(
            Act::new("Unpublish", view.write(slug, "bulk/unpublish")).over(SELECTION),
        ))
        .with(Node::Act(
            Act::new("Set Price", view.write(slug, "bulk/price"))
                .over(SELECTION)
                .asking(
                    Field::new(layout::FieldKind::Number, "price_dollars", "New price ($)")
                        .hint("Enter 0 to make items free."),
                ),
        ))
        .with(Node::Act(
            Act::new("Add Tag", view.write(slug, "bulk/tag"))
                .over(SELECTION)
                .asking(
                    ghost(
                        Field::new(layout::FieldKind::Text, "tag_slug", "Tag slug"),
                        "e.g. audio.genre.ambient",
                    )
                    .hint("Use dot-notation: type.category.value"),
                ),
        ))
        .with(Node::Act(
            Act::new("Delete", view.write(slug, "bulk/delete"))
                .over(SELECTION)
                .tone(layout::Tone::Danger)
                // The JS listed the titles in a `confirm()`. A description
                // carries no list of what is ticked -- it does not know -- so
                // the question is the one every host can ask.
                .confirm("Delete every selected item? This cannot be undone."),
        ));

    // Select-all is an address. Its opposite is the same address without it, and
    // is only offered when there is something to clear.
    slot = slot.with(Node::act(
        "Select all",
        View {
            ticked: true,
            ..view.clone()
        }
        .panel(slug),
    ));
    if view.ticked {
        slot = slot.with(Node::act("Deselect", view.narrowed().panel(slug)));
    }
    slot
}

/// The columns, each carrying what pressing it does.
fn columns(slug: &str, view: &View) -> Vec<Column> {
    let sortable = [
        (
            "Item",
            SortBy::Item,
            layout::Width::Fill,
            layout::Priority::Essential,
        ),
        (
            "Type",
            SortBy::Kind,
            layout::Width::Content,
            layout::Priority::Secondary,
        ),
        (
            "Price",
            SortBy::Price,
            layout::Width::Content,
            layout::Priority::Secondary,
        ),
        (
            "Sales",
            SortBy::Sales,
            layout::Width::Content,
            layout::Priority::Optional,
        ),
        (
            "Revenue",
            SortBy::Revenue,
            layout::Width::Content,
            layout::Priority::Optional,
        ),
        (
            "Status",
            SortBy::Status,
            layout::Width::Content,
            layout::Priority::Essential,
        ),
    ];

    let mut out = vec![Column::new("#").width(layout::Width::Content)];
    for (name, sort, width, priority) in sortable {
        let mut column = Column::new(name)
            .width(width)
            .priority(priority)
            .reorder(view.sorted_by(sort).panel(slug));
        if view.sort == Some(sort) {
            column = column.sorted(if view.descending {
                layout::Sort::Descending
            } else {
                layout::Sort::Ascending
            });
        }
        out.push(column);
    }
    out.push(
        Column::new("Actions")
            .width(layout::Width::Content)
            .priority(layout::Priority::Essential),
    );
    out
}

/// The items table, with each open bundle's children under it.
fn table(slug: &str, view: &View, shown: &[&ContentItem]) -> Node {
    let mut rows = Vec::new();
    for (at, item) in shown.iter().enumerate() {
        rows.push(item_row(slug, view, item, at, shown.len()));
        if view.open.iter().any(|open| open == &item.id) {
            rows.extend(item.children.iter().map(|child| child_row(view, child)));
        }
    }

    Node::Table {
        columns: columns(slug, view),
        rows,
        // No paging: the handler reads the project's whole catalogue and the
        // table shows what the filters left.
        more: None,
    }
}

/// One item, and everything that can be done to it.
fn item_row(slug: &str, view: &View, item: &ContentItem, at: usize, of: usize) -> Cells {
    let mut position = Cell::new(item.position.to_string());
    // The order is the project's, so the arrows only mean something under it.
    // Under a sort they would move a row against an order the reader cannot see.
    if view.sort.is_none() {
        if at > 0 {
            position = position.act(Act::new(
                "Move up",
                view.write(slug, &format!("move/{}", item.id))
                    .carrying("direction", "up"),
            ));
        }
        if at + 1 < of {
            position = position.act(Act::new(
                "Move down",
                view.write(slug, &format!("move/{}", item.id))
                    .carrying("direction", "down"),
            ));
        }
    }

    let mut title = Cell::new(item.title.clone())
        .activate(Action::external(format!("/dashboard/item/{}", item.id)));
    if item.is_unlisted {
        title = title.token(Tag::badge("Unlisted"));
    }
    if !item.children.is_empty() {
        let open = view.open.iter().any(|id| id == &item.id);
        title = title.act(Act::new(
            if open { "Collapse" } else { "Expand" },
            view.toggling(&item.id).panel(slug),
        ));
    }

    let kind = if item.children.is_empty() {
        item.item_type.clone()
    } else {
        format!("{} ({})", item.item_type, item.children.len())
    };

    Cells::new([
        position,
        title,
        Cell::new(kind),
        Cell::new(item.price.clone()),
        Cell::new(item.sales.to_string()),
        Cell::new(item.revenue.clone()),
        Cell::tag(Tag::badge(item.status.clone()).tone(tone(item.status_tone))),
        Cell::acts(acts_for(slug, view, item)),
    ])
    .ticking(item.id.clone(), view.ticked)
}

/// A bundle's child, which is a row of the same table and not a table of its own.
///
/// Every cell muted in the template, which is presentation and is the
/// renderer's; what the description says is that the row is a child, and it says
/// it by the arrow the title carries. It is tickable for the reason the shipped
/// checkbox is: a child can be published or repriced with the rest.
fn child_row(view: &View, child: &ContentItem) -> Cells {
    Cells::new([
        Cell::new(""),
        Cell::new(format!("\u{21b3} {}", child.title))
            .activate(Action::external(format!("/dashboard/item/{}", child.id))),
        Cell::new(child.item_type.clone()),
        Cell::new(child.price.clone()),
        Cell::new(child.sales.to_string()),
        Cell::new(child.revenue.clone()),
        Cell::tag(Tag::badge(child.status.clone()).tone(tone(child.status_tone))),
        Cell::acts([Act::new(
            "Edit",
            Action::external(format!("/dashboard/item/{}", child.id)),
        )]),
    ])
    .ticking(child.id.clone(), view.ticked)
}

/// The row's own controls, which are not the selection's.
fn acts_for(slug: &str, view: &View, item: &ContentItem) -> Vec<Act> {
    let mut acts = Vec::new();
    if item.status == "Draft" {
        acts.push(Act::new(
            "Continue",
            Action::external(format!(
                "/dashboard/project/{slug}/new-item/{}/step/details",
                item.id
            )),
        ));
        acts.push(Act::new(
            "Publish",
            view.write(slug, &format!("publish/{}", item.id)),
        ));
    } else {
        acts.push(Act::new(
            "View",
            Action::external(format!("/i/{}", item.id)),
        ));
    }
    acts.push(Act::new(
        "Edit",
        Action::external(format!("/dashboard/item/{}", item.id)),
    ));
    // Finding 3: the inline editor becomes a control that asks for a value.
    acts.push(
        Act::new("Rename", view.write(slug, &format!("rename/{}", item.id))).asking(
            Field::new(layout::FieldKind::Text, "title", "Title").value(item.title.clone()),
        ),
    );
    acts
}

/// What is recoverable, and for how long.
fn deleted_table(slug: &str, view: &View, deleted: &[DeletedItemRow]) -> Node {
    Node::Table {
        columns: vec![
            Column::new("Title")
                .width(layout::Width::Fill)
                .priority(layout::Priority::Essential),
            Column::new("Deleted").width(layout::Width::Content),
            Column::new("")
                .width(layout::Width::Content)
                .priority(layout::Priority::Essential),
        ],
        rows: deleted
            .iter()
            .map(|item| {
                Cells::new([
                    Cell::new(item.title.clone()),
                    Cell::new(item.deleted_at.clone()),
                    Cell::acts([Act::new(
                        "Restore",
                        view.write(slug, &format!("restore/{}", item.id)),
                    )]),
                ])
            })
            .collect(),
        more: None,
    }
}

/// The project's blog posts, which share this tab and not much else.
fn posts_table(slug: &str, view: &View, posts: &[BlogPostDashboardRow]) -> Node {
    Node::Table {
        columns: vec![
            Column::new("Title")
                .width(layout::Width::Fill)
                .priority(layout::Priority::Essential),
            Column::new("Status").width(layout::Width::Content),
            Column::new("Published")
                .width(layout::Width::Content)
                .priority(layout::Priority::Optional),
            Column::new("Actions")
                .width(layout::Width::Content)
                .priority(layout::Priority::Essential),
        ],
        rows: posts
            .iter()
            .map(|post| {
                Cells::new([
                    Cell::new(post.title.clone())
                        .activate(Action::external(format!("/p/{slug}/blog/{}", post.slug))),
                    Cell::tag(Tag::badge(post.status.clone()).tone(tone(post.status_tone))),
                    Cell::new(post.published_at.clone()),
                    Cell::acts([
                        Act::new(
                            "View",
                            Action::external(format!("/p/{slug}/blog/{}", post.slug)),
                        ),
                        Act::new(
                            "Edit",
                            Action::external(format!(
                                "/dashboard/project/{slug}/blog/new?post={}",
                                post.id
                            )),
                        ),
                        Act::new(
                            "Delete",
                            view.write(slug, &format!("blog/{}/delete", post.id)),
                        )
                        .tone(layout::Tone::Danger)
                        .confirm("Delete this blog post?"),
                    ]),
                ])
            })
            .collect(),
        more: None,
    }
}

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

    const SLUG: &str = "a-project";

    fn item(id: &str, title: &str, kind: &str, status: &str, cents: i32) -> ContentItem {
        ContentItem {
            position: 1,
            title: title.into(),
            item_type: kind.into(),
            price: format!("${}", cents / 100),
            price_cents: cents,
            price_dollars: format!("{}.00", cents / 100),
            sales: 0,
            revenue: "$0".into(),
            status: status.into(),
            status_tone: if status == "Active" {
                "success"
            } else {
                "warning"
            },
            id: id.into(),
            is_unlisted: false,
            children: Vec::new(),
        }
    }

    fn catalogue() -> Vec<ContentItem> {
        vec![
            item("i-1", "Kick Pack", "audio", "Active", 500),
            item("i-2", "Snare Pack", "audio", "Draft", 0),
            item("i-3", "Field Notes", "text", "Active", 1200),
        ]
    }

    fn panel(view: &View) -> String {
        fragment(SLUG, &catalogue(), &[], &[], view)
    }

    #[test]
    fn a_filter_is_a_route_and_not_a_pass_over_rendered_rows() {
        // `N12`'s decision, read off the document. Each of the three controls
        // carries an address; none of them names a client-side function, which
        // is what `data-input="filterContentTable"` was.
        let html = panel(&View::default());

        assert!(html.contains("name=\"q\""), "{html}");
        assert!(html.contains("name=\"status\""), "{html}");
        assert!(html.contains("name=\"type\""), "{html}");
        assert!(!html.contains("filterContentTable"), "{html}");
        assert!(
            html.contains("/dashboard/project/a-project/tabs/content"),
            "{html}"
        );
    }

    #[test]
    fn a_control_does_not_carry_the_value_it_is_asking_for() {
        // A field sends its own value under its own name. An address that also
        // carried the value it was offered under would send both, and the
        // handler would have to guess.
        let view = View {
            query: Some("kick".into()),
            status: Some("Active".into()),
            ..View::default()
        };
        let filters = filters(SLUG, &catalogue(), &view);
        let html = {
            use quasi_axum::Serves as _;
            Webview::new().fragment(&Node::Region(filters))
        };

        // Each control's own address, read off the three divs the section holds.
        let controls: Vec<&str> = html.split("<div class=\"field-").skip(1).collect();
        assert_eq!(controls.len(), 3, "{html}");

        // The search box carries the status it was offered under and not the
        // query it is about to send.
        assert!(controls[0].contains("status=Active"), "{html}");
        assert!(!controls[0].contains("q=kick"), "{html}");

        // The status picker, the other way round.
        assert!(controls[1].contains("q=kick"), "{html}");
        assert!(!controls[1].contains("status=Active"), "{html}");

        // And the type picker, which is asking about neither, carries both.
        assert!(controls[2].contains("q=kick"), "{html}");
        assert!(controls[2].contains("status=Active"), "{html}");
    }

    #[test]
    fn every_row_joins_the_selection_under_its_own_id() {
        let html = panel(&View::default());

        for id in ["i-1", "i-2", "i-3"] {
            assert!(
                html.contains(&format!("name=\"ticked\" value=\"{id}\"")),
                "{html}"
            );
        }
        // Nothing arrives ticked until the address says so.
        assert!(!html.contains("checked"), "{html}");
    }

    #[test]
    fn select_all_is_an_address() {
        let html = panel(&View::default());
        assert!(html.contains("ticked=all"), "{html}");

        let all = panel(&View {
            ticked: true,
            ..View::default()
        });
        assert_eq!(all.matches("checked").count(), 3, "{all}");
        assert!(all.contains(">Deselect<"), "{all}");
    }

    #[test]
    fn the_bar_holds_five_verbs_over_the_selection() {
        let html = panel(&View::default());

        // Five controls act on the set, and the two that need a value reveal a
        // box rather than being a form of their own.
        assert_eq!(html.matches("data-over=\"chosen\"").count(), 5, "{html}");
        for verb in ["Publish", "Unpublish", "Set Price", "Add Tag", "Delete"] {
            assert!(html.contains(verb), "{verb} missing:\n{html}");
        }
        assert!(html.contains("name=\"price_dollars\""), "{html}");
        assert!(html.contains("name=\"tag_slug\""), "{html}");
        assert!(html.contains("Enter 0 to make items free."), "{html}");
    }

    #[test]
    fn a_destructive_verb_asks_before_it_runs() {
        let html = panel(&View::default());
        assert!(
            html.contains("Delete every selected item? This cannot be undone."),
            "{html}"
        );
    }

    #[test]
    fn pressing_a_heading_orders_by_it_and_pressing_it_again_flips() {
        let first = View::default().sorted_by(SortBy::Price);
        assert_eq!(first.sort, Some(SortBy::Price));
        assert!(!first.descending);

        let again = first.sorted_by(SortBy::Price);
        assert!(again.descending);

        // A different heading starts ascending rather than inheriting.
        let elsewhere = again.sorted_by(SortBy::Item);
        assert_eq!(elsewhere.sort, Some(SortBy::Item));
        assert!(!elsewhere.descending);
    }

    #[test]
    fn the_sorted_column_says_so_where_a_reader_can_hear_it() {
        let html = panel(&View {
            sort: Some(SortBy::Item),
            descending: true,
            ..View::default()
        });

        assert!(html.contains("aria-sort=\"descending\""), "{html}");
        assert_eq!(html.matches("aria-sort=").count(), 1, "{html}");
    }

    #[test]
    fn ordering_is_the_view_and_not_the_documents_order() {
        let items = catalogue();
        let by_price = View {
            sort: Some(SortBy::Price),
            ..View::default()
        };
        let titles: Vec<&str> = by_price
            .shown(&items)
            .iter()
            .map(|item| item.title.as_str())
            .collect();
        assert_eq!(titles, ["Snare Pack", "Kick Pack", "Field Notes"]);

        let down = View {
            descending: true,
            ..by_price
        };
        let titles: Vec<&str> = down
            .shown(&items)
            .iter()
            .map(|item| item.title.as_str())
            .collect();
        assert_eq!(titles, ["Field Notes", "Kick Pack", "Snare Pack"]);
    }

    #[test]
    fn the_reorder_arrows_leave_when_a_sort_is_in_force() {
        // They move a row within the project's own order, which is the order
        // the `#` column shows. Under a sort that order is not on screen.
        let plain = panel(&View::default());
        assert!(
            plain.contains("Move up") || plain.contains("Move down"),
            "{plain}"
        );

        let sorted = panel(&View {
            sort: Some(SortBy::Item),
            ..View::default()
        });
        assert!(!sorted.contains("Move up"), "{sorted}");
        assert!(!sorted.contains("Move down"), "{sorted}");
    }

    #[test]
    fn narrowing_drops_the_rows_it_hides_rather_than_hiding_them() {
        let items = catalogue();

        let searched = View {
            query: Some("pack".into()),
            ..View::default()
        };
        assert_eq!(searched.shown(&items).len(), 2);

        let drafts = View {
            status: Some("Draft".into()),
            ..View::default()
        };
        assert_eq!(drafts.shown(&items).len(), 1);

        let text = View {
            kind: Some("text".into()),
            ..View::default()
        };
        assert_eq!(text.shown(&items).len(), 1);

        // And the document holds only what survived, where the JS kept every row
        // and put a class on the rest.
        let html = panel(&drafts);
        assert!(html.contains("Snare Pack"), "{html}");
        assert!(!html.contains("Kick Pack"), "{html}");
    }

    #[test]
    fn the_status_filter_can_name_every_status_a_row_wears() {
        // Finding 2: the template offered two of the three, so a scheduled item
        // was hidden by either choice and nothing offered a way back.
        let html = panel(&View::default());
        for status in STATUSES {
            assert!(html.contains(&format!("value=\"{status}\"")), "{html}");
        }
    }

    #[test]
    fn a_filter_that_matches_nothing_says_so_and_offers_a_way_out() {
        let html = panel(&View {
            query: Some("nothing here".into()),
            ..View::default()
        });

        assert!(html.contains("No items match these filters."), "{html}");
        assert!(html.contains("Clear filters"), "{html}");
    }

    #[test]
    fn an_empty_project_is_a_different_sentence_from_an_empty_filter() {
        let html = fragment(SLUG, &[], &[], &[], &View::default());

        assert!(html.contains("No items in this project yet."), "{html}");
        assert!(html.contains("Add First Item"), "{html}");
        // Nothing to narrow, so no bar and no boxes.
        assert!(!html.contains("data-over"), "{html}");
        assert!(!html.contains("name=\"q\""), "{html}");
    }

    #[test]
    fn a_bundles_children_arrive_when_the_address_says_they_are_open() {
        let mut items = catalogue();
        items[0].children = vec![item("i-1a", "Kick 01", "audio", "Active", 0)];

        let shut = fragment(SLUG, &items, &[], &[], &View::default());
        assert!(shut.contains("Expand"), "{shut}");
        assert!(!shut.contains("Kick 01"), "{shut}");

        let open = fragment(
            SLUG,
            &items,
            &[],
            &[],
            &View {
                open: vec!["i-1".into()],
                ..View::default()
            },
        );
        assert!(open.contains("Kick 01"), "{open}");
        assert!(open.contains("Collapse"), "{open}");
        // A child can be published with the rest, as its checkbox always could.
        assert!(open.contains("name=\"ticked\" value=\"i-1a\""), "{open}");
    }

    #[test]
    fn a_rename_is_a_control_that_asks_for_the_new_name() {
        // Finding 3. The box arrives holding the current title, which is what
        // the inline editor did before it was a round trip.
        let html = panel(&View::default());

        assert!(html.contains("Rename"), "{html}");
        assert!(html.contains("value=\"Kick Pack\""), "{html}");
        assert!(html.contains("/tabs/content/rename/i-1"), "{html}");
    }

    #[test]
    fn a_route_answers_with_the_id_its_answer_lands_on() {
        // Every control here aims at `#project-content` and htmx swaps
        // `outerMorph`, so an answer without the id would replace the panel with
        // markup nothing can target afterwards.
        let answer = panel(&View::default());
        assert!(answer.contains("id=\"project-content\""), "{answer}");
        assert!(
            answer.contains("hx-target=\"#project-content\""),
            "{answer}"
        );

        // The page's copy goes inside the strip's own div, so it must not carry
        // the id a second time.
        let inline = fill(SLUG, &catalogue(), &[], &[], &View::default());
        assert!(!inline.contains("id=\"project-content\""), "{inline}");
    }

    #[test]
    fn a_write_comes_back_under_the_view_it_was_pressed_on() {
        let view = View {
            query: Some("pack".into()),
            status: Some("Active".into()),
            ..View::default()
        };
        let html = panel(&view);

        // The bulk verbs post to an address that still names the filter, so a
        // publish under a search answers the same rows.
        assert!(html.contains("bulk/publish?"), "{html}");
        assert!(html.contains("q=pack"), "{html}");
    }

    #[test]
    fn an_address_naming_a_column_no_heading_carries_is_refused() {
        // Answering it with the default order would hide the wiring mistake.
        assert!(View::of(None, None, None, Some("urgency"), None, None, None).is_none());
        assert!(View::of(None, None, None, Some("price"), None, None, None).is_some());
    }

    #[test]
    fn a_blank_param_is_an_absent_one() {
        // What "All statuses" sends.
        let view = View::of(Some("  "), Some(""), Some(""), None, None, None, None)
            .expect("a blank view parses");
        assert!(view.is_default());
        assert!(!view.filtered());
    }

    #[test]
    fn a_status_the_table_cannot_show_narrows_nothing() {
        // The filter offers three; a hand-typed fourth is dropped rather than
        // answering an empty table.
        let view =
            View::of(None, Some("Retired"), None, None, None, None, None).expect("the view parses");
        assert_eq!(view.status, None);
    }

    #[test]
    fn a_narrowing_does_not_carry_everything_forward() {
        // `ticked=all` under a new filter would silently come to mean a
        // different everything, which is the rule the JS enforced by hand.
        let view = View {
            ticked: true,
            query: Some("pack".into()),
            ..View::default()
        };
        assert!(!view.sorted_by(SortBy::Item).ticked);
        assert!(!view.narrowed().ticked);
        // Opening a bundle is not a narrowing and keeps them.
        assert!(view.toggling("i-1").ticked);
    }

    #[test]
    fn the_deleted_and_blog_tables_are_the_panels_own() {
        let deleted = [DeletedItemRow {
            id: "i-9".into(),
            title: "Old Pack".into(),
            deleted_at: "Aug 10, 2026".into(),
        }];
        let posts = [BlogPostDashboardRow {
            id: "p-1".into(),
            title: "Release notes".into(),
            slug: "release-notes".into(),
            status: "Published".into(),
            status_tone: "success",
            published_at: "Aug 12, 2026".into(),
        }];

        let html = fragment(SLUG, &catalogue(), &deleted, &posts, &View::default());

        assert!(html.contains("Recently Deleted (1)"), "{html}");
        assert!(html.contains("/tabs/content/restore/i-9"), "{html}");
        assert!(html.contains("Release notes"), "{html}");
        assert!(html.contains("/tabs/content/blog/p-1/delete"), "{html}");
        assert!(html.contains("Delete this blog post?"), "{html}");
    }
}