cryptic_tui/

app.rs

//! Application state and data structures.
//!
//! This module contains the core data structures for managing the application state,
//! including user data, messages, message history, UI state, and connection status.
//!
//! # Key Types
//!
//! - [`App`] - Main application state
//! - [`ConversationView`] - Per-peer message history with lazy loading
//! - [`Tab`] - UI tab navigation
//! - [`User`] - User information
//! - [`Message`] - Chat message data
//! - [`Secret`] - Secure string wrapper with automatic zeroization
//!
//! # Message History
//!
//! The module implements efficient message history management through [`ConversationView`],
//! which uses a [`VecDeque`] for O(1) prepending when loading older messages. This enables
//! infinite scrolling with lazy loading from the persistent SQLite storage.

use crate::erlang::ConnectionStatus;
use std::collections::{HashMap, VecDeque};
use std::time::{Duration, Instant};
use zeroize::Zeroize;

/// A system message with display timing information.
#[derive(Debug, Clone)]
pub struct SystemMessage {
    /// The message text
    pub text: String,
    /// Optional system code (e.g., "server_connection_down")
    #[allow(dead_code)]
    pub sys_code: Option<String>,
    /// When this message was added to the queue
    pub timestamp: Instant,
    /// Minimum duration to display this message (default 3 seconds)
    pub min_display_duration: Duration,
}

impl SystemMessage {
    /// Create a new system message with default 3-second display duration.
    pub fn new(text: String) -> Self {
        Self {
            text,
            sys_code: None,
            timestamp: Instant::now(),
            min_display_duration: Duration::from_secs(3),
        }
    }

    /// Create a new system message with a system code.
    pub fn with_code(text: String, sys_code: String) -> Self {
        Self {
            text,
            sys_code: Some(sys_code),
            timestamp: Instant::now(),
            min_display_duration: Duration::from_secs(3),
        }
    }

    /// Check if the minimum display duration has elapsed.
    pub fn can_advance(&self) -> bool {
        self.timestamp.elapsed() >= self.min_display_duration
    }

    /// Reset the timestamp to now (called when message starts displaying).
    pub fn reset_timestamp(&mut self) {
        self.timestamp = Instant::now();
    }
}

/// UI tab navigation.
///
/// Represents the different tabs available in the main application screen.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Tab {
    /// Chat view with user list and message history
    Chat,
    /// Admin panel for user management
    Admin,
    /// Connection and system status
    Status,
    /// Help and keyboard shortcuts
    Help,
}

impl Tab {
    /// Move to the next tab in the sequence.
    ///
    /// Wraps around from Help back to Chat.
    pub fn next(&self) -> Self {
        match self {
            Tab::Chat => Tab::Admin,
            Tab::Admin => Tab::Status,
            Tab::Status => Tab::Help,
            Tab::Help => Tab::Chat,
        }
    }

    /// Move to the previous tab in the sequence.
    ///
    /// Wraps around from Chat back to Help.
    pub fn previous(&self) -> Self {
        match self {
            Tab::Chat => Tab::Help,
            Tab::Admin => Tab::Chat,
            Tab::Status => Tab::Admin,
            Tab::Help => Tab::Status,
        }
    }
}

/// Represents a user in the messaging system.
#[derive(Debug, Clone)]
pub struct User {
    /// Username identifier
    pub name: String,
    /// Whether the user is currently online
    pub online: bool,
}

/// Represents a chat message.
#[derive(Debug, Clone)]
pub struct Message {
    /// Username of the sender
    pub from: String,
    /// Message content (decrypted plaintext)
    pub content: String,
    /// Whether this message was sent by the current user
    pub is_sent: bool,
    /// Unix timestamp of the message
    #[allow(dead_code)]
    pub timestamp: u64,
}

impl Message {
    pub fn received(from: &str, content: &str) -> Self {
        Self {
            from: from.to_string(),
            content: content.to_string(),
            is_sent: false,
            timestamp: 0,
        }
    }

    pub fn sent(from: &str, content: &str) -> Self {
        Self {
            from: from.to_string(),
            content: content.to_string(),
            is_sent: true,
            timestamp: 0,
        }
    }
}

