//! Status-line and terminal-title rendering helpers for `ChatWidget`.
//!
//! Keeping this logic in a focused submodule makes the additive title/status
//! behavior easier to review without paging through the rest of `chatwidget.rs`.

use super::*;
use crate::bottom_pane::status_line_from_segments;
use crate::branch_summary;
use crate::chatwidget::limit_label_for_window;
use crate::chatwidget::rate_limits::get_limits_duration;
use crate::legacy_core::config::Config;
use crate::status::format_tokens_compact;
use codex_app_server_protocol::AskForApproval;
use codex_protocol::config_types::ApprovalsReviewer;
use codex_protocol::config_types::ServiceTier;
use codex_protocol::models::PermissionProfile;
use codex_utils_sandbox_summary::summarize_permission_profile;

use super::status_state::TerminalTitleStatusKind;

/// Items shown in the terminal title when the user has not configured a
/// custom selection. Intentionally minimal: activity indicator + project name.
pub(super) const DEFAULT_TERMINAL_TITLE_ITEMS: [&str; 2] = ["activity", "project-name"];

/// Braille-pattern dot-spinner frames for the terminal title animation.
pub(super) const TERMINAL_TITLE_SPINNER_FRAMES: [&str; 10] =
    ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];

/// Time between spinner frame advances in the terminal title.
pub(super) const TERMINAL_TITLE_SPINNER_INTERVAL: Duration = Duration::from_millis(100);

/// Time between action-required blink phases in the terminal title.
const TERMINAL_TITLE_ACTION_REQUIRED_INTERVAL: Duration = Duration::from_secs(1);

/// Prefix shown in the terminal title when the agent is blocked on user input.
const TERMINAL_TITLE_ACTION_REQUIRED_PREFIX: &str = "[ ! ] Action Required";
const TERMINAL_TITLE_ACTION_REQUIRED_PREFIX_HIDDEN: &str = "[ . ] Action Required";

#[derive(Debug)]
/// Parsed status-surface configuration for one refresh pass.
///
/// The status line and terminal title share some expensive or stateful inputs
/// (notably git branch lookup and invalid-item warnings). This snapshot lets one
/// refresh pass compute those shared concerns once, then render both surfaces
/// from the same selection set.
struct StatusSurfaceSelections {
    status_line_items: Vec<StatusLineItem>,
    invalid_status_line_items: Vec<String>,
    terminal_title_items: Vec<TerminalTitleItem>,
    invalid_terminal_title_items: Vec<String>,
}

impl StatusSurfaceSelections {
    fn uses_git_branch(&self) -> bool {
        self.status_line_items.contains(&StatusLineItem::GitBranch)
            || self
                .terminal_title_items
                .contains(&TerminalTitleItem::GitBranch)
    }

    fn uses_git_summary(&self) -> bool {
        self.status_line_items
            .contains(&StatusLineItem::PullRequestNumber)
            || self
                .status_line_items
                .contains(&StatusLineItem::BranchChanges)
    }
}

/// Cached project-root display name keyed by the cwd used for the last lookup.
///
/// Terminal-title refreshes can happen very frequently, so the title path avoids
/// repeatedly walking up the filesystem to rediscover the same project root name
/// while the working directory is unchanged.
#[derive(Clone, Debug)]
pub(super) struct CachedProjectRootName {
    pub(super) cwd: PathBuf,
    pub(super) root_name: Option<String>,
}

impl ChatWidget {
    fn status_surface_selections(&self) -> StatusSurfaceSelections {
        let (status_line_items, invalid_status_line_items) = self.status_line_items_with_invalids();
        let (terminal_title_items, invalid_terminal_title_items) =
            self.terminal_title_items_with_invalids();
        StatusSurfaceSelections {
            status_line_items,
            invalid_status_line_items,
            terminal_title_items,
            invalid_terminal_title_items,
        }
    }

    fn warn_invalid_status_line_items_once(&mut self, invalid_items: &[String]) {
        if self.thread_id.is_some()
            && !invalid_items.is_empty()
            && self
                .status_line_invalid_items_warned
                .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
                .is_ok()
        {
            let label = if invalid_items.len() == 1 {
                "item"
            } else {
                "items"
            };
            let message = format!(
                "Ignored invalid status line {label}: {}.",
                proper_join(invalid_items)
            );
            self.on_warning(message);
        }
    }

    fn warn_invalid_terminal_title_items_once(&mut self, invalid_items: &[String]) {
        if self.thread_id.is_some()
            && !invalid_items.is_empty()
            && self
                .terminal_title_invalid_items_warned
                .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
                .is_ok()
        {
            let label = if invalid_items.len() == 1 {
                "item"
            } else {
                "items"
            };
            let message = format!(
                "Ignored invalid terminal title {label}: {}.",
                proper_join(invalid_items)
            );
            self.on_warning(message);
        }
    }

