use super::app::{AppState, CommandSuggestion, MessageSender, TuiMode, THEMES};
use brokecrew::persona::Tier;
use ratatui::{
    layout::{Alignment, Constraint, Direction, Layout, Position, Rect},
    style::{Color, Modifier, Style, Stylize},
    text::{Line, Span},
    widgets::{Block, BorderType, Borders, Clear, List, ListItem, Paragraph, Wrap},
    Frame,
};

#[derive(Debug, Clone)]
pub struct ThemePalette {
    pub accent: Color,
    pub user_bg: Color,
    pub card_border: Color,
    pub tool_bg: Color,
    pub text_bright: Color,
    pub text_muted: Color,
}

pub fn get_theme_palette(theme: &str) -> ThemePalette {
    match theme {
        "warm" => ThemePalette {
            accent: Color::Rgb(240, 160, 60), // warm amber
            user_bg: Color::Rgb(48, 40, 36),  // warm charcoal
            card_border: Color::Rgb(100, 80, 60),
            tool_bg: Color::Rgb(36, 32, 28),
            text_bright: Color::Rgb(250, 245, 235),
            text_muted: Color::Rgb(160, 145, 130),
        },
        "forest" => ThemePalette {
            accent: Color::Rgb(80, 200, 140), // emerald mint
            user_bg: Color::Rgb(30, 46, 38),  // deep pine
            card_border: Color::Rgb(60, 95, 75),
            tool_bg: Color::Rgb(24, 38, 30),
            text_bright: Color::Rgb(235, 250, 240),
            text_muted: Color::Rgb(130, 165, 145),
        },
        "cyberpunk" => ThemePalette {
            accent: Color::Rgb(255, 60, 150), // neon pink
            user_bg: Color::Rgb(42, 25, 52),  // midnight magenta
            card_border: Color::Rgb(110, 50, 130),
            tool_bg: Color::Rgb(30, 20, 40),
            text_bright: Color::Rgb(255, 230, 250),
            text_muted: Color::Rgb(160, 120, 180),
        },
        "mono" => ThemePalette {
            accent: Color::White,
            user_bg: Color::Rgb(38, 38, 38),
            card_border: Color::Rgb(85, 85, 85),
            tool_bg: Color::Rgb(28, 28, 28),
            text_bright: Color::White,
            text_muted: Color::DarkGray,
        },
        "catppuccin" => ThemePalette {
            accent: Color::Rgb(180, 190, 254),      // lavender
            user_bg: Color::Rgb(49, 50, 68),        // surface0
            card_border: Color::Rgb(88, 91, 112),   // surface2
            tool_bg: Color::Rgb(30, 30, 46),        // base
            text_bright: Color::Rgb(205, 214, 244), // text
            text_muted: Color::Rgb(147, 153, 178),  // overlay0
        },
        "tokyo_night" => ThemePalette {
            accent: Color::Rgb(122, 162, 247), // tokyo blue
            user_bg: Color::Rgb(36, 40, 59),
            card_border: Color::Rgb(65, 72, 104),
            tool_bg: Color::Rgb(26, 27, 38),
            text_bright: Color::Rgb(192, 202, 245),
            text_muted: Color::Rgb(120, 130, 160),
        },
        "nord" => ThemePalette {
            accent: Color::Rgb(136, 192, 208),      // frost cyan
            user_bg: Color::Rgb(59, 66, 82),        // nord1
            card_border: Color::Rgb(76, 86, 106),   // nord3
            tool_bg: Color::Rgb(46, 52, 64),        // nord0
            text_bright: Color::Rgb(236, 239, 244), // nord6
            text_muted: Color::Rgb(140, 155, 170),
        },
        "dracula" => ThemePalette {
            accent: Color::Rgb(189, 147, 249),      // purple
            user_bg: Color::Rgb(68, 71, 90),        // current line
            card_border: Color::Rgb(98, 114, 164),  // comment
            tool_bg: Color::Rgb(40, 42, 54),        // bg
            text_bright: Color::Rgb(248, 248, 242), // fg
            text_muted: Color::Rgb(139, 147, 185),
        },
        "solarized" => ThemePalette {
            accent: Color::Rgb(42, 161, 152),       // cyan
            user_bg: Color::Rgb(7, 54, 66),         // base02
            card_border: Color::Rgb(88, 110, 117),  // base01
            tool_bg: Color::Rgb(0, 43, 54),         // base03
            text_bright: Color::Rgb(238, 232, 213), // base2
            text_muted: Color::Rgb(147, 161, 161),  // base1
        },
        "gruvbox" => ThemePalette {
            accent: Color::Rgb(254, 128, 25),       // orange
            user_bg: Color::Rgb(60, 56, 54),        // dark2
            card_border: Color::Rgb(102, 92, 84),   // dark4
            tool_bg: Color::Rgb(40, 40, 40),        // dark0
            text_bright: Color::Rgb(235, 219, 178), // light1
            text_muted: Color::Rgb(168, 153, 132),  // light4
        },
        _ => ThemePalette {
            // opencode (default)
            accent: Color::Rgb(80, 210, 230), // cyan / sky
            user_bg: Color::Rgb(46, 50, 66),  // deep slate
            card_border: Color::Rgb(70, 90, 115),
            tool_bg: Color::Rgb(30, 38, 34),
            text_bright: Color::White,
            text_muted: Color::Rgb(140, 145, 160),
        },
    }
}

pub fn render(frame: &mut Frame, app: &mut AppState) {
    let size = frame.area();
    let palette = get_theme_palette(&app.current_theme);

    if app.is_start_screen() {
        render_start_screen(frame, app, size, &palette);
    } else {
        let root_chunks = Layout::default()
            .direction(Direction::Vertical)
            .constraints([
                Constraint::Length(1), // Sleek 1-line top session tab
                Constraint::Min(6),    // Main workspace (Split: Chat left, Workings right)
                Constraint::Length(1), // Minimal Bottom status
            ])
            .split(size);

        render_header(frame, app, root_chunks[0], &palette);
        render_workspace(frame, app, root_chunks[1], &palette);
        render_footer(frame, app, root_chunks[2], &palette);
    }

    match app.mode {
        TuiMode::PersonaSelect => render_persona_popup(frame, app, &palette),
        TuiMode::PipelineSelect => render_pipeline_popup(frame, app, &palette),
        TuiMode::SessionSelect => render_session_popup(frame, app, &palette),
        TuiMode::ThemeSelect => render_theme_popup(frame, app, &palette),
        TuiMode::Normal => {}
    }
}