/// Engine status information from cryptic_engine.
#[derive(Debug, Clone, Default)]
pub struct EngineStatus {
    pub username: String,
    pub active_sessions: u32,
    pub message_count: u32,
    pub error_count: u32,
    pub uptime_ms: u64,
    pub session_details: Vec<SessionDetail>,
    pub cert_expires_at: Option<i64>,
    pub cert_renewal_in_progress: bool,
    pub cert_time_until_expiry: Option<i64>,
}

/// Details about a specific Double Ratchet session.
#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct SessionDetail {
    pub peer_username: String,
    pub message_count: u32,
    pub error_count: u32,
    pub dh_ratchet_step: u32,
    pub send_msg_number: u32,
    pub recv_msg_number: u32,
    pub prev_recv_chain_length: u32,
    pub skipped_keys_count: u32,
    pub current_state: String,
    pub transition_count: u32,
    pub created_at: u64,
    pub last_updated: u64,
    pub receiving_chain_active: bool,
    pub sending_chain_active: bool,
    pub has_remote_dh: bool,
}

/// Detailed user information from admin user list.
#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct DetailedUser {
    pub username: String,
    pub gpg_fp: String,
    pub online: bool,
    pub status: String,
    pub registered_at: u64,
    pub last_seen: u64,
    pub registered_by: String,
    pub metadata: Option<UserMetadata>,
}

/// Optional metadata for a user.
/// Contains arbitrary key-value pairs like team, name, note, etc.
#[derive(Debug, Clone)]
pub struct UserMetadata {
    pub fields: std::collections::HashMap<String, String>,
}

/// Certificate information for a user.
#[derive(Debug, Clone)]
pub struct Certificate {
    pub serial: String,
    pub issued_at: i64,
    pub expires_at: i64,
    pub status: String,
    pub revoked_at: Option<i64>,
    pub revoked_by: Option<String>,
    pub revoked_reason: Option<String>,
}

/// Manages a conversation with message history.
///
/// This struct handles lazy loading of message history with infinite scrolling.
/// Messages are stored in a VecDeque for efficient prepending when loading older messages.
#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct ConversationView {
    /// Username of the peer
    pub peer: String,

    /// Message cache (ordered by timestamp, oldest first)
    pub messages: VecDeque<Message>,

    /// Current scroll position (0 = bottom/newest)
    pub scroll_offset: usize,

    /// Total messages loaded from storage
    pub loaded_count: usize,

    /// Total messages in storage (if known)
    pub total_count: Option<usize>,

    /// Whether we're currently loading history
    pub is_loading: bool,

    /// Whether more history exists to load
    pub has_more_history: bool,

    /// Timestamp of oldest loaded message
    pub oldest_timestamp: Option<u64>,

    /// Timestamp of newest loaded message
    pub newest_timestamp: Option<u64>,
}

impl ConversationView {
    /// Create a new conversation view for a peer.
    pub fn new(peer: String) -> Self {
        Self {
            peer,
            messages: VecDeque::with_capacity(100),
            scroll_offset: 0,
            loaded_count: 0,
            total_count: None,
            is_loading: false,
            has_more_history: true,
            oldest_timestamp: None,
            newest_timestamp: None,
        }
    }

    /// Add messages to the front (older messages).
    ///
    /// Used when loading history backwards in time.
    pub fn prepend_messages(&mut self, messages: Vec<Message>) {
        if let Some(first) = messages.first() {
            self.oldest_timestamp = Some(first.timestamp);
        }

        for msg in messages.into_iter().rev() {
            self.messages.push_front(msg);
        }

        self.loaded_count = self.messages.len();
    }

    /// Add messages to the back (newer messages).
    ///
    /// Used when initially loading recent messages or when receiving new messages.
    pub fn append_messages(&mut self, messages: Vec<Message>) {
        if let Some(last) = messages.last() {
            self.newest_timestamp = Some(last.timestamp);
        }

        self.messages.extend(messages);
        self.loaded_count = self.messages.len();
    }