    fn sync_status_surface_shared_state(&mut self, selections: &StatusSurfaceSelections) {
        if !selections.uses_git_branch() {
            self.status_line_branch = None;
            self.status_line_branch_pending = false;
            self.status_line_branch_lookup_complete = false;
        } else {
            let cwd = self.status_line_cwd().to_path_buf();
            self.sync_status_line_branch_state(&cwd);
            if !self.status_line_branch_lookup_complete {
                self.request_status_line_branch(cwd);
            }
        }

        if !selections.uses_git_summary() {
            self.status_line_git_summary = None;
            self.status_line_git_summary_pending = false;
            self.status_line_git_summary_lookup_complete = false;
        } else {
            let cwd = self.status_line_cwd().to_path_buf();
            self.sync_status_line_git_summary_state(&cwd);
            if !self.status_line_git_summary_lookup_complete {
                self.request_status_line_git_summary(cwd);
            }
        }
    }

    fn refresh_status_line_from_selections(&mut self, selections: &StatusSurfaceSelections) {
        let enabled = !selections.status_line_items.is_empty();
        self.bottom_pane.set_status_line_enabled(enabled);
        if !enabled {
            self.set_status_line(/*status_line*/ None);
            self.set_status_line_hyperlink(/*url*/ None);
            return;
        }

        let mut segments = Vec::new();
        for item in &selections.status_line_items {
            if let Some(value) = self.status_line_value_for_item(*item) {
                segments.push((*item, value));
            }
        }

        self.set_status_line(status_line_from_segments(
            segments,
            self.config.tui_status_line_use_colors,
        ));
        let hyperlink_url = selections
            .status_line_items
            .contains(&StatusLineItem::PullRequestNumber)
            .then(|| self.status_line_pull_request_url())
            .flatten();
        self.set_status_line_hyperlink(hyperlink_url);
    }

    /// Clears the terminal title Codex most recently wrote, if any.
    ///
    /// This does not attempt to restore the shell or terminal's previous title;
    /// it only clears the managed title and updates the cache after a successful
    /// OSC write.
    pub(crate) fn clear_managed_terminal_title(&mut self) -> std::io::Result<()> {
        if self.last_terminal_title.is_some() {
            clear_terminal_title()?;
            self.last_terminal_title = None;
        }

        Ok(())
    }

    /// Renders and applies the terminal title for one parsed selection snapshot.
    ///
    /// Empty selections clear the managed title. Non-empty selections render the
    /// current values in configured order, skip unavailable segments, and cache
    /// the last successfully written title so redundant OSC writes are avoided.
    /// When the `activity` item is present in an animated running state, this also
    /// schedules the next frame so the title animation keeps advancing.
    fn refresh_terminal_title_from_selections(&mut self, selections: &StatusSurfaceSelections) {
        self.last_terminal_title_requires_action =
            self.terminal_title_shows_action_required_with_selections(selections);
        if selections.terminal_title_items.is_empty() {
            if let Err(err) = self.clear_managed_terminal_title() {
                tracing::debug!(error = %err, "failed to clear terminal title");
            }
            return;
        }

        let now = Instant::now();
        let title = self.terminal_title_text_for_selections(selections, now);
        let animation_interval = self.terminal_title_animation_interval_with_selections(selections);
        if self.last_terminal_title == title {
            if let Some(interval) = animation_interval {
                self.frame_requester.schedule_frame_in(interval);
            }
            return;
        }
        match title {
            Some(title) => match set_terminal_title(&title) {
                Ok(SetTerminalTitleResult::Applied) => {
                    self.last_terminal_title = Some(title);
                }
                Ok(SetTerminalTitleResult::NoVisibleContent) => {
                    if let Err(err) = self.clear_managed_terminal_title() {
                        tracing::debug!(error = %err, "failed to clear terminal title");
                    }
                }
                Err(err) => {
                    tracing::debug!(error = %err, "failed to set terminal title");
                }
            },
            None => {
                if let Err(err) = self.clear_managed_terminal_title() {
                    tracing::debug!(error = %err, "failed to clear terminal title");
                }
            }
        }

        if let Some(interval) = animation_interval {
            self.frame_requester.schedule_frame_in(interval);
        }
    }

    /// Recomputes both status surfaces from one shared config snapshot.
    ///
    /// This is the common refresh entrypoint for the footer status line and the
    /// terminal title. It parses both configurations once, emits invalid-item
    /// warnings once, synchronizes shared cached state (such as git-branch
    /// lookup), then renders each surface from that shared snapshot.
    pub(crate) fn refresh_status_surfaces(&mut self) {
        let selections = self.status_surface_selections();
        self.warn_invalid_status_line_items_once(&selections.invalid_status_line_items);
        self.warn_invalid_terminal_title_items_once(&selections.invalid_terminal_title_items);
        self.sync_status_surface_shared_state(&selections);
        self.refresh_status_line_from_selections(&selections);
        self.refresh_terminal_title_from_selections(&selections);
    }

