cryptic_tui/

formatting.rs

//! Text formatting for emoji and markdown processing.
//!
//! This module provides transformation of ASCII emoticons to Unicode emoji
//! and basic markdown formatting (*bold*, _italic_, `code`) with Ratatui styling.
//!
//! ## Supported ASCII Emoticons
//!
//! The following ASCII emoticons are automatically converted to Unicode emoji:
//!
//! | ASCII | Emoji | Description |
//! |-------|-------|-------------|
//! | `(y)` | 👍 | Thumbs up |
//! | `:-)` | 😊 | Smile |
//! | `:)` | 🙂 | Simple smile |
//! | `:-D` | 😄 | Grin |
//! | `:D` | 😄 | Grin |
//! | `;-)` | 😉 | Wink |
//! | `;)` | 😉 | Wink |
//! | `:-P` | 😛 | Tongue |
//! | `:P` | 😛 | Tongue |
//! | `:-(` | 😞 | Sad |
//! | `:(` | 😞 | Sad |
//! | `:/` | 😕 | Unsure |
//! | `:o` | 😮 | Surprised |
//! | `:O` | 😮 | Surprised |
//! | `:*` | 😘 | Kiss |
//! | `:\|` | 😐 | Neutral |
//! | `:Q` | 👶 | Baby face |
//!
//! ## Markdown Formatting
//!
//! - `*bold text*` - Renders in bold
//! - `_italic text_` - Renders in italic  
//! - `` `code` `` - Renders with code styling (reversed video)
//!
//! **Important**: Content within backticks is treated as **verbatim text**.
//! No emoji replacement, bold, or italic formatting will be applied inside
//! backtick pairs. For example:
//! - `` `*not bold*` `` - The asterisks remain literal
//! - `` `:) no emoji` `` - The emoticon remains as `:)`
//!
//! Processing order ensures backticks are handled first, protecting their
//! content from all subsequent transformations.

use ratatui::{
    style::{Modifier, Style},
    text::{Line, Span},
};

/// Emoji replacement mappings (ASCII -> Unicode)
const EMOJI_MAP: &[(&str, &str)] = &[
    ("(y)", "👍"), // Thumbs up
    (":-)", "😊"), // Smile
    (":)", "🙂"),  // Simple smile
    (":-D", "😄"), // Grin
    (":D", "😄"),  // Grin
    (";-)", "😉"), // Wink
    (";)", "😉"),  // Wink
    (":-P", "😛"), // Tongue
    (":P", "😛"),  // Tongue
    (":-(", "😞"), // Sad
    (":(", "😞"),  // Sad
    (":/", "😕"),  // Unsure
    (":o", "😮"),  // Surprised
    (":O", "😮"),  // Surprised
    (":*", "😘"),  // Kiss
    (":|", "😐"),  // Neutral
    (":Q", "👶"),  // Baby face
];

/// Text segment type after processing backticks
#[derive(Debug, Clone)]
enum Segment {
    Text(String),
    Code(String),
}

/// Process text with emoji and markdown formatting.
///
/// Processing order:
/// 1. Backticks (code) - processed first, content protected from further formatting
/// 2. Emoji replacement - applied to text segments only
/// 3. Bold (*text*) and italic (_text_) - applied to text segments only
///
/// Returns a Line containing styled Spans for Ratatui rendering.
///
/// # Examples
///
/// ```
/// let line = process_text("This is *bold* and :) `code`");
/// // Returns: Line with styled spans: "This is ", bold("bold"), " and 🙂 ", code("code")
/// ```
pub fn process_text(input: &str) -> Line<'static> {
    // Step 1: Process backticks first, protecting content
    let segments = process_backticks(input);

    // Step 2 & 3: Process emoji, bold, and italic on text segments only
    let mut spans = Vec::new();

    for segment in segments {
        match segment {
            Segment::Code(text) => {
                // Code segments are rendered in reverse video (no further processing)
                spans.push(Span::styled(
                    text,
                    Style::default().add_modifier(Modifier::REVERSED),
                ));
            }
            Segment::Text(text) => {
                // Text segments get emoji + markdown processing
                let emoji_text = replace_emoji(&text);
                let formatted_spans = process_markdown(&emoji_text);
                spans.extend(formatted_spans);
            }
        }
    }

    Line::from(spans)
}