    /// Add a single new message (for real-time incoming messages).
    pub fn add_message(&mut self, message: Message) {
        self.newest_timestamp = Some(message.timestamp);
        self.messages.push_back(message);
        self.loaded_count = self.messages.len();
    }

    /// Get oldest timestamp for pagination.
    pub fn get_oldest_timestamp(&self) -> Option<u64> {
        self.messages.front().map(|m| m.timestamp)
    }

    /// Check if we're scrolled to the top.
    pub fn is_at_top(&self) -> bool {
        self.scroll_offset >= self.messages.len().saturating_sub(1)
    }

    /// Check if we're scrolled to the bottom.
    #[allow(dead_code)]
    pub fn is_at_bottom(&self) -> bool {
        self.scroll_offset == 0
    }
}

/// Main application state.
///
/// Contains all the data needed to render the UI and manage the application.
/// This includes user lists, messages, input state, connection status, and more.
///
/// # Examples
///
/// ```no_run
/// use cryptic_tui::app::App;
///
/// // Create app with mock data for testing
/// let app = App::with_mock_data();
///
/// // Create empty app
/// let app = App::new();
/// ```
pub struct App {
    /// Currently active tab
    pub active_tab: Tab,
    /// List of all users
    pub users: Vec<User>,
    /// Messages grouped by peer username
    pub messages: HashMap<String, Vec<Message>>,
    /// Currently selected peer for chat
    pub current_peer: Option<String>,
    /// Input buffer for message composition
    pub input_buffer: String,
    /// Cursor position in input buffer (byte index, not char index)
    pub input_cursor: usize,
    /// Currently selected user index in the user list
    pub selected_user: usize,
    /// Whether running with mock data or real Erlang connection
    pub is_mock_mode: bool,
    /// Current screen (Splash or Main)
    pub screen: AppScreen,
    /// Encrypted passphrase (zeroized on drop)
    pub passphrase: Option<Secret>,
    /// Passphrase input buffer (cleared after validation)
    pub passphrase_input: String,
    /// Error message to display on splash screen
    pub splash_error: Option<String>,
    /// Flag to trigger application exit
    pub should_exit: bool,
    /// Current Erlang connection status
    pub connection_status: ConnectionStatus,
    /// Name of the Erlang node to connect to
    pub erlang_node_name: Option<String>,
    /// Cryptographic engine status
    pub engine_status: Option<EngineStatus>,
    /// Detailed user list from admin API
    pub detailed_users: Option<Vec<DetailedUser>>,
    /// Active conversation views (keyed by peer username)
    pub conversations: HashMap<String, ConversationView>,
    /// Flag to trigger history loading
    pub should_load_history: bool,
    /// Status message to display to user (e.g., errors, notifications)
    pub status_message: Option<String>,
    /// Pending admin form inputs
    pub admin_form: AdminForm,
    /// Current admin view mode
    pub admin_mode: AdminMode,
    /// Selected user index in admin user list
    pub admin_selected_user: usize,
    /// Certificates for currently viewed user
    pub certificates: Option<Vec<Certificate>>,
    /// User whose certificates are being viewed
    pub certificates_for_user: Option<String>,
    /// Admin view scroll offset (for scrolling content)
    pub admin_scroll_offset: u16,
    /// Status view scroll offset (for scrolling content)
    pub status_scroll_offset: u16,
    /// Help view scroll offset (for scrolling content)
    pub help_scroll_offset: u16,
    /// Queue of system messages to display
    pub system_message_queue: VecDeque<SystemMessage>,
    /// Currently displayed system message (if any)
    pub current_system_message: Option<SystemMessage>,
    /// Server connection state (tracked via sys_code from system_message events)
    pub server_connection_up: bool,
}

/// Form state for Admin actions.
#[derive(Debug, Clone, Default)]
#[allow(dead_code)]
pub struct AdminForm {
    /// GPG fingerprint input field
    pub gpg_fp: String,
    /// Path to GPG public key file
    pub key_path: String,
    /// Optional metadata string (e.g., "--name John Doe --team Engineering")
    pub metadata: String,
    /// Which input is currently active (for focus switching)
    pub active_field: AdminField,
    /// Whether the form is visible
    pub visible: bool,
}