    /// Recomputes and emits the terminal title from config and runtime state.
    pub(crate) fn refresh_terminal_title(&mut self) {
        let selections = self.status_surface_selections();
        self.warn_invalid_terminal_title_items_once(&selections.invalid_terminal_title_items);
        self.sync_status_surface_shared_state(&selections);
        self.refresh_terminal_title_from_selections(&selections);
    }

    fn terminal_title_requires_action(&self) -> bool {
        self.bottom_pane.terminal_title_requires_action()
    }

    pub(super) fn terminal_title_shows_action_required(&self) -> bool {
        self.terminal_title_requires_action() && self.terminal_title_uses_activity()
    }

    fn terminal_title_text_for_selections(
        &mut self,
        selections: &StatusSurfaceSelections,
        now: Instant,
    ) -> Option<String> {
        if self.terminal_title_shows_action_required_with_selections(selections) {
            return Some(self.action_required_terminal_title_text(selections, now));
        }

        let mut previous = None;
        let title = selections
            .terminal_title_items
            .iter()
            .copied()
            .filter_map(|item| {
                self.terminal_title_value_for_item(item, now)
                    .map(|value| (item, value))
            })
            .fold(String::new(), |mut title, (item, value)| {
                title.push_str(item.separator_from_previous(previous));
                title.push_str(&value);
                previous = Some(item);
                title
            });
        (!title.is_empty()).then_some(title)
    }

    fn action_required_terminal_title_text(
        &mut self,
        selections: &StatusSurfaceSelections,
        now: Instant,
    ) -> String {
        crate::bottom_pane::build_action_required_title_text(
            self.action_required_terminal_title_prefix_at(now),
            selections.terminal_title_items.iter().copied(),
            &[TerminalTitleItem::Status],
            |item| self.terminal_title_value_for_item(item, now),
        )
    }

    fn action_required_terminal_title_prefix_at(&self, now: Instant) -> &'static str {
        if !self.config.animations {
            return TERMINAL_TITLE_ACTION_REQUIRED_PREFIX;
        }

