mahbot 0.5.1

//! Sessions dashboard page — view and manage conversation sessions.

use std::cell::RefCell;
use std::collections::{HashMap, HashSet};
use std::time::Duration;

use crate::ChatMessage;
use crate::session::SessionMetadata;

use iced::widget::{
    Column, Id, Space, button, column, container, markdown, responsive, row, scrollable, text,
};
use iced::{Alignment, Element, Length, Task};

use iced_fonts::lucide;

use super::ToastMessage;
use super::media_markers;
use super::menus::{ContextMenu, MenuItem};
use super::session_view::preview::{
    MAX_PREVIEW_LINES, MessageMeasure, measure_message, re_measure, width_bucket,
};
use super::session_view::{self, SessionEntry, ToolCallEntry};
use super::theme;
use super::widgets;
use super::widgets::selectable_text;

/// Fraction of the transcript row width a chat bubble occupies (FillPortion 3
/// of a 3:1 row). The collapse measurement uses this to narrow the measured
/// width to the actual bubble body (container padding + a safety margin).
const BUBBLE_BODY_RATIO: f32 = 0.75;

/// Delay before a click-scheduled collapse of an expanded element actually
/// applies: the widget's double-click window (300 ms) plus a small margin, so
/// a canceling second click published at the window boundary always arrives
/// before the commit. A click inside the margin (beyond the double-click
/// window) is a deliberate second click and re-affirms the still-scheduled
/// collapse.
const COLLAPSE_COMMIT_DELAY: Duration = Duration::from_millis(350);

/// Max characters for the card title (user/workspace name) before an
/// ellipsis is appended — the card column is 350px wide.
const CARD_TITLE_MAX_CHARS: usize = 32;

/// Shared transcript render context: the flat session ledger, its per-entry
/// markdown bodies, the element expansion set, the collapse-measurement
/// cache, and the single text measurement width (bubble body width, used for
/// all collapsible-element measurement).
struct TranscriptCtx<'a> {
    entries: &'a [SessionEntry],
    entry_md: &'a [Option<Vec<markdown::Item>>],
    expanded: &'a HashSet<(usize, usize)>,
    measure_cache: &'a RefCell<HashMap<(usize, usize), MessageMeasure>>,
    text_width: f32,
}

#[derive(Debug, Clone)]
pub(crate) enum SessionsMessage {
    Refreshed(Vec<SessionMetadata>),
    RefreshError(String),
    SelectSession(String),
    SessionMessages(String, Vec<ChatMessage>),
    SessionError(String),
    /// Toggle an element's collapsed preview / full content, keyed by
    /// (entry index, element index within entry). Expanding applies
    /// immediately; collapsing is deferred past the double-click window (see
    /// `SessionsState::update`) and confirmed by [`SessionsMessage::ToggleCommit`].
    ToggleExpand(usize, usize),

    /// The second click of a double-click on a collapsible element: a
    /// word/line selection, so any collapse scheduled by the first click is
    /// dropped.
    ToggleCancel(usize, usize),

    /// Apply a collapse previously scheduled by [`SessionsMessage::ToggleExpand`]
    /// once the double-click window has passed without a canceling second
    /// click.
    ToggleCommit(usize, usize),

    /// Scroll position changed in the transcript viewport.
    ScrollChanged(scrollable::Viewport),

    /// Dismiss modals/panels (Escape key).
    Escape,

    /// A link was clicked in rendered markdown.
    LinkClicked(String),

    /// A toast notification to surface from the dashboard.
    Toast(ToastMessage),
    /// Delete a session (context-menu action).
    DeleteSession(String),
    /// A session delete finished — remove it from the list. The bool is the
    /// store-reported row deletion (`true` when a real removal happened).
    SessionDeleted(String, bool),
}

#[derive(Debug, Clone)]
struct CachedSessionItem {
    agent_id: String,
    /// Agent role parsed from the metadata role string; `None` renders the
    /// title without an icon.
    role: Option<crate::Role>,
    /// User name when present (Some and non-empty), otherwise the workspace
    /// name (may be empty if both are absent).
    title: String,
    /// Pre-formatted message count string.
    msg_count_label: String,
    /// Pre-formatted compact token count (same format as the Running Agents
    /// card), when the session ever recorded a provider-reported length.
    token_label: Option<String>,
    /// Pre-formatted timestamp string.
    timestamp_label: String,
}