/// Admin view mode
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AdminMode {
    Menu,
    RegisterUser,
    SuspendUser,
    ReactivateUser,
    RevokeUser,
    ListCertificates,
}

/// Identifies active admin form field.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AdminField {
    GpgFingerprint,
    KeyPath,
    Metadata,
}

impl Default for AdminField {
    fn default() -> Self {
        AdminField::GpgFingerprint
    }
}

impl App {
    /// Create a new empty App without mock data.
    ///
    /// Used when connecting to a real Erlang node - users will be populated
    /// from the server's user list.
    pub fn new() -> Self {
        Self {
            active_tab: Tab::Chat,
            users: Vec::new(), // Start with empty user list
            messages: HashMap::new(),
            current_peer: None,
            input_buffer: String::new(),
            input_cursor: 0,
            selected_user: 0,
            is_mock_mode: false,
            screen: AppScreen::Splash,
            passphrase: None,
            passphrase_input: String::new(),
            splash_error: None,
            should_exit: false,
            connection_status: ConnectionStatus::Disconnected,
            erlang_node_name: None,
            engine_status: None,
            detailed_users: None,
            conversations: HashMap::new(),
            should_load_history: false,
            status_message: None,
            admin_form: AdminForm::default(),
            admin_mode: AdminMode::Menu,
            admin_selected_user: 0,
            certificates: None,
            certificates_for_user: None,
            admin_scroll_offset: 0,
            status_scroll_offset: 0,
            help_scroll_offset: 0,
            system_message_queue: VecDeque::new(),
            current_system_message: None,
            server_connection_up: false,
        }
    }

    /// Update the users list with online status from the server.
    ///
    /// # Arguments
    ///
    /// * `online_users` - List of usernames currently online
    pub fn update_online_users(&mut self, online_users: Vec<String>) {
        // Get current username to exclude from list (as owned String to avoid borrow issues)
        let current_username = self.get_current_username().map(|s| s.to_string());

        // Mark all users as offline first
        for user in &mut self.users {
            user.online = false;
        }

        // Mark online users (excluding ourselves)
        for username in &online_users {
            // Skip our own username
            if current_username.as_deref() == Some(username.as_str()) {
                continue;
            }

            if let Some(user) = self.users.iter_mut().find(|u| &u.name == username) {
                user.online = true;
            } else {
                // Add new user if not in list
                self.users.push(User {
                    name: username.clone(),
                    online: true,
                });
            }
        }

        // Remove current user from the list if they somehow got added
        if let Some(current_user) = current_username {
            self.users.retain(|u| u.name != current_user);
        }

        // Sort users: online first, then alphabetically
        self.users.sort_by(|a, b| match (a.online, b.online) {
            (true, false) => std::cmp::Ordering::Less,
            (false, true) => std::cmp::Ordering::Greater,
            _ => a.name.cmp(&b.name),
        });
    }

    /// Get the current username from the Erlang node name.
    ///
    /// Extracts the username portion before '@' in node names like "alice@localhost".
    /// Returns None if no node name is set.
    pub fn get_current_username(&self) -> Option<&str> {
        self.erlang_node_name
            .as_ref()
            .map(|name| name.split('@').next().unwrap_or(name.as_str()))
    }

