cryptic_tui/

erlang.rs

//! Erlang node connectivity and RPC communication.
//!
//! This module provides functionality to connect to Erlang nodes using the
//! distributed Erlang protocol and make RPC calls for messaging operations,
//! including persistent message history loading.
//!
//! # Architecture
//!
//! The module uses `erl_dist` for the distributed Erlang protocol and `erl_rpc`
//! for making RPC calls. The connection is established asynchronously and the
//! RPC client runs in a background task.
//!
//! # Message History
//!
//! The module provides three methods for loading message history:
//! - `load_recent_messages()` - Load the most recent N messages
//! - `load_messages_before()` - Load older messages before a timestamp (for scrolling up)
//! - `load_messages_range()` - Load messages within a time range
//!
//! Messages are retrieved from the Erlang backend's SQLite database via RPC calls
//! to `cryptic_rpc` module, which decrypts and returns them as structured data.
//!
//! # Examples
//!
//! ```no_run
//! use cryptic_tui::erlang::ErlangConnection;
//!
//! #[tokio::main]
//! async fn main() -> anyhow::Result<()> {
//!     // Create connection
//!     let conn = ErlangConnection::new(
//!         "admin@localhost".to_string(),
//!         "mycookie".to_string()
//!     );
//!
//!     // Connect to remote node
//!     conn.connect().await?;
//!
//!     // Load recent message history
//!     let messages = conn.load_recent_messages("alice", 50).await?;
//!     println!("Loaded {} messages", messages.len());
//!
//!     Ok(())
//! }
//! ```

use anyhow::{anyhow, Context, Result};
use async_lock::Mutex;
use eetf::{Binary, List, Term};
use std::sync::Arc;
use tracing::{debug, error, info, warn};

