ai_usagebar/widget/

render.rs

//! Pango-markup rendering for the Anthropic widget — both the bar text and
//! the bordered tooltip.
//!
//! Closely mirrors claudebar:625-860. Pure functions over an immutable
//! [`RenderInput`] so all of the visual logic is unit-testable without I/O.

use std::collections::HashMap;

use chrono::{DateTime, Utc};

use crate::anthropic::fetch::FetchOutcome;
use crate::countdown;
use crate::format::{placeholders, substitute, updated_at_hm};
use crate::pacing;
use crate::pango::{self, color_span, escape, severity_for};
use crate::theme::Theme;
use crate::tooltip::{self, Line};
use crate::usage::{AnthropicSnapshot, ExtraUsage, anthropic_severity};
use crate::vendor::VendorId;
use crate::waybar::{Class, WaybarOutput};

/// Default format string when `--format` is omitted (claudebar:55).
pub const DEFAULT_FORMAT: &str = "{session_pct}% · {session_reset}";
/// Default format for an account with no five-hour window: the weekly window
/// takes the bar, as it does for a Codex account without one.
pub const WEEKLY_ONLY_FORMAT: &str = "{weekly_pct}% · {weekly_reset}";

/// The bar text used when `--format` is omitted. [`DEFAULT_FORMAT`] reads the
/// session placeholders, which are empty when the account has no five-hour
/// window, so such an account gets [`WEEKLY_ONLY_FORMAT`] instead of `% · `.
pub fn default_format(snap: &AnthropicSnapshot) -> &'static str {
    if snap.session.is_some() {
        DEFAULT_FORMAT
    } else {
        WEEKLY_ONLY_FORMAT
    }
}

/// All inputs needed to render the widget — packaged so tests can construct
/// it without any I/O.
pub struct RenderInput<'a> {
    pub outcome: &'a FetchOutcome,
    pub theme: &'a Theme,
    pub format: &'a str,
    pub tooltip_format: Option<&'a str>,
    pub icon: Option<&'a str>,
    pub pace_tolerance: u32,
    pub format_pace_color: bool,
    pub tooltip_pace_pts: bool,
    pub now: DateTime<Utc>,
    /// What this account's live Claude Code sessions are doing, for the
    /// tooltip (#356). `None`, or nothing working or waiting, = no line.
    pub claude_sessions: Option<&'a crate::context::activity::SessionActivity>,
}

/// Compose the full Waybar output for an Anthropic snapshot.
pub fn render_anthropic(input: &RenderInput) -> WaybarOutput {
    let snap = &input.outcome.snapshot;
    let class = Class::from(anthropic_severity(snap));
    let bar_text = render_bar_text(input, class);
    let tooltip = if let Some(fmt) = input.tooltip_format {
        // Custom tooltip uses the same placeholder set as the bar.
        let values = build_placeholders(input);
        substitute(fmt, &values)
    } else {
        render_default_tooltip(input)
    };

    WaybarOutput {
        text: bar_text,
        tooltip,
        class,
    }
}

/// Build the bar-text string with all placeholders substituted and the
/// surrounding `<span foreground='…'>` wrapper applied.
fn render_bar_text(input: &RenderInput, class: Class) -> String {
    let values = build_placeholders(input);
    let mut text = substitute(input.format, &values);

    // Append stale indicator (claudebar:687-690).
    if input.outcome.stale {
        text.push_str(" ⏸");
    }

    // Wrap in the global color or the neutral foreground (when individual
    // pace placeholders supply their own color via --format-pace-color).
    let wrapper_color = if input.format_pace_color && input.format.contains("_pace") {
        input.theme.fg.clone()
    } else {
        bar_color_for(class, input.theme).to_string()
    };
    let icon_prefix = match input.icon {
        Some(ic) if !ic.is_empty() => format!("{ic} "),
        _ => String::new(),
    };
    color_span(&wrapper_color, &format!("{icon_prefix}{text}"))
}

fn bar_color_for(class: Class, theme: &Theme) -> &str {
    match class {
        Class::Low => &theme.green,
        Class::Mid => &theme.yellow,
        Class::High => &theme.orange,
        Class::Critical => &theme.red,
    }
}