    /// Create app with mock data for Phase 0 development.
    ///
    /// Populates the app with sample users and messages for UI testing
    /// without requiring an Erlang connection.
    pub fn with_mock_data() -> Self {
        let users = vec![
            User {
                name: "alice".to_string(),
                online: true,
            },
            User {
                name: "bob".to_string(),
                online: false,
            },
            User {
                name: "charlie".to_string(),
                online: true,
            },
            User {
                name: "dave".to_string(),
                online: false,
            },
            User {
                name: "eve".to_string(),
                online: true,
            },
        ];

        let mut messages = HashMap::new();

        // Mock conversation with alice
        messages.insert(
            "alice".to_string(),
            vec![
                Message::received("alice", "Hey there! How's the TUI coming along?"),
                Message::sent("me", "Pretty good! Just got the layout working."),
                Message::received("alice", "That's awesome! Can't wait to try it."),
                Message::sent("me", "Still need to hook up the Erlang backend though."),
                Message::received("alice", "One step at a time! 🚀"),
            ],
        );

        // Mock conversation with charlie
        messages.insert(
            "charlie".to_string(),
            vec![
                Message::received("charlie", "Did you see the new design?"),
                Message::sent("me", "Yes! Looks great with the tabs."),
                Message::received("charlie", "Thanks! Let me know if you need help."),
            ],
        );

        Self {
            active_tab: Tab::Chat,
            users,
            messages,
            current_peer: Some("alice".to_string()),
            input_buffer: String::new(),
            input_cursor: 0,
            selected_user: 0,
            is_mock_mode: true,
            screen: AppScreen::Splash,
            passphrase: None,
            passphrase_input: String::new(),
            splash_error: None,
            should_exit: false,
            connection_status: ConnectionStatus::Disconnected,
            erlang_node_name: None,
            engine_status: None,
            detailed_users: None,
            conversations: HashMap::new(),
            should_load_history: false,
            status_message: None,
            admin_form: AdminForm::default(),
            admin_mode: AdminMode::Menu,
            admin_selected_user: 0,
            certificates: None,
            certificates_for_user: None,
            admin_scroll_offset: 0,
            status_scroll_offset: 0,
            help_scroll_offset: 0,
            system_message_queue: VecDeque::new(),
            current_system_message: None,
            server_connection_up: false,
        }
    }

    /// Switch to next tab
    pub fn next_tab(&mut self) {
        self.active_tab = self.active_tab.next();
        // Reset scroll offsets when switching tabs
        self.admin_reset_scroll();
        self.status_reset_scroll();
        self.help_reset_scroll();
    }

    /// Switch to previous tab
    pub fn previous_tab(&mut self) {
        self.active_tab = self.active_tab.previous();
        // Reset scroll offsets when switching tabs
        self.admin_reset_scroll();
        self.status_reset_scroll();
        self.help_reset_scroll();
    }

    /// Select next user in the list
    pub fn next_user(&mut self) {
        if self.users.is_empty() {
            return;
        }
        self.selected_user = (self.selected_user + 1) % self.users.len();
        
        // Auto-open chat when navigating to show message history
        self.open_selected_chat();
    }

    /// Select previous user in the list
    pub fn previous_user(&mut self) {
        if self.users.is_empty() {
            return;
        }
        if self.selected_user == 0 {
            self.selected_user = self.users.len() - 1;
        } else {
            self.selected_user -= 1;
        }
        
        // Auto-open chat when navigating to show message history
        self.open_selected_chat();
    }

    /// Open chat with selected user
    pub fn open_selected_chat(&mut self) {
        let idx = self.selected_user;
        if idx < self.users.len() {
            let peer = self.users[idx].name.clone();
            self.current_peer = Some(peer.clone());

            // Trigger initial history load if this conversation has no messages
            let needs_load = {
                let conv = self.get_conversation(&peer);
                conv.map(|c| c.messages.is_empty()).unwrap_or(true)
            };

            if needs_load {
                self.should_load_history = true;
            }
        }
    }

    /// Send message from input buffer
    pub fn send_message(&mut self) {
        if self.input_buffer.is_empty() {
            return;
        }

        if let Some(peer) = self.current_peer.clone() {
            let content = self.input_buffer.clone();
            let timestamp = std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs();

            let message = Message {
                from: "me".to_string(),
                content: content.clone(),
                is_sent: true,
                timestamp,
            };

            // Add to old messages structure (for backward compatibility)
            self.messages
                .entry(peer.clone())
                .or_insert_with(Vec::new)
                .push(message.clone());

            // Add to conversation view (new structure that UI uses)
            let conv = self.get_conversation_mut(&peer);
            conv.add_message(message);
            conv.scroll_offset = 0; // Reset scroll to show sent message

            // Clear input
            self.input_buffer.clear();
            self.input_cursor = 0;

            // TODO: Phase 2+ - Send via RPC to Erlang
            // chat_rpc:send_message(peer, message)
        }
    }