pub(crate) struct SessionsState {
    sessions: Vec<SessionMetadata>,
    pub(crate) load_state: super::common::AsyncLoadState,
    selected_session: Option<String>,
    /// The flat session ledger built from the selected session's messages.
    entries: Vec<SessionEntry>,
    /// Per-entry markdown bodies, parallel to `entries` (parsed from the
    /// ledger via `session_view::parse_entry_bodies`).
    entry_md: Vec<Option<Vec<markdown::Item>>>,
    selected_loading: bool,
    /// Elements the user expanded beyond their collapsed preview, keyed by
    /// (entry index, element index within entry): 0 = body/narration,
    /// 1 = thinking block, 2+j = result block of call `j`. Cleared on
    /// session switch.
    expanded: HashSet<(usize, usize)>,
    /// Expanded elements whose click-scheduled collapse is waiting out the
    /// double-click window (keyed like `expanded`). The second click of a
    /// double-click removes the entry — the double-click belongs to word/line
    /// selection — and a later [`SessionsMessage::ToggleCommit`] applies the
    /// collapse only if the entry survived. Cleared on session switch.
    pending_collapses: HashSet<(usize, usize)>,
    /// Per-element collapse measurement cache, keyed like `expanded`.
    /// Session entries are append-only, so an existing entry stays valid and
    /// only new elements are measured lazily. Mutated during layout (the
    /// bubble width is only known there), hence `RefCell`.
    measure_cache: RefCell<HashMap<(usize, usize), MessageMeasure>>,
    /// Cached session list display data. Rebuilt only when `sessions` changes.
    /// `view()` builds widgets from this data on every frame.
    cached_session_items: Option<Vec<CachedSessionItem>>,

    // ── Transcript viewport fields ───────────────────────────────
    /// Stable scrollable ID for the transcript area, preserves scroll position
    /// across widget rebuilds.
    scrollable_id: Id,
    /// Whether auto-scroll-to-bottom is enabled (user is at or near the bottom).
    auto_scroll_enabled: bool,
}

impl SessionsState {
    pub(crate) fn new() -> Self {
        Self {
            sessions: Vec::new(),
            load_state: super::common::AsyncLoadState::new(),
            selected_session: None,
            entries: Vec::new(),
            entry_md: Vec::new(),
            selected_loading: false,
            expanded: HashSet::new(),
            pending_collapses: HashSet::new(),
            measure_cache: RefCell::new(HashMap::new()),
            cached_session_items: None,
            scrollable_id: Id::new("session_transcript_scroll"),
            auto_scroll_enabled: false,
        }
    }

    pub(crate) fn refresh() -> Task<SessionsMessage> {
        Task::perform(
            async {
                let store = crate::session::store();
                let list = store.list_sessions_with_metadata().await;
                Ok::<_, String>(list)
            },
            |res| match res {
                Ok(sessions) => SessionsMessage::Refreshed(sessions),
                Err(e) => SessionsMessage::RefreshError(e),
            },
        )
    }

