cryptic_tui/

ui.rs

//! Terminal user interface rendering.
//!
//! This module handles all UI rendering using the Ratatui framework.
//! It provides functions to draw the splash screen, main screen with tabs,
//! and all UI components including message history with date separators.
//!
//! # Layout
//!
//! The main screen consists of:
//! - Tab bar at the top
//! - Tab content area
//! - Status bar at the bottom
//!
//! ## Available Tabs
//!
//! - **Chat**: User list and message history with infinite scrolling
//! - **Admin**: Administrative functions
//! - **Status**: Connection and system status
//! - **Help**: Keyboard shortcuts and help
//!
//! # Message Display
//!
//! Messages are rendered with:
//! - Date separators ("Today", "Yesterday", or formatted dates)
//! - Timestamps in 12-hour format (HH:MM AM/PM)
//! - Emoji and markdown formatting via the [`formatting`] module
//! - Loading indicators for history pagination
//! - Scroll position indicators

use chrono::{Local, TimeZone};
use ratatui::{
    layout::{Constraint, Direction, Layout, Rect},
    style::{Color, Modifier, Style},
    text::{Line, Span},
    widgets::{Block, Borders, List, ListItem, Paragraph, Tabs, Wrap},
    Frame,
};

use crate::app::{AdminField, App, AppScreen, Tab};
use crate::formatting;

/// Main drawing function - delegates to splash or main screen.
///
/// # Arguments
///
/// * `f` - Ratatui frame to draw on
/// * `app` - Application state
pub fn draw(f: &mut Frame, app: &App) {
    if app.screen == AppScreen::Splash {
        render_splash(f, app, f.area());
        return;
    }

    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(3), // Tab bar
            Constraint::Min(0),    // Content area
            Constraint::Length(1), // Status bar
        ])
        .split(f.area());

    render_tabs(f, app, chunks[0]);

    match app.active_tab {
        Tab::Chat => render_chat_tab(f, app, chunks[1]),
        Tab::Admin => render_admin_tab(f, app, chunks[1]),
        Tab::Status => render_status_tab(f, app, chunks[1]),
        Tab::Help => render_help_tab(f, app, chunks[1]),
    }

    // Render status bar at the bottom
    render_status_bar(f, app, chunks[2]);
}

fn render_tabs(f: &mut Frame, app: &App, area: Rect) {
    // Explicit type annotation to satisfy collect inference
    let titles: Vec<Line<'static>> = ["Chat", "Admin", "Status", "Help"]
        .iter()
        .map(|t| Line::from(*t))
        .collect();

    let tabs = Tabs::new(titles)
        .block(Block::default().borders(Borders::ALL).title("Cryptic TUI"))
        .select(app.active_tab as usize)
        .style(Style::default().fg(Color::White))
        .highlight_style(
            Style::default()
                .fg(Color::Cyan)
                .add_modifier(Modifier::BOLD),
        );

    f.render_widget(tabs, area);
}

fn render_chat_tab(f: &mut Frame, app: &App, area: Rect) {
    let chunks = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Percentage(30), // User list
            Constraint::Percentage(70), // Chat area
        ])
        .split(area);

    // Render user list
    render_user_list(f, app, chunks[0]);

    // Render chat area
    render_chat_area(f, app, chunks[1]);
}

fn render_user_list(f: &mut Frame, app: &App, area: Rect) {
    let users: Vec<ListItem> = app
        .users
        .iter()
        .enumerate()
        .map(|(i, user)| {
            let status = if user.online { "●" } else { "○" };
            let style = if i == app.selected_user {
                Style::default()
                    .fg(Color::Cyan)
                    .add_modifier(Modifier::BOLD)
            } else {
                Style::default()
            };

            let content = format!(
                "{} {} {}",
                status,
                user.name,
                if user.online { "online" } else { "offline" }
            );

            ListItem::new(content).style(style)
        })
        .collect();

    let user_list = List::new(users)
        .block(
            Block::default()
                .borders(Borders::ALL)
                .title("Users (↑/↓ to select, Enter to chat)"),
        )
        .style(Style::default().fg(Color::White));

    f.render_widget(user_list, area);
}

fn render_chat_area(f: &mut Frame, app: &App, area: Rect) {
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(3), // Chat header
            Constraint::Min(0),    // Messages
            Constraint::Length(3), // Input box
        ])
        .split(area);

    // Chat header
    let peer_name = app.current_peer.as_deref().unwrap_or("No chat selected");
    let header = Paragraph::new(format!("Chat with: {}", peer_name))
        .block(Block::default().borders(Borders::ALL))
        .style(
            Style::default()
                .fg(Color::Green)
                .add_modifier(Modifier::BOLD),
        );
    f.render_widget(header, chunks[0]);

    // Messages
    render_messages(f, app, chunks[1]);

    // Input box with cursor and horizontal scrolling
    let input_width = chunks[2].width.saturating_sub(2) as usize; // subtract borders
    let cursor_pos = app.input_cursor;

    // Calculate horizontal scroll to keep cursor visible
    let scroll_offset = if cursor_pos >= input_width {
        cursor_pos - input_width + 1
    } else {
        0
    };

    let input = Paragraph::new(app.input_buffer.as_str())
        .block(
            Block::default()
                .borders(Borders::ALL)
                .title("Message (Enter to send, Tab for next tab)"),
        )
        .style(Style::default().fg(Color::White))
        .scroll((0, scroll_offset as u16)); // Horizontal scroll

    f.render_widget(input, chunks[2]);

    // Set cursor position in the input area
    if app.current_peer.is_some() {
        let cursor_x = chunks[2].x + 1 + (cursor_pos.saturating_sub(scroll_offset)) as u16;
        let cursor_y = chunks[2].y + 1;
        f.set_cursor_position((cursor_x, cursor_y));
    }
}