    /// Add character to input buffer at cursor position
    pub fn input_char(&mut self, c: char) {
        let byte_index = self.char_index_to_byte_index(self.input_cursor);
        self.input_buffer.insert(byte_index, c);
        self.input_cursor += 1;
    }

    /// Remove character before cursor (backspace)
    pub fn input_backspace(&mut self) {
        if self.input_cursor > 0 {
            self.input_cursor -= 1;
            let byte_index = self.char_index_to_byte_index(self.input_cursor);
            self.input_buffer.remove(byte_index);
        }
    }

    /// Clear input buffer
    pub fn clear_input(&mut self) {
        self.input_buffer.clear();
        self.input_cursor = 0;
    }

    /// Move cursor to beginning of line (Ctrl-A)
    pub fn input_move_home(&mut self) {
        self.input_cursor = 0;
    }

    /// Move cursor to end of line (Ctrl-E)
    pub fn input_move_end(&mut self) {
        self.input_cursor = self.input_buffer.chars().count();
    }

    /// Move cursor left one character (Ctrl-B)
    pub fn input_move_left(&mut self) {
        if self.input_cursor > 0 {
            self.input_cursor -= 1;
        }
    }

    /// Move cursor right one character (Ctrl-F)
    pub fn input_move_right(&mut self) {
        let len = self.input_buffer.chars().count();
        if self.input_cursor < len {
            self.input_cursor += 1;
        }
    }

    /// Delete character at cursor (Delete key / Ctrl-D)
    pub fn input_delete(&mut self) {
        let len = self.input_buffer.chars().count();
        if self.input_cursor < len {
            let byte_index = self.char_index_to_byte_index(self.input_cursor);
            self.input_buffer.remove(byte_index);
        }
    }

    /// Convert character index to byte index (for UTF-8 safety)
    fn char_index_to_byte_index(&self, char_index: usize) -> usize {
        self.input_buffer
            .char_indices()
            .nth(char_index)
            .map(|(byte_idx, _)| byte_idx)
            .unwrap_or(self.input_buffer.len())
    }

    /// Simulate receiving a message (mock event bus)
    #[allow(dead_code)]
    pub fn receive_message(&mut self, from: &str, content: &str) {
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();

        let message = Message {
            from: from.to_string(),
            content: content.to_string(),
            is_sent: false,
            timestamp,
        };

        // Add to old messages structure (for backward compatibility)
        self.messages
            .entry(from.to_string())
            .or_insert_with(Vec::new)
            .push(message.clone());

        // Add to conversation view (new structure that UI uses)
        self.get_conversation_mut(from).add_message(message);
    }

    /// Update engine status with new data
    pub fn update_engine_status(&mut self, status: EngineStatus) {
        self.engine_status = Some(status);
    }

    /// Update detailed user list from admin API
    pub fn update_detailed_users(&mut self, users: Vec<DetailedUser>) {
        self.detailed_users = Some(users);
    }

    /// Set a status message to display to the user.
    ///
    /// # Arguments
    ///
    /// * `message` - The status message to display
    pub fn set_status_message(&mut self, message: String) {
        self.status_message = Some(message);
    }

    /// Clear the current status message.
    pub fn clear_status_message(&mut self) {
        self.status_message = None;
    }

    /// Switch active admin form field.
    pub fn admin_focus_next(&mut self) {
        self.admin_form.active_field = match self.admin_form.active_field {
            AdminField::GpgFingerprint => AdminField::KeyPath,
            AdminField::KeyPath => AdminField::Metadata,
            AdminField::Metadata => AdminField::GpgFingerprint,
        };
    }

    /// Switch active admin form field in reverse order.
    pub fn admin_focus_previous(&mut self) {
        self.admin_form.active_field = match self.admin_form.active_field {
            AdminField::GpgFingerprint => AdminField::Metadata,
            AdminField::KeyPath => AdminField::GpgFingerprint,
            AdminField::Metadata => AdminField::KeyPath,
        };
    }

