//! The Stripe payout-summary card, described.
//!
//! S4: no `hx-` attributes of its own, no id or class that any file in
//! `static/` or `frontend/src` reaches for, and no form.
//!
//! It replaces `dashboard_tab_payout_summary`, which is deleted with its
//! `PayoutSummaryPartialTemplate` and `templates/partials/tabs/payout_summary.html`.
//! There is no switch and no fallback: since `64b33b26` a described screen owns
//! its address outright, so the Askama half goes in the same change.
//!
//! # It is a card the Payments tab fetches, not a tab of its own
//!
//! `templates/partials/tabs/user_payments.html:74` leaves an empty
//! `#payout-summary-section` and fills it on `revealed`, because the Stripe
//! balance is a network round trip and the tab should not wait for it. That
//! split is preserved exactly: this screen answers the same
//! address on the same trigger and replaces the same region. The lazy fetch is
//! the point of the split and not an artefact of Askama.
//!
//! That also makes it the one conversion in the batch where [`super::ssh_keys`]'s
//! "a list it can read now is a list the reader should not wait for twice"
//! does NOT apply. Reading the balance inline would put a Stripe round trip in
//! front of the Payments tab, which is the cost the split was made to avoid.
//!
//! # The three things the description says that the template did not
//!
//! 1. **The failure branch is a readiness, not a second card.** The template's
//!    `{% else %}` hand-writes a near-copy of the whole card carrying "Unable
//!    to load balance". That is [`layout::Readiness::Failed`], which every
//!    renderer already draws, so it is [`Node::failed`] here and the copy goes.
//! 2. **The two balances are a strip.** `.payout-stats-grid` holding two
//!    `.amount-big` divs with `.text-xs` captions is [`Node::stats`] over two
//!    [`Figure`]s. The grid was the markup spelling of "these are tiles".
//! 3. **"Payouts are not yet enabled" is a banner.** The template gives it a
//!    bespoke `.payouts-disabled-notice` class; it is a persistent message
//!    dismissed by fixing its cause, which is [`layout::Notice::Banner`] at
//!    [`layout::Tone::Warning`].
//!
//! # Two parity differences, both deliberate
//!
//! The parity test names each rather than blanket-ignoring them.
//!
//! - **`rel`.** The template writes `rel="noopener"`; quasi-webview emits
//!   `rel="noopener noreferrer"` for every external destination. The stricter
//!   one is right and it is not this screen's call to make either way.
//! - **The Stripe link is an anchor, not a button inside an anchor.** The
//!   template nests `<button>` inside `<a>`, which is invalid: a button is
//!   interactive content and an anchor may not contain it. Browsers recover,
//!   so it renders; a described act that leaves is one anchor. Fixing it was
//!   not this conversion's goal and is a consequence of saying the thing once.

use makeover_layout as layout;
use quasi_declare::declare;
use quasi_router::screen::Figure;
use quasi_router::{Request, Response, RouteError};
use quasi_webview::Webview;

use super::Viewer;
use crate::db;

/// This screen's name, for the tab strips that mark a section described.
pub const SCREEN: &str = "payout_summary";

/// The address this screen answers, and the one the Askama route gives up.
pub const PATH: &str = "/dashboard/tabs/payout-summary";

/// The region the answer replaces: the div the Payments tab leaves empty.
///
/// `pub` so `tests/workflows/described_screens.rs` reads it rather than
/// transcribing it. That file says why: a constant its table can name is a
/// constant its table cannot disagree with.
pub const REGION: &str = "payout-summary-section";

/// Where a creator manages payouts, which is not a page this server serves.
const STRIPE_PAYOUTS: &str = "https://dashboard.stripe.com/payouts";

/// The balance, as the screen needs it: two strings the app has already
/// formatted in the creator's settlement currency.
pub(crate) struct BalanceView {
    available: String,
    pending: String,
}

/// The one read this card makes, for the mount that serves it from a residual.
pub(crate) fn reading(viewer: &Viewer) -> Result<(Option<BalanceView>, bool), RouteError> {
    let user = viewer
        .block_on(db::users::get_user_by_id(
            &viewer.app.db,
            viewer.reader()?.id,
        ))
        .map_err(|_| RouteError::internal("your account could not be read"))?
        .ok_or_else(|| RouteError::not_found("that account is gone"))?;

    Ok((balance(viewer, &user), user.stripe_payouts_enabled))
}

/// The card.
pub fn screen(viewer: &Viewer, _request: Request) -> Result<Response, RouteError> {
    let (balance, payouts_enabled) = reading(viewer)?;

    Ok(Response::fragment(
        REGION,
        card(balance.as_ref(), payouts_enabled),
    ))
}

/// The reader's Stripe balance, or nothing.
///
/// Both `None` cases are the same screen: no Stripe account configured and a
/// balance call that failed are indistinguishable to a reader, and the template
/// already drew one card for both.
fn balance(viewer: &Viewer, user: &crate::db::DbUser) -> Option<BalanceView> {
    let (Some(stripe), Some(account_id)) = (&viewer.app.payments, &user.stripe_account_id) else {
        return None;
    };

    match viewer.block_on(stripe.get_balance(account_id, user.settlement_currency)) {
        Ok(balance) => Some(BalanceView {
            available: crate::formatting::format_revenue(
                balance.available_cents,
                user.settlement_currency,
            ),
            pending: crate::formatting::format_revenue(
                balance.pending_cents,
                user.settlement_currency,
            ),
        }),
        Err(error) => {
            // Warned rather than surfaced, as the Askama handler did: a creator
            // cannot act on a Stripe API error and the card says so in words
            // they can.
            tracing::warn!(?error, "failed to fetch Stripe balance for payout summary");
            None
        }
    }
}