    pub(crate) fn update(&mut self, msg: SessionsMessage) -> Task<SessionsMessage> {
        match msg {
            SessionsMessage::Refreshed(sessions) => {
                self.sessions = sessions;
                self.rebuild_session_cache();
                self.load_state.finish_loading();
                Task::none()
            }
            SessionsMessage::RefreshError(e) => {
                self.load_state.fail(e);
                Task::none()
            }
            SessionsMessage::SelectSession(key) => {
                self.selected_session = Some(key.clone());
                self.selected_loading = true;
                self.expanded.clear();
                self.pending_collapses.clear();
                // The measurement cache is cleared in SessionMessages when the
                // new session's messages actually arrive. The loading frames in
                // between show "Loading..." (old messages are not rendered),
                // but the cache must not be cleared here: on SessionError the
                // fallback keeps rendering the previous session's messages,
                // whose cache entries are still valid for that path. `expanded`
                // is cleared eagerly because the design resets collapse state
                // on session switch; on the error path that simply renders the
                // previous transcript collapsed (cosmetic, error-path only).
                // Do NOT set auto_scroll_enabled here — let ScrollChanged
                // determine it from the user's scroll behavior. The initial
                // snap to bottom happens eagerly in SessionMessages.
                Task::perform(
                    async move {
                        let store = crate::session::store();
                        let messages = store.load(&key).await;
                        Ok::<_, String>((key, messages))
                    },
                    |res| match res {
                        Ok((key, messages)) => SessionsMessage::SessionMessages(key, messages),
                        Err(e) => SessionsMessage::SessionError(e),
                    },
                )
            }
            SessionsMessage::SessionMessages(key, messages) => {
                if self.selected_session.as_deref() == Some(&key) {
                    self.entries = session_view::build_ledger(&messages);
                    self.entry_md = session_view::parse_entry_bodies(&self.entries);
                    // Fresh session load: reset the measurement cache (the
                    // previous session's keys are index-stale) and any pending
                    // collapse from the old ledger.
                    self.measure_cache.borrow_mut().clear();
                    self.pending_collapses.clear();
                    self.selected_loading = false;
                    // Snap to bottom so the user sees the most recent messages
                    // immediately.
                    return iced::widget::operation::snap_to_end(self.scrollable_id.clone());
                }
                Task::none()
            }
            SessionsMessage::SessionError(e) => {
                self.load_state.fail(e);
                self.selected_loading = false;
                Task::none()
            }
            SessionsMessage::ScrollChanged(viewport) => {
                let bounds = viewport.bounds();
                let content = viewport.content_bounds();
                let at_bottom = if content.height > bounds.height {
                    viewport.relative_offset().y >= 0.99
                } else {
                    content.height <= bounds.height
                };
                self.auto_scroll_enabled = at_bottom;
                Task::none()
            }
            SessionsMessage::ToggleExpand(i, j) => self.handle_toggle_expand(i, j),
            SessionsMessage::ToggleCancel(i, j) => {
                // Double-click word/line selection: the scheduled collapse is
                // dropped and the block stays put.
                self.pending_collapses.remove(&(i, j));
                Task::none()
            }
            SessionsMessage::ToggleCommit(i, j) => {
                // Apply the collapse only if no double-click canceled it.
                if self.pending_collapses.remove(&(i, j)) {
                    self.expanded.remove(&(i, j));
                }
                Task::none()
            }
            SessionsMessage::DeleteSession(key) => Task::perform(
                async move {
                    // User-initiated deletion: abandon the session's unfinished
                    // sync jobs first — a delete must not orphan them. A failure
                    // surfaces via the error toast and the delete is skipped so
                    // the user can retry.
                    crate::jobs::abandon_session_jobs(&key)
                        .await
                        .map_err(|e| e.to_string())?;
                    let store = crate::session::store();
                    let deleted = store.delete(&key).await.map_err(|e| e.to_string())?;
                    Ok::<_, String>((key, deleted))
                },
                |res| match res {
                    Ok((key, deleted)) => SessionsMessage::SessionDeleted(key, deleted),
                    Err(e) => SessionsMessage::Toast(ToastMessage::Error(e)),
                },
            ),
            SessionsMessage::SessionDeleted(key, deleted) => {
                self.sessions.retain(|s| s.agent_id != key);
                self.rebuild_session_cache();
                if self.selected_session.as_deref() == Some(&key) {
                    self.clear_selection();
                }
                // Only claim a "Deleted" success when a real row removal
                // happened; an already-absent session (cleaned up elsewhere)
                // just vanishes from the list without an inaccurate toast.
                if deleted {
                    Task::done(SessionsMessage::Toast(ToastMessage::Deleted))
                } else {
                    Task::none()
                }
            }
            SessionsMessage::Toast(_) | SessionsMessage::LinkClicked(_) => Task::none(),
            SessionsMessage::Escape => {
                self.clear_selection();
                Task::none()
            }
        }
    }

    /// Click-to-toggle of one collapsible element: expanding applies
    /// immediately; collapsing is scheduled and confirmed by a delayed
    /// [`SessionsMessage::ToggleCommit`]. The widget's second-click message
    /// ([`SessionsMessage::ToggleCancel`]) drops a scheduled collapse so a
    /// word/line-selection double-click never moves the block.
    fn handle_toggle_expand(&mut self, i: usize, j: usize) -> Task<SessionsMessage> {
        let key = (i, j);
        if self.expanded.contains(&key) {
            self.pending_collapses.insert(key);
            Task::perform(
                async { tokio::time::sleep(COLLAPSE_COMMIT_DELAY).await },
                move |()| SessionsMessage::ToggleCommit(i, j),
            )
        } else {
            self.expanded.insert(key);
            Task::none()
        }
    }

    /// Clear the currently selected session and ALL per-session transcript
    /// state, returning the transcript column to its placeholder.
    fn clear_selection(&mut self) {
        self.selected_session = None;
        self.entries.clear();
        self.entry_md.clear();
        self.selected_loading = false;
        self.expanded.clear();
        self.pending_collapses.clear();
        self.auto_scroll_enabled = false;
        self.measure_cache.borrow_mut().clear();
    }

    /// Rebuild the cached session list display data. Called when `self.sessions`
    /// changes. `view()` builds widgets from this data on every frame.
    fn rebuild_session_cache(&mut self) {
        let now = chrono::Local::now();
        let items: Vec<CachedSessionItem> = self
            .sessions
            .iter()
            .map(|s| {
                let role = s
                    .role
                    .as_deref()
                    .and_then(|r| r.parse::<crate::Role>().ok());
                let name = s
                    .user_name
                    .as_deref()
                    .filter(|n| !n.is_empty())
                    .or_else(|| s.workspace_name.as_deref().filter(|n| !n.is_empty()))
                    .unwrap_or("");
                CachedSessionItem {
                    agent_id: s.agent_id.clone(),
                    role,
                    title: crate::util::truncate(name, CARD_TITLE_MAX_CHARS),
                    msg_count_label: format!("{} msgs", s.message_count),
                    token_label: s.token_length.map(theme::format_compact_tokens),
                    timestamp_label: theme::format_relative_time(
                        &s.last_activity.to_rfc3339(),
                        now,
                    ),
                }
            })
            .collect();
        self.cached_session_items = if items.is_empty() { None } else { Some(items) };
    }

