use serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ParsedCodexLine {
    pub(crate) title: String,
    pub(crate) display: String,
    pub(crate) input_tokens: u64,
    pub(crate) output_tokens: u64,
}

pub(crate) fn parse_codex_line(line: &str) -> ParsedCodexLine {
    let Ok(value) = serde_json::from_str::<Value>(line) else {
        return ParsedCodexLine {
            title: "Output".to_string(),
            display: line.to_string(),
            input_tokens: 0,
            output_tokens: 0,
        };
    };

    let (title, display) = parse_codex_event(&value).unwrap_or_else(|| {
        (
            value
                .get("type")
                .and_then(Value::as_str)
                .map(humanize_type)
                .unwrap_or_else(|| "Output".to_string()),
            first_text(&value).unwrap_or_default(),
        )
    });

    ParsedCodexLine {
        title,
        display,
        input_tokens: collect_usage_tokens(&value, true),
        output_tokens: collect_usage_tokens(&value, false),
    }
}

fn parse_codex_event(value: &Value) -> Option<(String, String)> {
    let event_type = value
        .get("type")
        .and_then(Value::as_str)
        .unwrap_or_default();
    match event_type {
        "thread.started" | "turn.started" | "turn.completed" => {
            Some(("Status".to_string(), String::new()))
        }
        "item.started" | "item.completed" => value
            .get("item")
            .and_then(|item| parse_codex_item(event_type, item)),
        _ => {
            let display = first_text(value)?;
            Some((humanize_type(event_type), display))
        }
    }
}

fn parse_codex_item(event_type: &str, item: &Value) -> Option<(String, String)> {
    let item_type = item.get("type").and_then(Value::as_str).unwrap_or_default();
    let title = classify_codex_item(item_type, item);
    let (title, display) = match title.as_str() {
        "Thinking" => render_thinking_event(item)?,
        "Command" => (title, render_command_event(event_type, item)?),
        "Patch" | "MCP" | "Plugin" => (title, render_tool_event(event_type, item)?),
        _ => (title, render_generic_item(item_type, item)?),
    };
    let display = display.trim().to_string();
    (!display.is_empty()).then_some((title, display))
}

fn render_thinking_event(item: &Value) -> Option<(String, String)> {
    let text = item
        .get("text")
        .and_then(Value::as_str)
        .map(ToString::to_string)
        .or_else(|| first_text(item))?;

    if let Some(summary) = summarize_plan_update(&text) {
        return Some(("Plan Update".to_string(), summary));
    }

    Some(("Thinking".to_string(), text))
}

fn summarize_plan_update(text: &str) -> Option<String> {
    let value = serde_json::from_str::<Value>(text).ok()?;
    if let Some(summary) = summarize_plan_delta_update(&value) {
        return Some(summary);
    }
    let plan = extract_plan_value(&value)?;
    let goal_summary = plan.get("goal_summary").and_then(Value::as_str)?.trim();
    let steps = plan.get("steps").and_then(Value::as_array)?;

    let mut done = 0usize;
    let mut active = 0usize;
    let mut todo = 0usize;
    let mut blocked = 0usize;

    for step in steps {
        match step
            .get("status")
            .and_then(Value::as_str)
            .unwrap_or_default()
        {
            "done" => done += 1,
            "active" => active += 1,
            "blocked" => blocked += 1,
            _ => todo += 1,
        }
    }

    let current = steps
        .iter()
        .find(|step| step.get("status").and_then(Value::as_str) == Some("active"))
        .or_else(|| {
            steps
                .iter()
                .find(|step| step.get("status").and_then(Value::as_str) == Some("todo"))
        })
        .or_else(|| {
            steps
                .iter()
                .find(|step| step.get("status").and_then(Value::as_str) == Some("blocked"))
        });

    let current_line = current
        .map(summarize_plan_step)
        .unwrap_or_else(|| "current none".to_string());

    Some(format!(
        "goal {}\nprogress {} done, {} active, {} todo, {} blocked\n{}",
        truncate_text(goal_summary, 120),
        done,
        active,
        todo,
        blocked,
        current_line
    ))
}

