rusty-rich 0.2.0

//! HTML and SVG export — equivalent to Rich's `_export_format.py` and
//! Console export methods.
//!
//! Converts rendered console output into HTML and SVG documents, preserving
//! colors, styles, and layout. Uses `TerminalTheme` to map ANSI colors to
//! CSS-compatible RGB values.

use crate::color::Color;
use crate::segment::Segment;

// ---------------------------------------------------------------------------
// Terminal theme presets (matching Python Rich defaults)
// ---------------------------------------------------------------------------

/// A terminal color theme used for HTML/SVG export.
#[derive(Debug, Clone)]
pub struct ExportTheme {
    pub background: (u8, u8, u8),
    pub foreground: (u8, u8, u8),
    /// ANSI palette: 16 standard colors
    pub ansi_colors: [(u8, u8, u8); 16],
}

impl Default for ExportTheme {
    fn default() -> Self {
        ExportTheme {
            background: (0, 0, 0),
            foreground: (255, 255, 255),
            ansi_colors: [
                (0, 0, 0),       // 0: black
                (128, 0, 0),     // 1: red
                (0, 128, 0),     // 2: green
                (128, 128, 0),   // 3: yellow
                (0, 0, 128),     // 4: blue
                (128, 0, 128),   // 5: magenta
                (0, 128, 128),   // 6: cyan
                (192, 192, 192), // 7: white
                (128, 128, 128), // 8: bright black
                (255, 0, 0),     // 9: bright red
                (0, 255, 0),     // 10: bright green
                (255, 255, 0),   // 11: bright yellow
                (0, 0, 255),     // 12: bright blue
                (255, 0, 255),   // 13: bright magenta
                (0, 255, 255),   // 14: bright cyan
                (255, 255, 255), // 15: bright white
            ],
        }
    }
}

/// Monokai-inspired dark theme.
pub const EXPORT_THEME_MONOKAI: ExportTheme = ExportTheme {
    background: (39, 40, 34),
    foreground: (248, 248, 242),
    ansi_colors: [
        (39, 40, 34),   // 0: black (bg)
        (249, 38, 114), // 1: red
        (166, 226, 46), // 2: green
        (230, 219, 116),// 3: yellow
        (102, 217, 239),// 4: blue
        (174, 129, 255),// 5: magenta
        (161, 239, 228),// 6: cyan
        (248, 248, 242),// 7: white
        (117, 113, 94), // 8: bright black
        (249, 38, 114), // 9: bright red
        (166, 226, 46), // 10: bright green
        (230, 219, 116),// 11: bright yellow
        (102, 217, 239),// 12: bright blue
        (174, 129, 255),// 13: bright magenta
        (161, 239, 228),// 14: bright cyan
        (248, 248, 242),// 15: bright white
    ],
};

/// Dimmed Monokai variant.
pub const EXPORT_THEME_DIMMED_MONOKAI: ExportTheme = ExportTheme {
    background: (35, 35, 35),
    foreground: (185, 188, 186),
    ansi_colors: [
        (35, 35, 35),   // 0
        (190, 63, 72),  // 1
        (135, 154, 59), // 2
        (197, 166, 56), // 3
        (79, 118, 161), // 4
        (133, 92, 141), // 5
        (87, 143, 164), // 6
        (185, 188, 186),// 7
        (83, 83, 83),   // 8
        (240, 80, 80),  // 9
        (148, 166, 73), // 10
        (215, 180, 66), // 11
        (108, 147, 177),// 12
        (152, 117, 171),// 13
        (101, 164, 179),// 14
        (230, 235, 235),// 15
    ],
};

/// Night Owl-inspired dark theme.
pub const EXPORT_THEME_NIGHT_OWLISH: ExportTheme = ExportTheme {
    background: (1, 22, 39),
    foreground: (214, 222, 235),
    ansi_colors: [
        (1, 22, 39),    // 0
        (255, 88, 116), // 1
        (173, 219, 103),// 2
        (255, 203, 107),// 3
        (130, 170, 255),// 4
        (199, 146, 234),// 5
        (137, 221, 255),// 6
        (214, 222, 235),// 7
        (84, 94, 109),  // 8
        (255, 88, 116), // 9
        (173, 219, 103),// 10
        (255, 203, 107),// 11
        (130, 170, 255),// 12
        (199, 146, 234),// 13
        (137, 221, 255),// 14
        (255, 255, 255),// 15
    ],
};