    #[expect(clippy::too_many_lines)]
    pub(crate) fn view(&self) -> Element<'_, SessionsMessage> {
        let mut content = column![];

        // Error display — inset to align with the vscroll-wrapped list below.
        content = widgets::push_error_banner_inset(content, self.load_state.error());

        if self.load_state.loading() && !self.load_state.has_loaded() {
            content = content.push(widgets::scroll_h_inset(widgets::loading_text()));
        } else if self.sessions.is_empty() {
            content = content.push(widgets::empty_state_placeholder(
                lucide::layout_dashboard::<iced::Theme, iced::Renderer>(),
                "No sessions",
                theme::TEXT_MUTED,
            ));
        } else {
            // Session list on the left side — built from cached display data.
            // The cache is rebuilt only when `self.sessions` changes (in
            // `Refreshed`); cards are rebuilt from it on every frame.
            let mut session_list = Column::new().spacing(theme::SPACE_4);
            if let Some(ref cached) = self.cached_session_items {
                for item in cached {
                    let is_selected = self.selected_session.as_deref() == Some(&item.agent_id);

                    let mut title_row = iced::widget::Row::new()
                        .spacing(theme::SPACE_6)
                        .align_y(Alignment::Center);
                    if let Some(role) = item.role {
                        title_row = title_row.push(
                            theme::role_icon(&role)
                                .size(theme::TEXT_14)
                                .color(theme::role_badge_color_for(&role).0),
                        );
                    }
                    let title_color = if is_selected {
                        theme::ACCENT
                    } else {
                        theme::TEXT_PRIMARY
                    };
                    title_row = title_row.push(
                        text(item.title.clone())
                            .size(theme::TEXT_13)
                            .color(title_color),
                    );

                    let sess_row: Element<'_, SessionsMessage> = ContextMenu::new(
                        container(
                            column![
                                row![
                                    button(
                                        container(
                                            column![
                                                title_row,
                                                {
                                                    // Meta row: messages left / tokens center /
                                                    // time right, spread via two Fill gaps
                                                    // across the card. Sessions that never
                                                    // recorded a token length leave the center
                                                    // empty.
                                                    let mut meta_row = iced::widget::Row::new()
                                                        .width(Length::Fill)
                                                        .push(
                                                            text(&item.msg_count_label)
                                                                .size(theme::TEXT_11)
                                                                .color(theme::TEXT_SECONDARY),
                                                        )
                                                        .push(Space::new().width(Length::Fill));
                                                    if let Some(token) = &item.token_label {
                                                        meta_row = meta_row.push(
                                                            text(token)
                                                                .size(theme::TEXT_11)
                                                                .color(theme::TEXT_SECONDARY),
                                                        );
                                                    }
                                                    meta_row
                                                        .push(Space::new().width(Length::Fill))
                                                        .push(
                                                            text(&item.timestamp_label)
                                                                .size(theme::TEXT_11)
                                                                .color(theme::TEXT_SECONDARY),
                                                        )
                                                },
                                                text(&item.agent_id)
                                                    .size(theme::TEXT_11)
                                                    .color(theme::TEXT_MUTED),
                                            ]
                                            .width(Length::Fill)
                                            .spacing(theme::SPACE_2),
                                        )
                                        .padding(theme::PAD_6)
                                        .width(Length::Fill),
                                    )
                                    .width(Length::Fill)
                                    .style(theme::button_text)
                                    .on_press(
                                        SessionsMessage::SelectSession(item.agent_id.clone())
                                    ),
                                ]
                                .width(Length::Fill)
                                .align_y(Alignment::Center),
                            ]
                            .spacing(theme::SPACE_2),
                        )
                        .style(theme::surface_card_style),
                        vec![MenuItem::with_icon(
                            iced_fonts::lucide::advanced_text::trash,
                            "Delete".into(),
                            SessionsMessage::DeleteSession(item.agent_id.clone()),
                        )],
                    )
                    .into();

                    session_list = session_list.push(sess_row);
                }
            }

            let session_scroll =
                widgets::vscroll_sized(session_list, Length::Fixed(350.0), Length::Shrink);