/// Replace ASCII emoticons with Unicode emoji.
fn replace_emoji(text: &str) -> String {
    let mut result = text.to_string();

    // Process in order (longer patterns first to avoid ambiguity)
    for (ascii, emoji) in EMOJI_MAP {
        result = result.replace(ascii, emoji);
    }

    result
}

/// Process backticks and return segments.
///
/// Returns a list of Text or Code segments. Code segments are already
/// identified and should not receive further markdown processing.
fn process_backticks(text: &str) -> Vec<Segment> {
    let mut segments = Vec::new();
    let chars: Vec<char> = text.chars().collect();
    let mut i = 0;
    let mut current_text = String::new();

    while i < chars.len() {
        if chars[i] == '`' {
            // Found opening backtick
            // Save accumulated text
            if !current_text.is_empty() {
                segments.push(Segment::Text(current_text.clone()));
                current_text.clear();
            }

            // Look for closing backtick
            let mut code_content = String::new();
            let mut j = i + 1;
            let mut found_closing = false;

            while j < chars.len() {
                if chars[j] == '`' {
                    found_closing = true;
                    break;
                }
                code_content.push(chars[j]);
                j += 1;
            }

            if found_closing {
                if code_content.is_empty() {
                    // Empty backticks `` - treat as literal
                    current_text.push_str("``");
                } else {
                    // Valid code segment
                    segments.push(Segment::Code(code_content));
                }
                i = j + 1; // Skip past closing backtick
            } else {
                // Unpaired backtick - treat as literal
                current_text.push('`');
                i += 1;
            }
        } else {
            current_text.push(chars[i]);
            i += 1;
        }
    }

    // Add remaining text
    if !current_text.is_empty() {
        segments.push(Segment::Text(current_text));
    }

    // Handle case where input was empty or only whitespace
    if segments.is_empty() {
        segments.push(Segment::Text(String::new()));
    }

    segments
}

/// Process markdown formatting (*bold* and _italic_) in text.
///
/// Returns a vector of styled Spans. This function handles:
/// - *text* -> Bold
/// - _text_ -> Italic (dim)
///
/// Processing is done in sequence: asterisks first, then underscores.
fn process_markdown(text: &str) -> Vec<Span<'static>> {
    // First process asterisks (bold)
    let bold_spans = process_delimiter(text, '*', |s| {
        Span::styled(s, Style::default().add_modifier(Modifier::BOLD))
    });

    // Then process underscores (italic/dim) on the result
    let mut result = Vec::new();
    for span in bold_spans {
        if span.style.add_modifier.is_empty() {
            // Plain text span - check for underscores
            let italic_spans = process_delimiter(&span.content, '_', |s| {
                Span::styled(s, Style::default().add_modifier(Modifier::DIM))
            });
            result.extend(italic_spans);
        } else {
            // Already styled (bold) - keep as is
            result.push(span);
        }
    }

    result
}