/// Light theme suitable for SVG export.
pub const EXPORT_THEME_SVG: ExportTheme = ExportTheme {
    background: (255, 255, 255),
    foreground: (0, 0, 0),
    ansi_colors: [
        (0, 0, 0),       // 0: black
        (204, 0, 0),     // 1: red
        (0, 170, 0),     // 2: green
        (204, 102, 0),   // 3: yellow
        (0, 0, 204),     // 4: blue
        (170, 0, 170),   // 5: magenta
        (0, 170, 170),   // 6: cyan
        (170, 170, 170), // 7: white
        (102, 102, 102), // 8: bright black
        (255, 0, 0),     // 9: bright red
        (0, 255, 0),     // 10: bright green
        (255, 255, 0),   // 11: bright yellow
        (0, 0, 255),     // 12: bright blue
        (255, 0, 255),   // 13: bright magenta
        (0, 255, 255),   // 14: bright cyan
        (255, 255, 255), // 15: bright white
    ],
};

// ---------------------------------------------------------------------------
// HTML export
// ---------------------------------------------------------------------------

/// The HTML document template used by `export_html`.
pub const CONSOLE_HTML_FORMAT: &str = r#"<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>rusty-rich</title>
<style>
    body {{
        margin: 0;
        padding: 0;
    }}
    pre.rich-html {{
        font-family: {font_family};
        font-size: {font_size}px;
        line-height: {line_height};
        color: {foreground};
        background-color: {background};
        margin: 0;
        padding: 16px 24px;
        white-space: pre-wrap;
        word-wrap: break-word;
        overflow-x: auto;
    }}
</style>
</head>
<body>
<pre class="rich-html">
{code}
</pre>
</body>
</html>"#;

/// Options for HTML export.
#[derive(Debug, Clone)]
pub struct ExportHtmlOptions {
    /// Font family for the output.
    pub font_family: String,
    /// Font size in pixels.
    pub font_size: u32,
    /// Line height multiplier.
    pub line_height: f64,
    /// Terminal color theme.
    pub theme: ExportTheme,
    /// Code block to insert.
    pub code: String,
}

impl Default for ExportHtmlOptions {
    fn default() -> Self {
        Self {
            font_family: "'Fira Code', 'Cascadia Code', 'JetBrains Mono', 'Source Code Pro', Menlo, Consolas, monospace".into(),
            font_size: 14,
            line_height: 1.45,
            theme: ExportTheme::default(),
            code: String::new(),
        }
    }
}

/// Generate a full HTML document from rendered terminal output.
///
/// # Example
///
/// ```rust,no_run
/// use rusty_rich::export::{export_html, ExportHtmlOptions};
///
/// let html = export_html(&ExportHtmlOptions {
///     code: "[bold red]Hello[/bold red]".into(),
///     ..Default::default()
/// });
/// std::fs::write("output.html", html).unwrap();
/// ```
pub fn export_html(options: &ExportHtmlOptions) -> String {
    let fg = options.theme.foreground;
    let bg = options.theme.background;

    CONSOLE_HTML_FORMAT
        .replace("{font_family}", &options.font_family)
        .replace("{font_size}", &options.font_size.to_string())
        .replace("{line_height}", &options.line_height.to_string())
        .replace("{foreground}", &format!("rgb({},{},{})", fg.0, fg.1, fg.2))
        .replace("{background}", &format!("rgb({},{},{})", bg.0, bg.1, bg.2))
        .replace("{code}", &escape_html(&options.code))
}

/// Save rendered output as an HTML file.
///
/// Convenience wrapper around `export_html` that writes to disk.
pub fn save_html(path: impl AsRef<std::path::Path>, options: &ExportHtmlOptions) -> std::io::Result<()> {
    std::fs::write(path.as_ref(), export_html(options))
}

// ---------------------------------------------------------------------------
// SVG export
// ---------------------------------------------------------------------------

/// The SVG document template used by `export_svg`.
pub const CONSOLE_SVG_FORMAT: &str = r#"<svg class="rich-svg" xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}">
<style>
    text {{ font-family: {font_family}; font-size: {font_size}px; }}
</style>
<rect width="100%" height="100%" fill="{background}"/>
<text x="0" y="{baseline}" xml:space="preserve">
{code}
</text>
</svg>"#;

/// Options for SVG export.
#[derive(Debug, Clone)]
pub struct ExportSvgOptions {
    /// Font family for the output.
    pub font_family: String,
    /// Font size in pixels.
    pub font_size: u32,
    /// Terminal color theme.
    pub theme: ExportTheme,
    /// Code block to insert.
    pub code: String,
    /// SVG canvas width.
    pub width: u32,
    /// SVG canvas height.
    pub height: u32,
}

