tix-tracker 0.10.0

use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span};

use crate::assignee::assignee_display;
use crate::model::Priority;

use super::board::Card;

pub fn priority_glyph(priority: &Priority) -> &'static str {
    match priority {
        Priority::High => "!",
        Priority::Other(s) if s.eq_ignore_ascii_case("urgent") => "!!",
        _ => "",
    }
}

pub fn priority_style(priority: &Priority) -> Style {
    match priority {
        Priority::High => Style::default().fg(Color::Red),
        Priority::Other(s) if s.eq_ignore_ascii_case("urgent") => {
            Style::default().fg(Color::Red).add_modifier(Modifier::BOLD)
        }
        Priority::Low => Style::default().fg(Color::DarkGray),
        _ => Style::default(),
    }
}

/// Single-line card render (title wrapping disabled), truncated to `width`.
/// Kept for callers and tests that want today's one-line behavior.
pub fn card_line(card: &Card, width: usize) -> Line<'static> {
    let mut lines = card_lines(card, width, false, 1);
    lines.remove(0)
}

/// The styled word tokens making up a card's rendered content: `#N` (a bare `N`
/// for a sub-issue, tix #1536), then the classification chips — up to three
/// labels (type), the assignee, the category chip (status) — then the title words
/// and the priority glyph, then the state markers. The chips lead so they hold a
/// fixed column across cards instead of being pushed around by a long title
/// (tix #1536). Wrapping and truncation operate on this token stream so suffix
/// segments flow onto continuation lines instead of overflowing the column.
/// The styled tokens one card's first line is made of.
///
/// `pub` so a test can assert the **marker text** rather than a screenshot of it.
/// A board rendering test that only captures the whole screen cannot say *why* it
/// passed, and a marker with the wrong contents still renders a screen.
pub fn card_tokens(card: &Card) -> Vec<(String, Style)> {
    card_tokens_themed(card, &crate::ui::color::Theme::default())
}