/// Build the full placeholder map for an Anthropic snapshot.
///
/// Mirrors claudebar's "{...}" surface (claudebar:625-667). Per-window pacing
/// is pre-computed once; bars are rendered both raw (for `{*_bar}`) and with
/// elapsed-position markers in the tooltip when `--tooltip-pace-pts` is set.
fn build_placeholders(input: &RenderInput) -> HashMap<&'static str, String> {
    let snap = &input.outcome.snapshot;
    let theme = input.theme;

    let session_window = snap.session.as_ref();
    let session = session_window.map(|w| {
        pacing::calc(
            w.utilization_pct,
            w.resets_at,
            input.now,
            w.window_duration,
            input.pace_tolerance,
        )
    });
    let weekly = pacing::calc(
        snap.weekly.utilization_pct,
        snap.weekly.resets_at,
        input.now,
        snap.weekly.window_duration,
        input.pace_tolerance,
    );
    let sonnet_window = snap.sonnet.as_ref();
    let sonnet = sonnet_window.map(|w| {
        pacing::calc(
            w.utilization_pct,
            w.resets_at,
            input.now,
            w.window_duration,
            input.pace_tolerance,
        )
    });

    let session_color =
        session_window.map(|w| pango::severity_color(severity_for(w.utilization_pct), theme));
    let weekly_color = pango::severity_color(severity_for(snap.weekly.utilization_pct), theme);
    let sonnet_color =
        sonnet_window.map(|w| pango::severity_color(severity_for(w.utilization_pct), theme));
    let extra_color = snap
        .extra
        .as_ref()
        .map(|e| pango::severity_color(severity_for(e.percent()), theme));

    let session_bar = if let (Some(w), Some(c)) = (session_window, session_color) {
        pango::progress_bar(w.utilization_pct, c, theme, None)
    } else {
        String::new()
    };
    let weekly_bar = pango::progress_bar(snap.weekly.utilization_pct, weekly_color, theme, None);
    let sonnet_bar = if let (Some(w), Some(c)) = (sonnet_window, sonnet_color) {
        pango::progress_bar(w.utilization_pct, c, theme, None)
    } else {
        String::new()
    };
    let extra_bar = if let (Some(e), Some(c)) = (snap.extra.as_ref(), extra_color) {
        pango::progress_bar(e.percent(), c, theme, None)
    } else {
        String::new()
    };

    // Primary model-scoped weekly window (the common case is exactly one, e.g.
    // "Fable"). The tooltip renders every entry of `snap.scoped`, but the
    // desktop surfaces (macOS menu bar, GNOME, Windows tray) redraw from
    // `--format` and have a single per-model row — so expose the first scoped
    // window through flat `{scoped_*}` placeholders they can read. Empty /
    // neutral when the account has no scoped window.
    let scoped0 = snap.scoped.first();
    let scoped0_pacing = scoped0.map(|s| {
        pacing::calc(
            s.window.utilization_pct,
            s.window.resets_at,
            input.now,
            s.window.window_duration,
            input.pace_tolerance,
        )
    });
    let scoped0_bar = if let Some(s) = scoped0 {
        let c = pango::severity_color(severity_for(s.window.utilization_pct), theme);
        pango::progress_bar(s.window.utilization_pct, c, theme, None)
    } else {
        String::new()
    };

    let mut v = placeholders(vec![
        ("icon", "󰚩".to_string()),
        ("vendor_short", VendorId::Anthropic.short_name().to_string()),
        ("plan", snap.plan.clone()),
        // No five-hour window: the whole session family is empty, the
        // missing-placeholder convention the native frontends hide a row on.
        (
            "session_pct",
            session_window
                .map(|w| w.utilization_pct.to_string())
                .unwrap_or_default(),
        ),
        (
            "session_reset",
            session_window
                .map(|w| countdown::format(w.resets_at, input.now))
                .unwrap_or_default(),
        ),
        (
            "session_elapsed",
            session
                .as_ref()
                .map(|s| s.elapsed_pct.to_string())
                .unwrap_or_default(),
        ),
        ("session_bar", session_bar.clone()),
        ("weekly_pct", snap.weekly.utilization_pct.to_string()),
        (
            "weekly_reset",
            countdown::format(snap.weekly.resets_at, input.now),
        ),
        ("weekly_elapsed", weekly.elapsed_pct.to_string()),
        ("weekly_bar", weekly_bar.clone()),
        (
            "sonnet_pct",
            sonnet_window
                .map(|w| w.utilization_pct.to_string())
                .unwrap_or_else(|| "0".into()),
        ),
        (
            "sonnet_reset",
            sonnet_window
                .map(|w| countdown::format(w.resets_at, input.now))
                .unwrap_or_else(|| "—".into()),
        ),
        (
            "sonnet_elapsed",
            sonnet
                .as_ref()
                .map(|s| s.elapsed_pct.to_string())
                .unwrap_or_else(|| "0".into()),
        ),
        ("sonnet_bar", sonnet_bar.clone()),
        // Model-scoped weekly window (first entry of `snap.scoped`, e.g. Fable).
        (
            "scoped_model",
            scoped0.map(|s| s.label.clone()).unwrap_or_default(),
        ),
        (
            "scoped_pct",
            scoped0
                .map(|s| s.window.utilization_pct.to_string())
                .unwrap_or_else(|| "0".into()),
        ),
        (
            "scoped_reset",
            scoped0
                .map(|s| countdown::format(s.window.resets_at, input.now))
                .unwrap_or_else(|| "—".into()),
        ),
        (
            "scoped_elapsed",
            scoped0_pacing
                .as_ref()
                .map(|p| p.elapsed_pct.to_string())
                .unwrap_or_else(|| "0".into()),
        ),
        ("scoped_bar", scoped0_bar.clone()),
        (
            "extra_spent",
            snap.extra
                .as_ref()
                .map(ExtraUsage::fmt_spent)
                .unwrap_or_default(),
        ),
        (
            "extra_limit",
            // "—" (not empty) for an uncapped plan: GNOME and the macOS menu
            // bar hide the whole extra row when this field is empty, which
            // would hide real spend — the exact symptom of #30.
            snap.extra
                .as_ref()
                .map(|e| e.fmt_limit().unwrap_or_else(|| "—".into()))
                .unwrap_or_default(),
        ),
        (
            "extra_pct",
            snap.extra
                .as_ref()
                .map(|e| e.percent().to_string())
                .unwrap_or_else(|| "0".into()),
        ),
        ("extra_bar", extra_bar),
        ("resets_available", snap.reset_credits.available.to_string()),
        ("resets", crate::format::reset_credits(&snap.reset_credits)),
    ]);

    insert_pace(
        &mut v,
        "session",
        session.as_ref(),
        input.format_pace_color,
        theme,
    );
    insert_pace(
        &mut v,
        "weekly",
        Some(&weekly),
        input.format_pace_color,
        theme,
    );
    if let Some(sp) = sonnet.as_ref() {
        insert_pace(&mut v, "sonnet", Some(sp), input.format_pace_color, theme);
    } else {
        // Empty placeholders so `{sonnet_pace}` etc. don't render the literal
        // brace text when sonnet is absent.
        insert_pace(
            &mut v,
            "sonnet",
            Some(&pacing::Pacing::neutral()),
            input.format_pace_color,
            theme,
        );
    }
    // Both sinks fed by this map (bar text and --tooltip-format) are Pango
    // markup. The plan label comes from the credentials file and the scoped
    // model name from the API, so escape them at the projection boundary.
    // The default tooltip escapes the raw snapshot.
    for key in ["plan", "scoped_model"] {
        if let Some(value) = v.get_mut(key) {
            *value = escape(value);
        }
    }
    v
}