fn render_messages(f: &mut Frame, app: &App, area: Rect) {
    let mut lines: Vec<Line> = Vec::new();
    let mut current_scroll_offset: usize = 0;
    let mut has_messages = false;

    if let Some(peer) = &app.current_peer {
        if let Some(conv) = app.get_conversation(peer) {
            has_messages = !conv.messages.is_empty();
            current_scroll_offset = conv.scroll_offset;
            // Show loading indicator if loading history
            if conv.is_loading {
                lines.push(Line::from(Span::styled(
                    "⏳ Loading older messages...",
                    Style::default()
                        .fg(Color::Gray)
                        .add_modifier(Modifier::ITALIC),
                )));
            }

            // Show "no more history" indicator if at top and exhausted
            if !conv.has_more_history && !conv.messages.is_empty() {
                lines.push(Line::from(Span::styled(
                    "─── Beginning of conversation ───",
                    Style::default().fg(Color::DarkGray),
                )));
            }

            // Render messages with date separators
            let mut last_date: Option<String> = None;

            for msg in conv.messages.iter() {
                let msg_date = format_message_date(msg.timestamp);

                // Insert date separator if date changed
                if last_date.as_ref() != Some(&msg_date) {
                    lines.push(Line::from(Span::styled(
                        format!("─── {} ───", msg_date),
                        Style::default()
                            .fg(Color::Blue)
                            .add_modifier(Modifier::BOLD),
                    )));
                    last_date = Some(msg_date);
                }

                // Format message with timestamp
                let time_str = format_message_time(msg.timestamp);
                let base_color = if msg.is_sent {
                    Color::Cyan
                } else {
                    Color::Yellow
                };

                let prefix = if msg.is_sent { "me" } else { &msg.from };

                // Process message content for emoji and markdown
                let formatted_content = formatting::process_text(&msg.content);

                // Build the line with timestamp, prefix, and formatted content
                let mut line_spans = vec![
                    Span::styled(format!("[{}] ", time_str), Style::default().fg(base_color)),
                    Span::styled(format!("{}: ", prefix), Style::default().fg(base_color)),
                ];

                // Add formatted content spans with base color applied
                for span in formatted_content.spans {
                    let mut style = span.style;
                    // Preserve formatting modifiers but use base color if no color set
                    if style.fg.is_none() {
                        style.fg = Some(base_color);
                    }
                    line_spans.push(Span::styled(span.content, style));
                }

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

            // Show scroll position indicator
            if has_messages {
                let scroll_info = if current_scroll_offset > 0 {
                    format!("↑ Scrolled up {} lines | Ctrl+U/D or PgUp/PgDn to scroll | Home/End to jump", 
                            current_scroll_offset)
                } else {
                    "↓ At newest messages | Ctrl+U or PgUp to scroll up".to_string()
                };

                lines.push(Line::from(Span::styled(
                    scroll_info,
                    Style::default()
                        .fg(Color::DarkGray)
                        .add_modifier(Modifier::ITALIC),
                )));
            }

            if lines.is_empty() {
                lines.push(Line::from("No messages yet. Start typing!"));
            }
        } else {
            lines.push(Line::from("No messages yet. Start typing!"));
        }
    } else {
        lines.push(Line::from("Select a user from the list to start chatting"));
    }

    let title = if let Some(peer) = &app.current_peer {
        format!("Messages - {}", peer)
    } else {
        "Messages".to_string()
    };

    // Calculate scroll position using rendered line heights to account for wrapping
    let inner_width = area.width.saturating_sub(2) as usize; // subtract borders
    let inner_width = inner_width.max(1);
    let visible_height = area.height.saturating_sub(2) as usize; // subtract borders
    let visible_height = visible_height.max(1);

    let total_height: usize = lines
        .iter()
        .map(|line| line_display_height(line, inner_width))
        .sum();

    let bottom_start = total_height.saturating_sub(visible_height);
    let effective_offset = current_scroll_offset.min(bottom_start);
    let scroll_y_lines = bottom_start.saturating_sub(effective_offset);
    let scroll_y = scroll_y_lines.min(u16::MAX as usize) as u16;

    if has_messages {
        if let Some(last_line) = lines.last_mut() {
            let scroll_info = if effective_offset > 0 {
                format!(
                    "↑ Scrolled up {} lines | Ctrl+U/D or PgUp/PgDn to scroll | Home/End to jump",
                    effective_offset
                )
            } else {
                "↓ At newest messages | Ctrl+U or PgUp to scroll up".to_string()
            };

            *last_line = Line::from(Span::styled(
                scroll_info,
                Style::default()
                    .fg(Color::DarkGray)
                    .add_modifier(Modifier::ITALIC),
            ));
        }
    }

    let paragraph = Paragraph::new(lines)
        .block(Block::default().borders(Borders::ALL).title(title))
        .style(Style::default().fg(Color::White))
        .scroll((scroll_y, 0)) // Scroll vertically by scroll_y lines
        .wrap(Wrap { trim: false }); // Enable word wrapping, preserve leading spaces

    f.render_widget(paragraph, area);
}

/// Estimate how many terminal rows a line will occupy once wrapped.
fn line_display_height(line: &Line, available_width: usize) -> usize {
    if available_width == 0 {
        return 1;
    }

    let width = line.width();
    if width == 0 {
        1
    } else {
        // Ceiling division to determine how many rows the line spans
        (width + available_width - 1) / available_width
    }
}

/// Format timestamp as a date label for message grouping.
/// Returns "Today", "Yesterday", or "Mon, Jan 15, 2025"
fn format_message_date(timestamp: u64) -> String {
    // Convert u64 to i64 safely (timestamps shouldn't exceed i64::MAX)
    let timestamp_i64 = timestamp.min(i64::MAX as u64) as i64;

    let msg_time = match Local.timestamp_opt(timestamp_i64, 0) {
        chrono::LocalResult::Single(dt) => dt,
        _ => return "Unknown date".to_string(),
    };

    let now = Local::now();
    let msg_date = msg_time.date_naive();
    let today = now.date_naive();

    if msg_date == today {
        "Today".to_string()
    } else if msg_date == today - chrono::Duration::days(1) {
        "Yesterday".to_string()
    } else {
        msg_time.format("%a, %b %d, %Y").to_string()
    }
}

/// Format timestamp as time for individual messages.
/// Returns "10:23 AM" format
fn format_message_time(timestamp: u64) -> String {
    // Convert u64 to i64 safely (timestamps shouldn't exceed i64::MAX)
    let timestamp_i64 = timestamp.min(i64::MAX as u64) as i64;

    match Local.timestamp_opt(timestamp_i64, 0) {
        chrono::LocalResult::Single(dt) => dt.format("%I:%M %p").to_string(),
        _ => "??:??".to_string(),
    }
}

fn render_admin_tab(f: &mut Frame, app: &App, area: Rect) {
    use crate::app::AdminMode;

    match app.admin_mode {
        AdminMode::Menu => render_admin_menu(f, app, area),
        AdminMode::RegisterUser => render_admin_register(f, app, area),
        AdminMode::SuspendUser => render_admin_suspend(f, app, area),
        AdminMode::ReactivateUser => render_admin_reactivate(f, app, area),
        AdminMode::RevokeUser => render_admin_revoke(f, app, area),
        AdminMode::ListCertificates => render_admin_certificates(f, app, area),
    }
}fn render_admin_menu(f: &mut Frame, app: &App, area: Rect) {
    let mut content = vec![
        Line::from(Span::styled(
            "Admin Panel - User Management",
            Style::default()
                .fg(Color::Cyan)
                .add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
        Line::from("Available actions:"),
        Line::from(""),
        Line::from(vec![
            Span::styled("  l", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
            Span::raw(" - List registered users"),
        ]),
        Line::from(vec![
            Span::styled("  r", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
            Span::raw(" - Register new user"),
        ]),
        Line::from(vec![
            Span::styled("  s", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
            Span::raw(" - Suspend user"),
        ]),
        Line::from(vec![
            Span::styled("  a", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
            Span::raw(" - Reactivate (activate) user"),
        ]),
        Line::from(vec![
            Span::styled("  v", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
            Span::raw(" - Revoke user"),
        ]),
        Line::from(vec![
            Span::styled("  c", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
            Span::raw(" - Certificate management"),
        ]),
        Line::from(""),
    ];

    // Show user list if available
    if let Some(ref users) = app.detailed_users {
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            format!("Registered Users ({})", users.len()),
            Style::default()
                .fg(Color::Green)
                .add_modifier(Modifier::BOLD),
        )));
        content.push(Line::from(""));
        
        // Table header
        content.push(Line::from(vec![Span::styled(
            format!(
                "{:<12} {:<10} {:<8} {:<12} {:<12} {:<12}",
                "Username", "Status", "Online", "Registered", "Last Seen", "GPG FP (short)"
            ),
            Style::default()
                .fg(Color::Green)
                .add_modifier(Modifier::BOLD),
        )]));
        content.push(Line::from("─".repeat(80)));

        // Table rows
        for (idx, user) in users.iter().enumerate() {
            let online_indicator = if user.online { "🟢 Yes" } else { "⚫ No" };
            let registered = format_timestamp(user.registered_at);
            let last_seen = format_timestamp(user.last_seen);
            let gpg_short = if user.gpg_fp.len() >= 8 {
                &user.gpg_fp[user.gpg_fp.len() - 8..]
            } else {
                &user.gpg_fp
            };

            let status_style = match user.status.as_str() {
                "active" => Style::default().fg(Color::Green),
                "suspended" => Style::default().fg(Color::Yellow),
                "revoked" => Style::default().fg(Color::Red),
                _ => Style::default().fg(Color::Gray),
            };

            let online_style = if user.online {
                Style::default().fg(Color::Green)
            } else {
                Style::default().fg(Color::Gray)
            };

            // Highlight selected user
            let is_selected = idx == app.admin_selected_user;
            let selection_marker = if is_selected { "→ " } else { "  " };

            let mut line_style = Style::default();
            if is_selected {
                line_style = line_style.add_modifier(Modifier::BOLD).fg(Color::Cyan);
            }

            content.push(Line::from(vec![
                Span::styled(selection_marker, line_style),
                Span::styled(format!("{:<10} ", truncate_string(&user.username, 10)), line_style),
                Span::styled(format!("{:<10} ", user.status), if is_selected { line_style } else { status_style }),
                Span::styled(format!("{:<8} ", online_indicator), if is_selected { line_style } else { online_style }),
                Span::styled(format!("{:<12} ", registered), line_style),
                Span::styled(format!("{:<12} ", last_seen), line_style),
                Span::styled(gpg_short.to_string(), if is_selected { line_style } else { Style::default().fg(Color::DarkGray) }),
            ]));

            // Display metadata if available
            if let Some(ref metadata) = user.metadata {
                if !metadata.fields.is_empty() {
                    // Sort keys for consistent display
                    let mut keys: Vec<_> = metadata.fields.keys().collect();
                    keys.sort();
                    
                    let metadata_str = keys
                        .iter()
                        .map(|k| format!("{}: {}", k, metadata.fields.get(*k).unwrap_or(&"".to_string())))
                        .collect::<Vec<_>>()
                        .join(", ");
                    
                    content.push(Line::from(Span::styled(
                        format!("    └─ {}", metadata_str),
                        Style::default()
                            .fg(Color::DarkGray)
                            .add_modifier(Modifier::ITALIC),
                    )));
                }
            }
        }

        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            "Use ↑/↓ to select user",
            Style::default().fg(Color::DarkGray).add_modifier(Modifier::ITALIC),
        )));
    } else {
        content.push(Line::from(Span::styled(
            "Press 'l' to load user list from server",
            Style::default().fg(Color::Yellow),
        )));
    }

    if let Some(ref status) = app.status_message {
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            status.clone(),
            Style::default()
                .fg(Color::LightCyan)
                .add_modifier(Modifier::ITALIC),
        )));
    }

    let paragraph = Paragraph::new(content)
        .block(Block::default().borders(Borders::ALL).title("Admin"))
        .style(Style::default().fg(Color::White))
        .wrap(Wrap { trim: false })
        .scroll((app.admin_scroll_offset, 0));

    f.render_widget(paragraph, area);
}