impl Default for ExportSvgOptions {
    fn default() -> Self {
        Self {
            font_family: "'Fira Code', 'Cascadia Code', 'JetBrains Mono', monospace".into(),
            font_size: 14,
            theme: EXPORT_THEME_SVG,
            code: String::new(),
            width: 800,
            height: 600,
        }
    }
}

/// Generate a full SVG document from rendered terminal output.
///
/// # Example
///
/// ```rust,no_run
/// use rusty_rich::export::{export_svg, ExportSvgOptions};
///
/// let svg = export_svg(&ExportSvgOptions {
///     code: "[bold blue]Hello SVG[/bold blue]".into(),
///     ..Default::default()
/// });
/// std::fs::write("output.svg", svg).unwrap();
/// ```
pub fn export_svg(options: &ExportSvgOptions) -> String {
    let fg = options.theme.foreground;
    let bg = options.theme.background;
    let baseline = options.font_size as f64 * 1.2; // approximate first-line baseline

    CONSOLE_SVG_FORMAT
        .replace("{font_family}", &options.font_family)
        .replace("{font_size}", &options.font_size.to_string())
        .replace("{width}", &options.width.to_string())
        .replace("{height}", &options.height.to_string())
        .replace("{background}", &format!("rgb({},{},{})", bg.0, bg.1, bg.2))
        .replace("{baseline}", &format!("{:.0}", baseline))
        .replace("{code}", &escape_xml(&options.code))
        .replace("{foreground}", &format!("rgb({},{},{})", fg.0, fg.1, fg.2))
}

/// Save rendered output as an SVG file.
pub fn save_svg(path: impl AsRef<std::path::Path>, options: &ExportSvgOptions) -> std::io::Result<()> {
    std::fs::write(path.as_ref(), export_svg(options))
}

// ---------------------------------------------------------------------------
// Text export
// ---------------------------------------------------------------------------

/// Options for plain-text export (strips ANSI escape codes).
#[derive(Debug, Clone)]
pub struct ExportTextOptions {
    /// The text to export (may contain ANSI escapes).
    pub text: String,
    /// If true, strip ANSI escape sequences. If false, keep them.
    pub strip_ansi: bool,
}

impl Default for ExportTextOptions {
    fn default() -> Self {
        Self {
            text: String::new(),
            strip_ansi: true,
        }
    }
}

/// Export text, optionally stripping ANSI escape sequences.
pub fn export_text(options: &ExportTextOptions) -> String {
    if options.strip_ansi {
        strip_ansi_escapes(&options.text)
    } else {
        options.text.clone()
    }
}

/// Save text output to a file, optionally stripping ANSI.
pub fn save_text(
    path: impl AsRef<std::path::Path>,
    options: &ExportTextOptions,
) -> std::io::Result<()> {
    std::fs::write(path.as_ref(), export_text(options))
}

// ---------------------------------------------------------------------------
// Utilities
// ---------------------------------------------------------------------------

/// Escape special HTML characters in text.
pub fn escape_html(text: &str) -> String {
    text.replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
}

/// Escape special XML characters in text.
pub fn escape_xml(text: &str) -> String {
    text.replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
        .replace('\'', "&apos;")
}

/// Strip ANSI escape sequences from text, returning plain text.
pub fn strip_ansi_escapes(text: &str) -> String {
    let mut result = String::with_capacity(text.len());
    let mut chars = text.chars().peekable();

    while let Some(ch) = chars.next() {
        if ch == '\x1b' {
            // Consume the escape sequence
            if chars.peek() == Some(&'[') {
                chars.next(); // consume '['
                // Read parameter bytes (digits, semicolons, etc.)
                while let Some(&c) = chars.peek() {
                    if c.is_ascii_digit() || c == ';' || c == '?' || c == '!' {
                        chars.next();
                    } else {
                        break;
                    }
                }
                // Consume the final byte (letter)
                chars.next();
            }
        } else {
            result.push(ch);
        }
    }

    result
}