    /// Insert character into active admin field.
    pub fn admin_input_char(&mut self, ch: char) {
        if ch.is_control() {
            return;
        }

        match self.admin_form.active_field {
            AdminField::GpgFingerprint => self.admin_form.gpg_fp.push(ch),
            AdminField::KeyPath => self.admin_form.key_path.push(ch),
            AdminField::Metadata => self.admin_form.metadata.push(ch),
        }
    }

    /// Handle backspace in active admin field.
    pub fn admin_backspace(&mut self) {
        match self.admin_form.active_field {
            AdminField::GpgFingerprint => {
                self.admin_form.gpg_fp.pop();
            }
            AdminField::KeyPath => {
                self.admin_form.key_path.pop();
            }
            AdminField::Metadata => {
                self.admin_form.metadata.pop();
            }
        }
    }

    /// Clear both admin input fields.
    pub fn admin_clear_inputs(&mut self) {
        self.admin_form.gpg_fp.clear();
        self.admin_form.key_path.clear();
        self.admin_form.metadata.clear();
        self.admin_form.active_field = AdminField::GpgFingerprint;
    }

    /// Determine if admin form is ready to submit.
    pub fn admin_form_complete(&self) -> bool {
        !self.admin_form.gpg_fp.trim().is_empty() && !self.admin_form.key_path.trim().is_empty()
    }

    /// Move to next user in admin user list.
    pub fn admin_next_user(&mut self) {
        if let Some(ref users) = self.detailed_users {
            if !users.is_empty() {
                self.admin_selected_user = (self.admin_selected_user + 1) % users.len();
            }
        }
    }

    /// Move to previous user in admin user list.
    pub fn admin_previous_user(&mut self) {
        if let Some(ref users) = self.detailed_users {
            if !users.is_empty() {
                if self.admin_selected_user == 0 {
                    self.admin_selected_user = users.len() - 1;
                } else {
                    self.admin_selected_user -= 1;
                }
            }
        }
    }

    /// Get currently selected user in admin list.
    pub fn admin_get_selected_user(&self) -> Option<&DetailedUser> {
        self.detailed_users
            .as_ref()
            .and_then(|users| users.get(self.admin_selected_user))
    }

    /// Scroll admin view up
    pub fn admin_scroll_up(&mut self) {
        self.admin_scroll_offset = self.admin_scroll_offset.saturating_sub(1);
    }

    /// Scroll admin view down
    pub fn admin_scroll_down(&mut self) {
        self.admin_scroll_offset = self.admin_scroll_offset.saturating_add(1);
    }

    /// Reset admin scroll to top
    pub fn admin_reset_scroll(&mut self) {
        self.admin_scroll_offset = 0;
    }

    /// Scroll status view up
    pub fn status_scroll_up(&mut self) {
        self.status_scroll_offset = self.status_scroll_offset.saturating_add(1);
    }

    /// Scroll status view down
    pub fn status_scroll_down(&mut self) {
        self.status_scroll_offset = self.status_scroll_offset.saturating_sub(1);
    }

    /// Reset status scroll to top
    pub fn status_reset_scroll(&mut self) {
        self.status_scroll_offset = 0;
    }

    /// Scroll help view up
    pub fn help_scroll_up(&mut self) {
        self.help_scroll_offset = self.help_scroll_offset.saturating_add(1);
    }

    /// Scroll help view down
    pub fn help_scroll_down(&mut self) {
        self.help_scroll_offset = self.help_scroll_offset.saturating_sub(1);
    }

    /// Reset help scroll to top
    pub fn help_reset_scroll(&mut self) {
        self.help_scroll_offset = 0;
    }

    /// Get or create conversation view for a peer.
    ///
    /// If a conversation doesn't exist, creates a new one.
    pub fn get_conversation_mut(&mut self, peer: &str) -> &mut ConversationView {
        self.conversations
            .entry(peer.to_string())
            .or_insert_with(|| ConversationView::new(peer.to_string()))
    }

    /// Get conversation view (read-only).
    ///
    /// Returns None if conversation doesn't exist yet.
    pub fn get_conversation(&self, peer: &str) -> Option<&ConversationView> {
        self.conversations.get(peer)
    }