fn render_admin_register(f: &mut Frame, app: &App, area: Rect) {
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(8), // Form section
            Constraint::Min(0),     // Spacer
        ])
        .split(area);

    render_admin_form(f, app, chunks[0]);
}

fn render_admin_suspend(f: &mut Frame, app: &App, area: Rect) {
    let mut content = vec![
        Line::from(Span::styled(
            "Suspend User",
            Style::default()
                .fg(Color::Yellow)
                .add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
    ];

    if let Some(user) = app.admin_get_selected_user() {
        let gpg_short = if user.gpg_fp.len() >= 16 {
            &user.gpg_fp[user.gpg_fp.len() - 16..]
        } else {
            &user.gpg_fp
        };

        content.push(Line::from(vec![
            Span::raw("Username: "),
            Span::styled(&user.username, Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)),
        ]));
        content.push(Line::from(vec![
            Span::raw("Fingerprint: "),
            Span::styled(gpg_short, Style::default().fg(Color::Gray)),
        ]));
        content.push(Line::from(vec![
            Span::raw("Current Status: "),
            Span::styled(&user.status, match user.status.as_str() {
                "active" => Style::default().fg(Color::Green),
                "suspended" => Style::default().fg(Color::Yellow),
                "revoked" => Style::default().fg(Color::Red),
                _ => Style::default().fg(Color::Gray),
            }),
        ]));
        content.push(Line::from(""));

        if user.status == "suspended" {
            content.push(Line::from(Span::styled(
                "⚠ User is already suspended",
                Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC),
            )));
            content.push(Line::from(""));
            content.push(Line::from(Span::styled(
                "Press Esc to return to menu",
                Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
            )));
        } else if user.status == "revoked" {
            content.push(Line::from(Span::styled(
                "✗ Cannot suspend revoked user",
                Style::default().fg(Color::Red).add_modifier(Modifier::ITALIC),
            )));
            content.push(Line::from(""));
            content.push(Line::from(Span::styled(
                "Press Esc to return to menu",
                Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
            )));
        } else {
            content.push(Line::from(Span::styled(
                "Press Enter to confirm suspension, or Esc to cancel",
                Style::default().fg(Color::White),
            )));
        }
    } else {
        content.push(Line::from(Span::styled(
            "No user selected",
            Style::default().fg(Color::Red),
        )));
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            "Press Esc to return to menu",
            Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
        )));
    }

    if let Some(ref status) = app.status_message {
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            status.clone(),
            Style::default()
                .fg(Color::LightCyan)
                .add_modifier(Modifier::ITALIC),
        )));
    }

    let paragraph = Paragraph::new(content)
        .block(Block::default().borders(Borders::ALL).title("Suspend User"))
        .style(Style::default().fg(Color::White))
        .wrap(Wrap { trim: false })
        .scroll((app.admin_scroll_offset, 0));

    f.render_widget(paragraph, area);
}