fn summarize_plan_delta_update(value: &Value) -> Option<String> {
    let delta = extract_plan_delta_value(value)?;
    let goal_summary = delta.get("goal_summary").and_then(Value::as_str);
    let step_updates = delta.get("step_updates").and_then(Value::as_array)?;
    let remove_step_ids = delta
        .get("remove_step_ids")
        .and_then(Value::as_array)
        .map(|items| items.len())
        .unwrap_or(0);
    let pending_step_order = delta
        .get("pending_step_order")
        .and_then(Value::as_array)
        .map(|items| items.len())
        .unwrap_or(0);

    let headline = goal_summary
        .map(|summary| format!("goal {}", truncate_text(summary, 120)))
        .unwrap_or_else(|| "goal unchanged".to_string());
    let detail = format!(
        "updates {} steps, removes {}, reorders {}",
        step_updates.len(),
        remove_step_ids,
        pending_step_order
    );
    let focus = step_updates
        .iter()
        .find(|step| step.get("status").and_then(Value::as_str) == Some("active"))
        .or_else(|| step_updates.first())
        .map(summarize_plan_step)
        .unwrap_or_else(|| "current unchanged".to_string());

    Some(format!("{headline}\n{detail}\n{focus}"))
}

fn extract_plan_value(value: &Value) -> Option<&Value> {
    if value.get("version").is_some()
        && value.get("goal_summary").is_some()
        && value.get("steps").is_some()
    {
        return Some(value);
    }

    value.get("plan").filter(|plan| {
        plan.get("version").is_some()
            && plan.get("goal_summary").is_some()
            && plan.get("steps").is_some()
    })
}

fn extract_plan_delta_value(value: &Value) -> Option<&Value> {
    if value.get("step_updates").is_some() && value.get("remove_step_ids").is_some() {
        return Some(value);
    }

    value
        .get("plan")
        .filter(|plan| plan.get("step_updates").is_some() && plan.get("remove_step_ids").is_some())
}

fn summarize_plan_step(step: &Value) -> String {
    let status = step.get("status").and_then(Value::as_str).unwrap_or("todo");
    let label = match status {
        "active" => "active",
        "blocked" => "blocked",
        _ => "next",
    };
    let id = step.get("id").and_then(Value::as_str).unwrap_or("unknown");
    let title = step
        .get("title")
        .and_then(Value::as_str)
        .unwrap_or("untitled");
    format!("{label} {id}: {}", truncate_text(title, 96))
}

fn truncate_text(text: &str, max_chars: usize) -> String {
    let text = text.trim();
    if max_chars == 0 || text.chars().count() <= max_chars {
        return text.to_string();
    }

    let suffix = "...";
    let keep = max_chars.saturating_sub(suffix.chars().count());
    let prefix = text.chars().take(keep).collect::<String>();
    format!("{prefix}{suffix}")
}

fn classify_codex_item(item_type: &str, item: &Value) -> String {
    let item_type = item_type.to_ascii_lowercase();
    let item_name = codex_item_name(item)
        .unwrap_or_default()
        .to_ascii_lowercase();

    if item_type == "agent_message"
        || item_type.contains("reasoning")
        || item_type.contains("thought")
    {
        return "Thinking".to_string();
    }

    if item_name.contains("apply_patch") || item_type.contains("patch") {
        return "Patch".to_string();
    }

    if item_type.contains("command") || item.get("command").is_some() {
        return "Command".to_string();
    }

    if item_name.starts_with("mcp__")
        || item_type.contains("mcp")
        || item.get("server").is_some()
        || item.get("server_name").is_some()
    {
        return "MCP".to_string();
    }

    if item_type.contains("tool") {
        return "Plugin".to_string();
    }

    humanize_type(if item_type.is_empty() {
        "output"
    } else {
        item_type.as_str()
    })
}

fn render_command_event(event_type: &str, item: &Value) -> Option<String> {
    if event_type == "item.started" {
        return string_field(item, &["command"]).map(|command| format_command_preview(&command));
    }

    let output = string_field(item, &["aggregated_output", "output", "result"])
        .unwrap_or_default()
        .trim()
        .to_string();
    let exit_code = item.get("exit_code").and_then(Value::as_i64);

    let output = summarize_diff_output(&output).unwrap_or(output);
    let output = truncate_command_output(&output, 6);

    match (output.is_empty(), exit_code) {
        (false, Some(code)) if code != 0 => Some(format!("{output}\nexit {code}")),
        (false, _) => Some(output),
        (true, Some(code)) => Some(format!("exit {code}")),
        _ => string_field(item, &["command"]).map(|command| format_command_preview(&command)),
    }
}