            // Transcript on the right side. Wrapped in `responsive` so the
            // collapse measurement uses the real bubble body width, correct on
            // first render and after every window resize.
            let transcript: iced::Element<'_, SessionsMessage> = if self.selected_loading {
                iced::widget::container(widgets::loading_text())
                    .width(Length::Fill)
                    .height(Length::Fill)
                    .padding(theme::PAD_16)
                    .into()
            } else if let Some(ref _key) = self.selected_session {
                let entries = &self.entries;
                let entry_md = &self.entry_md;
                let expanded = &self.expanded;
                let measure_cache = &self.measure_cache;
                let scrollable_id = self.scrollable_id.clone();
                responsive(move |size| {
                    // The transcript scrollable wrapper adds 8px padding per
                    // side. Every transcript round (message or tool round)
                    // renders as a chat bubble; all content measures at the
                    // bubble body width = 3/4 of the transcript row minus the
                    // bubble's 10px padding per side, folded in with a +4px
                    // safety margin that errs toward collapse.
                    let text_width = ((size.width - 16.0) * BUBBLE_BODY_RATIO - 24.0).max(0.0);
                    let ctx = TranscriptCtx {
                        entries,
                        entry_md,
                        expanded,
                        measure_cache,
                        text_width,
                    };
                    container(render_transcript(&ctx, &scrollable_id))
                        .width(Length::Fill)
                        .height(Length::Fill)
                        .padding([theme::PAD_8, 0.0])
                        .into()
                })
                .into()
            } else {
                container(
                    text("Select a session to view transcript.")
                        .size(theme::TEXT_13)
                        .color(theme::TEXT_MUTED),
                )
                .width(Length::Fill)
                .height(Length::Fill)
                .padding(theme::PAD_16)
                .center_x(Length::Fill)
                .center_y(Length::Fill)
                .into()
            };

            content = content.push(
                row![
                    session_scroll,
                    Space::new().width(theme::SPACE_12),
                    transcript
                ]
                .height(Length::Fill),
            );
        }

        container(content)
            .width(Length::Fill)
            .height(Length::Fill)
            .padding(theme::PAGE_PADDING)
            .style(theme::base_container_style)
            .into()
    }
}

/// Wrap a chat bubble in a 3:1 FillPortion row so it occupies 75% width,
/// aligned to the right for assistant messages or to the left for
/// system/user/tool messages. The caller must set `.width(FillPortion(3))`
/// on the bubble before passing it — this function only creates the spacer row.
fn align_bubble<'a>(
    bubble: impl Into<Element<'a, SessionsMessage>>,
    assistant: bool,
) -> Element<'a, SessionsMessage> {
    let bubble = bubble.into();
    if assistant {
        // Assistant: spacer left, bubble right.
        row![Space::new().width(Length::FillPortion(1)), bubble].into()
    } else {
        // System/user/tool: bubble left, spacer right.
        row![bubble, Space::new().width(Length::FillPortion(1))].into()
    }
}

/// Author label above a bubble, aligned to the bubble's side. One non-accent
/// color for every role, so roles stay visually consistent.
fn author_label<'a>(role: crate::ChatRole, assistant: bool) -> Element<'a, SessionsMessage> {
    let name = match role {
        crate::ChatRole::System => "System",
        crate::ChatRole::User => "User",
        crate::ChatRole::Assistant => "Assistant",
        crate::ChatRole::Tool => "Tool",
    };
    let label = text(name).size(theme::TEXT_11).color(theme::TEXT_SECONDARY);
    if assistant {
        row![Space::new().width(Length::FillPortion(1)), label].into()
    } else {
        row![label, Space::new().width(Length::FillPortion(1))].into()
    }
}

/// Author-labeled chat-bubble row for one ledger entry: the label sits above
/// the bubble, both aligned to the bubble's side (assistant right, others
/// left). Same background/typography as the Home chat bubbles.
fn bubble_row(
    role: crate::ChatRole,
    assistant: bool,
    body: Column<'_, SessionsMessage>,
) -> Element<'_, SessionsMessage> {
    let bubble = container(body)
        .padding(theme::PAD_10)
        .style(theme::bubble_style(
            if assistant {
                theme::BG_ELEVATED
            } else {
                theme::BG_SURFACE
            },
            Some(theme::TEXT_PRIMARY),
        ))
        .width(Length::FillPortion(3));
    column![
        author_label(role, assistant),
        align_bubble(bubble, assistant)
    ]
    .spacing(theme::SPACE_2)
    .into()
}