/// Convert Rich styled segments to HTML with inline CSS spans.
///
/// Each segment's foreground color, background color, bold, italic, etc.
/// are mapped to `<span style="...">` elements.
pub fn segments_to_html(
    segments: &[Segment],
    theme: &ExportTheme,
) -> String {
    let mut html = String::new();

    for seg in segments {
        let mut styles: Vec<String> = Vec::new();

        if let Some(ref style) = seg.style {
            // Foreground color
            if let Some(color) = &style.color {
                let rgb = resolve_color(color, theme);
                styles.push(format!("color:rgb({},{},{})", rgb.0, rgb.1, rgb.2));
            } else {
                // Use foreground default
                let fg = theme.foreground;
                styles.push(format!("color:rgb({},{},{})", fg.0, fg.1, fg.2));
            }

            // Background color
            if let Some(bgcolor) = &style.bgcolor {
                let rgb = resolve_color(bgcolor, theme);
                styles.push(format!("background-color:rgb({},{},{})", rgb.0, rgb.1, rgb.2));
            }

            // Text attributes
            let attrs = &style.attributes;
            if attrs.get(crate::style::Attributes::BOLD) {
                styles.push("font-weight:bold".into());
            }
            if attrs.get(crate::style::Attributes::ITALIC) {
                styles.push("font-style:italic".into());
            }
            if attrs.get(crate::style::Attributes::UNDERLINE)
                || attrs.get(crate::style::Attributes::UNDERLINE2)
            {
                styles.push("text-decoration:underline".into());
            }
            if attrs.get(crate::style::Attributes::STRIKE) {
                styles.push("text-decoration:line-through".into());
            }
            if attrs.get(crate::style::Attributes::DIM) {
                styles.push("opacity:0.7".into());
            }
            if attrs.get(crate::style::Attributes::CONCEAL) {
                styles.push("visibility:hidden".into());
            }

            // Hyperlink
            if let Some(ref link) = style.link {
                let escaped_link = escape_html(link);
                let style_attr = if styles.is_empty() {
                    String::new()
                } else {
                    format!(" style=\"{}\"", styles.join("; "))
                };
                html.push_str(&format!(
                    "<a href=\"{}\"{}>{}</a>",
                    escaped_link,
                    style_attr,
                    escape_html(&seg.text)
                ));
                continue; // skip normal span handling for links
            }
        } else {
            // No style — use theme defaults
            let fg = theme.foreground;
            styles.push(format!("color:rgb({},{},{})", fg.0, fg.1, fg.2));
        }

        // Emit styled span
        if styles.is_empty() {
            html.push_str(&escape_html(&seg.text));
        } else {
            let style_attr = styles.join("; ");
            html.push_str(&format!(
                "<span style=\"{}\">{}</span>",
                style_attr,
                escape_html(&seg.text)
            ));
        }
    }

    html
}

/// Resolve a color to an RGB triplet given a terminal theme.
fn resolve_color(color: &Color, theme: &ExportTheme) -> (u8, u8, u8) {
    match color.color_type {
        crate::color::ColorType::Default => theme.foreground,
        crate::color::ColorType::Standard => {
            let idx = color.number.unwrap_or(7) as usize % 16;
            theme.ansi_colors[idx]
        }
        crate::color::ColorType::EightBit => {
            let idx = color.number.unwrap_or(0) as usize % 256;
            rgb_for_8bit(idx)
        }
        crate::color::ColorType::TrueColor => {
            if let Some(ref triplet) = color.triplet {
                (triplet.0, triplet.1, triplet.2)
            } else {
                theme.foreground
            }
        }
    }
}