/// Process a single delimiter pattern (like * or _) in text.
///
/// Returns a vector of Spans with some styled according to formatter_fn.
fn process_delimiter<F>(text: &str, delimiter: char, formatter_fn: F) -> Vec<Span<'static>>
where
    F: Fn(String) -> Span<'static>,
{
    let mut spans = Vec::new();
    let chars: Vec<char> = text.chars().collect();
    let mut i = 0;
    let mut current_text = String::new();
    let mut inside_delimiter = false;
    let mut delimited_text = String::new();

    while i < chars.len() {
        if chars[i] == delimiter {
            if inside_delimiter {
                // End of delimited section
                if delimited_text.is_empty() {
                    // Empty delimiter pair (e.g., ** or __) - treat as literal
                    current_text.push(delimiter);
                    current_text.push(delimiter);
                } else {
                    // Format the delimited text
                    if !current_text.is_empty() {
                        spans.push(Span::raw(current_text.clone()));
                        current_text.clear();
                    }
                    spans.push(formatter_fn(delimited_text.clone()));
                    delimited_text.clear();
                }
                inside_delimiter = false;
            } else {
                // Start of delimited section
                if !current_text.is_empty() {
                    spans.push(Span::raw(current_text.clone()));
                    current_text.clear();
                }
                inside_delimiter = true;
            }
            i += 1;
        } else {
            if inside_delimiter {
                delimited_text.push(chars[i]);
            } else {
                current_text.push(chars[i]);
            }
            i += 1;
        }
    }

    // Handle unpaired delimiter at end
    if inside_delimiter {
        // Restore the opening delimiter and accumulated text as literal
        current_text.push(delimiter);
        current_text.push_str(&delimited_text);
    }

    // Add remaining text
    if !current_text.is_empty() {
        spans.push(Span::raw(current_text));
    }

    // Ensure we always return at least one span
    if spans.is_empty() {
        spans.push(Span::raw(""));
    }

    spans
}

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

    #[test]
    fn test_emoji_replacement() {
        assert_eq!(replace_emoji("Hello :-)"), "Hello 😊");
        assert_eq!(replace_emoji("Thanks (y)"), "Thanks 👍");
        assert_eq!(replace_emoji(":D :P"), "😄 😛");
    }

    #[test]
    fn test_backticks() {
        let segments = process_backticks("normal `code` text");
        assert_eq!(segments.len(), 3);
        matches!(&segments[0], Segment::Text(t) if t == "normal ");
        matches!(&segments[1], Segment::Code(c) if c == "code");
        matches!(&segments[2], Segment::Text(t) if t == " text");
    }

    #[test]
    fn test_empty_backticks() {
        let segments = process_backticks("empty `` here");
        // Empty backticks are treated as literal text
        assert!(segments
            .iter()
            .any(|s| matches!(s, Segment::Text(t) if t.contains("``"))));
    }

    #[test]
    fn test_unpaired_backtick() {
        let segments = process_backticks("unpaired ` here");
        // Unpaired backtick is treated as literal text
        assert!(segments
            .iter()
            .any(|s| matches!(s, Segment::Text(t) if t.contains("`"))));
    }

    #[test]
    fn test_markdown_bold() {
        let spans = process_markdown("This is *bold* text");
        assert!(spans.len() >= 2);
        // Should have plain text, bold styled, and more plain text
    }

    #[test]
    fn test_markdown_italic() {
        let spans = process_markdown("This is _italic_ text");
        assert!(spans.len() >= 2);
    }

    #[test]
    fn test_backticks_protect_from_emoji() {
        // Emoji outside backticks should be replaced
        let line = process_text("Hello :) and `:-) no emoji` here");
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();

        // The :) outside should become 🙂, but the :-) inside backticks should stay literal
        assert!(
            text.contains("🙂"),
            "Expected emoji replacement outside backticks"
        );
        assert!(
            text.contains(":-)"),
            "Expected literal emoticon inside backticks"
        );
    }

    #[test]
    fn test_backticks_protect_from_markdown() {
        // Bold/italic outside backticks should be processed
        let line = process_text("*bold* and `*not bold*` text");

        // We should have at least 3 spans: bold text, code text, plain text
        assert!(line.spans.len() >= 2, "Expected multiple spans");

        // The code span should contain the literal asterisks
        let has_literal_asterisks = line
            .spans
            .iter()
            .any(|span| span.content.contains("*not bold*"));
        assert!(
            has_literal_asterisks,
            "Expected literal asterisks in code segment"
        );
    }

    #[test]
    fn test_backticks_protect_both_emoji_and_markdown() {
        let line = process_text(":) *test* and `:-) *protected*` end");
        let text: String = line.spans.iter().map(|s| s.content.as_ref()).collect();

        // Outside backticks: emoji and markdown should be processed
        assert!(text.contains("🙂"), "Expected emoji outside backticks");

        // Inside backticks: both should be literal
        assert!(text.contains(":-)"), "Expected literal emoticon in code");
        assert!(
            text.contains("*protected*"),
            "Expected literal asterisks in code"
        );
    }

    #[test]
    fn test_empty_delimiters() {
        let spans = process_markdown("Empty ** and __ here");
        // Empty pairs should be treated as literals
        assert!(spans.iter().any(|s| s.content.contains("**")));
    }
}