/// Parse message history from Erlang RPC response.
///
/// Expected format from backend:
/// ```erlang
/// {ok, [
///   {FromUser, ToUser, Message, {{Y,M,D},{H,Min,S}}, ServerHost, ServerPort},
///   ...
/// ]}
/// ```
///
/// # Arguments
///
/// * `term` - EETF Term containing the response
/// * `current_user` - Username of the current user to determine sent/received
///
/// # Returns
///
/// Vector of Message structs ordered by timestamp
///
/// # Errors
///
/// Returns error if the term format is invalid or parsing fails
fn parse_message_history(term: Term, current_user: &str) -> Result<Vec<crate::app::Message>> {
    use crate::app::Message;

    // Expected: {ok, [tuple list]}
    match term {
        Term::Tuple(tuple) if tuple.elements.len() == 2 => {
            // Check for {ok, List}
            if let Term::Atom(atom) = &tuple.elements[0] {
                if atom.name != "ok" {
                    return Err(anyhow!(
                        "Expected {{ok, Messages}}, got {{{},...}}",
                        atom.name
                    ));
                }
            } else {
                return Err(anyhow!("Expected atom 'ok' in tuple"));
            }

            // Parse message list
            if let Term::List(list) = &tuple.elements[1] {
                let mut messages = Vec::new();

                for item in &list.elements {
                    if let Term::Tuple(msg_tuple) = item {
                        // Expected: {FromUser, ToUser, Message, {{Y,M,D},{H,Min,S}}, ServerHost, ServerPort}
                        if msg_tuple.elements.len() != 6 {
                            warn!(
                                "Skipping message tuple with unexpected length: {} (expected 6)",
                                msg_tuple.elements.len()
                            );
                            continue;
                        }

                        let from = extract_binary(&msg_tuple.elements[0])?;
                        let _to = extract_binary(&msg_tuple.elements[1])?;
                        let content = extract_binary(&msg_tuple.elements[2])?;

                        // Parse Erlang datetime: {{Year,Month,Day},{Hour,Min,Sec}}
                        let timestamp = match &msg_tuple.elements[3] {
                            Term::Tuple(dt_tuple) if dt_tuple.elements.len() == 2 => {
                                // Extract date: {Year, Month, Day}
                                let (year, month, day) = match &dt_tuple.elements[0] {
                                    Term::Tuple(date) if date.elements.len() == 3 => {
                                        let y = extract_integer(&date.elements[0])?;
                                        let m = extract_integer(&date.elements[1])?;
                                        let d = extract_integer(&date.elements[2])?;
                                        (y, m, d)
                                    }
                                    _ => return Err(anyhow!("Invalid date tuple format")),
                                };

                                // Extract time: {Hour, Min, Sec}
                                let (hour, min, sec) = match &dt_tuple.elements[1] {
                                    Term::Tuple(time) if time.elements.len() == 3 => {
                                        let h = extract_integer(&time.elements[0])?;
                                        let m = extract_integer(&time.elements[1])?;
                                        let s = extract_integer(&time.elements[2])?;
                                        (h, m, s)
                                    }
                                    _ => return Err(anyhow!("Invalid time tuple format")),
                                };

                                // Convert to Unix timestamp
                                use chrono::{TimeZone, Utc};
                                match Utc.with_ymd_and_hms(
                                    year as i32,
                                    month as u32,
                                    day as u32,
                                    hour as u32,
                                    min as u32,
                                    sec as u32,
                                ) {
                                    chrono::LocalResult::Single(dt) => dt.timestamp() as u64,
                                    _ => {
                                        warn!(
                                            "Invalid datetime: {}-{}-{} {}:{}:{}",
                                            year, month, day, hour, min, sec
                                        );
                                        0
                                    }
                                }
                            }
                            _ => {
                                warn!("Invalid timestamp format, expected datetime tuple");
                                0
                            }
                        };

                        // Note: elements[4] is ServerHost, elements[5] is ServerPort - we ignore these

                        // Determine if message was sent by us
                        let is_sent = from == current_user;

                        messages.push(Message {
                            from: from.clone(),
                            content: content.clone(),
                            is_sent,
                            timestamp,
                        });
                    } else {
                        warn!("Skipping non-tuple item in message list");
                    }
                }

                info!("Parsed {} messages from history", messages.len());
                Ok(messages)
            } else {
                Err(anyhow!(
                    "Expected list of messages, got: {:?}",
                    tuple.elements[1]
                ))
            }
        }
        Term::Tuple(tuple) if tuple.elements.len() == 2 => {
            // Check for {error, Reason}
            if let Term::Atom(atom) = &tuple.elements[0] {
                if atom.name == "error" {
                    let reason = format!("{:?}", tuple.elements[1]);
                    return Err(anyhow!("Backend returned error: {}", reason));
                }
            }
            Err(anyhow!("Unexpected tuple format: {:?}", tuple))
        }
        _ => Err(anyhow!("Expected tuple {{ok, Messages}}, got: {:?}", term)),
    }
}

/// Extract a string from a binary term
fn extract_binary(term: &Term) -> Result<String> {
    match term {
        Term::Binary(bin) => {
            // Use lossy conversion to handle non-UTF-8 bytes (e.g., Latin-1 encoded strings)
            Ok(String::from_utf8_lossy(&bin.bytes).into_owned())
        }
        Term::Atom(atom) => Ok(atom.name.clone()),
        _ => Err(anyhow!("Expected binary or atom, got: {:?}", term)),
    }
}

/// Extract an integer from a term
fn extract_integer(term: &Term) -> Result<i64> {
    match term {
        Term::FixInteger(i) => Ok(i.value as i64),
        Term::BigInteger(i) => {
            // Convert BigInt to i64 via string parsing
            let s = i.value.to_string();
            s.parse::<i64>()
                .context("BigInteger too large to fit in i64")
        }
        _ => Err(anyhow!("Expected integer, got: {:?}", term)),
    }
}

/// Connection status to an Erlang node.
///
/// Tracks the current state of the distributed Erlang connection.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ConnectionStatus {
    /// Not connected to any node
    Disconnected,
    /// Connection attempt in progress
    Connecting,
    /// Successfully connected and ready for RPC calls
    Connected,
    /// Connection failed or encountered an error
    Error,
}

impl ConnectionStatus {
    /// Get a human-readable string representation of the status.
    ///
    /// # Returns
    ///
    /// A static string describing the connection status.
    pub fn as_str(&self) -> &str {
        match self {
            ConnectionStatus::Disconnected => "Disconnected",
            ConnectionStatus::Connecting => "Connecting...",
            ConnectionStatus::Connected => "Connected",
            ConnectionStatus::Error => "Error",
        }
    }
}