fn render_start_screen(frame: &mut Frame, app: &AppState, area: Rect, palette: &ThemePalette) {
    let v_chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Percentage(16), // Top spacer
            Constraint::Length(6),      // ASCII Logo
            Constraint::Length(2),      // Subtitle
            Constraint::Length(1),      // Spacer
            Constraint::Length(3),      // Centered input card
            Constraint::Min(6),         // Suggestions or shortcuts
            Constraint::Length(1),      // Footer
        ])
        .split(area);

    // 1. ASCII Logo (Compact block)
    let width = area.width;
    let logo_lines = if width >= 80 {
        vec![
            "██████╗ ██████╗  ██████╗ ██╗  ██╗███████╗ ██████╗██████╗ ███████╗██╗    ██╗",
            "██╔══██╗██╔══██╗██╔═══██╗██║ ██╔╝██╔════╝██╔════╝██╔══██╗██╔════╝██║    ██║",
            "██████╔╝██████╔╝██║   ██║█████╔╝ █████╗  ██║     ██████╔╝█████╗  ██║ █╗ ██║",
            "██╔══██╗██╔══██╗██║   ██║██╔═██╗ ██╔══╝  ██║     ██╔══██╗██╔══╝  ██║███╗██║",
            "██████╔╝██║  ██║╚██████╔╝██║  ██╗███████╗╚██████╗██║  ██║███████╗╚███╔███╔╝",
            "╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚══╝╚══╝ ",
        ]
    } else {
        vec![
            "   ___           _        ___                 ",
            "  / _ )_______  / /_____ / _ \\_______ _    __ ",
            " / _  / __/ _ \\/  '_/ -_) // / __/ -_) |/|/ / ",
            "/____/_/  \\___/_/\\_\\\\__/\\___/_/  \\__/|__,__/  ",
            "",
            "",
        ]
    };

    let logo_spans: Vec<Line> = logo_lines
        .into_iter()
        .map(|l| {
            Line::from(Span::styled(l, Style::default().fg(palette.accent).bold()))
                .alignment(Alignment::Center)
        })
        .collect();
    frame.render_widget(Paragraph::new(logo_spans), v_chunks[1]);

    // 2. Subtitle
    let subtitle = Line::from(vec![Span::styled(
        "/help to view commands • v0.1.1",
        Style::default().fg(palette.text_muted),
    )])
    .alignment(Alignment::Center);
    frame.render_widget(Paragraph::new(subtitle), v_chunks[2]);

    // 3. Centered input card
    let h_card_chunks = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Percentage(20),
            Constraint::Percentage(60),
            Constraint::Percentage(20),
        ])
        .split(v_chunks[4]);

    let input_area = h_card_chunks[1];
    let input_block = Block::default()
        .borders(Borders::ALL)
        .border_type(BorderType::Rounded)
        .border_style(Style::default().fg(palette.card_border))
        .style(Style::default().bg(palette.user_bg));

    let input_inner = input_block.inner(input_area);
    frame.render_widget(input_block, input_area);

    let input_display = if app.input.is_empty() {
        Line::from(vec![
            Span::styled("▌ ", Style::default().fg(palette.accent)),
            Span::styled(
                "Ask anything or type / for commands...",
                Style::default().fg(palette.text_muted).italic(),
            ),
        ])
    } else {
        Line::from(vec![
            Span::styled("▌ ", Style::default().fg(palette.accent)),
            Span::styled(&app.input, Style::default().fg(palette.text_bright).bold()),
        ])
    };
    frame.render_widget(Paragraph::new(input_display), input_inner);

    // Terminal cursor positioning on start screen
    let cursor_x = input_inner.x + 2 + (app.cursor_pos as u16);
    let cursor_y = input_inner.y;
    if cursor_x < input_inner.x + input_inner.width {
        frame.set_cursor_position(Position {
            x: cursor_x,
            y: cursor_y,
        });
    }

    // 4. Suggestions dropdown OR shortcut hint pills
    let suggestions = app.get_matching_suggestions();
    if !suggestions.is_empty() {
        let sug_chunks = Layout::default()
            .direction(Direction::Horizontal)
            .constraints([
                Constraint::Percentage(20),
                Constraint::Percentage(60),
                Constraint::Percentage(20),
            ])
            .split(v_chunks[5]);

        render_suggestions_list(frame, app, sug_chunks[1], palette, &suggestions);
    } else {
        let hints = Line::from(vec![
            Span::styled("Tab ", Style::default().fg(palette.accent).bold()),
            Span::styled("persona  •  ", Style::default().fg(palette.text_muted)),
            Span::styled("Ctrl+P ", Style::default().fg(palette.accent).bold()),
            Span::styled("pipeline  •  ", Style::default().fg(palette.text_muted)),
            Span::styled("/theme ", Style::default().fg(palette.accent).bold()),
            Span::styled("color  •  ", Style::default().fg(palette.text_muted)),
            Span::styled("Esc ", Style::default().fg(palette.accent).bold()),
            Span::styled("quit", Style::default().fg(palette.text_muted)),
        ])
        .alignment(Alignment::Center);

        let hint_area = Rect {
            x: v_chunks[5].x,
            y: v_chunks[5].y + 1,
            width: v_chunks[5].width,
            height: 1,
        };
        frame.render_widget(Paragraph::new(hints), hint_area);
    }

    // 5. Footer
    render_footer(frame, app, v_chunks[6], palette);
}

fn render_header(frame: &mut Frame, app: &AppState, area: Rect, palette: &ThemePalette) {
    let session_title = truncate_str(&app.active_session.title, 32);
    let active_persona = app.current_persona_name();

    let pipe_tag = if let Some(ref p) = app.active_pipeline_for_prompt {
        format!(" [{p}]")
    } else {
        String::new()
    };

    let left_spans = vec![
        Span::styled("⠇ ", Style::default().fg(palette.accent).bold()),
        Span::styled(
            session_title,
            Style::default().fg(palette.text_bright).bold(),
        ),
        Span::styled(
            format!("  ({active_persona}{pipe_tag})"),
            Style::default().fg(palette.text_muted),
        ),
    ];

    let right_spans = if app.is_generating {
        let spinner_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
        let sp = spinner_frames[app.spinner_tick % spinner_frames.len()];
        vec![Span::styled(
            format!("{sp} thinking..."),
            Style::default().fg(Color::Yellow),
        )]
    } else if app.esc_pressed_at.is_some() {
        vec![Span::styled(
            "[esc again to quit]",
            Style::default().fg(Color::LightRed).bold(),
        )]
    } else {
        vec![]
    };

    let header_layout = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(70), Constraint::Percentage(30)])
        .split(area);

    frame.render_widget(Paragraph::new(Line::from(left_spans)), header_layout[0]);
    frame.render_widget(
        Paragraph::new(Line::from(right_spans)).alignment(Alignment::Right),
        header_layout[1],
    );
}