/// `None` is a window the account does not have: its whole pace family
/// expands to empty strings, like the rest of its placeholders. "On track"
/// would describe a window that is not there.
fn insert_pace(
    map: &mut HashMap<&'static str, String>,
    prefix: &'static str,
    p: Option<&pacing::Pacing>,
    pace_color: bool,
    theme: &Theme,
) {
    let neutral = pacing::Pacing::neutral();
    let present = p.is_some();
    let p = p.unwrap_or(&neutral);
    let pace_glyph = p.ratio_pace.glyph();
    let indicator_glyph = p.point_pace.glyph();
    let delta = p.delta.to_string();
    let abs_delta = p.delta.unsigned_abs().to_string();
    let pct = &p.ratio_label;
    let pts = &p.point_label;

    let wrap = |s: &str| -> String {
        if !present {
            String::new()
        } else if pace_color {
            let sev = pacing::pace_severity(p.delta);
            let color = pango::severity_color(sev, theme);
            color_span(color, s)
        } else {
            s.to_string()
        }
    };

    let keys: [(&'static str, String); 6] = match prefix {
        "session" => [
            ("session_pace", wrap(pace_glyph)),
            ("session_pace_indicator", wrap(indicator_glyph)),
            ("session_pace_pct", wrap(pct)),
            ("session_pace_pts", wrap(pts)),
            ("session_pace_delta", wrap(&delta)),
            ("session_pace_abs_delta", wrap(&abs_delta)),
        ],
        "weekly" => [
            ("weekly_pace", wrap(pace_glyph)),
            ("weekly_pace_indicator", wrap(indicator_glyph)),
            ("weekly_pace_pct", wrap(pct)),
            ("weekly_pace_pts", wrap(pts)),
            ("weekly_pace_delta", wrap(&delta)),
            ("weekly_pace_abs_delta", wrap(&abs_delta)),
        ],
        "sonnet" => [
            ("sonnet_pace", wrap(pace_glyph)),
            ("sonnet_pace_indicator", wrap(indicator_glyph)),
            ("sonnet_pace_pct", wrap(pct)),
            ("sonnet_pace_pts", wrap(pts)),
            ("sonnet_pace_delta", wrap(&delta)),
            ("sonnet_pace_abs_delta", wrap(&abs_delta)),
        ],
        _ => return,
    };
    for (k, v) in keys {
        map.insert(k, v);
    }
}

/// The bordered Pango tooltip (claudebar:707-860).
fn render_default_tooltip(input: &RenderInput) -> String {
    let snap = &input.outcome.snapshot;
    let theme = input.theme;
    let blue = &theme.blue;
    let dim = &theme.dim;
    let fg = &theme.fg;

    let weekly_color = pango::severity_color(severity_for(snap.weekly.utilization_pct), theme);

    let weekly_pacing = pacing::calc(
        snap.weekly.utilization_pct,
        snap.weekly.resets_at,
        input.now,
        snap.weekly.window_duration,
        input.pace_tolerance,
    );

    let weekly_bar = if input.tooltip_pace_pts {
        pango::progress_bar(
            snap.weekly.utilization_pct,
            weekly_color,
            theme,
            Some(weekly_pacing.elapsed_pct),
        )
    } else {
        pango::progress_bar(snap.weekly.utilization_pct, weekly_color, theme, None)
    };

    let weekly_pace_glyph = pick_pace_glyph(input.tooltip_pace_pts, &weekly_pacing);

    let mut lines: Vec<Line> = Vec::new();
    let _ = pango::severity_color; // silence unused-import warning if any
    lines.push(Line::Center(format!(
        "<span font_weight='bold' foreground='{blue}'>Claude {plan}</span>",
        plan = escape(&snap.plan)
    )));
    lines.push(Line::Sep);
    lines.push(Line::Body("".into()));

    // An account with no five-hour limit has no Session block at all: an
    // empty bar would claim a window that does not exist.
    if let Some(session) = snap.session.as_ref() {
        let session_color = pango::severity_color(severity_for(session.utilization_pct), theme);
        let session_pacing = pacing::calc(
            session.utilization_pct,
            session.resets_at,
            input.now,
            session.window_duration,
            input.pace_tolerance,
        );
        let session_bar = if input.tooltip_pace_pts {
            pango::progress_bar(
                session.utilization_pct,
                session_color,
                theme,
                Some(session_pacing.elapsed_pct),
            )
        } else {
            pango::progress_bar(session.utilization_pct, session_color, theme, None)
        };
        let session_pace_glyph = pick_pace_glyph(input.tooltip_pace_pts, &session_pacing);

        lines.push(Line::Body(format!(
            " <span foreground='{fg}'>  󰔟  Session</span>"
        )));
        lines.push(Line::Body(format!(
            "   {bar}  <span font_weight='bold' foreground='{color}'>{pct}% {glyph}</span>",
            bar = session_bar,
            color = session_color,
            pct = session.utilization_pct,
            glyph = session_pace_glyph
        )));
        lines.push(Line::Body(format!(
            " <span foreground='{dim}'>  ⏱  Resets in {cd}</span>",
            cd = escape(&countdown::format(session.resets_at, input.now))
        )));
        lines.push(Line::Body("".into()));
    }

    lines.push(Line::Body(format!(
        " <span foreground='{fg}'>  󰃰  Weekly</span>"
    )));
    lines.push(Line::Body(format!(
        "   {bar}  <span font_weight='bold' foreground='{color}'>{pct}% {glyph}</span>",
        bar = weekly_bar,
        color = weekly_color,
        pct = snap.weekly.utilization_pct,
        glyph = weekly_pace_glyph
    )));
    lines.push(Line::Body(format!(
        " <span foreground='{dim}'>  ⏱  Resets in {cd}</span>",
        cd = escape(&countdown::format(snap.weekly.resets_at, input.now))
    )));

    if let Some(sw) = snap.sonnet.as_ref() {
        let sonnet_color = pango::severity_color(severity_for(sw.utilization_pct), theme);
        let sonnet_pacing = pacing::calc(
            sw.utilization_pct,
            sw.resets_at,
            input.now,
            sw.window_duration,
            input.pace_tolerance,
        );
        let sonnet_bar = if input.tooltip_pace_pts {
            pango::progress_bar(
                sw.utilization_pct,
                sonnet_color,
                theme,
                Some(sonnet_pacing.elapsed_pct),
            )
        } else {
            pango::progress_bar(sw.utilization_pct, sonnet_color, theme, None)
        };
        lines.push(Line::Body("".into()));
        lines.push(Line::Body(format!(
            " <span foreground='{fg}'>  󱤔  Sonnet only</span>"
        )));
        lines.push(Line::Body(format!(
            "   {bar}  <span font_weight='bold' foreground='{color}'>{pct}%</span>",
            bar = sonnet_bar,
            color = sonnet_color,
            pct = sw.utilization_pct
        )));
        lines.push(Line::Body(format!(
            " <span foreground='{dim}'>  ⏱  Resets in {cd}</span>",
            cd = escape(&countdown::format(sw.resets_at, input.now))
        )));
    }

    for sw in &snap.scoped {
        let scoped_color = pango::severity_color(severity_for(sw.window.utilization_pct), theme);
        let scoped_pacing = pacing::calc(
            sw.window.utilization_pct,
            sw.window.resets_at,
            input.now,
            sw.window.window_duration,
            input.pace_tolerance,
        );
        let scoped_bar = if input.tooltip_pace_pts {
            pango::progress_bar(
                sw.window.utilization_pct,
                scoped_color,
                theme,
                Some(scoped_pacing.elapsed_pct),
            )
        } else {
            pango::progress_bar(sw.window.utilization_pct, scoped_color, theme, None)
        };
        lines.push(Line::Body("".into()));
        lines.push(Line::Body(format!(
            " <span foreground='{fg}'>  󰆧  {label} weekly</span>",
            label = escape(&sw.label)
        )));
        lines.push(Line::Body(format!(
            "   {bar}  <span font_weight='bold' foreground='{color}'>{pct}%</span>",
            bar = scoped_bar,
            color = scoped_color,
            pct = sw.window.utilization_pct
        )));
        lines.push(Line::Body(format!(
            " <span foreground='{dim}'>  ⏱  Resets in {cd}</span>",
            cd = escape(&countdown::format(sw.window.resets_at, input.now))
        )));
    }

    if let Some(extra) = snap.extra.as_ref() {
        let extra_color = pango::severity_color(severity_for(extra.percent()), theme);
        let extra_bar = pango::progress_bar(extra.percent(), extra_color, theme, None);
        lines.push(Line::Body("".into()));
        lines.push(Line::Sep);
        lines.push(Line::Body(format!(
            " <span foreground='{fg}'>  󰄑  Extra usage</span>"
        )));
        lines.push(Line::Body(format!(
            "   {bar}  <span font_weight='bold' foreground='{color}'>{spent}</span>",
            bar = extra_bar,
            color = extra_color,
            spent = escape(&extra.fmt_spent())
        )));
        let lim = match extra.fmt_limit() {
            Some(l) => l,
            // No usable `monthly_limit` in the payload (null — observed for
            // uncapped plans — or absent). "none reported" states exactly
            // that; inferring a plan tier from it would overclaim, and a
            // $0.00 ceiling would be invented.
            None => "none reported".into(),
        };
        lines.push(Line::Body(format!(
            " <span foreground='{dim}'>  󰀓  Limit: {lim}</span>",
            lim = escape(&lim)
        )));
        if let Some(note) = extra.status_note() {
            lines.push(Line::Body(format!(
                " <span foreground='{dim}'>  Status: {note}</span>",
                note = escape(note)
            )));
        }
    }

    if let Some(cloud) = snap.cloud_credits.as_ref() {
        // The same figures as the panel's "Cloud session credits" metric,
        // in the tooltip's one-line style: what is left of what, when it
        // expires, and whether the grant is locked. Everything here came
        // off the wire (or is a constant), and the whole line still goes
        // through `escape` at the sink.
        let mut detail = format!(
            "{} left of {}",
            crate::format::usd(cloud.remaining.0 as f64 / 100.0),
            crate::format::usd(cloud.limit.0 as f64 / 100.0)
        );
        if let Some(when) = cloud.expires_at {
            detail.push_str(" · expires ");
            detail.push_str(&crate::format::local_date_hm(when));
        }
        if cloud.locked {
            detail.push_str(" · locked");
        }
        lines.push(Line::Body("".into()));
        lines.push(Line::Sep);
        lines.push(Line::Body(format!(
            " <span foreground='{fg}'>  󰀓  Cloud session credits</span>"
        )));
        lines.push(Line::Body(format!(
            " <span foreground='{dim}'>  {detail}</span>",
            detail = escape(&detail)
        )));
    }

    if let Some(usage) = snap.usage_credits.as_ref() {
        lines.push(Line::Body("".into()));
        lines.push(Line::Sep);
        lines.push(Line::Body(format!(
            " <span foreground='{fg}'>  󰀓  Usage credits</span>"
        )));
        // The currency code is response text, so the line is escaped at the
        // sink like every other line here.
        lines.push(Line::Body(format!(
            " <span foreground='{dim}'>  balance: {balance}</span>",
            balance = escape(&crate::usage::fmt_minor(
                usage.balance.0,
                usage.decimal_places,
                usage.currency.as_deref(),
            ))
        )));
        // `None` means "not reported": the row is absent, never an invented
        // "off".
        if let Some(auto_reload) = usage.auto_reload {
            lines.push(Line::Body(format!(
                " <span foreground='{dim}'>  auto-reload: {state}</span>",
                state = if auto_reload { "on" } else { "off" }
            )));
        }
    }

    if snap.reset_credits.available > 0 {
        lines.push(Line::Body("".into()));
        lines.push(Line::Sep);
        lines.push(Line::Body(format!(
            " <span foreground='{fg}'>  󰁯  Reset credits</span>"
        )));
        for line in crate::format::reset_credit_lines(&snap.reset_credits, input.now) {
            lines.push(Line::Body(format!(
                " <span foreground='{dim}'>     {}</span>",
                escape(&line)
            )));
        }
    }

    if let Some((code, msg)) = input.outcome.last_error.as_ref()
        && *code != 0
    {
        let (icon, color) = if *code >= 500 {
            ("󰅚", theme.red.as_str())
        } else {
            ("󰀪", theme.orange.as_str())
        };
        lines.push(Line::Body("".into()));
        lines.push(Line::Sep);
        lines.push(Line::Body(format!(
            " <span foreground='{color}'>  {icon}  HTTP {code}</span>"
        )));
        for wrapped in wrap_words(&escape(msg), 35) {
            lines.push(Line::Body(format!(
                "     <span foreground='{dim}'>{wrapped}</span>"
            )));
        }
    }

    if let Some(text) = input.claude_sessions.and_then(|s| s.summary()) {
        lines.push(Line::Body("".into()));
        lines.push(Line::Body(format!(
            " <span foreground='{dim}'>  {text}</span>"
        )));
    }

    let updated = updated_at_hm(input.now, input.outcome.cache_age);
    lines.push(Line::Body("".into()));
    lines.push(Line::Sep);
    lines.push(Line::Body(format!(
        " <span foreground='{dim}'>  󰅐  Updated {updated}</span>"
    )));

    tooltip::render_bordered(&lines, theme)
}

fn pick_pace_glyph(point_mode: bool, p: &pacing::Pacing) -> &'static str {
    if point_mode {
        p.point_pace.glyph()
    } else {
        p.ratio_pace.glyph()
    }
}

