harumi 1.4.0

//! Minimal HTML tokenizer for harumi's HTML→PDF renderer.
//!
//! A pure-Rust, zero-dependency HTML parser that handles a document-oriented
//! subset of HTML (headings, paragraphs, lists, tables, inline styles).
//! Designed to replace the `scraper` crate for lightweight PDF generation.

use std::collections::HashMap;

/// A node in the HTML tree: either text or an element.
#[derive(Debug, Clone)]
pub(crate) enum HtmlNode {
    Text(String),
    Element {
        tag: String,
        attrs: HashMap<String, String>,
        children: Vec<HtmlNode>,
    },
}

impl HtmlNode {
    /// Returns the tag name if this is an element, None if text.
    pub(crate) fn tag_name(&self) -> Option<&str> {
        match self {
            HtmlNode::Element { tag, .. } => Some(tag),
            HtmlNode::Text(_) => None,
        }
    }

    /// Returns the text content if this is a text node, None if element.
    pub(crate) fn as_text(&self) -> Option<&str> {
        match self {
            HtmlNode::Text(s) => Some(s),
            HtmlNode::Element { .. } => None,
        }
    }

    /// Returns attribute value by name (case-insensitive keys).
    pub(crate) fn attr(&self, name: &str) -> Option<String> {
        match self {
            HtmlNode::Element { attrs, .. } => {
                let lower = name.to_ascii_lowercase();
                attrs
                    .iter()
                    .find(|(k, _)| k.to_ascii_lowercase() == lower)
                    .map(|(_, v)| v.clone())
            }
            HtmlNode::Text(_) => None,
        }
    }

    /// Returns iterator over child elements (skipping text nodes).
    #[allow(dead_code)]
    pub(crate) fn child_elements(&self) -> impl Iterator<Item = &HtmlNode> {
        match self {
            HtmlNode::Element { children, .. } => children.iter(),
            HtmlNode::Text(_) => [].iter(),
        }
    }

    /// Returns iterator over all children (element and text).
    pub(crate) fn children(&self) -> impl Iterator<Item = &HtmlNode> {
        match self {
            HtmlNode::Element { children, .. } => children.iter(),
            HtmlNode::Text(_) => [].iter(),
        }
    }

    /// Recursively collects all text content.
    pub(crate) fn text_content(&self) -> String {
        match self {
            HtmlNode::Text(s) => s.clone(),
            HtmlNode::Element { children, .. } => children
                .iter()
                .map(|child| child.text_content())
                .collect::<Vec<_>>()
                .join(""),
        }
    }
}

/// Parse HTML string into a document tree.
///
/// This is a best-effort HTML parser for harumi's document-oriented subset.
/// It handles:
/// - Basic tags and attributes
/// - Self-closing tags (`<br>`, `<img>`, `<hr>`)
/// - HTML entities (`&amp;`, `&lt;`, `&gt;`, `&nbsp;`, `&#...;`)
/// - Malformed HTML (closes unclosed tags, ignores unmatched closing tags)
/// - Comments (`<!-- ... -->`)
pub(crate) fn parse_html(html: &str) -> HtmlNode {
    let mut parser = HtmlParser::new(html);
    parser.parse_root()
}

struct HtmlParser {
    input: Vec<char>,
    pos: usize,
}

impl HtmlParser {
    fn new(html: &str) -> Self {
        HtmlParser {
            input: html.chars().collect(),
            pos: 0,
        }
    }

    fn current(&self) -> Option<char> {
        if self.pos < self.input.len() {
            Some(self.input[self.pos])
        } else {
            None
        }
    }

    fn peek(&self, offset: usize) -> Option<char> {
        let p = self.pos + offset;
        if p < self.input.len() {
            Some(self.input[p])
        } else {
            None
        }
    }

    fn advance(&mut self) {
        self.pos += 1;
    }

    fn skip_whitespace(&mut self) {
        while let Some(c) = self.current() {
            if c.is_whitespace() {
                self.advance();
            } else {
                break;
            }
        }
    }

    fn read_until(&mut self, terminator: char) -> String {
        let mut result = String::new();
        while let Some(c) = self.current() {
            if c == terminator {
                break;
            }
            result.push(c);
            self.advance();
        }
        result
    }

    fn read_tag_name(&mut self) -> String {
        let mut result = String::new();
        while let Some(c) = self.current() {
            if c.is_ascii_alphanumeric() || c == '-' {
                result.push(c);
                self.advance();
            } else {
                break;
            }
        }
        result.to_lowercase()
    }

    fn read_attribute_name(&mut self) -> String {
        let mut result = String::new();
        while let Some(c) = self.current() {
            if c.is_ascii_alphanumeric() || c == '-' || c == ':' {
                result.push(c);
                self.advance();
            } else {
                break;
            }
        }
        result.to_lowercase()
    }

    fn read_attribute_value(&mut self) -> String {
        self.skip_whitespace();
        if self.current() != Some('=') {
            return String::new();
        }
        self.advance(); // skip '='
        self.skip_whitespace();

        let quote = self.current();
        if quote == Some('"') || quote == Some('\'') {
            self.advance();
            let value = self.read_until(quote.unwrap());
            if self.current() == quote {
                self.advance();
            }
            Self::decode_html_entities(&value)
        } else {
            // Unquoted attribute
            let mut result = String::new();
            while let Some(c) = self.current() {
                if c.is_whitespace() || c == '>' {
                    break;
                }
                result.push(c);
                self.advance();
            }
            Self::decode_html_entities(&result)
        }
    }