fn render_workspace(frame: &mut Frame, app: &mut AppState, area: Rect, palette: &ThemePalette) {
    let (chat_pct, side_pct) = if area.width >= 130 {
        (72, 28)
    } else if area.width >= 95 {
        (68, 32)
    } else {
        (64, 36)
    };

    let workspace_chunks = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Percentage(chat_pct), // Left: Chat
            Constraint::Percentage(side_pct), // Right: Telemetry & Pipeline
        ])
        .split(area);

    render_conversation_pane(frame, app, workspace_chunks[0], palette);
    render_workings_pane(frame, app, workspace_chunks[1], palette);
}

fn render_conversation_pane(
    frame: &mut Frame,
    app: &mut AppState,
    area: Rect,
    palette: &ThemePalette,
) {
    let chat_chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Min(4),    // Messages stream
            Constraint::Length(1), // Top input border
            Constraint::Length(1), // Input text line
            Constraint::Length(1), // Bottom input border
            Constraint::Length(1), // ~ indicator line
        ])
        .split(area);

    render_minimal_messages(frame, app, chat_chunks[0], palette);

    // Top input border
    let top_border = Line::from(Span::styled(
        "─".repeat(chat_chunks[1].width as usize),
        Style::default().fg(palette.card_border),
    ));
    frame.render_widget(Paragraph::new(top_border), chat_chunks[1]);

    // Input text line
    render_minimal_input(frame, app, chat_chunks[2], palette);

    // Bottom input border
    let bot_border = Line::from(Span::styled(
        "─".repeat(chat_chunks[3].width as usize),
        Style::default().fg(palette.card_border),
    ));
    frame.render_widget(Paragraph::new(bot_border), chat_chunks[3]);

    // ~ indicator line
    let tilde = Line::from(vec![
        Span::raw(" "),
        Span::styled("~", Style::default().fg(palette.text_muted)),
    ]);
    frame.render_widget(Paragraph::new(tilde), chat_chunks[4]);

    // Suggestions popup when typing /
    let suggestions = app.get_matching_suggestions();
    if !suggestions.is_empty() {
        render_suggestions_overlay(frame, app, chat_chunks[1], palette, &suggestions);
    }
}