fn render_admin_reactivate(f: &mut Frame, app: &App, area: Rect) {
    let mut content = vec![
        Line::from(Span::styled(
            "Reactivate User",
            Style::default()
                .fg(Color::Green)
                .add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
    ];

    if let Some(user) = app.admin_get_selected_user() {
        let gpg_short = if user.gpg_fp.len() >= 16 {
            &user.gpg_fp[user.gpg_fp.len() - 16..]
        } else {
            &user.gpg_fp
        };

        content.push(Line::from(vec![
            Span::raw("Username: "),
            Span::styled(&user.username, Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)),
        ]));
        content.push(Line::from(vec![
            Span::raw("Fingerprint: "),
            Span::styled(gpg_short, Style::default().fg(Color::Gray)),
        ]));
        content.push(Line::from(vec![
            Span::raw("Current Status: "),
            Span::styled(&user.status, match user.status.as_str() {
                "active" => Style::default().fg(Color::Green),
                "suspended" => Style::default().fg(Color::Yellow),
                "revoked" => Style::default().fg(Color::Red),
                _ => Style::default().fg(Color::Gray),
            }),
        ]));
        content.push(Line::from(""));

        if user.status == "active" {
            content.push(Line::from(Span::styled(
                "✓ User is already active",
                Style::default().fg(Color::Green).add_modifier(Modifier::ITALIC),
            )));
            content.push(Line::from(""));
            content.push(Line::from(Span::styled(
                "Press Esc to return to menu",
                Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
            )));
        } else if user.status == "revoked" {
            content.push(Line::from(Span::styled(
                "✗ Cannot reactivate revoked user",
                Style::default().fg(Color::Red).add_modifier(Modifier::ITALIC),
            )));
            content.push(Line::from(""));
            content.push(Line::from(Span::styled(
                "Press Esc to return to menu",
                Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
            )));
        } else {
            content.push(Line::from(Span::styled(
                "Press Enter to confirm reactivation, or Esc to cancel",
                Style::default().fg(Color::White),
            )));
        }
    } else {
        content.push(Line::from(Span::styled(
            "No user selected",
            Style::default().fg(Color::Red),
        )));
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            "Press Esc to return to menu",
            Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
        )));
    }

    if let Some(ref status) = app.status_message {
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            status.clone(),
            Style::default()
                .fg(Color::LightCyan)
                .add_modifier(Modifier::ITALIC),
        )));
    }

    let paragraph = Paragraph::new(content)
        .block(Block::default().borders(Borders::ALL).title("Reactivate User"))
        .style(Style::default().fg(Color::White))
        .wrap(Wrap { trim: false })
        .scroll((app.admin_scroll_offset, 0));

    f.render_widget(paragraph, area);
}

fn render_admin_revoke(f: &mut Frame, app: &App, area: Rect) {
    let mut content = vec![
        Line::from(Span::styled(
            "Revoke User",
            Style::default()
                .fg(Color::Red)
                .add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
    ];

    if let Some(user) = app.admin_get_selected_user() {
        let gpg_short = if user.gpg_fp.len() >= 16 {
            &user.gpg_fp[user.gpg_fp.len() - 16..]
        } else {
            &user.gpg_fp
        };

        content.push(Line::from(vec![
            Span::raw("Username: "),
            Span::styled(&user.username, Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)),
        ]));
        content.push(Line::from(vec![
            Span::raw("Fingerprint: "),
            Span::styled(gpg_short, Style::default().fg(Color::Gray)),
        ]));
        content.push(Line::from(vec![
            Span::raw("Current Status: "),
            Span::styled(&user.status, match user.status.as_str() {
                "active" => Style::default().fg(Color::Green),
                "suspended" => Style::default().fg(Color::Yellow),
                "revoked" => Style::default().fg(Color::Red),
                _ => Style::default().fg(Color::Gray),
            }),
        ]));
        content.push(Line::from(""));

        if user.status == "revoked" {
            content.push(Line::from(Span::styled(
                "✗ User is already revoked",
                Style::default().fg(Color::Red).add_modifier(Modifier::ITALIC),
            )));
            content.push(Line::from(""));
            content.push(Line::from(Span::styled(
                "Press Esc to return to menu",
                Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
            )));
        } else {
            content.push(Line::from(Span::styled(
                "⚠️  WARNING: Revoking a user is PERMANENT and cannot be undone!",
                Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
            )));
            content.push(Line::from(""));
            content.push(Line::from(Span::styled(
                "Press Enter to confirm revocation, or Esc to cancel",
                Style::default().fg(Color::White),
            )));
        }
    } else {
        content.push(Line::from(Span::styled(
            "No user selected",
            Style::default().fg(Color::Red),
        )));
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            "Press Esc to return to menu",
            Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
        )));
    }

    if let Some(ref status) = app.status_message {
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            status.clone(),
            Style::default()
                .fg(Color::LightCyan)
                .add_modifier(Modifier::ITALIC),
        )));
    }

    let paragraph = Paragraph::new(content)
        .block(Block::default().borders(Borders::ALL).title("Revoke User"))
        .style(Style::default().fg(Color::White))
        .wrap(Wrap { trim: false })
        .scroll((app.admin_scroll_offset, 0));

    f.render_widget(paragraph, area);
}