fn format_command_preview(command: &str) -> String {
    let command = summarize_heredoc_command(command.trim());
    let command = truncate_command_preview_lines(&command, 6);
    let command = truncate_command_preview_chars(&command, 240);
    format!("$ {command}")
}

fn summarize_heredoc_command(command: &str) -> String {
    let mut summarized = Vec::new();
    let mut lines = command.lines().peekable();

    while let Some(line) = lines.next() {
        summarized.push(line.to_string());

        let Some(delimiter) = heredoc_delimiter(line) else {
            continue;
        };

        let mut omitted = 0usize;
        while let Some(next_line) = lines.peek().copied() {
            lines.next();
            if is_heredoc_terminator(next_line, &delimiter) {
                break;
            }
            omitted += 1;
        }

        if omitted > 0 {
            summarized.push(format!("... {omitted} heredoc lines omitted"));
        }
    }

    summarized.join("\n")
}

fn heredoc_delimiter(line: &str) -> Option<String> {
    let marker = line.find("<<")?;
    let mut rest = &line[marker + 2..];
    if let Some(stripped) = rest.strip_prefix('-') {
        rest = stripped;
    }
    rest = rest.trim_start();
    if rest.is_empty() {
        return None;
    }

    let first = rest.chars().next()?;
    if matches!(first, '\'' | '"') {
        let quoted = &rest[first.len_utf8()..];
        let end = quoted.find(first)?;
        return Some(quoted[..end].to_string());
    }

    let delimiter = rest
        .split_whitespace()
        .next()?
        .trim_matches(|ch: char| matches!(ch, ';' | ')' | '(' | '"' | '\''));
    (!delimiter.is_empty()).then(|| delimiter.to_string())
}

fn is_heredoc_terminator(line: &str, delimiter: &str) -> bool {
    let trimmed = line.trim();
    trimmed == delimiter
        || trimmed
            .strip_prefix(delimiter)
            .map(|suffix| {
                suffix
                    .chars()
                    .all(|ch| matches!(ch, '"' | '\'' | ';' | ')' | '('))
            })
            .unwrap_or(false)
}

fn truncate_command_preview_lines(command: &str, max_lines: usize) -> String {
    if max_lines == 0 || command.is_empty() {
        return String::new();
    }

    let lines = command.lines().collect::<Vec<_>>();
    if lines.len() <= max_lines {
        return command.to_string();
    }

    let hidden = lines.len().saturating_sub(max_lines);
    format!(
        "{}\n... {hidden} more command lines omitted",
        lines[..max_lines].join("\n")
    )
}

fn truncate_command_preview_chars(command: &str, max_chars: usize) -> String {
    let char_count = command.chars().count();
    if max_chars == 0 || char_count <= max_chars {
        return command.to_string();
    }

    let suffix = "... command text truncated";
    let keep = max_chars.saturating_sub(suffix.chars().count());
    if keep == 0 {
        return suffix.chars().take(max_chars).collect();
    }

    let prefix = command.chars().take(keep).collect::<String>();
    format!("{prefix}{suffix}")
}

fn truncate_command_output(output: &str, max_lines: usize) -> String {
    if max_lines == 0 || output.is_empty() {
        return String::new();
    }

    let lines = output.lines().collect::<Vec<_>>();
    if lines.len() <= max_lines {
        return output.to_string();
    }

    let hidden = lines.len().saturating_sub(max_lines);
    let visible = &lines[lines.len() - max_lines..];
    format!(
        "... {} earlier lines omitted\n{}",
        hidden,
        visible.join("\n")
    )
}

fn render_tool_event(event_type: &str, item: &Value) -> Option<String> {
    let name = codex_item_name(item).unwrap_or_else(|| "tool".to_string());
    if event_type == "item.started" {
        return Some(name);
    }

    let output = string_field(
        item,
        &["output", "result", "aggregated_output", "summary", "text"],
    )
    .unwrap_or_default()
    .trim()
    .to_string();
    if !output.is_empty() {
        return Some(summarize_diff_output(&output).unwrap_or(output));
    }

    let status = string_field(item, &["status"]).unwrap_or_default();
    if !status.is_empty() && status != "completed" {
        return Some(status);
    }

    None
}