fn render_suggestions_overlay(
    frame: &mut Frame,
    app: &AppState,
    anchor: Rect,
    palette: &ThemePalette,
    suggestions: &[&'static CommandSuggestion],
) {
    let count = suggestions.len().min(8);
    let box_height = (count as u16) + 2;
    let box_y = anchor.y.saturating_sub(box_height);
    let sug_rect = Rect {
        x: anchor.x + 1,
        y: box_y,
        width: anchor.width.saturating_sub(2).min(64),
        height: box_height,
    };

    render_suggestions_list(frame, app, sug_rect, palette, suggestions);
}

fn render_suggestions_list(
    frame: &mut Frame,
    app: &AppState,
    area: Rect,
    palette: &ThemePalette,
    suggestions: &[&'static CommandSuggestion],
) {
    frame.render_widget(Clear, area);
    let block = Block::default()
        .borders(Borders::ALL)
        .border_type(BorderType::Rounded)
        .border_style(Style::default().fg(palette.accent))
        .style(Style::default().bg(Color::Rgb(26, 30, 42)));

    let inner = block.inner(area);
    frame.render_widget(block, area);

    let count = suggestions.len().min(inner.height as usize);
    let items: Vec<ListItem> = suggestions
        .iter()
        .enumerate()
        .take(count)
        .map(|(idx, sug)| {
            let is_selected = idx == app.selected_suggestion_idx;
            let (prefix, prefix_style) = if is_selected {
                ("→ ", Style::default().fg(palette.accent).bold())
            } else {
                ("  ", Style::default().fg(Color::DarkGray))
            };

            let line = Line::from(vec![
                Span::styled(prefix, prefix_style),
                Span::styled(
                    format!("{:<13} ", sug.name),
                    if is_selected {
                        Style::default().fg(palette.accent).bold()
                    } else {
                        Style::default().fg(Color::White)
                    },
                ),
                Span::styled(sug.description, Style::default().fg(palette.text_muted)),
            ]);

            if is_selected {
                ListItem::new(line).style(Style::default().bg(Color::Rgb(38, 44, 62)))
            } else {
                ListItem::new(line)
            }
        })
        .collect();

    let list = List::new(items);
    frame.render_widget(list, inner);
}

fn wrap_text(line: &str, max_width: usize) -> Vec<String> {
    if line.is_empty() {
        return vec![String::new()];
    }
    if max_width == 0 {
        return vec![line.to_string()];
    }
    let mut result = Vec::new();
    let mut current = String::new();
    let mut current_len = 0;

    for word in line.split(' ') {
        let word_len = word.chars().count();
        if current.is_empty() {
            if word_len > max_width {
                let chars: Vec<char> = word.chars().collect();
                for chunk in chars.chunks(max_width) {
                    result.push(chunk.iter().collect());
                }
            } else {
                current.push_str(word);
                current_len = word_len;
            }
        } else if current_len + 1 + word_len <= max_width {
            current.push(' ');
            current.push_str(word);
            current_len += 1 + word_len;
        } else {
            result.push(current);
            if word_len > max_width {
                let chars: Vec<char> = word.chars().collect();
                for chunk in chars.chunks(max_width) {
                    result.push(chunk.iter().collect());
                }
                current = String::new();
                current_len = 0;
            } else {
                current = word.to_string();
                current_len = word_len;
            }
        }
    }
    if !current.is_empty() {
        result.push(current);
    }
    result
}

fn render_minimal_messages(frame: &mut Frame, app: &AppState, area: Rect, palette: &ThemePalette) {
    let mut lines: Vec<Line> = Vec::new();
    let full_width = area.width.saturating_sub(1) as usize;

    for msg in &app.messages {
        match &msg.sender {
            MessageSender::User => {
                let card_width = full_width.max(12);
                let inner_text_width = card_width.saturating_sub(4); // 2 cols for "▌ ", 2 cols right safety margin

                lines.push(Line::from(""));

                // Top padding line
                let top_pad = card_width.saturating_sub(2);
                lines.push(
                    Line::from(vec![
                        Span::styled(
                            "▌ ",
                            Style::default().fg(palette.accent).bg(palette.user_bg),
                        ),
                        Span::styled(" ".repeat(top_pad), Style::default().bg(palette.user_bg)),
                    ])
                    .style(Style::default().bg(palette.user_bg)),
                );

                // Content lines with proper word-wrapping and exact right padding
                for raw_line in msg.content.lines() {
                    let wrapped_lines = wrap_text(raw_line, inner_text_width);
                    for text_line in wrapped_lines {
                        let text_len = text_line.chars().count();
                        let pad_len = card_width.saturating_sub(2 + text_len);
                        lines.push(
                            Line::from(vec![
                                Span::styled(
                                    "▌ ",
                                    Style::default().fg(palette.accent).bg(palette.user_bg),
                                ),
                                Span::styled(
                                    text_line,
                                    Style::default()
                                        .fg(palette.text_bright)
                                        .bold()
                                        .bg(palette.user_bg),
                                ),
                                Span::styled(
                                    " ".repeat(pad_len),
                                    Style::default().bg(palette.user_bg),
                                ),
                            ])
                            .style(Style::default().bg(palette.user_bg)),
                        );
                    }
                }

                // Bottom padding line
                let bot_pad = card_width.saturating_sub(2);
                lines.push(
                    Line::from(vec![
                        Span::styled(
                            "▌ ",
                            Style::default().fg(palette.accent).bg(palette.user_bg),
                        ),
                        Span::styled(" ".repeat(bot_pad), Style::default().bg(palette.user_bg)),
                    ])
                    .style(Style::default().bg(palette.user_bg)),
                );

                lines.push(Line::from(""));
            }

            MessageSender::Persona { name, model, tier } => {
                let tier_str = match tier {
                    Tier::Free => "free",
                    Tier::Paid => "paid",
                };
                let persona_color = get_persona_color(name);
                let mut header_spans = vec![
                    Span::raw(" "),
                    Span::styled(
                        format!("⚡ {name}"),
                        Style::default().fg(persona_color).bold(),
                    ),
                    Span::styled(
                        format!("  ({model} • {tier_str})"),
                        Style::default().fg(palette.text_muted),
                    ),
                ];
                if msg.fell_back {
                    header_spans.push(Span::raw("  "));
                    header_spans.push(Span::styled(
                        "⚠ fallback",
                        Style::default().fg(Color::Yellow).bold(),
                    ));
                }
                lines.push(Line::from(header_spans));
                lines.push(Line::from(""));

                render_clean_markdown_body(&msg.content, &mut lines);
                lines.push(Line::from(""));
            }

            MessageSender::PipelineStep {
                step_index,
                total_steps,
                persona,
                model,
                tier,
            } => {
                let tier_str = match tier {
                    Tier::Free => "free",
                    Tier::Paid => "paid",
                };
                let persona_color = get_persona_color(persona);
                let mut header_spans = vec![
                    Span::raw(" "),
                    Span::styled(
                        format!("⚡ Step {}/{}: {persona}", step_index + 1, total_steps),
                        Style::default().fg(persona_color).bold(),
                    ),
                    Span::styled(
                        format!("  ({model} • {tier_str})"),
                        Style::default().fg(palette.text_muted),
                    ),
                ];
                if msg.fell_back {
                    header_spans.push(Span::raw("  "));
                    header_spans.push(Span::styled(
                        "⚠ fallback",
                        Style::default().fg(Color::Yellow).bold(),
                    ));
                }
                lines.push(Line::from(header_spans));
                lines.push(Line::from(""));

                render_clean_markdown_body(&msg.content, &mut lines);
                lines.push(Line::from(""));
            }

            MessageSender::Tool {
                command,
                exit_code,
                duration_ms,
            } => {
                let tool_bg = palette.tool_bg;

                lines.push(Line::from(""));

                // Header line: $ <command> (timeout 30s)
                let header_prefix = format!(" $ {command} ");
                let timeout_tag = "(timeout 30s)";
                let h_rem = full_width.saturating_sub(header_prefix.len() + timeout_tag.len());
                lines.push(
                    Line::from(vec![
                        Span::styled(
                            header_prefix,
                            Style::default()
                                .fg(Color::Rgb(170, 220, 180))
                                .bold()
                                .bg(tool_bg),
                        ),
                        Span::styled(" ".repeat(h_rem), Style::default().bg(tool_bg)),
                        Span::styled(
                            timeout_tag,
                            Style::default().fg(Color::Rgb(110, 130, 120)).bg(tool_bg),
                        ),
                    ])
                    .style(Style::default().bg(tool_bg)),
                );

                // Body content lines
                let raw_content = msg.content.trim();
                if !raw_content.is_empty() {
                    let content_lines: Vec<&str> = raw_content.lines().collect();
                    let total_c_lines = content_lines.len();

                    // Blank line inside tool box
                    lines.push(
                        Line::from(vec![Span::styled(
                            " ".repeat(full_width),
                            Style::default().bg(tool_bg),
                        )])
                        .style(Style::default().bg(tool_bg)),
                    );

                    if !app.expand_tool_outputs && total_c_lines > 6 {
                        let earlier_count = total_c_lines.saturating_sub(5);
                        let collapsed_msg =
                            format!(" ... ({earlier_count} earlier lines, ctrl+o to expand)");
                        let e_rem = full_width.saturating_sub(collapsed_msg.len());
                        lines.push(
                            Line::from(vec![
                                Span::styled(
                                    collapsed_msg,
                                    Style::default()
                                        .fg(Color::Rgb(140, 150, 145))
                                        .italic()
                                        .bg(tool_bg),
                                ),
                                Span::styled(" ".repeat(e_rem), Style::default().bg(tool_bg)),
                            ])
                            .style(Style::default().bg(tool_bg)),
                        );

                        for line in &content_lines[earlier_count..] {
                            let l_pad = full_width.saturating_sub(line.len() + 1);
                            lines.push(
                                Line::from(vec![
                                    Span::raw(" ").style(Style::default().bg(tool_bg)),
                                    Span::styled(
                                        *line,
                                        Style::default().fg(Color::Rgb(210, 215, 210)).bg(tool_bg),
                                    ),
                                    Span::styled(" ".repeat(l_pad), Style::default().bg(tool_bg)),
                                ])
                                .style(Style::default().bg(tool_bg)),
                            );
                        }
                    } else {
                        for line in &content_lines {
                            let l_pad = full_width.saturating_sub(line.len() + 1);
                            lines.push(
                                Line::from(vec![
                                    Span::raw(" ").style(Style::default().bg(tool_bg)),
                                    Span::styled(
                                        *line,
                                        Style::default().fg(Color::Rgb(210, 215, 210)).bg(tool_bg),
                                    ),
                                    Span::styled(" ".repeat(l_pad), Style::default().bg(tool_bg)),
                                ])
                                .style(Style::default().bg(tool_bg)),
                            );
                        }
                    }

                    // Blank line inside tool box
                    lines.push(
                        Line::from(vec![Span::styled(
                            " ".repeat(full_width),
                            Style::default().bg(tool_bg),
                        )])
                        .style(Style::default().bg(tool_bg)),
                    );
                }

                // Took Xs duration footer
                let duration_s = (*duration_ms as f64) / 1000.0;
                let took_str = format!(" Took {:.1}s", duration_s);
                let exit_str = if *exit_code != 0 {
                    format!(" [exit {}]", exit_code)
                } else {
                    String::new()
                };
                let f_rem = full_width.saturating_sub(took_str.len() + exit_str.len());
                let mut footer_spans = vec![Span::styled(
                    took_str,
                    Style::default().fg(Color::Rgb(130, 140, 135)).bg(tool_bg),
                )];
                if *exit_code != 0 {
                    footer_spans.push(Span::styled(
                        exit_str,
                        Style::default().fg(Color::LightRed).bg(tool_bg),
                    ));
                }
                footer_spans.push(Span::styled(
                    " ".repeat(f_rem),
                    Style::default().bg(tool_bg),
                ));

                lines.push(Line::from(footer_spans).style(Style::default().bg(tool_bg)));
                lines.push(Line::from(""));
            }

            MessageSender::System => {
                for text_line in msg.content.lines() {
                    lines.push(Line::from(vec![
                        Span::raw(" "),
                        Span::styled(
                            text_line.to_string(),
                            Style::default().fg(palette.text_muted),
                        ),
                    ]));
                }
                lines.push(Line::from(""));
            }
        }
    }

    let total_lines = lines.len();
    let inner_height = area.height as usize;
    let scroll_y = if app.auto_scroll {
        total_lines.saturating_sub(inner_height) as u16
    } else {
        total_lines
            .saturating_sub(inner_height)
            .saturating_sub(app.scroll_offset as usize) as u16
    };

    let paragraph = Paragraph::new(lines)
        .wrap(Wrap { trim: false })
        .scroll((scroll_y, 0));

    frame.render_widget(paragraph, area);
}

fn render_clean_markdown_body(content: &str, lines: &mut Vec<Line>) {
    let mut in_code_block = false;

    for line in content.lines() {
        if line.trim_start().starts_with("```") {
            in_code_block = !in_code_block;
            lines.push(Line::from(vec![
                Span::raw(" "),
                Span::styled(
                    line.to_string(),
                    Style::default().fg(Color::DarkGray).bold(),
                ),
            ]));
        } else if in_code_block {
            lines.push(Line::from(vec![
                Span::raw(" "),
                Span::styled(line.to_string(), Style::default().fg(Color::LightCyan)),
            ]));
        } else {
            lines.push(Line::from(parse_markdown_line_spans(line)));
        }
    }
}

fn parse_markdown_line_spans(line: &str) -> Vec<Span<'static>> {
    let mut spans = Vec::new();
    spans.push(Span::raw(" "));

    let trimmed = line.trim();
    if trimmed.is_empty() {
        return spans;
    }

    // Italic thought / preamble
    if (trimmed.starts_with('*') && trimmed.ends_with('*') && !trimmed.starts_with("**"))
        || (trimmed.starts_with('_') && trimmed.ends_with('_'))
        || trimmed.starts_with("Report. Maybe")
        || trimmed.starts_with("Honest answer.")
        || trimmed.starts_with("Yes, briefly.")
    {
        spans.push(Span::styled(
            line.to_string(),
            Style::default()
                .fg(Color::Rgb(140, 140, 150))
                .add_modifier(Modifier::ITALIC),
        ));
        return spans;
    }

    // Bullet point
    if trimmed.starts_with("- ") || trimmed.starts_with("* ") {
        spans.push(Span::styled("- ", Style::default().fg(Color::Cyan)));
        parse_inline_spans(&trimmed[2..], &mut spans);
        return spans;
    }

    parse_inline_spans(line, &mut spans);
    spans
}

fn parse_inline_spans(text: &str, spans: &mut Vec<Span<'static>>) {
    let mut rest = text;
    while let Some(start) = rest.find('`') {
        if start > 0 {
            spans.push(Span::styled(
                rest[..start].to_string(),
                Style::default().fg(Color::White),
            ));
        }
        let after_start = &rest[start + 1..];
        if let Some(end) = after_start.find('`') {
            let code_token = &after_start[..end];
            spans.push(Span::styled(
                code_token.to_string(),
                Style::default()
                    .fg(Color::LightCyan)
                    .add_modifier(Modifier::BOLD),
            ));
            rest = &after_start[end + 1..];
        } else {
            spans.push(Span::styled(
                rest[start..].to_string(),
                Style::default().fg(Color::White),
            ));
            return;
        }
    }

    if !rest.is_empty() {
        spans.push(Span::styled(
            rest.to_string(),
            Style::default().fg(Color::White),
        ));
    }
}

fn render_minimal_input(frame: &mut Frame, app: &AppState, area: Rect, palette: &ThemePalette) {
    let input_line = if app.input.is_empty() {
        Line::from(vec![
            Span::styled("▌ ", Style::default().fg(palette.accent)),
            Span::styled(
                "Ask anything or type / for commands...",
                Style::default().fg(palette.text_muted).italic(),
            ),
        ])
    } else {
        Line::from(vec![
            Span::styled("▌ ", Style::default().fg(palette.accent)),
            Span::styled(&app.input, Style::default().fg(palette.text_bright)),
        ])
    };
    frame.render_widget(Paragraph::new(input_line), area);

    // Terminal cursor positioning
    let cursor_x = area.x + 2 + (app.cursor_pos as u16);
    let cursor_y = area.y;
    if cursor_x < area.x + area.width {
        frame.set_cursor_position(Position {
            x: cursor_x,
            y: cursor_y,
        });
    }
}

fn render_workings_pane(frame: &mut Frame, app: &AppState, area: Rect, palette: &ThemePalette) {
    let is_pipeline = !app.workings.pipeline_steps.is_empty();
    let title_str = if is_pipeline {
        " pipeline flow "
    } else {
        " routing & models "
    };

    let block = Block::default()
        .borders(Borders::LEFT)
        .border_style(Style::default().fg(palette.card_border))
        .title(Span::styled(
            title_str,
            Style::default().fg(palette.text_muted).bold(),
        ));

    let inner = block.inner(area);
    frame.render_widget(block, area);

    let mut lines: Vec<Line> = Vec::new();
    let spinner_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
    let sp = spinner_frames[app.spinner_tick % spinner_frames.len()];

    if is_pipeline {
        // Render Animated Multi-Agent Pipeline Flow
        let pipe_name = app
            .workings
            .active_pipeline
            .as_deref()
            .unwrap_or("build-and-review");

        lines.push(Line::from(vec![
            Span::raw(" "),
            Span::styled(
                format!("⚡ pipeline: {pipe_name}"),
                Style::default().fg(palette.accent).bold(),
            ),
        ]));
        lines.push(Line::from(""));

        let total_steps = app.workings.pipeline_steps.len();
        for (idx, step) in app.workings.pipeline_steps.iter().enumerate() {
            if idx > 0 {
                let prev_completed = app.workings.pipeline_steps[idx - 1].is_completed;
                let (connector_str, connector_color) = if prev_completed && step.is_active {
                    let anim_frames = ["  │  ", "  ╽  ", "  ┃  ", "  ▼  "];
                    let a = anim_frames[(app.spinner_tick / 2) % anim_frames.len()];
                    (a, palette.accent)
                } else if prev_completed && step.is_completed {
                    ("  │  ", Color::LightGreen)
                } else {
                    ("  ·  ", palette.text_muted)
                };

                lines.push(Line::from(vec![Span::styled(
                    connector_str,
                    Style::default().fg(connector_color).bold(),
                )]));
            }

            if step.is_active {
                lines.push(Line::from(vec![
                    Span::raw(" "),
                    Span::styled(
                        format!("[{sp}] "),
                        Style::default().fg(palette.accent).bold(),
                    ),
                    Span::styled(
                        format!("{}. {}", idx + 1, step.persona),
                        Style::default().fg(palette.text_bright).bold(),
                    ),
                ]));
                let model_label = truncate_str(&step.model, inner.width.saturating_sub(7) as usize);
                lines.push(Line::from(vec![
                    Span::raw("     "),
                    Span::styled(
                        format!("↳ {model_label}"),
                        Style::default().fg(Color::LightCyan),
                    ),
                ]));
            } else if step.is_completed {
                lines.push(Line::from(vec![
                    Span::raw(" "),
                    Span::styled("[✔] ", Style::default().fg(Color::LightGreen).bold()),
                    Span::styled(
                        format!("{}. {}", idx + 1, step.persona),
                        Style::default().fg(Color::White).bold(),
                    ),
                ]));
                let model_label = truncate_str(&step.model, inner.width.saturating_sub(7) as usize);
                let tier_str = if step.tier == Tier::Paid {
                    "paid"
                } else {
                    "free"
                };
                let mut status_spans = vec![
                    Span::raw("     "),
                    Span::styled(
                        format!("served ({model_label} • {tier_str})"),
                        Style::default().fg(Color::Green),
                    ),
                ];
                if step.fell_back {
                    status_spans.push(Span::styled(
                        " [fallback]",
                        Style::default().fg(Color::Yellow),
                    ));
                }
                lines.push(Line::from(status_spans));
            } else {
                lines.push(Line::from(vec![
                    Span::raw(" "),
                    Span::styled("[○] ", Style::default().fg(palette.text_muted)),
                    Span::styled(
                        format!("{}. {}", idx + 1, step.persona),
                        Style::default().fg(palette.text_muted),
                    ),
                ]));
                lines.push(Line::from(vec![
                    Span::raw("     "),
                    Span::styled(
                        format!("queued ({}/{})", idx + 1, total_steps),
                        Style::default().fg(palette.text_muted).italic(),
                    ),
                ]));
            }
        }
    } else if app.workings.route_stage.is_some() || !app.workings.candidate_attempts.is_empty() {
        // Render Single Persona Routing Telemetry & Cascade Attempts
        if let Some(stage) = &app.workings.route_stage {
            lines.push(Line::from(vec![
                Span::raw(" "),
                Span::styled("⚡ ", Style::default().fg(palette.accent).bold()),
                Span::styled(stage.clone(), Style::default().fg(palette.accent).bold()),
            ]));
            if let Some(details) = &app.workings.route_details {
                let d_trunc = truncate_str(details, inner.width.saturating_sub(4) as usize);
                lines.push(Line::from(vec![
                    Span::raw("   "),
                    Span::styled(d_trunc, Style::default().fg(palette.text_muted)),
                ]));
            }
            if let Some(score) = app.workings.complexity_score {
                let filled = (score as usize).min(10);
                let empty = 10 - filled;
                let bar_str = format!("{}{}", "■".repeat(filled), "□".repeat(empty));
                let color = if score >= 7 {
                    Color::Yellow
                } else {
                    Color::Green
                };
                let esc_tag = if score >= 7 {
                    " [paid escalation]"
                } else {
                    " [free tier]"
                };
                lines.push(Line::from(vec![
                    Span::raw("   "),
                    Span::styled(
                        format!("[{bar_str}] {score}/10{esc_tag}"),
                        Style::default().fg(color).bold(),
                    ),
                ]));
            }
            lines.push(Line::from(""));
        }

        if !app.workings.candidate_attempts.is_empty() {
            lines.push(Line::from(vec![
                Span::raw(" "),
                Span::styled(
                    "candidates evaluated:",
                    Style::default().fg(palette.text_muted).bold(),
                ),
            ]));

            for att in &app.workings.candidate_attempts {
                let (icon, color) = if att.is_success {
                    ("•", Color::LightGreen)
                } else if att.is_error {
                    ("✖", Color::LightRed)
                } else {
                    (sp, Color::Yellow)
                };

                let tier_str = match att.tier {
                    Tier::Free => "free",
                    Tier::Paid => "paid",
                };

                let model_display =
                    truncate_str(&att.model, inner.width.saturating_sub(6) as usize);

                lines.push(Line::from(vec![
                    Span::raw(" "),
                    Span::styled(format!("{icon} "), Style::default().fg(color).bold()),
                    Span::styled(
                        model_display,
                        Style::default()
                            .fg(if att.is_success {
                                palette.text_bright
                            } else {
                                Color::Gray
                            })
                            .bold(),
                    ),
                ]));

                let status_text = if att.is_success {
                    format!("  served [{tier_str}]")
                } else if att.is_error {
                    let err_short =
                        truncate_str(&att.status, inner.width.saturating_sub(6) as usize);
                    format!("  failed: {err_short}")
                } else {
                    format!("  attempting [{tier_str}]...")
                };

                lines.push(Line::from(vec![
                    Span::raw(" "),
                    Span::styled(
                        status_text,
                        if att.is_error {
                            Style::default().fg(Color::LightRed).italic()
                        } else if att.is_success {
                            Style::default().fg(Color::LightGreen)
                        } else {
                            Style::default().fg(palette.text_muted)
                        },
                    ),
                ]));

                if att.is_error {
                    lines.push(Line::from(vec![
                        Span::raw(" "),
                        Span::styled(
                            "  ↳ cascading to fallback...",
                            Style::default().fg(Color::Yellow).italic(),
                        ),
                    ]));
                }
                lines.push(Line::from(""));
            }
        }
    } else {
        // Idle state: Helpful team & feature overview
        lines.push(Line::from(vec![
            Span::raw(" "),
            Span::styled(
                "team status: ready",
                Style::default().fg(palette.accent).bold(),
            ),
        ]));
        lines.push(Line::from(""));
        lines.push(Line::from(vec![
            Span::raw(" "),
            Span::styled(
                "available personas:",
                Style::default().fg(palette.text_muted).bold(),
            ),
        ]));
        for p in app.persona_items.iter().take(5) {
            let p_color = get_persona_color(&p.name);
            lines.push(Line::from(vec![
                Span::raw("  • "),
                Span::styled(&p.name, Style::default().fg(p_color).bold()),
            ]));
        }
        if !app.pipelines.is_empty() {
            lines.push(Line::from(""));
            lines.push(Line::from(vec![
                Span::raw(" "),
                Span::styled(
                    "pipelines (ctrl+p):",
                    Style::default().fg(palette.text_muted).bold(),
                ),
            ]));
            for pipe in &app.pipelines {
                lines.push(Line::from(vec![
                    Span::raw("  ⚡ "),
                    Span::styled(&pipe.name, Style::default().fg(Color::Yellow)),
                ]));
            }
        }
        lines.push(Line::from(""));
        lines.push(Line::from(vec![
            Span::raw(" "),
            Span::styled("shortcuts:", Style::default().fg(palette.text_muted).bold()),
        ]));
        lines.push(Line::from(vec![
            Span::styled("  Tab   ", Style::default().fg(palette.accent)),
            Span::styled("Select persona", Style::default().fg(palette.text_muted)),
        ]));
        lines.push(Line::from(vec![
            Span::styled("  Ctrl+P", Style::default().fg(palette.accent)),
            Span::styled("Run pipeline", Style::default().fg(palette.text_muted)),
        ]));
        lines.push(Line::from(vec![
            Span::styled("  Ctrl+S", Style::default().fg(palette.accent)),
            Span::styled("Saved sessions", Style::default().fg(palette.text_muted)),
        ]));
        lines.push(Line::from(vec![
            Span::styled("  /theme", Style::default().fg(palette.accent)),
            Span::styled("Color palettes", Style::default().fg(palette.text_muted)),
        ]));
    }

    let para = Paragraph::new(lines).wrap(Wrap { trim: false });
    frame.render_widget(para, inner);
}

fn render_footer(frame: &mut Frame, app: &AppState, area: Rect, palette: &ThemePalette) {
    let active_str = if app.is_auto_route() {
        "(auto)".to_string()
    } else {
        format!("({})", app.current_persona_name())
    };

    let active_model = if let Some(att) = app
        .workings
        .candidate_attempts
        .iter()
        .find(|a| a.is_success)
    {
        att.model.as_str()
    } else {
        app.current_persona_name()
    };

    let stealth_str = if app.allow_stealth {
        "stealth • free"
    } else {
        "free"
    };

    let left_spans = vec![Span::styled(
        format!(
            "↑{} ↓{}  1m: {}/{}  24h: {}/{}  {active_str}",
            AppState::format_tokens(app.tokens_in),
            AppState::format_tokens(app.tokens_out),
            app.minute_requests,
            app.minute_limit,
            app.daily_requests,
            app.daily_limit
        ),
        Style::default().fg(palette.text_muted),
    )];

    let right_spans = vec![Span::styled(
        format!("{active_model} • {stealth_str}"),
        Style::default().fg(palette.text_muted),
    )];

    let footer_layout = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(60), Constraint::Percentage(40)])
        .split(area);

    frame.render_widget(Paragraph::new(Line::from(left_spans)), footer_layout[0]);
    frame.render_widget(
        Paragraph::new(Line::from(right_spans)).alignment(Alignment::Right),
        footer_layout[1],
    );
}