fn render_admin_certificates(f: &mut Frame, app: &App, area: Rect) {
    let mut content = vec![
        Line::from(Span::styled(
            "Certificate Management",
            Style::default()
                .fg(Color::Cyan)
                .add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
    ];

    if let Some(ref username) = app.certificates_for_user {
        content.push(Line::from(vec![
            Span::raw("User: "),
            Span::styled(username, Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)),
        ]));
        content.push(Line::from(""));
    }

    match &app.certificates {
        Some(certs) if !certs.is_empty() => {
            content.push(Line::from(Span::styled(
                format!("Found {} certificate(s):", certs.len()),
                Style::default().fg(Color::Green),
            )));
            content.push(Line::from(""));

            for (idx, cert) in certs.iter().enumerate() {
                content.push(Line::from(Span::styled(
                    format!("Certificate #{}:", idx + 1),
                    Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD),
                )));
                content.push(Line::from(vec![
                    Span::raw("  Serial: "),
                    Span::styled(&cert.serial, Style::default().fg(Color::White)),
                ]));
                
                // Format issued_at timestamp
                let issued_str = if cert.issued_at > 0 {
                    use chrono::{DateTime, Utc};
                    DateTime::<Utc>::from_timestamp(cert.issued_at, 0)
                        .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
                        .unwrap_or_else(|| format!("{}", cert.issued_at))
                } else {
                    "N/A".to_string()
                };
                content.push(Line::from(vec![
                    Span::raw("  Issued At: "),
                    Span::styled(issued_str, Style::default().fg(Color::Green)),
                ]));
                
                // Format expires_at timestamp
                let expires_str = if cert.expires_at > 0 {
                    use chrono::{DateTime, Utc};
                    DateTime::<Utc>::from_timestamp(cert.expires_at, 0)
                        .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
                        .unwrap_or_else(|| format!("{}", cert.expires_at))
                } else {
                    "N/A".to_string()
                };
                content.push(Line::from(vec![
                    Span::raw("  Expires At: "),
                    Span::styled(expires_str, Style::default().fg(Color::Green)),
                ]));
                
                // Status with color coding
                let status_color = match cert.status.as_str() {
                    "valid" => Color::Green,
                    "revoked" => Color::Red,
                    "expired" => Color::Yellow,
                    _ => Color::Gray,
                };
                content.push(Line::from(vec![
                    Span::raw("  Status: "),
                    Span::styled(&cert.status, Style::default().fg(status_color).add_modifier(Modifier::BOLD)),
                ]));
                
                // Show revocation info if revoked
                if cert.status == "revoked" {
                    if let Some(revoked_at) = cert.revoked_at {
                        let revoked_str = {
                            use chrono::{DateTime, Utc};
                            DateTime::<Utc>::from_timestamp(revoked_at, 0)
                                .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
                                .unwrap_or_else(|| format!("{}", revoked_at))
                        };
                        content.push(Line::from(vec![
                            Span::raw("  Revoked At: "),
                            Span::styled(revoked_str, Style::default().fg(Color::Red)),
                        ]));
                    }
                    if let Some(ref revoked_by) = cert.revoked_by {
                        content.push(Line::from(vec![
                            Span::raw("  Revoked By: "),
                            Span::styled(revoked_by, Style::default().fg(Color::Red)),
                        ]));
                    }
                    if let Some(ref reason) = cert.revoked_reason {
                        content.push(Line::from(vec![
                            Span::raw("  Reason: "),
                            Span::styled(reason, Style::default().fg(Color::Red)),
                        ]));
                    }
                }
                
                content.push(Line::from(""));
            }

            content.push(Line::from(Span::styled(
                "Press Esc to return to menu",
                Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
            )));
        }
        Some(_) => {
            content.push(Line::from(Span::styled(
                "No certificates found for this user",
                Style::default().fg(Color::Yellow),
            )));
            content.push(Line::from(""));
            content.push(Line::from(Span::styled(
                "Press Esc to return to menu",
                Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
            )));
        }
        None => {
            if let Some(user) = app.admin_get_selected_user() {
                content.push(Line::from(vec![
                    Span::raw("Selected user: "),
                    Span::styled(&user.username, Style::default().fg(Color::Cyan)),
                ]));
                content.push(Line::from(""));
                content.push(Line::from(Span::styled(
                    "Press Enter to load certificates, or Esc to cancel",
                    Style::default().fg(Color::White),
                )));
            } else {
                content.push(Line::from(Span::styled(
                    "No user selected",
                    Style::default().fg(Color::Red),
                )));
                content.push(Line::from(""));
                content.push(Line::from(Span::styled(
                    "Press Esc to return to menu",
                    Style::default().fg(Color::Gray).add_modifier(Modifier::ITALIC),
                )));
            }
        }
    }

    if let Some(ref status) = app.status_message {
        content.push(Line::from(""));
        content.push(Line::from(Span::styled(
            status.clone(),
            Style::default()
                .fg(Color::LightCyan)
                .add_modifier(Modifier::ITALIC),
        )));
    }

    let paragraph = Paragraph::new(content)
        .block(Block::default().borders(Borders::ALL).title("Certificate Management"))
        .style(Style::default().fg(Color::White))
        .wrap(Wrap { trim: false })
        .scroll((app.admin_scroll_offset, 0));

    f.render_widget(paragraph, area);
}