        let elapsed = now.saturating_duration_since(self.terminal_title_animation_origin);
        let phase = (elapsed.as_millis() / TERMINAL_TITLE_ACTION_REQUIRED_INTERVAL.as_millis()) % 2;
        if phase == 0 {
            TERMINAL_TITLE_ACTION_REQUIRED_PREFIX
        } else {
            TERMINAL_TITLE_ACTION_REQUIRED_PREFIX_HIDDEN
        }
    }

    fn terminal_title_shows_action_required_with_selections(
        &self,
        selections: &StatusSurfaceSelections,
    ) -> bool {
        self.terminal_title_requires_action()
            && selections
                .terminal_title_items
                .contains(&TerminalTitleItem::Spinner)
    }

    fn terminal_title_animation_interval_with_selections(
        &self,
        selections: &StatusSurfaceSelections,
    ) -> Option<Duration> {
        if self.config.animations
            && self.terminal_title_shows_action_required_with_selections(selections)
        {
            return Some(TERMINAL_TITLE_ACTION_REQUIRED_INTERVAL);
        }

        self.should_animate_terminal_title_spinner_with_selections(selections)
            .then_some(TERMINAL_TITLE_SPINNER_INTERVAL)
    }

    pub(super) fn request_status_line_branch_refresh(&mut self) {
        let selections = self.status_surface_selections();
        if !selections.uses_git_branch() {
            return;
        }
        let cwd = self.status_line_cwd().to_path_buf();
        self.sync_status_line_branch_state(&cwd);
        self.request_status_line_branch(cwd);
    }

    pub(super) fn request_status_line_git_summary_refresh(&mut self) {
        let selections = self.status_surface_selections();
        if !selections.uses_git_summary() {
            return;
        }
        let cwd = self.status_line_cwd().to_path_buf();
        self.sync_status_line_git_summary_state(&cwd);
        self.request_status_line_git_summary(cwd);
    }

    /// Parses configured status-line ids into known items and collects unknown ids.
    ///
    /// Unknown ids are deduplicated in insertion order for warning messages.
    fn status_line_items_with_invalids(&self) -> (Vec<StatusLineItem>, Vec<String>) {
        parse_items_with_invalids(self.configured_status_line_items())
    }

    pub(super) fn configured_status_line_items(&self) -> Vec<String> {
        self.config.tui_status_line.clone().unwrap_or_else(|| {
            DEFAULT_STATUS_LINE_ITEMS
                .iter()
                .map(ToString::to_string)
                .collect()
        })
    }

    /// Parses configured terminal-title ids into known items and collects unknown ids.
    ///
    /// Unknown ids are deduplicated in insertion order for warning messages.
    fn terminal_title_items_with_invalids(&self) -> (Vec<TerminalTitleItem>, Vec<String>) {
        parse_items_with_invalids(self.configured_terminal_title_items())
    }

    /// Returns the configured terminal-title ids, or the default ordering when unset.
    pub(super) fn configured_terminal_title_items(&self) -> Vec<String> {
        self.config.tui_terminal_title.clone().unwrap_or_else(|| {
            DEFAULT_TERMINAL_TITLE_ITEMS
                .iter()
                .map(ToString::to_string)
                .collect()
        })
    }

    fn status_line_cwd(&self) -> &Path {
        self.current_cwd
            .as_deref()
            .unwrap_or(self.config.cwd.as_path())
    }

    /// Resolves the project root associated with `cwd`.
    ///
    /// Git repository root wins when available. Otherwise we fall back to the
    /// nearest project config layer so non-git projects can still surface a
    /// stable project label.
    fn status_line_project_root_for_cwd(&self, cwd: &Path) -> Option<PathBuf> {
        if let Some(repo_root) = get_git_repo_root(cwd) {
            return Some(repo_root);
        }

        self.config
            .config_layer_stack
            .get_layers(
                ConfigLayerStackOrdering::LowestPrecedenceFirst,
                /*include_disabled*/ true,
            )
            .iter()
            .find_map(|layer| match &layer.name {
                ConfigLayerSource::Project { dot_codex_folder } => {
                    dot_codex_folder.as_path().parent().map(Path::to_path_buf)
                }
                _ => None,
            })
    }

    fn status_line_project_root_name_for_cwd(&self, cwd: &Path) -> Option<String> {
        self.status_line_project_root_for_cwd(cwd).map(|root| {
            root.file_name()
                .map(|name| name.to_string_lossy().to_string())
                .unwrap_or_else(|| format_directory_display(&root, /*max_width*/ None))
        })
    }

    /// Returns a cached project-root display name for the active cwd.
    fn status_line_project_root_name(&mut self) -> Option<String> {
        let cwd = self.status_line_cwd().to_path_buf();
        if let Some(cache) = &self.status_line_project_root_name_cache
            && cache.cwd == cwd
        {
            return cache.root_name.clone();
        }

        let root_name = self.status_line_project_root_name_for_cwd(&cwd);
        self.status_line_project_root_name_cache = Some(CachedProjectRootName {
            cwd,
            root_name: root_name.clone(),
        });
        root_name
    }

    /// Produces the terminal-title `project` value.
    ///
    /// This prefers the cached project-root name and falls back to the current
    /// directory name when no project root can be inferred.
    fn terminal_title_project_name(&mut self) -> Option<String> {
        let project = self.status_line_project_root_name().or_else(|| {
            let cwd = self.status_line_cwd();
            Some(
                cwd.file_name()
                    .map(|name| name.to_string_lossy().to_string())
                    .unwrap_or_else(|| format_directory_display(cwd, /*max_width*/ None)),
            )
        })?;
        Some(Self::truncate_terminal_title_part(
            project, /*max_chars*/ 24,
        ))
    }

    /// Resets git-branch cache state when the status-line cwd changes.
    ///
    /// The branch cache is keyed by cwd because branch lookup is performed relative to that path.
    /// Keeping stale branch values across cwd changes would surface incorrect repository context.
    fn sync_status_line_branch_state(&mut self, cwd: &Path) {
        if self
            .status_line_branch_cwd
            .as_ref()
            .is_some_and(|path| path == cwd)
        {
            return;
        }
        self.status_line_branch_cwd = Some(cwd.to_path_buf());
        self.status_line_branch = None;
        self.status_line_branch_pending = false;
        self.status_line_branch_lookup_complete = false;
    }

    fn sync_status_line_git_summary_state(&mut self, cwd: &Path) {
        if self.status_line_git_summary_cwd.as_deref() == Some(cwd) {
            return;
        }
        self.status_line_git_summary_cwd = Some(cwd.to_path_buf());
        self.status_line_git_summary = None;
        self.status_line_git_summary_pending = false;
        self.status_line_git_summary_lookup_complete = false;
    }

    /// Starts an async git-branch lookup unless one is already running.
    ///
    /// The resulting `StatusLineBranchUpdated` event carries the lookup cwd so callers can reject
    /// stale completions after directory changes.
    fn request_status_line_branch(&mut self, cwd: PathBuf) {
        if self.status_line_branch_pending {
            return;
        }
        let Some(runner) = self.workspace_command_runner.clone() else {
            self.status_line_branch_lookup_complete = true;
            return;
        };
        self.status_line_branch_pending = true;
        let tx = self.app_event_tx.clone();
        tokio::spawn(async move {
            let branch = branch_summary::current_branch_name(runner.as_ref(), &cwd).await;
            tx.send(AppEvent::StatusLineBranchUpdated { cwd, branch });
        });
    }

    fn request_status_line_git_summary(&mut self, cwd: PathBuf) {
        if self.status_line_git_summary_pending {
            return;
        }
        let Some(runner) = self.workspace_command_runner.clone() else {
            self.status_line_git_summary_lookup_complete = true;
            return;
        };
        self.status_line_git_summary_pending = true;
        let tx = self.app_event_tx.clone();
        tokio::spawn(async move {
            let summary = branch_summary::status_line_git_summary(runner.as_ref(), &cwd).await;
            tx.send(AppEvent::StatusLineGitSummaryUpdated { cwd, summary });
        });
    }

    /// Resolves a display string for one configured status-line item.
    ///
    /// Returning `None` means "omit this item for now", not "configuration error". Callers rely on
    /// this to keep partially available status lines readable while waiting for session, token, or
    /// git metadata.
    pub(super) fn status_line_value_for_item(&mut self, item: StatusLineItem) -> Option<String> {
        match item {
            StatusLineItem::ModelName => Some(self.model_display_name().to_string()),
            StatusLineItem::ModelWithReasoning => Some(self.model_with_reasoning_display_name()),
            StatusLineItem::Reasoning => Some(self.reasoning_display_name()),
            StatusLineItem::CurrentDir => {
                Some(format_directory_display(
                    self.status_line_cwd(),
                    /*max_width*/ None,
                ))
            }
            StatusLineItem::ProjectRoot => self.status_line_project_root_name(),
            StatusLineItem::GitBranch => self.status_line_branch.clone(),
            StatusLineItem::PullRequestNumber => self
                .status_line_git_summary
                .as_ref()
                .and_then(|summary| summary.pull_request.as_ref())
                .map(|pull_request| format!("PR #{}", pull_request.number)),
            StatusLineItem::BranchChanges => self
                .status_line_git_summary
                .as_ref()
                .and_then(|summary| summary.branch_change_stats.as_ref())
                .map(|stats| {
                    if stats.additions == 0 && stats.deletions == 0 {
                        "No changes".to_string()
                    } else {
                        format!("+{} -{}", stats.additions, stats.deletions)
                    }
                }),
            StatusLineItem::Status => Some(self.run_state_status_text()),
            StatusLineItem::Permissions => Some(permissions_display(&self.config)),
            StatusLineItem::ApprovalMode => Some(approval_mode_display(&self.config)),
            StatusLineItem::UsedTokens => {
                let usage = self.status_line_total_usage();
                let total = usage.blended_total();
                if total <= 0 {
                    None
                } else {
                    Some(format!("{} used", format_tokens_compact(total)))
                }
            }
            StatusLineItem::ContextRemaining => self
                .status_line_context_remaining_percent()
                .map(|remaining| format!("Context {remaining}% left")),
            StatusLineItem::ContextUsed => self
                .status_line_context_used_percent()
                .map(|used| format!("Context {used}% used")),
            StatusLineItem::FiveHourLimit => {
                let (window, is_secondary) = self
                    .rate_limit_snapshots_by_limit_id
                    .get("codex")
                    .and_then(five_hour_status_window)?;
                let label = limit_label_for_window(window.window_minutes, is_secondary);
                self.status_line_limit_display(Some(window), &label)
            }
            StatusLineItem::WeeklyLimit => {
                let (window, is_secondary) = self
                    .rate_limit_snapshots_by_limit_id
                    .get("codex")
                    .and_then(weekly_status_window)?;
                let label = limit_label_for_window(window.window_minutes, is_secondary);
                self.status_line_limit_display(Some(window), &label)
            }
            StatusLineItem::CodexVersion => Some(CODEX_CLI_VERSION.to_string()),
            StatusLineItem::ContextWindowSize => self
                .status_line_context_window_size()
                .map(|cws| format!("{} window", format_tokens_compact(cws))),
            StatusLineItem::TotalInputTokens => Some(format!(
                "{} in",
                format_tokens_compact(self.status_line_total_usage().input_tokens)
            )),
            StatusLineItem::TotalOutputTokens => Some(format!(
                "{} out",
                format_tokens_compact(self.status_line_total_usage().output_tokens)
            )),
            StatusLineItem::SessionId => self.thread_id.map(|id| id.to_string()),
            StatusLineItem::FastMode => Some(
                if self.current_service_tier() == Some(ServiceTier::Fast.request_value()) {
                    "Fast on".to_string()
                } else {
                    "Fast off".to_string()
                },
            ),
            StatusLineItem::RawOutput => self.raw_output_mode().then(|| "raw output".to_string()),
            StatusLineItem::ThreadTitle => self.thread_name.as_ref().map_or_else(
                || self.thread_id.map(|id| id.to_string()),
                |name| {
                    let trimmed = name.trim();
                    if trimmed.is_empty() {
                        self.thread_id.map(|id| id.to_string())
                    } else {
                        Some(trimmed.to_string())
                    }
                },
            ),
            StatusLineItem::TaskProgress => self.terminal_title_task_progress(),
        }
    }

    fn status_line_pull_request_url(&self) -> Option<String> {
        self.status_line_git_summary
            .as_ref()
            .and_then(|summary| summary.pull_request.as_ref())
            .map(|pull_request| pull_request.url.clone())
    }

    pub(super) fn status_surface_preview_value_for_item(
        &mut self,
        item: StatusSurfacePreviewItem,
    ) -> Option<String> {
        let status_line_item = match item {
            StatusSurfacePreviewItem::AppName => return Some("codex".to_string()),
            StatusSurfacePreviewItem::ProjectName => return self.terminal_title_project_name(),
            StatusSurfacePreviewItem::ProjectRoot => StatusLineItem::ProjectRoot,
            StatusSurfacePreviewItem::Status => return Some(self.run_state_status_text()),
            StatusSurfacePreviewItem::TaskProgress => return self.terminal_title_task_progress(),
            StatusSurfacePreviewItem::CurrentDir => StatusLineItem::CurrentDir,
            StatusSurfacePreviewItem::ThreadTitle => StatusLineItem::ThreadTitle,
            StatusSurfacePreviewItem::GitBranch => StatusLineItem::GitBranch,
            StatusSurfacePreviewItem::PullRequestNumber => StatusLineItem::PullRequestNumber,
            StatusSurfacePreviewItem::BranchChanges => StatusLineItem::BranchChanges,
            StatusSurfacePreviewItem::Permissions => StatusLineItem::Permissions,
            StatusSurfacePreviewItem::ApprovalMode => StatusLineItem::ApprovalMode,
            StatusSurfacePreviewItem::ContextRemaining => StatusLineItem::ContextRemaining,
            StatusSurfacePreviewItem::ContextUsed => StatusLineItem::ContextUsed,
            StatusSurfacePreviewItem::FiveHourLimit => StatusLineItem::FiveHourLimit,
            StatusSurfacePreviewItem::WeeklyLimit => StatusLineItem::WeeklyLimit,
            StatusSurfacePreviewItem::CodexVersion => StatusLineItem::CodexVersion,
            StatusSurfacePreviewItem::ContextWindowSize => StatusLineItem::ContextWindowSize,
            StatusSurfacePreviewItem::UsedTokens => StatusLineItem::UsedTokens,
            StatusSurfacePreviewItem::TotalInputTokens => StatusLineItem::TotalInputTokens,
            StatusSurfacePreviewItem::TotalOutputTokens => StatusLineItem::TotalOutputTokens,
            StatusSurfacePreviewItem::SessionId => StatusLineItem::SessionId,
            StatusSurfacePreviewItem::FastMode => StatusLineItem::FastMode,
            StatusSurfacePreviewItem::RawOutput => StatusLineItem::RawOutput,
            StatusSurfacePreviewItem::Model => StatusLineItem::ModelName,
            StatusSurfacePreviewItem::ModelWithReasoning => StatusLineItem::ModelWithReasoning,
            StatusSurfacePreviewItem::Reasoning => StatusLineItem::Reasoning,
        };
        self.status_line_value_for_item(status_line_item)
    }
    /// Resolves one configured terminal-title item into a displayable segment.
    ///
    /// Returning `None` means "omit this segment for now" so callers can keep
    /// the configured order while hiding values that are not yet available.
    pub(super) fn terminal_title_value_for_item(
        &mut self,
        item: TerminalTitleItem,
        now: Instant,
    ) -> Option<String> {
        match item {
            TerminalTitleItem::AppName => Some("codex".to_string()),
            TerminalTitleItem::Project => self.terminal_title_project_name(),
            TerminalTitleItem::CurrentDir => Some(Self::truncate_terminal_title_part(
                format_directory_display(self.status_line_cwd(), /*max_width*/ None),
                /*max_chars*/ 32,
            )),
            TerminalTitleItem::Spinner => self.terminal_title_spinner_text_at(now),
            TerminalTitleItem::Status => Some(self.run_state_status_text()),
            TerminalTitleItem::Thread => self
                .status_line_value_for_item(StatusLineItem::ThreadTitle)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 48)),
            TerminalTitleItem::GitBranch => self.status_line_branch.as_ref().map(|branch| {
                Self::truncate_terminal_title_part(branch.clone(), /*max_chars*/ 32)
            }),
            TerminalTitleItem::ContextRemaining => self
                .status_line_value_for_item(StatusLineItem::ContextRemaining)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::ContextUsed => self
                .status_line_value_for_item(StatusLineItem::ContextUsed)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::FiveHourLimit => self
                .status_line_value_for_item(StatusLineItem::FiveHourLimit)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::WeeklyLimit => self
                .status_line_value_for_item(StatusLineItem::WeeklyLimit)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::CodexVersion => self
                .status_line_value_for_item(StatusLineItem::CodexVersion)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::UsedTokens => self
                .status_line_value_for_item(StatusLineItem::UsedTokens)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::TotalInputTokens => self
                .status_line_value_for_item(StatusLineItem::TotalInputTokens)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::TotalOutputTokens => self
                .status_line_value_for_item(StatusLineItem::TotalOutputTokens)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::SessionId => self
                .status_line_value_for_item(StatusLineItem::SessionId)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::FastMode => self
                .status_line_value_for_item(StatusLineItem::FastMode)
                .map(|value| Self::truncate_terminal_title_part(value, /*max_chars*/ 32)),
            TerminalTitleItem::Model => Some(Self::truncate_terminal_title_part(
                self.model_display_name().to_string(),
                /*max_chars*/ 32,
            )),
            TerminalTitleItem::ModelWithReasoning => Some(Self::truncate_terminal_title_part(
                self.model_with_reasoning_display_name(),
                /*max_chars*/ 32,
            )),
            TerminalTitleItem::Reasoning => Some(Self::truncate_terminal_title_part(
                self.reasoning_display_name(),
                /*max_chars*/ 32,
            )),
            TerminalTitleItem::TaskProgress => self.terminal_title_task_progress(),
        }
    }

    fn reasoning_display_name(&self) -> String {
        let effort = self.effective_reasoning_effort();
        Self::status_line_reasoning_effort_label(effort.as_ref())
    }

    fn model_with_reasoning_display_name(&self) -> String {
        let label = self.reasoning_display_name();
        let service_tier_label = self
            .current_service_tier()
            .and_then(|service_tier| {
                self.current_model_service_tier_commands()
                    .into_iter()
                    .find(|tier| tier.id == service_tier)
                    .map(|tier| tier.name)
            })
            .filter(|_| self.has_chatgpt_account)
            .map(|tier| format!(" {tier}"))
            .unwrap_or_default();
        format!("{} {label}{service_tier_label}", self.model_display_name())
    }

    /// Computes the compact runtime status label used by word-based status items.
    ///
    /// Startup takes precedence over normal task states, and idle state renders
    /// as `Ready` regardless of the last active status bucket.
    pub(super) fn run_state_status_text(&self) -> String {
        if self.mcp_startup_status.is_some() {
            return "Starting".to_string();
        }

        match self.status_state.terminal_title_status_kind {
            TerminalTitleStatusKind::Working if !self.bottom_pane.is_task_running() => {
                "Ready".to_string()
            }
            TerminalTitleStatusKind::WaitingForBackgroundTerminal
                if !self.bottom_pane.is_task_running() =>
            {
                "Ready".to_string()
            }
            TerminalTitleStatusKind::Thinking if !self.bottom_pane.is_task_running() => {
                "Ready".to_string()
            }
            TerminalTitleStatusKind::Working => "Working".to_string(),
            TerminalTitleStatusKind::WaitingForBackgroundTerminal => "Waiting".to_string(),
            TerminalTitleStatusKind::Thinking => "Thinking".to_string(),
        }
    }

    pub(super) fn terminal_title_spinner_text_at(&self, now: Instant) -> Option<String> {
        if !self.config.animations {
            return None;
        }

        if !self.terminal_title_has_active_progress() {
            return None;
        }

        Some(self.terminal_title_spinner_frame_at(now).to_string())
    }

    fn terminal_title_spinner_frame_at(&self, now: Instant) -> &'static str {
        let elapsed = now.saturating_duration_since(self.terminal_title_animation_origin);
        let frame_index =
            (elapsed.as_millis() / TERMINAL_TITLE_SPINNER_INTERVAL.as_millis()) as usize;
        TERMINAL_TITLE_SPINNER_FRAMES[frame_index % TERMINAL_TITLE_SPINNER_FRAMES.len()]
    }

    fn terminal_title_uses_activity(&self) -> bool {
        self.config.tui_terminal_title.as_ref().is_none_or(|items| {
            items
                .iter()
                .any(|item| item == "activity" || item == "spinner")
        })
    }

    fn terminal_title_has_active_progress(&self) -> bool {
        if self.terminal_title_shows_action_required() {
            return false;
        }

        self.mcp_startup_status.is_some() || self.bottom_pane.is_task_running()
    }

    pub(super) fn should_animate_terminal_title_spinner(&self) -> bool {
        self.config.animations
            && self.terminal_title_uses_activity()
            && self.terminal_title_has_active_progress()
    }

    pub(super) fn should_animate_terminal_title_action_required(&self) -> bool {
        self.config.animations && self.terminal_title_shows_action_required()
    }

    fn should_animate_terminal_title_spinner_with_selections(
        &self,
        selections: &StatusSurfaceSelections,
    ) -> bool {
        self.config.animations
            && selections
                .terminal_title_items
                .contains(&TerminalTitleItem::Spinner)
            && self.terminal_title_has_active_progress()
    }

    /// Formats the last `update_plan` progress snapshot for terminal-title display.
    pub(super) fn terminal_title_task_progress(&self) -> Option<String> {
        let (completed, total) = self.transcript.last_plan_progress?;
        if total == 0 {
            return None;
        }
        Some(format!("Tasks {completed}/{total}"))
    }

    /// Truncates a title segment by grapheme cluster and appends `...` when needed.
    pub(super) fn truncate_terminal_title_part(value: String, max_chars: usize) -> String {
        if max_chars == 0 {
            return String::new();
        }

        let mut graphemes = value.graphemes(true);
        let head: String = graphemes.by_ref().take(max_chars).collect();
        if graphemes.next().is_none() || max_chars <= 3 {
            return head;
        }

        let mut truncated = head.graphemes(true).take(max_chars - 3).collect::<String>();
        truncated.push_str("...");
        truncated
    }
}