    fn read_attributes(&mut self) -> HashMap<String, String> {
        let mut attrs = HashMap::new();
        loop {
            self.skip_whitespace();
            if self.current() == Some('>') || self.current() == Some('/') {
                break;
            }
            let name = self.read_attribute_name();
            if name.is_empty() {
                break;
            }
            let value = self.read_attribute_value();
            attrs.insert(name, value);
        }
        attrs
    }

    fn parse_tag(&mut self) -> Option<(String, HashMap<String, String>, bool)> {
        // Current char should be '<'
        if self.current() != Some('<') {
            return None;
        }
        self.advance();

        // Check for comment
        if self.current() == Some('!') && self.peek(1) == Some('-') && self.peek(2) == Some('-') {
            self.advance(); // skip '!'
            self.advance(); // skip first '-'
            self.advance(); // skip second '-'
            // Skip until '-->'
            while self.current().is_some() {
                if self.current() == Some('-')
                    && self.peek(1) == Some('-')
                    && self.peek(2) == Some('>')
                {
                    self.advance();
                    self.advance();
                    self.advance();
                    break;
                }
                self.advance();
            }
            return None; // Comment nodes are skipped
        }

        // Check for closing tag
        if self.current() == Some('/') {
            return None;
        }

        let tag_name = self.read_tag_name();
        if tag_name.is_empty() {
            return None;
        }

        let attrs = self.read_attributes();

        let self_closing = self.current() == Some('/');
        if self_closing {
            self.advance();
        }

        if self.current() == Some('>') {
            self.advance();
        }

        Some((tag_name, attrs, self_closing))
    }

    fn is_self_closing_tag(tag: &str) -> bool {
        matches!(
            tag,
            "br" | "hr"
                | "img"
                | "input"
                | "meta"
                | "link"
                | "area"
                | "base"
                | "col"
                | "embed"
                | "source"
                | "track"
                | "wbr"
        )
    }

    fn decode_html_entities(text: &str) -> String {
        let mut result = String::new();
        let mut chars = text.chars().peekable();

        while let Some(c) = chars.next() {
            if c == '&' {
                let mut entity = String::new();
                while let Some(&next) = chars.peek() {
                    if next == ';' {
                        chars.next();
                        break;
                    }
                    entity.push(next);
                    chars.next();
                }

                let decoded: String = match entity.as_str() {
                    "amp" => "&".to_string(),
                    "lt" => "<".to_string(),
                    "gt" => ">".to_string(),
                    "quot" => "\"".to_string(),
                    "apos" => "'".to_string(),
                    "nbsp" => "\u{00A0}".to_string(),
                    _ if entity.starts_with('#') => {
                        if let Ok(code) = entity[1..].parse::<u32>() {
                            if let Some(ch) = char::from_u32(code) {
                                ch.to_string()
                            } else {
                                format!("&{};", entity)
                            }
                        } else {
                            format!("&{};", entity)
                        }
                    }
                    _ => format!("&{};", entity),
                };
                result.push_str(&decoded);
            } else {
                result.push(c);
            }
        }

        result
    }

    fn parse_root(&mut self) -> HtmlNode {
        let mut stack: Vec<(String, HashMap<String, String>, Vec<HtmlNode>)> = Vec::new(); // (tag, attrs, children)
        stack.push(("root".to_string(), HashMap::new(), Vec::new()));

        while self.current().is_some() && !stack.is_empty() {
            self.skip_whitespace();
            if self.current() == Some('<') {
                if self.peek(1) == Some('/') {
                    // Closing tag
                    self.advance(); // skip '<'
                    self.advance(); // skip '/'
                    let closing_tag = self.read_tag_name();
                    self.skip_whitespace();
                    if self.current() == Some('>') {
                        self.advance();
                    }
                    // Pop from stack if tag matches
                    if let Some((tag, _, _)) = stack.last() && closing_tag == *tag {
                        let (tag, attrs, children) = stack.pop().unwrap();
                        let node = HtmlNode::Element {
                            tag,
                            attrs,
                            children,
                        };
                        if let Some((_, _, parent_children)) = stack.last_mut() {
                            parent_children.push(node);
                        }
                    }
                } else if let Some((tag, attrs, is_self_closing)) = self.parse_tag() {
                    if is_self_closing || Self::is_self_closing_tag(&tag) {
                        let node = HtmlNode::Element {
                            tag,
                            attrs,
                            children: Vec::new(),
                        };
                        if let Some((_, _, children)) = stack.last_mut() {
                            children.push(node);
                        }
                    } else {
                        stack.push((tag, attrs, Vec::new()));
                    }
                }
            } else {
                // Text node
                let mut text = String::new();
                while let Some(c) = self.current() {
                    if c == '<' {
                        break;
                    }
                    text.push(c);
                    self.advance();
                }
                let decoded = Self::decode_html_entities(&text);
                if !decoded.trim().is_empty() && let Some((_, _, children)) = stack.last_mut() {
                    children.push(HtmlNode::Text(decoded));
                }
            }
        }

        if let Some((_, _, children)) = stack.pop() {
            HtmlNode::Element {
                tag: "root".to_string(),
                attrs: HashMap::new(),
                children,
            }
        } else {
            HtmlNode::Element {
                tag: "root".to_string(),
                attrs: HashMap::new(),
                children: Vec::new(),
            }
        }
    }
}