fn render_persona_popup(frame: &mut Frame, app: &AppState, palette: &ThemePalette) {
    let area = centered_rect(55, 55, frame.area());
    frame.render_widget(Clear, area);

    let items: Vec<ListItem> = app
        .persona_items
        .iter()
        .enumerate()
        .map(|(idx, item)| {
            let is_selected = idx == app.selected_persona_idx;
            let prefix = if is_selected { "> " } else { "  " };

            let line = Line::from(vec![
                Span::styled(
                    format!("{prefix}{:<12} ", item.name),
                    if is_selected {
                        Style::default()
                            .fg(palette.accent)
                            .add_modifier(Modifier::BOLD)
                    } else {
                        Style::default().fg(get_persona_color(&item.name))
                    },
                ),
                Span::styled(
                    item.description.clone(),
                    Style::default().fg(palette.text_muted),
                ),
            ]);

            if is_selected {
                ListItem::new(line).style(Style::default().bg(Color::Rgb(30, 30, 45)))
            } else {
                ListItem::new(line)
            }
        })
        .collect();

    let list = List::new(items).block(
        Block::default()
            .borders(Borders::ALL)
            .border_type(BorderType::Rounded)
            .border_style(Style::default().fg(palette.accent))
            .title(Span::styled(
                " select persona [up/down, enter select, esc cancel] ",
                Style::default()
                    .fg(palette.accent)
                    .add_modifier(Modifier::BOLD),
            )),
    );

    frame.render_widget(list, area);
}