/// Manages a connection to a remote Erlang node.
///
/// This struct handles the distributed Erlang protocol connection and provides
/// methods for making RPC calls to the remote node.
///
/// # Thread Safety
///
/// This struct uses `Arc<Mutex<>>` internally and can be safely shared across
/// threads and async tasks.
///
/// # Examples
///
/// ```no_run
/// # use cryptic_tui::erlang::ErlangConnection;
/// # #[tokio::main]
/// # async fn main() -> anyhow::Result<()> {
/// let conn = ErlangConnection::new(
///     "admin@localhost".to_string(),
///     "secretcookie".to_string()
/// );
///
/// conn.connect().await?;
/// # Ok(())
/// # }
/// ```
pub struct ErlangConnection {
    handle: Arc<Mutex<Option<erl_rpc::RpcClientHandle>>>,
    remote_node_name: String,
    cookie: String,
    status: Arc<Mutex<ConnectionStatus>>,
}

impl ErlangConnection {
    /// Create a new Erlang connection.
    ///
    /// This does not establish the connection immediately. Call [`connect`](Self::connect)
    /// to actually connect to the remote node.
    ///
    /// # Arguments
    ///
    /// * `remote_node_name` - Full node name (e.g., "admin@localhost")
    /// * `cookie` - Erlang cookie for authentication
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use cryptic_tui::erlang::ErlangConnection;
    /// let conn = ErlangConnection::new(
    ///     "admin@localhost".to_string(),
    ///     "mycookie".to_string()
    /// );
    /// ```
    pub fn new(remote_node_name: String, cookie: String) -> Self {
        info!("ErlangConnection created for node: {}", remote_node_name);
        Self {
            handle: Arc::new(Mutex::new(None)),
            remote_node_name,
            cookie,
            status: Arc::new(Mutex::new(ConnectionStatus::Disconnected)),
        }
    }

    /// Connect to the remote Erlang node.
    ///
    /// Establishes a distributed Erlang connection and spawns a background task
    /// to run the RPC client loop. The connection uses a unique local node name
    /// based on the process ID.
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - The remote node is unreachable
    /// - The cookie is incorrect
    /// - Network issues prevent connection
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use cryptic_tui::erlang::ErlangConnection;
    /// # #[tokio::main]
    /// # async fn main() -> anyhow::Result<()> {
    /// let conn = ErlangConnection::new(
    ///     "admin@localhost".to_string(),
    ///     "mycookie".to_string()
    /// );
    ///
    /// conn.connect().await?;
    /// println!("Connected!");
    /// # Ok(())
    /// # }
    /// ```
    pub async fn connect(&self) -> Result<()> {
        info!("Starting connection process to {}", self.remote_node_name);
        *self.status.lock().await = ConnectionStatus::Connecting;

        // Connect to remote node - RpcClient::connect is a static method
        info!(
            "Attempting to connect to remote node: {}",
            self.remote_node_name
        );
        let client = erl_rpc::RpcClient::connect(&self.remote_node_name, &self.cookie)
            .await
            .with_context(|| format!("Failed to connect to {}", self.remote_node_name))?;

        // Get the handle for making RPC calls
        let handle = client.handle();

        // Spawn the client's run loop in a background task
        smol::spawn(async move {
            if let Err(e) = client.run().await {
                error!("RPC client run loop error: {:?}", e);
            }
        })
        .detach();

        info!("Successfully connected to {}", self.remote_node_name);
        *self.handle.lock().await = Some(handle);
        *self.status.lock().await = ConnectionStatus::Connected;

        Ok(())
    }

    /// Get the remote node name.
    ///
    /// # Returns
    ///
    /// The full node name string (e.g., "admin@localhost").
    pub fn get_remote_node_name(&self) -> &str {
        &self.remote_node_name
    }