fn render_admin_form(f: &mut Frame, app: &App, area: Rect) {
    use AdminField::*;

    let block = Block::default()
        .borders(Borders::ALL)
        .title("Register New User");
    let inner = block.inner(area);
    f.render_widget(block, area);

    let sections = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(3),  // Instructions (2 lines + space)
            Constraint::Length(1),  // GPG Fingerprint field
            Constraint::Length(1),  // Key Path field
            Constraint::Length(1),  // Metadata field
            Constraint::Length(2),  // Metadata help text
            Constraint::Length(1),  // Submit hint
            Constraint::Min(0),     // Status message / remaining space
        ])
        .split(inner);

    let instruction_text = vec![
        Line::from("Provide the user's GPG fingerprint and the path to their public key."),
        Line::from("Press Tab to switch fields | Enter to submit | Esc to clear | Ctrl+Shift+L to load user list"),
    ];

    let instructions = Paragraph::new(instruction_text)
        .wrap(Wrap { trim: true })
        .style(Style::default().fg(Color::White));
    f.render_widget(instructions, sections[0]);

    // GPG Fingerprint label and field in one line
    let fp_value = app.admin_form.gpg_fp.as_str();
    let fp_cursor = fp_value.chars().count();
    let fp_style = if app.admin_form.active_field == GpgFingerprint {
        Style::default()
            .fg(Color::Cyan)
            .add_modifier(Modifier::BOLD)
    } else {
        Style::default()
    };
    
    let fp_label_width = 18; // "GPG Fingerprint: "
    let fp_field_width = sections[1].width.saturating_sub(fp_label_width) as usize;
    let fp_scroll = if fp_field_width > 0 && fp_cursor >= fp_field_width {
        fp_cursor - fp_field_width + 1
    } else {
        0
    };
    
    let fp_line = Line::from(vec![
        Span::styled("GPG Fingerprint: ", Style::default().fg(Color::Yellow)),
        Span::styled(fp_value, fp_style),
    ]);
    
    let fp_paragraph = Paragraph::new(vec![fp_line])
        .style(Style::default().fg(Color::White))
        .scroll((0, fp_scroll as u16));
    f.render_widget(fp_paragraph, sections[1]);

    // Key Path label and field in one line
    let key_value = app.admin_form.key_path.as_str();
    let key_cursor = key_value.chars().count();
    let key_style = if app.admin_form.active_field == KeyPath {
        Style::default()
            .fg(Color::Cyan)
            .add_modifier(Modifier::BOLD)
    } else {
        Style::default()
    };
    
    let key_label_width = 11; // "Key Path: "
    let key_field_width = sections[2].width.saturating_sub(key_label_width) as usize;
    let key_scroll = if key_field_width > 0 && key_cursor >= key_field_width {
        key_cursor - key_field_width + 1
    } else {
        0
    };
    
    let key_line = Line::from(vec![
        Span::styled("Key Path: ", Style::default().fg(Color::Yellow)),
        Span::styled(key_value, key_style),
    ]);
    
    let key_paragraph = Paragraph::new(vec![key_line])
        .style(Style::default().fg(Color::White))
        .scroll((0, key_scroll as u16));
    f.render_widget(key_paragraph, sections[2]);

    // Metadata label and field in one line
    let meta_value = app.admin_form.metadata.as_str();
    let meta_cursor = meta_value.chars().count();
    let meta_style = if app.admin_form.active_field == Metadata {
        Style::default()
            .fg(Color::Cyan)
            .add_modifier(Modifier::BOLD)
    } else {
        Style::default()
    };
    
    let meta_label_width = 11; // "Metadata: "
    let meta_field_width = sections[3].width.saturating_sub(meta_label_width) as usize;
    let meta_scroll = if meta_field_width > 0 && meta_cursor >= meta_field_width {
        meta_cursor - meta_field_width + 1
    } else {
        0
    };
    
    let meta_line = Line::from(vec![
        Span::styled("Metadata: ", Style::default().fg(Color::Yellow)),
        Span::styled(meta_value, meta_style),
    ]);
    
    let meta_paragraph = Paragraph::new(vec![meta_line])
        .style(Style::default().fg(Color::White))
        .scroll((0, meta_scroll as u16));
    f.render_widget(meta_paragraph, sections[3]);

    // Metadata help text
    let help_text = vec![
        Line::from(Span::styled(
            "  (Optional) Example: --name Bob Smith --team Engineering --birthdate 24 Dec",
            Style::default()
                .fg(Color::DarkGray)
                .add_modifier(Modifier::ITALIC),
        )),
    ];
    let help_para = Paragraph::new(help_text);
    f.render_widget(help_para, sections[4]);

    let hint_line = if app.admin_form_complete() {
        Line::from(Span::styled(
            "Press Enter to register user",
            Style::default()
                .fg(Color::LightGreen)
                .add_modifier(Modifier::ITALIC),
        ))
    } else {
        Line::from(Span::styled(
            "GPG Fingerprint and Key Path are required before submitting",
            Style::default()
                .fg(Color::DarkGray)
                .add_modifier(Modifier::ITALIC),
        ))
    };
    let hint = Paragraph::new(vec![hint_line]).wrap(Wrap { trim: true });
    f.render_widget(hint, sections[5]);

    if let Some(status) = &app.status_message {
        let status_para = Paragraph::new(vec![Line::from(Span::styled(
            status.clone(),
            Style::default()
                .fg(Color::LightCyan)
                .add_modifier(Modifier::ITALIC),
        ))])
        .wrap(Wrap { trim: true });
        f.render_widget(status_para, sections[6]);
    }

    // Position cursor at the end of the active field
    match app.admin_form.active_field {
        GpgFingerprint => {
            let visible_cursor = fp_cursor.saturating_sub(fp_scroll);
            let cursor_x = sections[1].x + fp_label_width as u16 + visible_cursor.min(fp_field_width) as u16;
            let cursor_y = sections[1].y;
            f.set_cursor_position((cursor_x, cursor_y));
        }
        KeyPath => {
            let visible_cursor = key_cursor.saturating_sub(key_scroll);
            let cursor_x = sections[2].x + key_label_width as u16 + visible_cursor.min(key_field_width) as u16;
            let cursor_y = sections[2].y;
            f.set_cursor_position((cursor_x, cursor_y));
        }
        Metadata => {
            let visible_cursor = meta_cursor.saturating_sub(meta_scroll);
            let cursor_x = sections[3].x + meta_label_width as u16 + visible_cursor.min(meta_field_width) as u16;
            let cursor_y = sections[3].y;
            f.set_cursor_position((cursor_x, cursor_y));
        }
    }
}

/// Format unix timestamp to human-readable string
fn format_timestamp(timestamp: u64) -> String {
    use std::time::{Duration, SystemTime, UNIX_EPOCH};

    let datetime = UNIX_EPOCH + Duration::from_secs(timestamp);
    let now = SystemTime::now();

    if let Ok(duration) = now.duration_since(datetime) {
        let secs = duration.as_secs();
        if secs < 60 {
            format!("{}s ago", secs)
        } else if secs < 3600 {
            format!("{}m ago", secs / 60)
        } else if secs < 86400 {
            format!("{}h ago", secs / 3600)
        } else if secs < 2592000 {
            format!("{}d ago", secs / 86400)
        } else {
            format!("{}mo ago", secs / 2592000)
        }
    } else {
        "future".to_string()
    }
}