/// Greedy word-wrap to a target column. Used for the API-error message
/// in the tooltip (claudebar:779-790).
fn wrap_words(s: &str, width: usize) -> Vec<String> {
    let mut out = Vec::new();
    let mut buf = String::new();
    for word in s.split_whitespace() {
        if buf.is_empty() {
            buf = word.into();
        } else if buf.len() + 1 + word.len() <= width {
            buf.push(' ');
            buf.push_str(word);
        } else {
            out.push(std::mem::take(&mut buf));
            buf = word.into();
        }
    }
    if !buf.is_empty() {
        out.push(buf);
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::anthropic::fetch::FetchOutcome;
    use crate::usage::{
        AnthropicSnapshot, Cents, CloudCredits, ExtraUsage, UsageCredits, UsageWindow,
    };
    use chrono::TimeZone;

    fn now() -> DateTime<Utc> {
        Utc.with_ymd_and_hms(2026, 5, 23, 12, 0, 0).unwrap()
    }

    fn sample_outcome() -> FetchOutcome {
        let session = UsageWindow {
            utilization_pct: 62,
            resets_at: Some(now() + chrono::Duration::minutes(90)),
            window_duration: chrono::Duration::hours(5),
        };
        let weekly = UsageWindow {
            utilization_pct: 27,
            resets_at: Some(now() + chrono::Duration::days(4) + chrono::Duration::hours(1)),
            window_duration: chrono::Duration::days(7),
        };
        let sonnet = UsageWindow {
            utilization_pct: 4,
            resets_at: Some(now() + chrono::Duration::hours(2) + chrono::Duration::minutes(24)),
            window_duration: chrono::Duration::days(7),
        };
        let snap = AnthropicSnapshot {
            plan: "Max 5x".into(),
            session: Some(session),
            weekly,
            sonnet: Some(sonnet),
            scoped: vec![],
            extra: Some(ExtraUsage {
                limit: Some(Cents(5000)),
                spent: Cents(250),
                currency: None,
                decimal_places: Some(2),
                status: crate::usage::ExtraUsageStatus::Active,
            }),
            reset_credits: Default::default(),
            cloud_credits: None,
            usage_credits: None,
        };
        FetchOutcome {
            snapshot: snap,
            stale: false,
            last_error: None,
            cache_age: Some(std::time::Duration::from_secs(30)),
        }
    }

    fn input<'a>(outcome: &'a FetchOutcome, theme: &'a Theme) -> RenderInput<'a> {
        RenderInput {
            claude_sessions: None,
            outcome,
            theme,
            format: DEFAULT_FORMAT,
            tooltip_format: None,
            icon: None,
            pace_tolerance: 5,
            format_pace_color: false,
            tooltip_pace_pts: false,
            now: now(),
        }
    }

    #[test]
    fn uncapped_extra_usage_renders_spend_with_dash_limit() {
        // The #30 shape: real spend, `monthly_limit: null`. The spend must
        // stay visible and `{extra_limit}` must be "—", NOT empty — GNOME and
        // the macOS menu bar hide the whole extra row on an empty limit,
        // which would re-hide the spend the fix is recovering.
        let mut oc = sample_outcome();
        if let Some(e) = oc.snapshot.extra.as_mut() {
            e.limit = None;
            e.spent = Cents(14157);
        }
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.format = "{extra_spent}|{extra_limit}|{extra_pct}";
        let out = render_anthropic(&inp);
        assert!(out.text.contains("$141.57|—|0"), "got: {}", out.text);

        // Default tooltip: spend shown, the missing limit stated as exactly
        // that, and no fabricated "$0.00" anywhere near the extra block.
        let inp2 = input(&oc, &theme);
        let out2 = render_anthropic(&inp2);
        assert!(out2.tooltip.contains("$141.57"));
        assert!(out2.tooltip.contains("none reported"));
        assert!(!out2.tooltip.contains("Limit: $0.00"));
    }

    #[test]
    fn extra_usage_placeholders_and_tooltip_use_the_blocks_currency() {
        // Non-vacuous currency pin: with BRL in the snapshot, formatting
        // with a bare `$` again ("$141.57") must fail this test — that is
        // the wrong-currency claim the wiring exists to prevent.
        let mut oc = sample_outcome();
        if let Some(e) = oc.snapshot.extra.as_mut() {
            e.limit = None;
            e.spent = Cents(14157);
            e.currency = Some("BRL".into());
        }
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.format = "{extra_spent}";
        let out = render_anthropic(&inp);
        assert!(out.text.contains("R$141.57"), "got: {}", out.text);
        assert!(!out.text.contains("$141.57|"), "got: {}", out.text);

        let inp2 = input(&oc, &theme);
        let out2 = render_anthropic(&inp2);
        assert!(
            out2.tooltip.contains("R$141.57"),
            "tooltip must carry the block's currency"
        );
    }

    #[test]
    fn provider_disabled_extra_usage_explains_why_it_stopped() {
        let mut oc = sample_outcome();
        oc.snapshot.extra.as_mut().unwrap().status = crate::usage::ExtraUsageStatus::OutOfCredits;
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert!(
            out.tooltip.contains("Status: out of credits"),
            "{}",
            out.tooltip
        );
        assert!(out.tooltip.contains("$2.50"), "{}", out.tooltip);
    }

    #[test]
    fn default_format_renders_pct_and_reset() {
        let oc = sample_outcome();
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        // Bar text wraps in a span; content should include "62%" and the
        // session countdown "1h 30m".
        assert!(out.text.contains("62%"));
        assert!(out.text.contains("1h 30m"));
        assert_eq!(out.class, Class::Mid); // session=62 → mid
    }

    #[test]
    fn stale_appends_pause_indicator() {
        let mut oc = sample_outcome();
        oc.stale = true;
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert!(out.text.contains("⏸"));
    }

    #[test]
    fn icon_prepends() {
        let oc = sample_outcome();
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.icon = Some("󰚩");
        let out = render_anthropic(&inp);
        assert!(out.text.contains("󰚩 "));
    }

    #[test]
    fn custom_tooltip_format_uses_placeholders() {
        let oc = sample_outcome();
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.tooltip_format = Some("S:{session_pct} W:{weekly_pct}");
        let out = render_anthropic(&inp);
        assert_eq!(out.tooltip, "S:62 W:27");
    }

    #[test]
    fn scoped_placeholders_expose_model_scoped_window() {
        // The desktop surfaces read these `{scoped_*}` fields to show the
        // model-scoped weekly bar (e.g. Fable) that only lives in `limits[]`.
        let mut oc = sample_outcome();
        oc.snapshot.scoped = vec![crate::usage::ScopedWindow {
            label: "Fable".into(),
            window: UsageWindow {
                utilization_pct: 84,
                resets_at: Some(now() + chrono::Duration::days(5)),
                window_duration: chrono::Duration::days(7),
            },
        }];
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.tooltip_format = Some(
            "M:{scoped_model} P:{scoped_pct} R:{scoped_reset} E:{scoped_elapsed} B:{scoped_bar}",
        );
        let out = render_anthropic(&inp);
        assert!(out.tooltip.starts_with("M:Fable P:84 R:"));
        for placeholder in [
            "{scoped_model}",
            "{scoped_pct}",
            "{scoped_reset}",
            "{scoped_elapsed}",
            "{scoped_bar}",
        ] {
            assert!(!out.tooltip.contains(placeholder));
        }
    }

    #[test]
    fn scoped_placeholders_are_neutral_when_absent() {
        let oc = sample_outcome(); // scoped: vec![]
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.tooltip_format = Some("[{scoped_model}] {scoped_pct} {scoped_reset}");
        let out = render_anthropic(&inp);
        assert_eq!(out.tooltip, "[] 0 —");
    }

    #[test]
    fn plan_and_scoped_model_are_pango_escaped_in_custom_formats() {
        // The plan label comes from the credentials file and the scoped model
        // name from the API's `limits[].scope.model.display_name`; both feed
        // the bar text and a custom --tooltip-format, which are Pango markup.
        let mut oc = sample_outcome();
        oc.snapshot.plan = "Max <5x> & Team".into();
        oc.snapshot.scoped = vec![crate::usage::ScopedWindow {
            label: "Fable & <Opus>".into(),
            window: UsageWindow {
                utilization_pct: 84,
                resets_at: Some(now() + chrono::Duration::days(5)),
                window_duration: chrono::Duration::days(7),
            },
        }];
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.format = "{plan} · {scoped_model}";
        inp.tooltip_format = Some("{plan} · {scoped_model}");
        let out = render_anthropic(&inp);
        let escaped = "Max &lt;5x&gt; &amp; Team · Fable &amp; &lt;Opus&gt;";
        assert!(out.text.contains(escaped), "{}", out.text);
        assert!(!out.text.contains("<5x>"), "{}", out.text);
        assert_eq!(out.tooltip, escaped);
    }

    #[test]
    fn tooltip_lists_cloud_session_and_usage_credits() {
        let mut oc = sample_outcome();
        oc.snapshot.cloud_credits = Some(CloudCredits {
            limit: Cents(25000),
            remaining: Cents(25000),
            expires_at: Some(now() + chrono::Duration::days(10)),
            locked: false,
        });
        oc.snapshot.usage_credits = Some(UsageCredits {
            balance: Cents(1500),
            decimal_places: 2,
            currency: Some("USD".into()),
            auto_reload: Some(true),
        });
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        let t = &out.tooltip;
        assert!(t.contains("Cloud session credits"), "{}", t);
        assert!(
            t.contains("$250.00 left of $250.00 · expires "),
            "cloud line: {}",
            t
        );
        assert!(t.contains("Usage credits"), "{}", t);
        assert!(t.contains("balance: $15.00"), "{}", t);
        assert!(t.contains("auto-reload: on"), "{}", t);
        // The blocks sit after the Extra usage section and before the
        // footer — the tooltip lists them under the account, in order.
        let extra_at = t.find("Extra usage").unwrap();
        let cloud_at = t.find("Cloud session credits").unwrap();
        let usage_at = t.find("Usage credits").unwrap();
        let updated_at = t.find("Updated").unwrap();
        assert!(
            extra_at < cloud_at && cloud_at < usage_at && usage_at < updated_at,
            "{}",
            t
        );

        // And a balance the response does not report stays out of the
        // tooltip: no row, never a $0.00.
        let quiet = sample_outcome();
        let out = render_anthropic(&input(&quiet, &theme));
        assert!(
            !out.tooltip.contains("Cloud session credits"),
            "{}",
            out.tooltip
        );
        assert!(!out.tooltip.contains("Usage credits"), "{}", out.tooltip);
        assert!(!out.tooltip.contains("balance: $0.00"), "{}", out.tooltip);
    }

    #[test]
    fn tooltip_lock_line_escapes_a_hostile_locked_reason() {
        // The `locked_reason` text is untrusted: it never leaves the parser
        // as text — only the boolean lock does — so the tooltip shows the
        // lock and not a single raw `<` from the reason.
        let raw = r#"{
            "five_hour": {"utilization": 12},
            "seven_day": {"utilization": 34},
            "iguana_necktie": {"resets_at": "2026-11-05T07:59:00Z",
                               "limit_dollars": 250, "remaining_dollars": 250,
                               "locked_reason": "<b>org_migrating</b>"}
        }"#;
        let resp: crate::anthropic::types::UsageResponse = serde_json::from_str(raw).unwrap();
        let mut oc = sample_outcome();
        oc.snapshot = resp.into_snapshot("Max 5x".into());
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert!(
            out.tooltip.contains("Cloud session credits"),
            "{}",
            out.tooltip
        );
        assert!(out.tooltip.contains("locked"), "{}", out.tooltip);
        assert!(!out.tooltip.contains("<b>"), "{}", out.tooltip);
        assert!(!out.tooltip.contains("org_migrating"), "{}", out.tooltip);
    }

    #[test]
    fn default_tooltip_contains_all_sections() {
        let oc = sample_outcome();
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert!(out.tooltip.contains("Claude Max 5x"));
        assert!(out.tooltip.contains("Session"));
        assert!(out.tooltip.contains("Weekly"));
        assert!(out.tooltip.contains("Sonnet only"));
        assert!(out.tooltip.contains("Extra usage"));
        assert!(out.tooltip.contains("Updated"));
        assert!(out.tooltip.contains("62%"));
        assert!(out.tooltip.contains("27%"));
        assert!(out.tooltip.contains("$2.50"));
        assert!(out.tooltip.contains("$50.00"));
    }

    #[test]
    fn tooltip_omits_sonnet_and_extra_when_absent() {
        let mut oc = sample_outcome();
        oc.snapshot.sonnet = None;
        oc.snapshot.extra = None;
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert!(!out.tooltip.contains("Sonnet only"));
        assert!(!out.tooltip.contains("Extra usage"));
        // Still contains the basics.
        assert!(out.tooltip.contains("Session"));
        assert!(out.tooltip.contains("Weekly"));
    }

    #[test]
    fn tooltip_reports_banked_resets_and_stays_silent_without_them() {
        let theme = Theme::default();
        let mut oc = sample_outcome();

        // The overwhelmingly common case: no grant, and therefore no row.
        let out = render_anthropic(&input(&oc, &theme));
        assert!(!out.tooltip.contains("Reset credits"), "{}", out.tooltip);

        oc.snapshot.reset_credits = crate::usage::ResetCredits {
            available: 1,
            credits: vec![crate::usage::ResetCredit {
                title: Some("Opus 5.5 launch reset".into()),
                expires_at: Some(now() + chrono::Duration::days(28)),
            }],
        };
        let out = render_anthropic(&input(&oc, &theme));
        assert!(out.tooltip.contains("Reset credits"), "{}", out.tooltip);
        assert!(
            out.tooltip.contains("Opus 5.5 launch reset"),
            "{}",
            out.tooltip
        );
        // The deadline is what the user acts on, so it travels with the row.
        // Asserted through the countdown rather than the rendered date: the
        // date is formatted in local time and this suite must not depend on
        // the machine's zone.
        assert!(out.tooltip.contains("expires"), "{}", out.tooltip);
        assert!(out.tooltip.contains("28d"), "{}", out.tooltip);

        let values = build_placeholders(&input(&oc, &theme));
        assert_eq!(values["resets_available"], "1");
        assert_eq!(values["resets"], "1 reset available");
    }

    #[test]
    fn tooltip_includes_http_error_when_last_error_present() {
        let mut oc = sample_outcome();
        oc.last_error = Some((429, "rate limited".into()));
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert!(out.tooltip.contains("HTTP 429"));
        assert!(out.tooltip.contains("rate limited"));
    }

    #[test]
    fn tooltip_omits_http_zero() {
        // claudebar treats code 0 (no HTTP response) as "don't render"
        // because it would be misleading.
        let mut oc = sample_outcome();
        oc.last_error = Some((0, "n/a".into()));
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert!(!out.tooltip.contains("HTTP 0"));
    }

    #[test]
    fn worst_window_promotes_class_to_critical() {
        let mut oc = sample_outcome();
        oc.snapshot.weekly.utilization_pct = 95;
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert_eq!(out.class, Class::Critical);
    }

    #[test]
    fn pace_color_mode_uses_neutral_wrapper() {
        let oc = sample_outcome();
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.format = "{session_pct}% {session_pace}";
        inp.format_pace_color = true;
        let out = render_anthropic(&inp);
        // Wrapper color should be the foreground (neutral), not severity.
        assert!(out.text.contains(&theme.fg));
    }

    /// A verified Ultra account: no five-hour limit, so no session window.
    fn without_session(mut oc: FetchOutcome) -> FetchOutcome {
        oc.snapshot.plan = "Ultra".into();
        oc.snapshot.session = None;
        oc
    }

    #[test]
    fn without_a_session_window_the_default_bar_shows_the_weekly_window() {
        let oc = without_session(sample_outcome());
        let theme = Theme::default();
        let mut inp = input(&oc, &theme);
        inp.format = default_format(&oc.snapshot);
        let out = render_anthropic(&inp);
        assert!(out.text.contains(">27% · 4d 1h<"), "{}", out.text);
        // An account that has the window keeps the session default.
        assert_eq!(default_format(&sample_outcome().snapshot), DEFAULT_FORMAT);
    }

    #[test]
    fn without_a_session_window_the_tooltip_has_no_session_block() {
        let oc = without_session(sample_outcome());
        let theme = Theme::default();
        let out = render_anthropic(&input(&oc, &theme));
        assert!(out.tooltip.contains("Claude Ultra"), "{}", out.tooltip);
        assert!(!out.tooltip.contains("Session"), "{}", out.tooltip);
        assert!(!out.tooltip.contains("Resets in 1h 30m"), "{}", out.tooltip);
        assert!(out.tooltip.contains("󰃰  Weekly"), "{}", out.tooltip);
        assert!(out.tooltip.contains("Resets in 4d 1h"), "{}", out.tooltip);
    }

    /// The session family is empty, never a confident 0%: the macOS and
    /// GNOME bars hide the five-hour row exactly when `{session_pct}` is not
    /// a number.
    #[test]
    fn without_a_session_window_its_placeholders_are_empty() {
        let oc = without_session(sample_outcome());
        let theme = Theme::default();
        let values = build_placeholders(&input(&oc, &theme));
        for key in [
            "session_pct",
            "session_reset",
            "session_elapsed",
            "session_bar",
            "session_pace",
            "session_pace_indicator",
            "session_pace_pct",
            "session_pace_pts",
            "session_pace_delta",
            "session_pace_abs_delta",
        ] {
            assert_eq!(values[key], "", "{key}");
        }
        assert_eq!(values["weekly_pct"], "27");
        assert_eq!(values["plan"], "Ultra");

        let mut inp = input(&oc, &theme);
        inp.format = "[{session_pct}{session_pace}] {weekly_pct}%";
        inp.format_pace_color = true;
        let out = render_anthropic(&inp);
        assert!(out.text.contains(">[] 27%<"), "{}", out.text);
    }

    #[test]
    fn wrap_words_breaks_on_width_boundary() {
        let lines = wrap_words("aaa bbb ccc ddd eee fff", 8);
        // "aaa bbb" (7) fits; "ccc ddd" (7) fits next; "eee fff" (7) next.
        assert_eq!(lines, vec!["aaa bbb", "ccc ddd", "eee fff"]);
    }

    /// #356: the tooltip says what the account's live sessions are doing, and
    /// says nothing when none are working or waiting.
    #[test]
    fn tooltip_names_working_and_waiting_sessions_only_when_there_are_some() {
        use crate::context::activity::SessionActivity;
        let oc = sample_outcome();
        let theme = Theme::default();

        let active = SessionActivity {
            working: 2,
            waiting: 1,
        };
        let mut inp = input(&oc, &theme);
        inp.claude_sessions = Some(&active);
        let out = render_anthropic(&inp);
        assert!(
            out.tooltip.contains("2 working · 1 waiting"),
            "{}",
            out.tooltip
        );

        let idle = SessionActivity::default();
        let mut inp = input(&oc, &theme);
        inp.claude_sessions = Some(&idle);
        let quiet = render_anthropic(&inp);
        assert!(!quiet.tooltip.contains("working"), "{}", quiet.tooltip);
        assert!(!quiet.tooltip.contains("waiting"), "{}", quiet.tooltip);
    }
}