fn five_hour_status_window(
    snapshot: &RateLimitSnapshotDisplay,
) -> Option<(&RateLimitWindowDisplay, bool)> {
    find_primary_codex_window(snapshot, "5h")
        .or_else(|| secondary_window_with_label_when_weekly_is_available(snapshot, "5h"))
        .or_else(|| non_weekly_primary_window(snapshot))
        .or_else(|| non_weekly_secondary_window_when_primary_is_weekly(snapshot))
}

fn weekly_status_window(
    snapshot: &RateLimitSnapshotDisplay,
) -> Option<(&RateLimitWindowDisplay, bool)> {
    find_codex_window(snapshot, "weekly")
        .or_else(|| snapshot.secondary.as_ref().map(|window| (window, true)))
}

fn find_codex_window<'a>(
    snapshot: &'a RateLimitSnapshotDisplay,
    label: &str,
) -> Option<(&'a RateLimitWindowDisplay, bool)> {
    if let Some(primary) = snapshot.primary.as_ref()
        && matches_window_label(primary, label)
    {
        return Some((primary, false));
    }

    if let Some(secondary) = snapshot.secondary.as_ref()
        && matches_window_label(secondary, label)
    {
        return Some((secondary, true));
    }

    None
}

fn find_primary_codex_window<'a>(
    snapshot: &'a RateLimitSnapshotDisplay,
    label: &str,
) -> Option<(&'a RateLimitWindowDisplay, bool)> {
    let primary = snapshot.primary.as_ref()?;
    if matches_window_label(primary, label) {
        Some((primary, false))
    } else {
        None
    }
}