    /// Extract the username from the node name.
    ///
    /// # Returns
    ///
    /// The username portion of the node name (e.g., "admin" from "admin@localhost").
    /// Returns the full node name if no '@' is found.
    pub fn get_username(&self) -> &str {
        self.remote_node_name
            .split('@')
            .next()
            .unwrap_or(&self.remote_node_name)
    }

    /// Get the Erlang cookie.
    pub fn get_cookie(&self) -> &str {
        &self.cookie
    }

    /// Call an RPC function on the remote Erlang node.
    ///
    /// Makes a synchronous RPC call and waits for the result. The call uses
    /// Erlang's external term format (EETF) for encoding arguments and results.
    ///
    /// # Arguments
    ///
    /// * `module` - Erlang module name
    /// * `function` - Function name to call
    /// * `args` - List of arguments as EETF terms
    ///
    /// # Returns
    ///
    /// The result as an EETF [`Term`].
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - Not connected to a node
    /// - The RPC call fails
    /// - The module or function doesn't exist
    /// - Network issues occur
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use cryptic_tui::erlang::ErlangConnection;
    /// # use eetf::{List, Binary};
    /// # #[tokio::main]
    /// # async fn main() -> anyhow::Result<()> {
    /// # let conn = ErlangConnection::new("admin@localhost".into(), "cookie".into());
    /// # conn.connect().await?;
    /// // Call erlang:node()
    /// let result = conn.rpc_call("erlang", "node", List::nil()).await?;
    /// println!("Node: {:?}", result);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn rpc_call(&self, module: &str, function: &str, args: List) -> Result<Term> {
        debug!("RPC call: {}:{}({:?})", module, function, args);

        let mut handle_guard = self.handle.lock().await;
        let handle = handle_guard
            .as_mut()
            .context("Not connected to Erlang node")?;

        let result = handle
            .call(module.into(), function.into(), args)
            .await
            .map_err(|e| {
                error!(
                    "RPC call {}:{} failed with error: {:?}",
                    module, function, e
                );
                anyhow!("RPC call failed: {}:{} - {:?}", module, function, e)
            })?;