/// Map an 8-bit (256) color index to an RGB triplet.
fn rgb_for_8bit(index: usize) -> (u8, u8, u8) {
    if index < 16 {
        // Standard ANSI colors
        crate::color::STANDARD_PALETTE
            .get(index)
            .copied()
            .unwrap_or((0, 0, 0))
    } else if index < 232 {
        // 6×6×6 color cube
        let idx = index - 16;
        let r = (idx / 36) as u8 * 51;
        let g = ((idx / 6) % 6) as u8 * 51;
        let b = (idx % 6) as u8 * 51;
        (r, g, b)
    } else {
        // Greyscale ramp (232–255)
        let g = ((index - 232) * 10 + 8) as u8;
        (g, g, g)
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use crate::style::Style;
    use crate::color::Color;

    #[test]
    fn test_escape_html_basic() {
        assert_eq!(escape_html("<hello>"), "&lt;hello&gt;");
        assert_eq!(escape_html("\"a\" & 'b'"), "&quot;a&quot; &amp; 'b'");
    }

    #[test]
    fn test_strip_ansi_escapes() {
        let input = "\x1b[31mred\x1b[0m normal";
        assert_eq!(strip_ansi_escapes(input), "red normal");
    }

    #[test]
    fn test_strip_ansi_complex() {
        let input = "\x1b[1;31mBold Red\x1b[0m \x1b[4munderlined\x1b[0m";
        assert_eq!(strip_ansi_escapes(input), "Bold Red underlined");
    }

    #[test]
    fn test_strip_ansi_no_escapes() {
        assert_eq!(strip_ansi_escapes("plain text"), "plain text");
    }

    #[test]
    fn test_export_html_basic() {
        let opts = ExportHtmlOptions {
            code: "Hello World".into(),
            ..Default::default()
        };
        let html = export_html(&opts);
        assert!(html.contains("<!DOCTYPE html>"));
        assert!(html.contains("Hello World"));
        assert!(html.contains("rich-html"));
        assert!(html.contains("font-family"));
    }

    #[test]
    fn test_export_html_escapes_markup() {
        let opts = ExportHtmlOptions {
            code: "<script>alert('xss')</script>".into(),
            ..Default::default()
        };
        let html = export_html(&opts);
        assert!(!html.contains("<script>"));
        assert!(html.contains("&lt;script&gt;"));
    }

    #[test]
    fn test_export_svg_basic() {
        let opts = ExportSvgOptions {
            code: "SVG text".into(),
            ..Default::default()
        };
        let svg = export_svg(&opts);
        assert!(svg.contains("<svg"));
        assert!(svg.contains("SVG text"));
        assert!(svg.contains("rich-svg"));
    }

    #[test]
    fn test_export_svg_theme() {
        let opts = ExportSvgOptions {
            code: "test".into(),
            theme: EXPORT_THEME_SVG,
            ..Default::default()
        };
        let svg = export_svg(&opts);
        assert!(svg.contains("rgb(255,255,255)")); // background
    }

    #[test]
    fn test_export_text_strip() {
        let opts = ExportTextOptions {
            text: "\x1b[1;32mGreen Bold\x1b[0m".into(),
            strip_ansi: true,
        };
        assert_eq!(export_text(&opts), "Green Bold");
    }

    #[test]
    fn test_export_text_keep() {
        let ansi = "\x1b[31mred\x1b[0m";
        let opts = ExportTextOptions {
            text: ansi.into(),
            strip_ansi: false,
        };
        assert_eq!(export_text(&opts), ansi);
    }

    #[test]
    fn test_rgb_for_8bit_standard() {
        assert_eq!(rgb_for_8bit(0), (0, 0, 0));     // black
        assert_eq!(rgb_for_8bit(1), (128, 0, 0));   // red
        assert_eq!(rgb_for_8bit(15), (255, 255, 255)); // bright white
    }

    #[test]
    fn test_rgb_for_8bit_cube() {
        assert_eq!(rgb_for_8bit(16), (0, 0, 0));
        let idx = 16 + 1 * 36 + 2 * 6 + 3; // R=1, G=2, B=3
        assert_eq!(rgb_for_8bit(idx), (51, 102, 153));
    }

    #[test]
    fn test_rgb_for_8bit_greyscale() {
        assert_eq!(rgb_for_8bit(232), (8, 8, 8));
        assert_eq!(rgb_for_8bit(255), (238, 238, 238));
    }

    #[test]
    fn test_segments_to_html_styled() {
        let seg = Segment::styled(
            "hello",
            Style::new()
                .color(Color::parse("red").unwrap())
                .bold(true),
        );
        let html = segments_to_html(&[seg], &ExportTheme::default());
        assert!(html.contains("color:rgb(128,0,0)"));
        assert!(html.contains("font-weight:bold"));
        assert!(html.contains("hello"));
    }

    #[test]
    fn test_segments_to_html_plain() {
        let seg = Segment::new("plain");
        let html = segments_to_html(&[seg], &ExportTheme::default());
        assert!(html.contains("plain"));
        assert!(html.contains("color:rgb(255,255,255)"));
    }

    #[test]
    fn test_export_theme_defaults() {
        let theme = ExportTheme::default();
        assert_eq!(theme.background, (0, 0, 0));
        assert_eq!(theme.foreground, (255, 255, 255));
    }

    #[test]
    fn test_save_to_disk() {
        let dir = std::env::temp_dir();
        let path = dir.join("test_export.html");
        let opts = ExportHtmlOptions {
            code: "test".into(),
            ..Default::default()
        };
        save_html(&path, &opts).unwrap();
        let contents = std::fs::read_to_string(&path).unwrap();
        assert!(contents.contains("test"));
        std::fs::remove_file(&path).unwrap();
    }
}