fn secondary_window_with_label_when_weekly_is_available<'a>(
    snapshot: &'a RateLimitSnapshotDisplay,
    label: &str,
) -> Option<(&'a RateLimitWindowDisplay, bool)> {
    find_codex_window(snapshot, "weekly")?;

    let secondary = snapshot.secondary.as_ref()?;
    if matches_window_label(secondary, label) {
        Some((secondary, true))
    } else {
        None
    }
}

fn non_weekly_primary_window(
    snapshot: &RateLimitSnapshotDisplay,
) -> Option<(&RateLimitWindowDisplay, bool)> {
    let primary = snapshot.primary.as_ref()?;
    if matches_window_label(primary, "weekly") {
        None
    } else {
        Some((primary, false))
    }
}

fn non_weekly_secondary_window_when_primary_is_weekly(
    snapshot: &RateLimitSnapshotDisplay,
) -> Option<(&RateLimitWindowDisplay, bool)> {
    let primary = snapshot.primary.as_ref()?;
    if !matches_window_label(primary, "weekly") {
        return None;
    }

    let secondary = snapshot.secondary.as_ref()?;
    if matches_window_label(secondary, "weekly") {
        None
    } else {
        Some((secondary, true))
    }
}

fn matches_window_label(window: &RateLimitWindowDisplay, label: &str) -> bool {
    window
        .window_minutes
        .and_then(get_limits_duration)
        .as_deref()
        == Some(label)
}