/// Resolve the collapse measurement for an element at the current
/// `text_width`, measuring on cache miss (cached per element and width; the
/// session ledger is append-only, so a cached entry stays valid). Returns the
/// wrapped-line count and — only when
/// `need_preview` is set (the element is currently collapsed) — its 3-line
/// plain-text preview, so expanded elements do not pay a per-frame preview
/// clone. `font_size` is the body size the element renders at (body or
/// narration).
///
/// Stale-fingerprint semantics: a cache hit with the same width bucket,
/// `content_len`, and `font_size` is reused; the same content at a different
/// bucket (or size) is re-measured via [`re_measure`]; otherwise a fresh
/// measurement runs.
#[expect(
    clippy::float_cmp,
    reason = "font sizes are theme constants passed verbatim; exact identity is intended"
)]
fn element_measurement(
    measure_cache: &RefCell<HashMap<(usize, usize), MessageMeasure>>,
    key: (usize, usize),
    text_width: f32,
    need_preview: bool,
    content: &str,
    font_size: f32,
) -> (u32, Option<String>) {
    let bucket = width_bucket(text_width);
    let content_len = content.len();
    let mut cache = measure_cache.borrow_mut();
    let cache_hit = cache.get(&key);
    let stale = cache_hit.is_none_or(|m| {
        m.width_bucket != bucket || m.content_len != content_len || m.font_size != font_size
    });
    if stale {
        // Cache miss: measure. A pure width change reuses the cached
        // processed display text (an `Arc` clone); otherwise measure from the
        // caller's plain-text content.
        let m = match cache_hit {
            Some(m)
                if m.width_bucket != bucket
                    && m.content_len == content_len
                    && m.font_size == font_size =>
            {
                re_measure(m, text_width)
            }
            _ => measure_message(content, text_width, content_len, font_size),
        };
        cache.insert(key, m);
    }
    let m = cache.get(&key).expect("measurement resolved above");
    (
        m.wrapped_lines,
        if need_preview {
            m.preview.clone()
        } else {
            None
        },
    )
}

/// The collapsed-preview-versus-full content of a collapsible element: when
/// it can collapse and is collapsed, a [`MAX_PREVIEW_LINES`]-line preview
/// (in `size`/`font`) with a small "ellipsis" marker for the hidden content;
/// otherwise the caller's `expanded` element. Callers wrap the result in
/// [`click_toggle`] — never nesting two toggle areas (a nested double-toggle
/// cancels out).
fn collapsible_text_block(
    collapses: bool,
    is_expanded: bool,
    preview: Option<String>,
    color: iced::Color,
    size: f32,
    font: iced::Font,
    expanded: Element<'_, SessionsMessage>,
) -> Element<'_, SessionsMessage> {
    if collapses && !is_expanded {
        let preview = preview.expect("a collapsing element always has a preview");
        row![
            selectable_text(preview, color).size(size).font(font),
            lucide::ellipsis::<iced::Theme, iced::Renderer>()
                .size(theme::TEXT_11)
                .color(theme::TEXT_MUTED),
        ]
        .spacing(theme::SPACE_4)
        .align_y(Alignment::Start)
        .into()
    } else {
        expanded
    }
}

/// Wrap an element in the click-to-toggle area when it can collapse (a short
/// click anywhere toggles, drag selection keeps working).
fn click_toggle(
    key: (usize, usize),
    active: bool,
    el: Element<'_, SessionsMessage>,
) -> Element<'_, SessionsMessage> {
    if active {
        widgets::click_to_toggle(
            el,
            SessionsMessage::ToggleExpand(key.0, key.1),
            SessionsMessage::ToggleCancel(key.0, key.1),
        )
    } else {
        el
    }
}

/// A plain-text collapsible element with the 3-line measured collapse rule:
/// when it renders more than [`MAX_PREVIEW_LINES`] wrapped lines and is not
/// expanded, a 3-line preview (with an "ellipsis" marker) is shown; otherwise
/// the full selectable text. The whole element is click-to-toggle when it can
/// collapse, so the selectable text stays drag-selectable. The measurement
/// stays at [`theme::MARKDOWN_TEXT_SIZE`] (the text renders at 11px) — the
/// err-toward-collapsing bias.
fn plain_collapsible<'a>(
    ctx: &TranscriptCtx<'a>,
    key: (usize, usize),
    content: &'a str,
    color: iced::Color,
) -> Element<'a, SessionsMessage> {
    let is_expanded = ctx.expanded.contains(&key);
    let (wrapped_lines, preview) = element_measurement(
        ctx.measure_cache,
        key,
        ctx.text_width,
        !is_expanded,
        content,
        theme::MARKDOWN_TEXT_SIZE,
    );
    let collapses = wrapped_lines > MAX_PREVIEW_LINES;
    let el = collapsible_text_block(
        collapses,
        is_expanded,
        preview,
        color,
        11.0,
        theme::FONT_REGULAR,
        selectable_text(content, color).size(theme::TEXT_11).into(),
    );
    click_toggle(key, collapses, el)
}