        debug!("RPC call {}:{} returned: {:?}", module, function, result);
        Ok(result)
    }

    /// Subscribe to the cryptic event bus for receiving events.
    ///
    /// # Errors
    ///
    /// Currently always returns `Ok(())`.
    pub async fn subscribe_to_event_bus(&self) -> Result<()> {
        // TODO: Implement event bus subscription
        // This will call cryptic_event_bus:subscribe(Pid)
        Ok(())
    }

    /// Start the cryptic_tui_bridge on the Erlang node to forward events to our Rust node.
    ///
    /// This should be called after the dist_node is connected so the bridge knows
    /// where to send messages.
    ///
    /// # Arguments
    ///
    /// * `rust_node_name` - The full node name of our Rust node (e.g., "cryptic_tui@127.0.0.1")
    /// * `passphrase` - User's passphrase for accessing encrypted chat storage
    ///
    /// # Returns
    ///
    /// The PID of the started bridge process.
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails or the bridge fails to start.
    pub async fn start_tui_bridge(
        &self,
        rust_node_name: &str,
        passphrase: &str,
    ) -> Result<eetf::Term> {
        let username = self.get_username();
        info!(
            "Starting cryptic_tui_bridge for Rust node: {} (user: {})",
            rust_node_name, username
        );
        info!(
            "  Node: {}, Username: {}, Passphrase length: {}",
            rust_node_name,
            username,
            passphrase.len()
        );

        // First, try to stop any existing bridge
        info!("Checking for existing cryptic_tui_bridge...");
        match self.stop_tui_bridge().await {
            Ok(_) => info!("Stopped existing bridge"),
            Err(e) => info!("No existing bridge to stop (this is OK): {}", e),
        }

        // Call cryptic_tui_bridge:start(Nodename, Username, Passphrase)
        let username_binary = eetf::Binary::from(username.as_bytes().to_vec());
        let passphrase_binary = eetf::Binary::from(passphrase.as_bytes().to_vec());

        info!("  Username binary bytes: {:?}", username_binary.bytes);
        info!("  Passphrase binary bytes: {:?}", passphrase_binary.bytes);

        let node_term = eetf::Term::Atom(eetf::Atom::from(rust_node_name));
        let username_term = eetf::Term::Binary(username_binary);
        let passphrase_term = eetf::Term::Binary(passphrase_binary);

        info!("  Term 1 (node): {:?}", node_term);
        info!("  Term 2 (username): {:?}", username_term);
        info!("  Term 3 (passphrase): {:?}", passphrase_term);

        let args = eetf::List::from(vec![node_term, username_term, passphrase_term]);

        info!("  Final args list has {} elements", args.elements.len());
        info!("  Final args: {:?}", args);

        let result = self.rpc_call("cryptic_tui_bridge", "start", args).await?;

        // Handle both success and already_started cases
        match &result {
            eetf::Term::Tuple(tuple) if tuple.elements.len() == 2 => {
                if let eetf::Term::Atom(ref atom) = tuple.elements[0] {
                    match atom.name.as_str() {
                        "ok" => {
                            info!("cryptic_tui_bridge started successfully: {:?}", result);
                            Ok(result)
                        }
                        "error" => {
                            // Check if it's {error, {already_started, Pid}}
                            if let eetf::Term::Tuple(ref inner) = tuple.elements[1] {
                                if inner.elements.len() == 2 {
                                    if let eetf::Term::Atom(ref inner_atom) = inner.elements[0] {
                                        if inner_atom.name == "already_started" {
                                            info!("cryptic_tui_bridge already running (this is OK): {:?}", result);
                                            return Ok(result);
                                        }
                                    }
                                }
                            }
                            // Other errors
                            warn!("cryptic_tui_bridge returned error: {:?}", result);
                            Ok(result)
                        }
                        _ => {
                            info!("cryptic_tui_bridge returned: {:?}", result);
                            Ok(result)
                        }
                    }
                } else {
                    Ok(result)
                }
            }
            _ => {
                info!("cryptic_tui_bridge returned: {:?}", result);
                Ok(result)
            }
        }
    }

    /// Stop an existing TUI bridge process.
    ///
    /// Calls `cryptic_tui_bridge:stop/1` with the bridge's registered PID.
    /// This is useful when restarting the TUI to ensure a clean state.
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails or if the bridge is not running.
    pub async fn stop_tui_bridge(&self) -> Result<()> {
        info!("Stopping existing cryptic_tui_bridge if running");

        // First, find the bridge PID using whereis
        // Call erlang:whereis(cryptic_tui_bridge)
        let whereis_args = eetf::List::from(vec![
            eetf::Term::Atom(eetf::Atom::from("cryptic_tui_bridge"))
        ]);

        match self.rpc_call("erlang", "whereis", whereis_args).await {
            Ok(eetf::Term::Pid(pid)) => {
                // Bridge is running, stop it
                info!("Found existing bridge at PID: {:?}, stopping it", pid);
                
                let stop_args = eetf::List::from(vec![
                    eetf::Term::Pid(pid)
                ]);
                
                self.rpc_call("cryptic_tui_bridge", "stop", stop_args).await?;
                info!("Successfully stopped existing bridge");
                Ok(())
            }
            Ok(eetf::Term::Atom(atom)) if atom.name == "undefined" => {
                // No bridge running, that's OK
                info!("No existing bridge found (undefined)");
                Ok(())
            }
            Ok(other) => {
                info!("whereis returned unexpected value: {:?}", other);
                Ok(())
            }
            Err(e) => {
                info!("Failed to check for existing bridge: {}", e);
                Ok(()) // Don't fail if we can't check
            }
        }
    }

    /// Request the list of online users from the server.
    ///
    /// Calls cryptic_rpc:online_users/0 which sends the request to the server.
    /// The response will arrive as a websocket_message event via the dist_node.
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails.
    pub async fn request_online_users(&self) -> Result<()> {
        info!("Requesting online users list");

        // Call cryptic_rpc:online_users/0 (no arguments needed)
        let args = eetf::List::from(vec![]);

        self.rpc_call("cryptic_rpc", "online_users", args).await?;
        info!("Online users request sent");
        Ok(())
    }

    /// Request engine status from the Cryptic engine.
    ///
    /// Calls cryptic_rpc:engine_status/0 which returns detailed status about
    /// the encryption engine including active sessions, ratchet states, etc.
    ///
    /// # Returns
    ///
    /// Raw EETF Term containing the engine status map
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails.
    pub async fn request_engine_status(&self) -> Result<Term> {
        info!("Requesting engine status");

        // Call cryptic_rpc:engine_status/0 (no arguments needed)
        let args = eetf::List::from(vec![]);

        let result = self.rpc_call("cryptic_rpc", "engine_status", args).await?;
        info!("Engine status request completed");
        Ok(result)
    }

    /// Request detailed user list from admin API.
    ///
    /// Calls `cryptic_rpc:list_users/0` which triggers an asynchronous operation.
    /// The response will arrive later via the distributed Erlang node as a
    /// `list_users_response` message.
    ///
    /// # Returns
    ///
    /// Ok(()) if the request was sent successfully. The actual response
    /// will be received asynchronously through the event bus.
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails.
    pub async fn request_list_users(&self) -> Result<()> {
        info!("Requesting detailed user list");

        // Call cryptic_rpc:list_users/0 (no arguments needed)
        let args = eetf::List::from(vec![]);

        self.rpc_call("cryptic_rpc", "list_users", args).await?;
        info!("User list request sent");
        Ok(())
    }

    /// Load the most recent N messages from a conversation.
    ///
    /// Calls `cryptic_chat_storage:get_conversation/4` to fetch recent messages
    /// between the current user and the specified peer.
    ///
    /// # Arguments
    ///
    /// * `peer` - Username of the peer
    /// * `limit` - Maximum number of messages to retrieve
    ///
    /// # Returns
    ///
    /// Vector of Message structs ordered by timestamp (oldest first)
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails or parsing fails.
    pub async fn load_recent_messages(
        &self,
        peer: &str,
        limit: usize,
    ) -> Result<Vec<crate::app::Message>> {
        let current_user = self.get_username();
        info!(
            "Loading recent {} messages for {} <-> {}",
            limit, current_user, peer
        );

        // Call cryptic_rpc:load_recent_messages(CurrentUser, Peer, Limit)
        let args = eetf::List::from(vec![
            eetf::Term::Binary(eetf::Binary::from(current_user.as_bytes().to_vec())),
            eetf::Term::Binary(eetf::Binary::from(peer.as_bytes().to_vec())),
            eetf::Term::FixInteger((limit as i32).into()),
        ]);

        let result = self
            .rpc_call("cryptic_rpc", "load_recent_messages", args)
            .await?;

        parse_message_history(result, current_user)
    }

    /// Load messages older than a specific timestamp.
    ///
    /// Used for infinite scrolling - loads the next batch of older messages
    /// when user scrolls to the top of the conversation.
    ///
    /// # Arguments
    ///
    /// * `peer` - Username of the peer
    /// * `before_timestamp` - Unix timestamp - only load messages before this time
    /// * `limit` - Maximum number of messages to retrieve
    ///
    /// # Returns
    ///
    /// Vector of Message structs ordered by timestamp (oldest first)
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails or parsing fails.
    pub async fn load_messages_before(
        &self,
        peer: &str,
        before_timestamp: u64,
        limit: usize,
    ) -> Result<Vec<crate::app::Message>> {
        let current_user = self.get_username();
        info!(
            "Loading {} messages before timestamp {} for {} <-> {}",
            limit, before_timestamp, current_user, peer
        );

        let args = eetf::List::from(vec![
            eetf::Term::Binary(eetf::Binary::from(current_user.as_bytes().to_vec())),
            eetf::Term::Binary(eetf::Binary::from(peer.as_bytes().to_vec())),
            eetf::Term::BigInteger((before_timestamp as i64).into()),
            eetf::Term::FixInteger((limit as i32).into()),
        ]);

        let result = self
            .rpc_call("cryptic_rpc", "load_messages_before", args)
            .await?;

        parse_message_history(result, current_user)
    }

    /// Load messages in a specific time range.
    ///
    /// Useful for jumping to a specific date or searching within a time period.
    ///
    /// # Arguments
    ///
    /// * `peer` - Username of the peer
    /// * `start_timestamp` - Unix timestamp for start of range (inclusive)
    /// * `end_timestamp` - Unix timestamp for end of range (inclusive)
    ///
    /// # Returns
    ///
    /// Vector of Message structs ordered by timestamp (oldest first)
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails or parsing fails.
    #[allow(dead_code)]
    pub async fn load_messages_range(
        &self,
        peer: &str,
        start_timestamp: u64,
        end_timestamp: u64,
    ) -> Result<Vec<crate::app::Message>> {
        let current_user = self.get_username();
        info!(
            "Loading messages from {} to {} for {} <-> {}",
            start_timestamp, end_timestamp, current_user, peer
        );

        let args = eetf::List::from(vec![
            eetf::Term::Binary(eetf::Binary::from(current_user.as_bytes().to_vec())),
            eetf::Term::Binary(eetf::Binary::from(peer.as_bytes().to_vec())),
            eetf::Term::BigInteger((start_timestamp as i64).into()),
            eetf::Term::BigInteger((end_timestamp as i64).into()),
        ]);

        let result = self
            .rpc_call("cryptic_rpc", "load_messages_range", args)
            .await?;

        parse_message_history(result, current_user)
    }

    /// Register a new user via admin RPC.
    pub async fn admin_register_user(&self, fingerprint: &str, key_path: &str, metadata: &str) -> Result<()> {
        info!(
            "Calling admin_register for fingerprint {} using key path {} with metadata '{}'",
            fingerprint, key_path, metadata
        );

        let args = List::from(vec![
            Binary::from(fingerprint.as_bytes().to_vec()).into(),
            Binary::from(key_path.as_bytes().to_vec()).into(),
            Binary::from(metadata.as_bytes().to_vec()).into(),
        ]);

        match self.rpc_call("cryptic_rpc", "admin_register", args).await? {
            Term::Atom(atom) if atom.name == "ok" => Ok(()),
            Term::Tuple(tuple) if tuple.elements.len() == 2 => {
                Err(anyhow!("admin_register error: {:?}", tuple.elements[1]))
            }
            other => Err(anyhow!("Unexpected admin_register response: {:?}", other)),
        }
    }

    /// Suspend a user via admin RPC.
    pub async fn admin_suspend_user(&self, fingerprint: &str) -> Result<()> {
        info!("Calling admin_suspend for fingerprint {}", fingerprint);

        let args = List::from(vec![Binary::from(fingerprint.as_bytes().to_vec()).into()]);

        match self
            .rpc_call("cryptic_rpc", "admin_suspend", args)
            .await?
        {
            Term::Atom(atom) if atom.name == "ok" => Ok(()),
            Term::Tuple(tuple) if tuple.elements.len() == 2 => {
                Err(anyhow!("admin_suspend error: {:?}", tuple.elements[1]))
            }
            other => Err(anyhow!("Unexpected admin_suspend response: {:?}", other)),
        }
    }

    /// Reactivate a suspended user via admin RPC.
    pub async fn admin_reactivate_user(&self, fingerprint: &str) -> Result<()> {
        info!(
            "Calling admin_reactivate for fingerprint {}",
            fingerprint
        );

        let args = List::from(vec![Binary::from(fingerprint.as_bytes().to_vec()).into()]);

        match self
            .rpc_call("cryptic_rpc", "admin_reactivate", args)
            .await?
        {
            Term::Atom(atom) if atom.name == "ok" => Ok(()),
            Term::Tuple(tuple) if tuple.elements.len() == 2 => {
                Err(anyhow!("admin_reactivate error: {:?}", tuple.elements[1]))
            }
            other => Err(anyhow!(
                "Unexpected admin_reactivate response: {:?}",
                other
            )),
        }
    }

    /// Revoke a user via admin RPC.
    pub async fn admin_revoke_user(&self, fingerprint: &str) -> Result<()> {
        info!("Calling admin_revoke for fingerprint {}", fingerprint);

        let args = List::from(vec![Binary::from(fingerprint.as_bytes().to_vec()).into()]);

        match self
            .rpc_call("cryptic_rpc", "admin_revoke", args)
            .await?
        {
            Term::Atom(atom) if atom.name == "ok" => Ok(()),
            Term::Tuple(tuple) if tuple.elements.len() == 2 => {
                Err(anyhow!("admin_revoke error: {:?}", tuple.elements[1]))
            }
            other => Err(anyhow!("Unexpected admin_revoke response: {:?}", other)),
        }
    }

    /// Trigger certificate renewal via RPC.
    pub async fn renew_certificate(&self) -> Result<()> {
        info!("Calling cryptic_rpc:renew_certificate()");

        let args = List::from(vec![]);

        match self
            .rpc_call("cryptic_rpc", "renew_certificate", args)
            .await?
        {
            Term::Atom(atom) if atom.name == "ok" => Ok(()),
            Term::Tuple(tuple) if tuple.elements.len() == 2 => {
                if let Term::Atom(atom) = &tuple.elements[0] {
                    if atom.name == "ok" {
                        return Ok(());
                    }
                }
                Err(anyhow!("renew_certificate error: {:?}", tuple.elements[1]))
            }
            other => Err(anyhow!("Unexpected renew_certificate response: {:?}", other)),
        }
    }

    /// List certificates for a user via admin RPC.
    ///
    /// Calls `cryptic_rpc:admin_list_certificates/1` which triggers an asynchronous operation.
    /// The response will arrive later via the distributed Erlang node as a
    /// `list_certificates_response` message.
    ///
    /// # Arguments
    ///
    /// * `fingerprint` - GPG fingerprint of the user
    ///
    /// # Returns
    ///
    /// Ok(()) if the request was sent successfully. The actual response
    /// will be received asynchronously through the event bus.
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails.
    pub async fn admin_list_certificates(&self, fingerprint: &str) -> Result<()> {
        info!("Requesting certificate list for fingerprint {}", fingerprint);

        let args = List::from(vec![Binary::from(fingerprint.as_bytes().to_vec()).into()]);

        self.rpc_call("cryptic_rpc", "admin_list_certificates", args).await?;
        info!("Certificate list request sent for {}", fingerprint);
        Ok(())
    }
}