fn permissions_display(config: &Config) -> String {
    let active_permission_profile = config.permissions.active_permission_profile();
    if let Some(active_permission_profile) = active_permission_profile.as_ref()
        && !active_permission_profile.id.starts_with(':')
    {
        return active_permission_profile.id.clone();
    }

    let permission_profile = config.permissions.effective_permission_profile();
    let workspace_roots = config.effective_workspace_roots();
    let summary =
        summarize_permission_profile(&permission_profile, &config.cwd, workspace_roots.as_slice());
    if let Some(details) = summary.strip_prefix("read-only")
        && !details.contains("(network access enabled)")
    {
        return "Read Only".to_string();
    }
    if let Some(details) = summary.strip_prefix("workspace-write")
        && !details.contains("(network access enabled)")
    {
        return "Workspace".to_string();
    }
    if permission_profile == PermissionProfile::Disabled {
        return "Full Access".to_string();
    }

    "Custom permissions".to_string()
}

fn approval_mode_display(config: &Config) -> String {
    let approval_policy = AskForApproval::from(config.permissions.approval_policy.value());
    if approval_policy == AskForApproval::OnRequest {
        return match config.approvals_reviewer {
            ApprovalsReviewer::AutoReview => "Approve for me".to_string(),
            ApprovalsReviewer::User => "Ask for approval".to_string(),
        };
    }

    config.permissions.approval_policy.value().to_string()
}

fn parse_items_with_invalids<T>(ids: impl IntoIterator<Item = String>) -> (Vec<T>, Vec<String>)
where
    T: std::str::FromStr,
{
    let mut invalid = Vec::new();
    let mut invalid_seen = HashSet::new();
    let mut items = Vec::new();
    for id in ids {
        match id.parse::<T>() {
            Ok(item) => items.push(item),
            Err(_) => {
                if invalid_seen.insert(id.clone()) {
                    invalid.push(format!(r#""{id}""#));
                }
            }
        }
    }
    (items, invalid)
}