/// [`card_tokens`] with a resolved theme (tix #1530): a label with a configured
/// tag color renders in it; an uncolored label keeps the board's default yellow.
pub fn card_tokens_themed(card: &Card, theme: &crate::ui::color::Theme) -> Vec<(String, Style)> {
    let mut tokens = Vec::new();
    // Sub-issues (depth 1) drop the `#` (tix #1536). The one-character indent
    // `indent_sub_issue` adds is exactly the `#`'s width, so the digits of a
    // sub-issue line up with the digits of its parent instead of sitting one
    // column to the right. A top-level card keeps the `#`, which is where the
    // marker earns its keep.
    let number = if card.depth == 0 {
        format!("#{}", card.number)
    } else {
        format!("{}", card.number)
    };
    tokens.push((number, Style::default().fg(Color::Cyan)));
    // Related-count marker (tix #1513), immediately after the number so a long
    // title can never wrap it off the card. A count, not the entries: the card is
    // one or two lines wide, and the list itself belongs to the detail pane.
    // Magenta matches the detail pane's `related:` block, so one color means one
    // concept on both surfaces.
    if card.related > 0 {
        tokens.push((
            format!("[↔ {}]", card.related),
            Style::default().fg(Color::Magenta),
        ));
    }
    // The classification chips — type (labels), assignee, status (category) — sit
    // **left**, directly after the number (tix #1536). They used to trail the title,
    // so a long title wrapped them onto a later line and every card put them in a
    // different column. Leading with them keeps the three in a fixed column across
    // cards, which is what makes the lines line up. Type, then assignee, then
    // status: the order the issue's own path (`{assignee}/{type}/{status}`) reads is
    // reversed because a line is read left to right and here the number leads.
    for label in card.labels.iter().take(3) {
        // tix #1530: a tag configured in `docs/tags` renders in its color; any
        // other label keeps the board's default yellow.
        let style = theme.tag(label).map_or_else(
            || Style::default().fg(Color::Yellow),
            |color| Style::default().fg(color),
        );
        tokens.push((format!("[{label}]"), style));
    }
    if let Some(a) = &card.assignee {
        let name = assignee_display(a);
        if !name.is_empty() {
            tokens.push((name, Style::default().fg(Color::Green)));
        }
    }
    // WP05: the category chip (T022/T024), in the same bracketed visual language as
    // `[overdue]` and `[~]`.
    tokens.push(category_token(
        card.category.as_deref(),
        card.category_color,
    ));
    // The title follows the classification chips, so a long title wraps after them
    // rather than pushing them around.
    tokens.extend(
        card.title
            .split_whitespace()
            .map(|w| (w.to_string(), Style::default())),
    );
    let glyph = priority_glyph(&card.priority);
    if !glyph.is_empty() {
        tokens.push((glyph.to_string(), priority_style(&card.priority)));
    }
    // Blocked marker, before the overdue marker so it is visible however the
    // title wraps. A glyph rather than the reason: the card is one or two lines
    // wide, and the full reason belongs in the detail view and the move warning.
    // `[~]` matches the board's existing bracketed-marker language (`[overdue]`,
    // `[label]`).
    if card.blocked.is_some() {
        tokens.push(("[~]".to_string(), Style::default().fg(Color::Red)));
    }
    // Child-count marker, in the same bracketed language and next to the blocked
    // marker, so a parent is identifiable on the board without opening it. A
    // *count* and a *rollup* rather than a word: the card is one or two lines wide.
    // A leaf has no marker at all, so the column of cards stays scannable.
    if let Some(children) = &card.children {
        tokens.push((format!("[{children}]"), Style::default().fg(Color::Cyan)));
    }
    // The health badge (mission `project-issue-health-status-01M3C8HX`, WP06 T030), in
    // the same bracketed language as `[~]`, `[N]` and `[archived]`. The word is the
    // state's stable spelling — the same one `tix list --columns health` prints — and
    // `→` marks a derived value that disagrees with the issue's own, so a parent whose
    // children are at risk reads `[at_risk→needs_attention]` rather than hiding
    // either layer.
    //
    // Tinted by the state, never *carried* by the color: a terminal with no color
    // still shows the state, because the text is unconditional (FR-004, research R6).
    // `None` — an issue that records no health — emits no token at all, so the column
    // of cards stays scannable and a legacy board is unchanged.
    if let Some(health) = &card.health {
        let (_, derived) = health
            .split_once('→')
            .map_or((health.as_str(), None), |(current, derived)| {
                (current, Some(derived))
            });
        let color = match derived.or(Some(health.as_str())) {
            Some("at_risk") => Color::Red,
            Some("needs_attention") => Color::Yellow,
            Some("on_track") => Color::Green,
            _ => Color::DarkGray,
        };
        tokens.push((format!("[{health}]"), Style::default().fg(color)));
    }
    // Archived marker (issue #1492), in the same bracketed language as `[~]` and
    // `[N]`. Dim, because an archived issue is history rather than work — it is
    // shown because the toggle asked for it, and it should not compete with the
    // active cards for attention.
    if card.archived {
        tokens.push((
            "[archived]".to_string(),
            Style::default().fg(Color::DarkGray),
        ));
    }
    if card
        .due_date
        .as_deref()
        .is_some_and(|due| due < crate::model::today().as_str())
        // WP05: `card.done` is the **service's** completion decision (C-004). This
        // compared `card.status != "done"` — a literal column name, in a file whose
        // sibling field already had the right answer. On a board whose completion
        // column is `shipped`, a completed issue with a past due date was marked
        // `[overdue]`.
        && !card.done
    {
        tokens.push(("[overdue]".to_string(), Style::default().fg(Color::Red)));
    }
    tokens
}

/// The category chip: a bracketed label, tinted by the category's color hint.
///
/// WP05 T024. Added because the **board card and the detail view both** need
/// "category label, optionally tinted", and rendering it twice is how the two drift
/// into spelling one category two ways — the failure the parity contract names.
///
/// **The label carries the meaning; the color only tints it** (FR-004, research R6).
/// A board or terminal with no color still shows the category, because the text is
/// unconditional and `hint` merely selects a foreground. That is the whole reason
/// this is a function and not a style: a caller cannot forget the label by forgetting
/// the color.
///
/// **No policy and no resolution.** It is handed a label and a hint and renders them;
/// it does not ask what a column means, and it cannot be made to disagree with the
/// service by editing this file. `None` renders `(unmapped)`, which is the renderers'
/// spelling for a column the board does not configure — a statement about the file,
/// not a transition-policy default.
pub fn category_token(
    label: Option<&str>,
    hint: Option<crate::workflow::ColorHint>,
) -> (String, Style) {
    let text = format!("[{}]", label.unwrap_or("unmapped"));
    let style = match hint {
        Some(crate::workflow::ColorHint::Dim) => Style::default().fg(Color::DarkGray),
        Some(crate::workflow::ColorHint::Accent) => Style::default().fg(Color::Cyan),
        Some(crate::workflow::ColorHint::Warn) => Style::default().fg(Color::Yellow),
        Some(crate::workflow::ColorHint::Ok) => Style::default().fg(Color::Green),
        Some(crate::workflow::ColorHint::Muted) => Style::default().fg(Color::Gray),
        // No hint: the label is still rendered, in the default foreground. This arm
        // is the no-color case T022 step 3 and T025 step 5 pin.
        None => Style::default(),
    };
    (text, style)
}