fn render_pipeline_popup(frame: &mut Frame, app: &AppState, palette: &ThemePalette) {
    let area = centered_rect(60, 50, frame.area());
    frame.render_widget(Clear, area);

    let items: Vec<ListItem> = if app.pipelines.is_empty() {
        vec![ListItem::new("no pipelines configured in personas.toml")]
    } else {
        app.pipelines
            .iter()
            .enumerate()
            .map(|(idx, pipe)| {
                let is_selected = idx == app.selected_pipeline_idx;
                let prefix = if is_selected { "> " } else { "  " };

                let steps: Vec<String> = pipe.steps.iter().map(|s| s.persona.clone()).collect();
                let steps_str = steps.join(" -> ");

                let line = Line::from(vec![
                    Span::styled(
                        format!("{prefix}{:<18} ", pipe.name),
                        if is_selected {
                            Style::default()
                                .fg(Color::Yellow)
                                .add_modifier(Modifier::BOLD)
                        } else {
                            Style::default().fg(Color::White)
                        },
                    ),
                    Span::styled(
                        format!("({steps_str})"),
                        Style::default().fg(palette.text_muted),
                    ),
                ]);

                if is_selected {
                    ListItem::new(line).style(Style::default().bg(Color::Rgb(45, 35, 20)))
                } else {
                    ListItem::new(line)
                }
            })
            .collect()
    };

    let list = List::new(items).block(
        Block::default()
            .borders(Borders::ALL)
            .border_type(BorderType::Rounded)
            .border_style(Style::default().fg(Color::Yellow))
            .title(Span::styled(
                " select pipeline [up/down, enter run, esc cancel] ",
                Style::default()
                    .fg(Color::Yellow)
                    .add_modifier(Modifier::BOLD),
            )),
    );

    frame.render_widget(list, area);
}