/// The collapsible Thinking block: lucide `brain` + "Thinking" header above a
/// 3-line-collapse body measured at the bubble body width. The measurement
/// stays at [`theme::MARKDOWN_TEXT_SIZE`] (the body renders at 11px) — the
/// err-toward-collapsing bias.
fn thinking_block<'a>(
    ctx: &TranscriptCtx<'a>,
    key: (usize, usize),
    content: &'a str,
) -> Element<'a, SessionsMessage> {
    let is_expanded = ctx.expanded.contains(&key);
    let (wrapped_lines, preview) = element_measurement(
        ctx.measure_cache,
        key,
        ctx.text_width,
        !is_expanded,
        content,
        theme::MARKDOWN_TEXT_SIZE,
    );
    let collapses = wrapped_lines > MAX_PREVIEW_LINES;
    let header = row![
        lucide::brain::<iced::Theme, iced::Renderer>()
            .size(theme::TEXT_11)
            .color(theme::TEXT_MUTED),
        text("Thinking")
            .size(theme::TEXT_11)
            .color(theme::TEXT_MUTED),
    ]
    .spacing(theme::SPACE_4)
    .align_y(Alignment::Center);
    let body = collapsible_text_block(
        collapses,
        is_expanded,
        preview,
        theme::TEXT_MUTED,
        11.0,
        theme::FONT_REGULAR,
        selectable_text(content, theme::TEXT_MUTED)
            .size(theme::TEXT_11)
            .into(),
    );
    let whole: Element<'a, SessionsMessage> = column![header, body].spacing(theme::SPACE_4).into();
    click_toggle(key, collapses, whole)
}

/// The message/narration body with the 3-line collapse rule: a collapsed
/// element shows a plain clickable preview; an expanded (or short) element
/// shows the markdown body parsed from `md`. `content` is the plain text used
/// for the collapse measurement (at the bubble body width); `md` is the parsed
/// markdown for the expanded view. Narration bodies render italic at
/// [`theme::NARRATION_TEXT_SIZE`]; user/assistant bodies stay at
/// [`theme::MARKDOWN_TEXT_SIZE`] regular.
fn body_block<'a>(
    ctx: &TranscriptCtx<'a>,
    key: (usize, usize),
    content: &'a str,
    md: Option<&'a [markdown::Item]>,
    is_narration: bool,
) -> Element<'a, SessionsMessage> {
    let is_expanded = ctx.expanded.contains(&key);
    let size = if is_narration {
        theme::NARRATION_TEXT_SIZE
    } else {
        theme::MARKDOWN_TEXT_SIZE
    };
    let (wrapped_lines, preview) = element_measurement(
        ctx.measure_cache,
        key,
        ctx.text_width,
        !is_expanded,
        content,
        size,
    );
    let collapses = wrapped_lines > MAX_PREVIEW_LINES;
    let font = if is_narration {
        theme::FONT_ITALIC
    } else {
        theme::FONT_REGULAR
    };
    let expanded: Element<'a, SessionsMessage> = if let Some(md) = md {
        let settings = if is_narration {
            theme::narration_markdown_settings()
        } else {
            theme::markdown_settings()
        };
        media_markers::selectable_markdown_view(md, settings).map(SessionsMessage::LinkClicked)
    } else {
        selectable_text(content, theme::TEXT_PRIMARY)
            .size(size)
            .font(font)
            .into()
    };
    let el = collapsible_text_block(
        collapses,
        is_expanded,
        preview,
        theme::TEXT_PRIMARY,
        size,
        font,
        expanded,
    );
    click_toggle(key, collapses, el)
}

/// The tool-call result block: plain collapsible text at [`theme::TEXT_SECONDARY`]
/// (11px) with the 3-line collapse — no leading icon (results are recognizable
/// from context; "(no result)" keeps its arrow below). Results render inside
/// the assistant bubble, so they measure at the bubble body width.
fn result_block<'a>(
    ctx: &TranscriptCtx<'a>,
    key: (usize, usize),
    result: &'a str,
) -> Element<'a, SessionsMessage> {
    plain_collapsible(ctx, key, result, theme::TEXT_SECONDARY)
}