/// Render a card as up to `max_lines` lines at `width` columns. With `wrap`
/// on, tokens are greedily wrapped onto the next line when they no longer fit;
/// the whole card body is clamped to `max_lines` and any surplus is clipped.
/// With `wrap` off the card is a single line truncated to `width`. Widths are
/// measured per Unicode column (CJK chars count 2) so wrapped lines never poke
/// through the column border.
pub fn card_lines(card: &Card, width: usize, wrap: bool, max_lines: usize) -> Vec<Line<'static>> {
    card_lines_themed(
        card,
        width,
        wrap,
        max_lines,
        &crate::ui::color::Theme::default(),
    )
}

/// [`card_lines`] with a resolved theme, so a configured tag color reaches the
/// card (tix #1530). The line count is unchanged by the theme, so hit-testing
/// still matches [`card_line_count`].
pub fn card_lines_themed(
    card: &Card,
    width: usize,
    wrap: bool,
    max_lines: usize,
    theme: &crate::ui::color::Theme,
) -> Vec<Line<'static>> {
    let tokens = card_tokens_themed(card, theme);
    let mut lines = if wrap {
        greedy_wrap(&tokens, width)
    } else {
        vec![tokens]
    };
    if lines.len() > max_lines {
        lines.truncate(max_lines);
    }
    let mut rendered: Vec<Line<'static>> = lines
        .into_iter()
        .map(|line_tokens| Line::from(truncate_tokens(&line_tokens, width)))
        .collect();
    indent_sub_issue(card, &mut rendered);
    rendered
}

/// Prefix a sub-issue card's lines with a one-character whitespace margin
/// (tix #1399).
///
/// A `depth == 0` card's lines are left untouched. A `depth == 1` card gets a
/// single ASCII space before **every** line, so the whole card reads as hanging one
/// column off the parent above it.
///
/// The margin is **added**, never carved out of the wrapped body: the tokens are
/// still wrapped at the same `width`, so the line count is exactly what it was
/// before the indent — and therefore exactly what [`card_line_count`] reports. That
/// is what keeps the pointer hit-test aligned with the drawn rows. The leading cell
/// is clipped by the column, a cost paid only on a card that is already marked as
/// subordinate.
fn indent_sub_issue(card: &Card, lines: &mut [Line<'static>]) {
    if card.depth == 0 {
        return;
    }
    for line in lines.iter_mut() {
        let mut spans = vec![Span::raw(" ")];
        spans.append(&mut line.spans);
        *line = Line::from(spans);
    }
}

/// The number of rows `card_lines` renders for `card` at `width` — the exact
/// index a `List` item occupies. Computed with the same wrap and title-line
/// clamping so pointer hit-testing can never drift from what is drawn (D3);
/// always at least 1 and bounded by `max_lines`.
pub fn card_line_count(card: &Card, width: usize, wrap: bool, max_lines: usize) -> u16 {
    let count = if wrap {
        greedy_wrap(&card_tokens(card), width).len()
    } else {
        1
    };
    let count = count.min(max_lines).max(1);
    u16::try_from(count).unwrap_or(u16::MAX)
}

fn greedy_wrap(tokens: &[(String, Style)], width: usize) -> Vec<Vec<(String, Style)>> {
    let mut lines: Vec<Vec<(String, Style)>> = Vec::new();
    let mut cur: Vec<(String, Style)> = Vec::new();
    let mut cur_width = 0usize;
    for (word, style) in tokens {
        let w = Span::raw(word).width();
        if !cur.is_empty() && cur_width + 1 + w > width {
            lines.push(std::mem::take(&mut cur));
            cur_width = 0;
        }
        cur.push((word.clone(), *style));
        cur_width += if cur.len() == 1 { w } else { w + 1 };
    }
    if !cur.is_empty() {
        lines.push(cur);
    }
    if lines.is_empty() {
        lines.push(Vec::new());
    }
    lines
}

fn truncate_tokens(tokens: &[(String, Style)], width: usize) -> Vec<Span<'static>> {
    let mut spans: Vec<Span<'static>> = Vec::new();
    let mut used = 0usize;
    let mut first = true;
    for (word, style) in tokens {
        let w = Span::raw(word).width();
        let sep = if first { 0 } else { 1 };
        first = false;
        if used + sep + w <= width {
            if sep == 1 {
                spans.push(Span::raw(" "));
                used += 1;
            }
            spans.push(Span::styled(word.clone(), *style));
            used += w;
        } else if used < width {
            let clipped = clip_to_width(word, width - used);
            if !clipped.is_empty() {
                spans.push(Span::styled(clipped, *style));
            }
            break;
        } else {
            break;
        }
    }
    spans
}