fn render_session_popup(frame: &mut Frame, app: &AppState, palette: &ThemePalette) {
    let area = centered_rect(65, 55, frame.area());
    frame.render_widget(Clear, area);

    let items: Vec<ListItem> = if app.session_summaries.is_empty() {
        vec![ListItem::new("no saved sessions yet")]
    } else {
        app.session_summaries
            .iter()
            .enumerate()
            .map(|(idx, s)| {
                let is_selected = idx == app.selected_session_idx;
                let prefix = if is_selected { "> " } else { "  " };

                let line = Line::from(vec![
                    Span::styled(
                        format!("{prefix}{:<24} ", truncate_str(&s.title, 24)),
                        if is_selected {
                            Style::default()
                                .fg(palette.accent)
                                .add_modifier(Modifier::BOLD)
                        } else {
                            Style::default().fg(Color::White)
                        },
                    ),
                    Span::styled(
                        format!(
                            "[{}] ({} msgs) - {}",
                            s.persona,
                            s.message_count,
                            truncate_str(&s.updated_at, 19)
                        ),
                        Style::default().fg(palette.text_muted),
                    ),
                ]);

                if is_selected {
                    ListItem::new(line).style(Style::default().bg(Color::Rgb(30, 30, 45)))
                } else {
                    ListItem::new(line)
                }
            })
            .collect()
    };

    let list = List::new(items).block(
        Block::default()
            .borders(Borders::ALL)
            .border_type(BorderType::Rounded)
            .border_style(Style::default().fg(palette.accent))
            .title(Span::styled(
                " saved sessions [up/down, enter resume, esc cancel] ",
                Style::default()
                    .fg(palette.accent)
                    .add_modifier(Modifier::BOLD),
            )),
    );

    frame.render_widget(list, area);
}