// Helper functions for common RPC calls (to be implemented in phases)
impl ErlangConnection {
    /// Load message history from Erlang backend.
    ///
    /// # Arguments
    ///
    /// * `peer` - Username of the peer to fetch history for
    /// * `limit` - Maximum number of messages to retrieve
    ///
    /// # Returns
    ///
    /// Vector of message strings (currently empty, to be implemented).
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails.
    ///
    /// # TODO
    ///
    /// Parse the result properly and return actual messages.
    #[allow(dead_code)]
    pub async fn load_history(&self, peer: &str, limit: usize) -> Result<Vec<String>> {
        let args = List::from(vec![
            Binary::from(peer.as_bytes().to_vec()).into(),
            Term::FixInteger((limit as i32).into()),
        ]);

        let _result = self.rpc_call("chat_rpc", "history", args).await?;

        // TODO: Parse result properly
        Ok(vec![])
    }

    /// Get the user roster (contact list).
    ///
    /// # Returns
    ///
    /// Vector of usernames (currently empty, to be implemented).
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails.
    ///
    /// # TODO
    ///
    /// Parse the result properly and return actual usernames.
    #[allow(dead_code)]
    pub async fn get_roster(&self) -> Result<Vec<String>> {
        let _result = self.rpc_call("chat_rpc", "roster", List::nil()).await?;

        // TODO: Parse result properly
        Ok(vec![])
    }

    /// Send a message to a peer.
    ///
    /// # Arguments
    ///
    /// * `peer` - Username of the recipient
    /// * `message` - Message content to send
    ///
    /// # Errors
    ///
    /// Returns an error if the RPC call fails.
    ///
    /// # TODO
    ///
    /// This should trigger encryption and delivery through the Cryptic engine.
    #[allow(dead_code)]
    pub async fn send_message(&self, peer: &str, message: &str) -> Result<()> {
        let args = List::from(vec![
            Binary::from(peer.as_bytes()).into(),
            Binary::from(message.as_bytes()).into(),
        ]);

        self.rpc_call("chat_rpc", "send_message", args).await?;

        Ok(())
    }
}