fn clip_to_width(word: &str, target: usize) -> String {
    let mut acc = String::new();
    for ch in word.chars() {
        let cand = format!("{acc}{ch}");
        if Span::raw(&cand).width() <= target {
            acc.push(ch);
        } else {
            break;
        }
    }
    acc
}

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

    fn card(priority: Priority) -> Card {
        Card {
            health: None,
            number: 1,
            title: "Test".into(),
            priority,
            labels: vec![],
            assignee: None,
            filename: "test.md".into(),
            commit: None,
            created: "2026-01-01".into(),
            due_date: None,
            status: "todo".into(),
            category: None,
            category_color: None,
            done: false,
            cycle: None,
            milestone: None,
            blocked: None,
            children: None,
            parent: None,
            depth: 0,
            archived: false,
            related: 0,
            projects: vec![],
            epics: Vec::new(),
        }
    }

    #[test]
    fn glyph_high_is_bang() {
        assert_eq!(priority_glyph(&Priority::High), "!");
    }

    #[test]
    fn glyph_urgent_is_double_bang() {
        assert_eq!(priority_glyph(&Priority::Other("urgent".into())), "!!");
    }

    #[test]
    fn glyph_medium_is_empty() {
        assert_eq!(priority_glyph(&Priority::Medium), "");
    }

    #[test]
    fn card_line_renders_number_and_title() {
        let c = card(Priority::Medium);
        let line = card_line(&c, 40);
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();
        assert!(text.contains("#1"));
        assert!(text.contains("Test"));
    }

    #[test]
    fn card_line_high_priority_shows_glyph() {
        let c = card(Priority::High);
        let line = card_line(&c, 40);
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();
        assert!(text.contains("!"));
    }

    #[test]
    fn card_line_assignee_shows_at_prefix() {
        let c = Card {
            assignee: Some("alice".into()),
            ..card(Priority::Medium)
        };
        let line = card_line(&c, 40);
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();
        assert!(text.contains("@alice"));
    }

    #[test]
    fn card_line_identity_shows_name_only() {
        let c = Card {
            assignee: Some("Herbert Maschke <thyseus@pm.me>".into()),
            ..card(Priority::Medium)
        };
        let line = card_line(&c, 40);
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();
        assert!(text.contains("Herbert Maschke"));

        assert!(
            !text.contains("thyseus@pm.me"),
            "identity email must not leak into the board line: {text:?}"
        );
    }

    #[test]
    fn card_line_shows_first_three_labels() {
        let c = Card {
            labels: vec!["a".into(), "b".into(), "c".into(), "d".into()],
            ..card(Priority::Medium)
        };
        let line = card_line(&c, 40);
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();
        assert!(text.contains("[a]"));
        assert!(text.contains("[b]"));
        assert!(text.contains("[c]"));
        assert!(!text.contains("[d]"));
    }

    #[test]
    fn card_line_shows_overdue_tag_for_open_past_due() {
        let c = Card {
            due_date: Some("2000-01-01".into()),
            status: "todo".into(),
            ..card(Priority::Medium)
        };
        let line = card_line(&c, 80);
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();
        assert!(text.contains("[overdue]"));
    }

    /// tix #1513 T008: a card with `related_issues` carries a count marker, right
    /// after `#num`; a card with none carries no marker at all.
    #[test]
    fn card_shows_a_related_count_right_after_the_number() {
        let none = card_tokens(&card(Priority::Medium));
        assert!(
            none.iter().all(|(text, _)| !text.starts_with("[↔")),
            "a card with no related_issues has no marker: {none:?}"
        );

        let c = Card {
            related: 3,
            projects: vec![],
            epics: Vec::new(),
            ..card(Priority::Medium)
        };
        let tokens = card_tokens(&c);
        assert_eq!(tokens[0].0, "#1", "the number stays the first token");
        assert_eq!(
            tokens[1].0, "[↔ 3]",
            "the related count sits immediately after the number, so title wrapping \
             cannot hide it: {tokens:?}"
        );
        assert_eq!(
            tokens[1].1.fg,
            Some(Color::Magenta),
            "the marker uses the detail pane's related accent"
        );
    }

    /// tix #1536: a top-level card keeps `#N`; a sub-issue (`depth == 1`) drops the
    /// `#`, so its digits start at the same column as its parent's once the
    /// one-character indent is applied.
    #[test]
    fn sub_issue_number_drops_the_hash_marker() {
        let top = card(Priority::Medium);
        assert_eq!(card_tokens(&top)[0].0, "#1");

        let sub = Card {
            depth: 1,
            ..card(Priority::Medium)
        };
        let tokens = card_tokens(&sub);
        assert_eq!(tokens[0].0, "1", "a sub-issue's number is bare: {tokens:?}");
        assert_eq!(
            tokens[0].1.fg,
            Some(Color::Cyan),
            "dropping the `#` does not change the number's color"
        );
    }

    fn long_title() -> Card {
        Card {
            title: "very long title that definitely exceeds a narrow column width".into(),
            ..card(Priority::Medium)
        }
    }

    #[test]
    fn no_wrap_is_single_truncated_line() {
        let c = long_title();
        let lines = card_lines(&c, 20, false, 3);
        assert_eq!(lines.len(), 1, "wrap off always yields one line");
        let text: String = lines[0].spans.iter().map(|s| s.content.as_ref()).collect();
        assert!(text.len() <= 20, "line is truncated to width: {text:?}");
    }

    #[test]
    fn wrap_produces_multiple_lines() {
        let c = long_title();
        let lines = card_lines(&c, 20, true, 10);
        assert!(lines.len() > 1, "long title wraps across lines");
        for line in &lines {
            let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();
            let width = line.width();
            assert!(width <= 20, "wrapped line fits width: {text:?} ({width})");
        }
        let joined: String = lines
            .iter()
            .flat_map(|l| l.spans.iter().map(|s| s.content.as_ref()))
            .collect();
        assert!(joined.contains("long") && joined.contains("column"));
    }

    #[test]
    fn wrapped_card_clamped_to_line_limit() {
        let c = long_title();
        let lines = card_lines(&c, 15, true, 3);
        assert!(lines.len() <= 3, "clamped at max_lines");
        let some_lines = card_lines(&c, 15, true, 5);
        assert!(
            some_lines.len() > lines.len(),
            "clamping removes surplus lines"
        );
    }

    #[test]
    fn overlong_single_token_is_truncated() {
        let c = Card {
            title: "supercalifragilisticexpialidocious".into(),
            ..card(Priority::Medium)
        };
        let lines = card_lines(&c, 10, true, 3);
        let first = &lines[0];
        let text: String = first.spans.iter().map(|s| s.content.as_ref()).collect();
        let width = first.width();
        assert!(width <= 10, "token clipped to width: {text:?} ({width})");
    }

    #[test]
    fn cjk_widths_count_two_columns_each() {
        let c = Card {
            title: "思出 头辞失 音州".into(),
            ..card(Priority::Medium)
        };
        // Each CJK char is 2 columns: `#1` (2) + "思出" (4) + space = 7 fits
        // width 8; the following 6-column word must wrap to the next line.
        let lines = card_lines(&c, 8, true, 5);
        assert!(lines.len() > 1, "CJK title wraps on the 2-column boundary");
        for line in &lines {
            assert!(
                line.width() <= 8,
                "CJK line fits width: {line:?} ({})",
                line.width()
            );
        }
        let joined: String = lines
            .iter()
            .flat_map(|l| l.spans.iter().map(|s| s.content.as_ref()))
            .collect();
        assert!(
            joined.contains("思出头辞失音州"),
            "no characters lost: {joined}"
        );
    }
}