fn render_generic_item(item_type: &str, item: &Value) -> Option<String> {
    if item_type.eq_ignore_ascii_case("file_change") {
        return string_field(item, &["path", "file_path", "filename", "file"]);
    }

    first_text(item)
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct DiffFileSummary {
    path: String,
    added: usize,
    removed: usize,
}

fn summarize_diff_output(text: &str) -> Option<String> {
    let summaries = summarize_unified_diff(text)?;
    Some(
        summaries
            .into_iter()
            .map(|summary| {
                format!(
                    "edited {} +{} -{}",
                    summary.path, summary.added, summary.removed
                )
            })
            .collect::<Vec<_>>()
            .join("\n"),
    )
}

fn summarize_unified_diff(text: &str) -> Option<Vec<DiffFileSummary>> {
    let mut current: Option<DiffFileSummary> = None;
    let mut summaries = Vec::new();
    let mut saw_diff_marker = false;

    for line in text.lines() {
        if let Some(path) = diff_file_path(line) {
            saw_diff_marker = true;
            if let Some(summary) = current.take() {
                summaries.push(summary);
            }
            current = Some(DiffFileSummary {
                path,
                added: 0,
                removed: 0,
            });
            continue;
        }

        let Some(summary) = current.as_mut() else {
            continue;
        };

        if line.starts_with("+++ ") || line.starts_with("--- ") || line.starts_with("@@") {
            continue;
        }
        if line.starts_with('+') {
            summary.added += 1;
        } else if line.starts_with('-') {
            summary.removed += 1;
        }
    }

    if let Some(summary) = current.take() {
        summaries.push(summary);
    }

    if !saw_diff_marker || summaries.is_empty() {
        None
    } else {
        Some(summaries)
    }
}

fn diff_file_path(line: &str) -> Option<String> {
    let rest = line.strip_prefix("diff --git ")?;
    let mut parts = rest.split_whitespace();
    let _old = parts.next()?;
    let new = parts.next()?;
    let path = new
        .strip_prefix("b/")
        .or_else(|| new.strip_prefix("a/"))
        .unwrap_or(new);
    Some(path.to_string())
}

fn codex_item_name(item: &Value) -> Option<String> {
    string_field(
        item,
        &["tool_name", "tool", "name", "server_name", "server"],
    )
}

fn string_field(value: &Value, keys: &[&str]) -> Option<String> {
    let Value::Object(map) = value else {
        return None;
    };

    keys.iter()
        .find_map(|key| map.get(*key).and_then(Value::as_str))
        .map(ToString::to_string)
}

fn humanize_type(raw: &str) -> String {
    raw.split(['-', '_', '.'])
        .filter(|part| !part.is_empty())
        .map(|part| {
            let mut chars = part.chars();
            match chars.next() {
                Some(first) => {
                    let mut word = String::new();
                    word.push(first.to_ascii_uppercase());
                    word.push_str(chars.as_str());
                    word
                }
                None => String::new(),
            }
        })
        .collect::<Vec<_>>()
        .join(" ")
}

fn first_text(value: &Value) -> Option<String> {
    match value {
        Value::String(text) => (!is_internal_item_id(text)).then(|| text.clone()),
        Value::Array(items) => items.iter().find_map(first_text),
        Value::Object(map) => {
            for key in ["msg", "message", "text", "content", "summary"] {
                if let Some(text) = map.get(key).and_then(Value::as_str) {
                    if !is_internal_item_id(text) {
                        return Some(text.to_string());
                    }
                }
            }
            map.iter()
                .filter(|(key, _)| !matches!(key.as_str(), "id" | "type" | "status"))
                .find_map(|(_, value)| first_text(value))
        }
        _ => None,
    }
}

fn is_internal_item_id(text: &str) -> bool {
    let Some(suffix) = text.strip_prefix("item_") else {
        return false;
    };
    !suffix.is_empty() && suffix.chars().all(|ch| ch.is_ascii_digit())
}

fn collect_usage_tokens(value: &Value, input: bool) -> u64 {
    match value {
        Value::Array(items) => items
            .iter()
            .map(|item| collect_usage_tokens(item, input))
            .sum(),
        Value::Object(map) => {
            let mut total = 0;
            for (key, child) in map {
                let matched_key = if input {
                    ["input_tokens", "input_token_count", "prompt_tokens"]
                } else {
                    ["output_tokens", "output_token_count", "completion_tokens"]
                };
                if matched_key.contains(&key.as_str()) {
                    total += child.as_u64().unwrap_or_default();
                } else {
                    total += collect_usage_tokens(child, input);
                }
            }
            total
        }
        _ => 0,
    }
}

pub(crate) fn should_ignore_codex_stderr(line: &str) -> bool {
    line.contains("failed to stat skills entry")
        || line.trim() == "Reading additional input from stdin..."
}

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

    #[test]
    fn filters_known_codex_stderr_noise() {
        assert!(should_ignore_codex_stderr(
            "2026-04-04T03:43:38Z ERROR codex_core_skills::loader: failed to stat skills entry /tmp/foo"
        ));
        assert!(should_ignore_codex_stderr(
            "Reading additional input from stdin..."
        ));
        assert!(!should_ignore_codex_stderr("actual planner failure"));
    }

    #[test]
    fn parses_agent_messages_as_thinking() {
        let parsed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"Planning next step."}}"#,
        );

        assert_eq!(parsed.title, "Thinking");
        assert_eq!(parsed.display, "Planning next step.");
    }

    #[test]
    fn summarizes_plan_json_thinking_as_plan_update() {
        let parsed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"{\"version\":5,\"goal_summary\":\"Refactor remaining modules without changing behavior\",\"steps\":[{\"id\":\"guardrails\",\"title\":\"Add Refactor Guardrails\",\"status\":\"done\"},{\"id\":\"process-modules\",\"title\":\"Split Process Execution And Parsing\",\"status\":\"todo\"}]}"}}"#,
        );

        assert_eq!(parsed.title, "Plan Update");
        assert_eq!(
            parsed.display,
            "goal Refactor remaining modules without changing behavior\nprogress 1 done, 0 active, 1 todo, 0 blocked\nnext process-modules: Split Process Execution And Parsing"
        );
    }

    #[test]
    fn summarizes_nested_plan_json_thinking_as_plan_update() {
        let parsed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"{\"kind\":\"final\",\"plan\":{\"version\":5,\"goal_summary\":\"Ship planner cleanup\",\"steps\":[{\"id\":\"planner-cleanup\",\"title\":\"Trim Planner Output\",\"status\":\"active\"}]}}"}}"#,
        );

        assert_eq!(parsed.title, "Plan Update");
        assert_eq!(
            parsed.display,
            "goal Ship planner cleanup\nprogress 0 done, 1 active, 0 todo, 0 blocked\nactive planner-cleanup: Trim Planner Output"
        );
    }

    #[test]
    fn summarizes_plan_delta_thinking_as_plan_update() {
        let parsed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"{\"goal_summary\":null,\"step_updates\":[{\"id\":\"process-modules\",\"title\":\"Split Process Execution And Parsing\",\"status\":\"active\"}],\"remove_step_ids\":[\"old-step\"],\"pending_step_order\":[\"process-modules\"]}"}}"#,
        );

        assert_eq!(parsed.title, "Plan Update");
        assert_eq!(
            parsed.display,
            "goal unchanged\nupdates 1 steps, removes 1, reorders 1\nactive process-modules: Split Process Execution And Parsing"
        );
    }

    #[test]
    fn parses_command_events_into_command_groups() {
        let started = parse_codex_line(
            r#"{"type":"item.started","item":{"id":"item_1","type":"command_execution","command":"/bin/zsh -lc pwd","status":"in_progress"}}"#,
        );
        let completed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_1","type":"command_execution","command":"/bin/zsh -lc pwd","aggregated_output":"/tmp/demo\n","exit_code":0,"status":"completed"}}"#,
        );

        assert_eq!(started.title, "Command");
        assert_eq!(started.display, "$ /bin/zsh -lc pwd");
        assert_eq!(completed.title, "Command");
        assert_eq!(completed.display, "/tmp/demo");
    }

    #[test]
    fn truncates_multiline_started_command_previews() {
        let parsed = parse_codex_line(
            r#"{"type":"item.started","item":{"id":"item_10","type":"command_execution","command":"/bin/zsh -lc \"line1\nline2\nline3\nline4\nline5\nline6\nline7\"","status":"in_progress"}}"#,
        );

        assert_eq!(
            parsed.display,
            "$ /bin/zsh -lc \"line1\nline2\nline3\nline4\nline5\nline6\n... 1 more command lines omitted"
        );
    }

    #[test]
    fn redacts_heredoc_bodies_in_command_previews() {
        let parsed = parse_codex_line(
            r#"{"type":"item.started","item":{"id":"item_11","type":"command_execution","command":"cat > /tmp/demo.rs <<'EOF'\nfirst\nsecond\nEOF\ncargo fmt","status":"in_progress"}}"#,
        );

        assert!(parsed.display.contains("$ cat > /tmp/demo.rs <<'EOF'"));
        assert!(parsed.display.contains("... 2 heredoc lines omitted"));
        assert!(parsed.display.contains("cargo fmt"));
        assert!(!parsed.display.contains("first\nsecond"));
    }

    #[test]
    fn parses_tool_events_and_nested_usage_tokens() {
        let started = parse_codex_line(
            r#"{"type":"item.started","item":{"id":"item_2","type":"mcp_tool_call","tool_name":"mcp__playwright__browser_snapshot"}}"#,
        );
        let completed = parse_codex_line(
            r#"{"type":"item.completed","usage":{"prompt_tokens":5},"item":{"id":"item_2","type":"patch_apply","tool_name":"apply_patch","output":"updated file","usage":{"completion_tokens":9}}}"#,
        );

        assert_eq!(started.title, "MCP");
        assert_eq!(started.display, "mcp__playwright__browser_snapshot");
        assert_eq!(completed.title, "Patch");
        assert_eq!(completed.display, "updated file");
        assert_eq!(completed.input_tokens, 5);
        assert_eq!(completed.output_tokens, 9);
    }

    #[test]
    fn summarizes_unified_diff_output_by_file() {
        let parsed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_3","type":"command_execution","aggregated_output":"diff --git a/src/main.rs b/src/main.rs\nindex 1111111..2222222 100644\n--- a/src/main.rs\n+++ b/src/main.rs\n@@ -1,3 +1,4 @@\n keep\n-old\n+new\n+extra\ndiff --git a/src/lib.rs b/src/lib.rs\nindex 3333333..4444444 100644\n--- a/src/lib.rs\n+++ b/src/lib.rs\n@@ -2,2 +2,1 @@\n-remove\n stay\n","exit_code":0,"status":"completed"}}"#,
        );

        assert_eq!(
            parsed.display,
            "edited src/main.rs +2 -1\nedited src/lib.rs +0 -1"
        );
    }

    #[test]
    fn leaves_non_diff_command_output_unchanged() {
        let parsed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_4","type":"command_execution","aggregated_output":"plain output\nsecond line","exit_code":0,"status":"completed"}}"#,
        );

        assert_eq!(parsed.display, "plain output\nsecond line");
    }

    #[test]
    fn truncates_long_command_output_to_latest_lines() {
        let parsed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_5","type":"command_execution","aggregated_output":"l1\nl2\nl3\nl4\nl5\nl6\nl7\nl8","exit_code":0,"status":"completed"}}"#,
        );

        assert_eq!(
            parsed.display,
            "... 2 earlier lines omitted\nl3\nl4\nl5\nl6\nl7\nl8"
        );
    }

    #[test]
    fn ignores_internal_item_ids_in_generic_output() {
        let parsed = parse_codex_line(
            r#"{"type":"item.completed","item":{"id":"item_21","type":"file_change","status":"completed"}}"#,
        );

        assert!(parsed.display.is_empty());
    }

    #[test]
    fn hides_turn_lifecycle_output_but_keeps_usage() {
        let parsed = parse_codex_line(
            r#"{"type":"turn.completed","usage":{"input_tokens":12,"output_tokens":34}}"#,
        );

        assert!(parsed.display.is_empty());
        assert_eq!(parsed.input_tokens, 12);
        assert_eq!(parsed.output_tokens, 34);
    }
}