fn render_theme_popup(frame: &mut Frame, app: &AppState, palette: &ThemePalette) {
    let area = centered_rect(60, 48, frame.area());
    frame.render_widget(Clear, area);

    let items: Vec<ListItem> = THEMES
        .iter()
        .enumerate()
        .map(|(idx, (name, desc))| {
            let is_selected = idx == app.selected_theme_idx;
            let is_active = *name == app.current_theme;
            let prefix = if is_selected { "→ " } else { "  " };

            let mut spans = vec![
                Span::styled(
                    format!("{prefix}{:<12} ", name),
                    if is_selected {
                        Style::default()
                            .fg(palette.accent)
                            .add_modifier(Modifier::BOLD)
                    } else {
                        Style::default().fg(palette.text_bright)
                    },
                ),
                Span::styled(*desc, Style::default().fg(palette.text_muted)),
            ];

            if is_active {
                spans.push(Span::styled(
                    " [active]",
                    Style::default().fg(Color::LightGreen).bold(),
                ));
            }

            let line = Line::from(spans);
            if is_selected {
                ListItem::new(line).style(Style::default().bg(Color::Rgb(32, 38, 54)))
            } else {
                ListItem::new(line)
            }
        })
        .collect();

    let list = List::new(items).block(
        Block::default()
            .borders(Borders::ALL)
            .border_type(BorderType::Rounded)
            .border_style(Style::default().fg(palette.accent))
            .title(Span::styled(
                " select theme [up/down, enter apply, esc cancel] ",
                Style::default()
                    .fg(palette.accent)
                    .add_modifier(Modifier::BOLD),
            )),
    );

    frame.render_widget(list, area);
}

fn get_persona_color(name: &str) -> Color {
    match name.to_lowercase().as_str() {
        "coder" => Color::LightGreen,
        "reviewer" => Color::LightYellow,
        "architect" => Color::LightBlue,
        "researcher" => Color::LightMagenta,
        "summarizer" => Color::LightCyan,
        _ => Color::White,
    }
}

fn truncate_str(s: &str, max: usize) -> String {
    if s.len() <= max {
        s.to_string()
    } else {
        format!("{}...", &s[..max.saturating_sub(3)])
    }
}

fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
    let popup_layout = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Percentage((100 - percent_y) / 2),
            Constraint::Percentage(percent_y),
            Constraint::Percentage((100 - percent_y) / 2),
        ])
        .split(r);

    Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Percentage((100 - percent_x) / 2),
            Constraint::Percentage(percent_x),
            Constraint::Percentage((100 - percent_x) / 2),
        ])
        .split(popup_layout[1])[1]
}