/// Render one session round as a single assistant bubble containing the
/// reasoning block, the narration body, and one tool block per call with its
/// collapsible result beneath. An empty narration slot with a decoded
/// Reasoning block promotes the reasoning into the narration slot (plain
/// text) instead of a separate Thinking block.
fn render_tool_round<'a>(
    ctx: &TranscriptCtx<'a>,
    i: usize,
    narration: Option<&'a str>,
    reasoning: Option<&'a str>,
    calls: &'a [ToolCallEntry],
) -> Element<'a, SessionsMessage> {
    let md = ctx.entry_md.get(i).and_then(|m| m.as_deref());
    let mut bubble_col = Column::new().spacing(theme::SPACE_4);

    if let Some(reasoning) = session_view::promoted_reasoning(narration, reasoning) {
        // The reasoning IS the narration for this round: render it in the
        // narration slot as plain text (md None — no markdown parse, so CoT
        // characters never become formatting) and skip the Thinking block,
        // whose text would duplicate it.
        bubble_col = bubble_col.push(body_block(ctx, (i, 0), reasoning, None, true));
    } else {
        if let Some(reasoning) = reasoning {
            bubble_col = bubble_col.push(thinking_block(ctx, (i, 1), reasoning));
        }
        if let Some(narration) = narration {
            bubble_col = bubble_col.push(body_block(ctx, (i, 0), narration, md, true));
        }
    }

    for (j, call) in calls.iter().enumerate() {
        let key = (i, 2 + j);
        // Only a result that actually collapses makes the tool block a click
        // target (toggling a short result's expansion would be a no-op).
        let collapses = call.result.as_deref().is_some_and(|result| {
            let (wrapped_lines, _) = element_measurement(
                ctx.measure_cache,
                key,
                ctx.text_width,
                false,
                result,
                theme::MARKDOWN_TEXT_SIZE,
            );
            wrapped_lines > MAX_PREVIEW_LINES
        });
        // The tool block is wrapped in a click-to-toggle (not a button) so the
        // shared tool block's hover tooltip keeps working; a short click
        // anywhere toggles the associated result's collapse, and dragging over
        // the selectable tool-args text selects instead. click_to_toggle also
        // never captures the pointer, so the tooltip stays.
        let tool_block = container(session_view::tool_block(
            &call.tool,
            session_view::ToolBlockView::Full,
        ))
        .width(Length::Fill)
        .padding([theme::PAD_2, theme::PAD_4]);
        if collapses {
            bubble_col = bubble_col.push(click_toggle(key, true, tool_block.into()));
        } else {
            bubble_col = bubble_col.push(tool_block);
        }

        match call.result.as_deref() {
            Some(result) if !result.is_empty() => {
                bubble_col = bubble_col.push(result_block(ctx, key, result));
            }
            // Empty or missing ToolResult record: the old view's explicit
            // "(no result)" indicator.
            _ => {
                bubble_col = bubble_col.push(
                    row![
                        lucide::arrow_down_to_line::<iced::Theme, iced::Renderer>()
                            .size(theme::TEXT_11)
                            .color(theme::TEXT_MUTED),
                        text("(no result)")
                            .size(theme::TEXT_10)
                            .color(theme::TEXT_SECONDARY),
                    ]
                    .spacing(theme::SPACE_4)
                    .align_y(Alignment::Center),
                );
            }
        }
    }

    // One bubble for the whole round, same container as assistant text rounds
    // (right-aligned, 75% width, author label above).
    bubble_row(crate::ChatRole::Assistant, true, bubble_col)
}

/// Render one ledger entry as a chat-bubble row: a `Message` renders its own
/// bubble, and a `ToolRound` renders a single assistant bubble containing the
/// round's reasoning, narration, and tool calls with their results.
fn render_entry<'a>(ctx: &TranscriptCtx<'a>, i: usize) -> Element<'a, SessionsMessage> {
    let md = ctx.entry_md.get(i).and_then(|m| m.as_deref());
    let entry = &ctx.entries[i];
    match entry {
        SessionEntry::Message {
            role,
            content,
            thinking,
        } => {
            let assistant = matches!(role, crate::ChatRole::Assistant);
            let mut bubble_col = Column::new().spacing(theme::SPACE_4);
            if let Some(thinking) = thinking {
                bubble_col = bubble_col.push(thinking_block(ctx, (i, 1), thinking));
            }
            if let Some(content) = content {
                bubble_col = bubble_col.push(body_block(ctx, (i, 0), content, md, false));
            }
            if thinking.is_some() || content.is_some() {
                bubble_row(*role, assistant, bubble_col)
            } else {
                // Nothing to show but the author.
                author_label(*role, assistant)
            }
        }
        SessionEntry::ToolRound {
            narration,
            reasoning,
            calls,
        } => render_tool_round(ctx, i, narration.as_deref(), reasoning.as_deref(), calls),
    }
}

/// Render the transcript column for the selected session: build the chat
/// bubbles from the shared ledger and apply the 3-line collapse rule to
/// message bodies, thinking blocks, and tool results.
fn render_transcript<'a>(
    ctx: &TranscriptCtx<'a>,
    scrollable_id: &Id,
) -> Element<'a, SessionsMessage> {
    if ctx.entries.is_empty() {
        return text("No messages in this session.")
            .size(theme::TEXT_13)
            .color(theme::TEXT_MUTED)
            .into();
    }
    let mut items = Column::new().spacing(widgets::CHAT_VERTICAL_RHYTHM);
    for i in 0..ctx.entries.len() {
        items = items.push(render_entry(ctx, i));
    }
    widgets::vscroll_tracked(
        items,
        Length::Fill,
        Length::Fill,
        scrollable_id.clone(),
        SessionsMessage::ScrollChanged,
    )
}