    /// Add a system message to the queue.
    ///
    /// If no message is currently being displayed, immediately shows the new message.
    /// Otherwise, adds it to the queue.
    ///
    /// # Arguments
    ///
    /// * `text` - The message text to display
    /// * `sys_code` - Optional system code (Erlang atom) such as:
    ///   - `"server_connection_up"` - Server is available
    ///   - `"server_connection_down"` - Server is unavailable
    ///
    /// When `sys_code` is "server_connection_down", all users are marked as offline.
    pub fn add_system_message(&mut self, text: String, sys_code: Option<String>) {
        // Update server connection state based on sys_code
        if let Some(ref code) = sys_code {
            match code.as_str() {
                "server_connection_up" => self.server_connection_up = true,
                "server_connection_down" => {
                    self.server_connection_up = false;
                    // Mark all users as offline when server goes down
                    for user in &mut self.users {
                        user.online = false;
                    }
                }
                _ => {}
            }
        }

        let message = if let Some(code) = sys_code {
            SystemMessage::with_code(text, code)
        } else {
            SystemMessage::new(text)
        };
        
        if self.current_system_message.is_none() {
            // No message currently displayed, show immediately
            self.current_system_message = Some(message);
        } else {
            // Queue the message
            self.system_message_queue.push_back(message);
        }
    }

    /// Update the system message display, advancing to the next message if the
    /// minimum display time has elapsed.
    ///
    /// Should be called periodically (e.g., from the event loop).
    pub fn update_system_message(&mut self) {
        if let Some(ref current) = self.current_system_message {
            // Check if we can advance to the next message
            if current.can_advance() {
                // Try to get the next message from the queue
                if let Some(mut next_message) = self.system_message_queue.pop_front() {
                    // Reset timestamp so it displays for the full duration
                    next_message.reset_timestamp();
                    self.current_system_message = Some(next_message);
                } else {
                    // No more messages, clear current
                    self.current_system_message = None;
                }
            }
        }
    }

    /// Get the current system message text for display.
    pub fn get_current_system_message(&self) -> Option<&str> {
        self.current_system_message.as_ref().map(|m| m.text.as_str())
    }

    /// Clear all system messages (current and queued).
    #[allow(dead_code)]
    pub fn clear_system_messages(&mut self) {
        self.current_system_message = None;
        self.system_message_queue.clear();
    }
}

/// Application screen state.
///
/// Determines which top-level screen is currently displayed.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum AppScreen {
    /// Initial splash screen with passphrase prompt
    Splash,
    /// Main application screen with tabs
    Main,
}

/// Secure string wrapper with automatic memory zeroization.
///
/// Wraps a `String` and ensures the memory is zeroized when dropped,
/// preventing sensitive data (like passphrases) from remaining in memory.
///
/// # Security
///
/// When this struct is dropped, the underlying string bytes are overwritten
/// with zeros before being deallocated.
///
/// # Examples
///
/// ```
/// # use cryptic_tui::app::Secret;
/// let secret = Secret::new("my_passphrase".to_string());
/// // Memory will be zeroized when secret goes out of scope
/// ```
#[derive(Debug, Clone)]
pub struct Secret(String);

impl Secret {
    /// Create a new secret from a string.
    ///
    /// # Arguments
    ///
    /// * `v` - The secret value to wrap
    ///
    /// # Examples
    ///
    /// ```
    /// # use cryptic_tui::app::Secret;
    /// let secret = Secret::new("password123".to_string());
    /// ```
    pub fn new(v: String) -> Self {
        Self(v)
    }

    /// Get a string slice of the secret value.
    ///
    /// # Returns
    ///
    /// A reference to the inner string.
    ///
    /// # Security Warning
    ///
    /// The returned reference does not have the same zeroization guarantees
    /// as the `Secret` struct itself. Avoid storing this reference or
    /// creating copies of the data.
    #[allow(dead_code)]
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

/// Implement `Drop` to ensure memory is zeroized when the secret is dropped.
impl Drop for Secret {
    fn drop(&mut self) {
        self.0.zeroize();
    }
}