fn render_status_tab(f: &mut Frame, app: &App, area: Rect) {
    // Split into two sections: connection status and engine status
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Length(10), // Connection status section
            Constraint::Min(10),    // Engine status section
        ])
        .split(area);

    // === Connection Status Section ===
    let connection_icon = match app.connection_status {
        crate::erlang::ConnectionStatus::Connected => "🟢",
        crate::erlang::ConnectionStatus::Connecting => "🟡",
        crate::erlang::ConnectionStatus::Disconnected => "⚫",
        crate::erlang::ConnectionStatus::Error => "🔴",
    };

    let node_info = if let Some(ref node_name) = app.erlang_node_name {
        format!("{} {}", connection_icon, node_name)
    } else {
        format!("{} Not configured", connection_icon)
    };

    let status_info = vec![
        Line::from(Span::styled(
            "Connection Status",
            Style::default().add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
        Line::from(format!(
            "Mode: {}",
            if app.is_mock_mode {
                "Mock Data"
            } else {
                "Live"
            }
        )),
        Line::from(format!("Erlang node: {}", node_info)),
        Line::from(format!("Status: {}", app.connection_status.as_str())),
        Line::from(""),
        Line::from(format!(
            "Users loaded: {} | Active conversations: {}",
            app.users.len(),
            app.messages.len()
        )),
    ];

    let connection_paragraph = Paragraph::new(status_info)
        .block(Block::default().borders(Borders::ALL).title("Connection"))
        .style(Style::default().fg(Color::White));

    f.render_widget(connection_paragraph, chunks[0]);

    // === Engine Status Section ===
    let mut engine_info = vec![];

    // Add certificate renewal status at the top if available
    if let Some(ref status) = app.engine_status {
        if let Some(expires_at) = status.cert_expires_at {
            engine_info.push(Line::from(Span::styled(
                "Certificate Status",
                Style::default()
                    .add_modifier(Modifier::BOLD)
                    .fg(Color::Magenta),
            )));
            engine_info.push(Line::from(""));

            // Format expiration date
            let expires_date = chrono::DateTime::from_timestamp(expires_at, 0)
                .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
                .unwrap_or_else(|| "Unknown".to_string());

            // Calculate days until expiry
            let days_until_expiry = if let Some(seconds) = status.cert_time_until_expiry {
                seconds / 86400
            } else {
                0
            };

            let expiry_color = if days_until_expiry < 1 {
                Color::Red
            } else if days_until_expiry < 3 {
                Color::Yellow
            } else {
                Color::Green
            };

            let status_icon = if days_until_expiry < 1 {
                "🔴"
            } else if days_until_expiry < 3 {
                "🟡"
            } else {
                "🟢"
            };

            engine_info.push(Line::from(vec![
                Span::raw(format!("{} ", status_icon)),
                Span::styled("Expires: ", Style::default().fg(Color::Yellow)),
                Span::styled(expires_date, Style::default().fg(expiry_color)),
                Span::raw(format!(" ({} days)", days_until_expiry)),
            ]));

            if status.cert_renewal_in_progress {
                engine_info.push(Line::from(Span::styled(
                    "⏳ Renewal in progress...",
                    Style::default().fg(Color::Cyan).add_modifier(Modifier::ITALIC),
                )));
            } else {
                engine_info.push(Line::from(Span::styled(
                    "Press 'n' to renew certificate now",
                    Style::default().fg(Color::DarkGray).add_modifier(Modifier::ITALIC),
                )));
            }

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

    if let Some(ref status) = app.engine_status {
        engine_info.push(Line::from(Span::styled(
            "Cryptic Engine Status",
            Style::default()
                .add_modifier(Modifier::BOLD)
                .fg(Color::Cyan),
        )));
        engine_info.push(Line::from(""));

        // Format uptime
        let uptime_str = format_uptime(status.uptime_ms);

        engine_info.push(Line::from(vec![
            Span::styled("Username: ", Style::default().fg(Color::Yellow)),
            Span::raw(status.username.clone()),
            Span::raw("  |  "),
            Span::styled("Uptime: ", Style::default().fg(Color::Yellow)),
            Span::raw(uptime_str),
        ]));

        engine_info.push(Line::from(vec![
            Span::styled("Active Sessions: ", Style::default().fg(Color::Yellow)),
            Span::raw(format!("{}", status.active_sessions)),
            Span::raw("  |  "),
            Span::styled("Messages: ", Style::default().fg(Color::Yellow)),
            Span::raw(format!("{}", status.message_count)),
            Span::raw("  |  "),
            Span::styled("Errors: ", Style::default().fg(Color::Yellow)),
            Span::raw(format!("{}", status.error_count)),
        ]));

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

        if !status.session_details.is_empty() {
            engine_info.push(Line::from(Span::styled(
                "Double Ratchet Sessions:",
                Style::default().add_modifier(Modifier::BOLD | Modifier::UNDERLINED),
            )));
            engine_info.push(Line::from(""));

            // Table headers - align with data columns
            engine_info.push(Line::from(vec![
                Span::styled(
                    format!("{:<12}", "Peer"),
                    Style::default()
                        .add_modifier(Modifier::BOLD)
                        .fg(Color::Green),
                ),
                Span::styled(
                    format!("{:>6}", "Step"),
                    Style::default()
                        .add_modifier(Modifier::BOLD)
                        .fg(Color::Green),
                ),
                Span::styled(
                    format!("{:>6}", "Send"),
                    Style::default()
                        .add_modifier(Modifier::BOLD)
                        .fg(Color::Green),
                ),
                Span::styled(
                    format!("{:>6}", "Recv"),
                    Style::default()
                        .add_modifier(Modifier::BOLD)
                        .fg(Color::Green),
                ),
                Span::styled(
                    format!("{:>6}", "Prev"),
                    Style::default()
                        .add_modifier(Modifier::BOLD)
                        .fg(Color::Green),
                ),
                Span::styled(
                    format!("{:>9}", "Skipped"),
                    Style::default()
                        .add_modifier(Modifier::BOLD)
                        .fg(Color::Green),
                ),
                Span::raw("  "),
                Span::styled(
                    "State",
                    Style::default()
                        .add_modifier(Modifier::BOLD)
                        .fg(Color::Green),
                ),
            ]));

            // Session rows
            for session in &status.session_details {
                engine_info.push(Line::from(vec![
                    Span::raw(format!(
                        "{:<12}",
                        truncate_string(&session.peer_username, 12)
                    )),
                    Span::raw(format!("{:>6}", session.dh_ratchet_step)),
                    Span::raw(format!("{:>6}", session.send_msg_number)),
                    Span::raw(format!("{:>6}", session.recv_msg_number)),
                    Span::raw(format!("{:>6}", session.prev_recv_chain_length)),
                    Span::raw(format!("{:>9}", session.skipped_keys_count)),
                    Span::raw("  "),
                    Span::styled(
                        &session.current_state,
                        if session.current_state.contains("error") {
                            Style::default().fg(Color::Red)
                        } else if session.receiving_chain_active || session.sending_chain_active {
                            Style::default().fg(Color::Green)
                        } else {
                            Style::default().fg(Color::Gray)
                        },
                    ),
                ]));
            }

            // Add explanation text
            engine_info.push(Line::from(""));
            engine_info.push(Line::from(Span::styled(
                "Legend:",
                Style::default()
                    .fg(Color::Gray)
                    .add_modifier(Modifier::ITALIC),
            )));
            engine_info.push(Line::from(Span::styled(
                "  Step: DH ratchet steps (key rotations) that have occurred",
                Style::default()
                    .fg(Color::DarkGray)
                    .add_modifier(Modifier::ITALIC),
            )));
            engine_info.push(Line::from(Span::styled(
                "  Send/Recv: Current chain message counters (reset on DH step)",
                Style::default()
                    .fg(Color::DarkGray)
                    .add_modifier(Modifier::ITALIC),
            )));
            engine_info.push(Line::from(Span::styled(
                "  Prev: Messages from the previous receiving chain",
                Style::default()
                    .fg(Color::DarkGray)
                    .add_modifier(Modifier::ITALIC),
            )));
            engine_info.push(Line::from(Span::styled(
                "  Skipped: Out-of-order messages cached for delayed delivery",
                Style::default()
                    .fg(Color::DarkGray)
                    .add_modifier(Modifier::ITALIC),
            )));
        } else {
            engine_info.push(Line::from(Span::styled(
                "No active sessions",
                Style::default()
                    .fg(Color::DarkGray)
                    .add_modifier(Modifier::ITALIC),
            )));
        }

        engine_info.push(Line::from(""));
        engine_info.push(Line::from(Span::styled(
            "Press 'r' to refresh engine status",
            Style::default().fg(Color::Gray),
        )));
    } else {
        engine_info.push(Line::from(Span::styled(
            "Engine Status",
            Style::default()
                .add_modifier(Modifier::BOLD)
                .fg(Color::Cyan),
        )));
        engine_info.push(Line::from(""));
        engine_info.push(Line::from(Span::styled(
            "No engine status available. Press 'r' to refresh.",
            Style::default().fg(Color::Yellow),
        )));
    }

    let engine_paragraph = Paragraph::new(engine_info)
        .block(
            Block::default()
                .borders(Borders::ALL)
                .title("System Status"),
        )
        .style(Style::default().fg(Color::White))
        .scroll((app.status_scroll_offset, 0));

    f.render_widget(engine_paragraph, chunks[1]);
}

/// Format uptime from microseconds to human-readable string
fn format_uptime(uptime_us: u64) -> String {
    let seconds = uptime_us / 1_000_000;
    let minutes = seconds / 60;
    let hours = minutes / 60;
    let days = hours / 24;

    if days > 0 {
        format!("{}d {}h", days, hours % 24)
    } else if hours > 0 {
        format!("{}h {}m", hours, minutes % 60)
    } else if minutes > 0 {
        format!("{}m {}s", minutes, seconds % 60)
    } else {
        format!("{}s", seconds)
    }
}

/// Truncate a string to a maximum length, adding "..." if needed
fn truncate_string(s: &str, max_len: usize) -> String {
    if s.len() <= max_len {
        s.to_string()
    } else if max_len > 3 {
        format!("{}...", &s[..max_len - 3])
    } else {
        s[..max_len].to_string()
    }
}

fn render_help_tab(f: &mut Frame, app: &App, area: Rect) {
    let help_text = vec![
        Line::from(Span::styled(
            "Keyboard Shortcuts",
            Style::default().add_modifier(Modifier::BOLD),
        )),
        Line::from(""),
        Line::from("Global:"),
        Line::from("  Ctrl+Q   - Quit application"),
        Line::from("  Tab      - Next tab"),
        Line::from("  Shift+Tab - Previous tab"),
        Line::from(""),
        Line::from("Chat Tab:"),
        Line::from("  ↑/↓      - Navigate user list"),
        Line::from("  Enter    - Select user / Send message"),
        Line::from("  Ctrl+U   - Scroll up messages (or PgUp / Fn+↑)"),
        Line::from("  Ctrl+D   - Scroll down messages (or PgDn / Fn+↓)"),
        Line::from("  Home     - Jump to beginning of conversation"),
        Line::from("  End      - Jump to latest messages"),
        Line::from("  Esc      - Clear input"),
        Line::from(""),
        Line::from("Text Editing (Emacs-style):"),
        Line::from("  Ctrl+A   - Move to beginning of line"),
        Line::from("  Ctrl+E   - Move to end of line"),
        Line::from("  Ctrl+B   - Move cursor left (or ←)"),
        Line::from("  Ctrl+F   - Move cursor right (or →)"),
        Line::from("  Backspace - Delete before cursor"),
        Line::from("  Delete   - Delete at cursor"),
        Line::from(""),
        Line::from("Status Tab:"),
        Line::from("  r        - Refresh engine status"),
        Line::from("  n        - Renew certificate now"),
        Line::from(""),
        Line::from("Admin Tab:"),
        Line::from("  Ctrl+Shift+L - Load/refresh detailed user list"),
        Line::from("  Tab/↑/↓ - Switch between register form fields"),
        Line::from("  Enter    - Submit new user registration"),
        Line::from("  Esc      - Clear register form"),
        Line::from("  Ctrl+H/L - Navigate to previous/next tab"),
        Line::from("  r        - Revoke user (coming soon)"),
        Line::from("  s        - Suspend user (coming soon)"),
        Line::from(""),
        Line::from(Span::styled(
            "MacBook Users: Use Ctrl+U/D for scrolling (easier than Fn+↑/↓)",
            Style::default().fg(Color::Yellow),
        )),
    ];

    let paragraph = Paragraph::new(help_text)
        .block(Block::default().borders(Borders::ALL).title("Help"))
        .style(Style::default().fg(Color::White))
        .scroll((app.help_scroll_offset, 0));

    f.render_widget(paragraph, area);
}

fn render_splash(f: &mut Frame, app: &App, area: Rect) {
    // Centered layout
    let outer = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Constraint::Percentage(30),
            Constraint::Percentage(40),
            Constraint::Percentage(30),
        ])
        .split(area);

    let inner = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Percentage(25),
            Constraint::Percentage(50),
            Constraint::Percentage(25),
        ])
        .split(outer[1]);

    let panel_area = inner[1];
    let title = Span::styled(
        "CRYPTIC TERMINAL UI",
        Style::default()
            .fg(Color::Cyan)
            .add_modifier(Modifier::BOLD),
    );

    let masked = if app.passphrase_input.is_empty() {
        "".to_string()
    } else {
        "*".repeat(app.passphrase_input.chars().count())
    };

    let mut lines: Vec<Line> = vec![
        Line::from(title),
        Line::from(""),
        Line::from("Secure messaging interface"),
        Line::from(""),
        Line::from(Span::styled(
            "Enter passphrase to unlock local key material",
            Style::default().fg(Color::White),
        )),
        Line::from(""),
        Line::from(format!("Passphrase: {}", masked)),
        Line::from(""),
        Line::from("Enter continue | Esc clear | Ctrl+Q quit"),
    ];

    if let Some(err) = &app.splash_error {
        lines.push(Line::from(Span::styled(
            err,
            Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
        )));
    }

    let block = Block::default()
        .title("Unlock")
        .borders(Borders::ALL)
        .border_style(Style::default().fg(Color::Cyan));

    let paragraph = Paragraph::new(lines)
        .block(block)
        .alignment(ratatui::layout::Alignment::Center);

    f.render_widget(paragraph, panel_area);
}

fn render_status_bar(f: &mut Frame, app: &App, area: Rect) {
    let text = if let Some(msg) = app.get_current_system_message() {
        // System message with distinct styling
        Span::styled(
            format!(" ℹ {}", msg),
            Style::default()
                .fg(Color::Black)
                .bg(Color::LightCyan)
                .add_modifier(Modifier::BOLD),
        )
    } else {
        // Default status bar shows server connection state
        let (icon, status_text) = if app.server_connection_up {
            ("🟢", "Server up!")
        } else {
            ("🔴", "Server down!")
        };
        
        Span::styled(
            format!(" {} {}", icon, status_text),
            Style::default()
                .fg(Color::White)
                .bg(Color::DarkGray),
        )
    };

    let paragraph = Paragraph::new(Line::from(text));
    f.render_widget(paragraph, area);
}