declare! {
    /// Everything inside the card.
    ///
    /// `subsection`, so the heading stays an `h3`: this card sits inside the
    /// Payments tab's own sections and the template wrote `<h3 class="card-h">`.
    #[staged]
    pub(crate) shape card(balance: Option<&BalanceView>, payouts_enabled: bool) -> Node;

    region REGION as Pane {
        subsection "Payout Summary";
        include stripe_link();
        failed "Unable to load balance. Check your Stripe dashboard for details."
            unless balance.is_some();
        text "Payouts are processed automatically via Stripe Connect." when balance.is_some();
        stats [
            Figure::new(available(balance), "Available Balance"),
            Figure::new(pending(balance), "Pending"),
        ] when balance.is_some();
        banner layout::Tone::Warning
            "Payouts are not yet enabled. Complete your Stripe account setup above."
            when balance.is_some() and not payouts_enabled;
    }
}

/// What the available balance says, or nothing.
///
/// Two suppliers answering strings rather than one answering `Vec<Figure>`, and
/// the seam is why. A `Figure` has no sentinel, so a staged shape cannot hand
/// one to `stats` as a value; what it can do is keep the constructor and stage
/// what the constructor is given, which puts the strip's markup in the residual
/// as a literal and each figure's number in it as a hole. That only works if
/// the description names the figures, so it does.
///
/// R9 is why these answer for the absent case rather than being skipped: a
/// guard decides whether a member is placed, not whether its holes are
/// evaluated, so both are asked even when the strip is not drawn.
fn available(balance: Option<&BalanceView>) -> String {
    balance
        .map(|held| held.available.clone())
        .unwrap_or_default()
}

/// What the pending balance says, or nothing. See [`available`].
fn pending(balance: Option<&BalanceView>) -> String {
    balance.map(|held| held.pending.clone()).unwrap_or_default()
}

declare! {
    /// The way out to Stripe's own dashboard.
    ///
    /// `external` rather than a route: this address is not one the server
    /// answers, and saying so is what lets a renderer that is not a browser decide
    /// what "leaving" means for it.
    #[constant]
    shape stripe_link() -> Node;

    act "View in Stripe" to external STRIPE_PAYOUTS;
}

/// The renderer this screen is drawn with.
pub fn renderer(viewer: &Viewer) -> Webview {
    Webview::new().with_shell(viewer.shell())
}

/// A balance as the tests draw it.
///
/// Module-level rather than inside `mod tests` because `quasi::residuals` needs
/// one too, and `BalanceView` is this module's own type. Test-only.
#[cfg(test)]
pub(crate) fn sample() -> BalanceView {
    BalanceView {
        available: "$1,240.00".into(),
        pending: "$310.50".into(),
    }
}

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

    use super::sample as balance;

    fn render(node: &Node) -> String {
        Webview::new().fragment(node)
    }

    #[test]
    fn the_region_is_the_one_the_payments_tab_leaves_empty() {
        // The tab fills this on `revealed`. If the id or the address ever
        // disagrees, the card loads into nothing and nothing else notices.
        let payments = include_str!("../../templates/partials/tabs/user_payments.html");
        assert!(payments.contains(&format!("id=\"{REGION}\"")), "{REGION}");
        assert!(payments.contains(&format!("hx-get=\"{PATH}\"")), "{PATH}");
    }

    #[test]
    fn the_balances_are_a_strip_of_two_figures() {
        let html = render(&card(Some(&balance()), true));

        assert!(html.contains("$1,240.00"), "{html}");
        assert!(html.contains("Available Balance"), "{html}");
        assert!(html.contains("$310.50"), "{html}");
        assert!(html.contains("Pending"), "{html}");
    }

    #[test]
    fn a_creator_without_payouts_enabled_is_told_so() {
        let html = render(&card(Some(&balance()), false));
        assert!(html.contains("Payouts are not yet enabled."), "{html}");
    }

    #[test]
    fn a_creator_with_payouts_enabled_is_not() {
        let html = render(&card(Some(&balance()), true));
        assert!(!html.contains("Payouts are not yet enabled."), "{html}");
    }

    #[test]
    fn a_balance_that_did_not_load_is_a_readiness_and_not_a_second_card() {
        let html = render(&card(None, true));

        assert!(html.contains("Unable to load balance."), "{html}");
        // The figures are the thing that is missing. A strip of two blanks
        // would be the template's failure mode, not this one's.
        assert!(!html.contains("Available Balance"), "{html}");
        // And the way out to Stripe survives the failure, which is the whole
        // reason the template drew a second card rather than nothing.
        assert!(html.contains(STRIPE_PAYOUTS), "{html}");
    }

    #[test]
    fn the_stripe_link_leaves_and_carries_no_verb() {
        let html = render(&stripe_link());

        assert!(
            html.contains(&format!("href=\"{STRIPE_PAYOUTS}\"")),
            "{html}"
        );
        assert!(html.contains("target=\"_blank\""), "{html}");
        assert!(html.contains("rel=\"noopener noreferrer\""), "{html}");
        // An external address is not htmx's business.
        assert!(!html.contains("hx-get"), "{html}");
    }
}