//! CSS resource loading: collect stylesheets from `<link>` and `<style>` elements.
//!
//! After HTML parsing, this module scans the DOM for stylesheet references,
//! fetches external CSS resources, resolves `@import` rules, and merges
//! everything into a single `Stylesheet` for style resolution.

use we_css::parser::{ImportRule, Parser, Rule, Stylesheet};
use we_dom::{Document, NodeData, NodeId};
use we_url::Url;

use crate::loader::{LoadError, Resource, ResourceLoader};

/// Maximum depth for `@import` resolution to prevent cycles.
const MAX_IMPORT_DEPTH: usize = 5;

/// Errors that can occur during CSS loading.
#[derive(Debug)]
pub enum CssLoadError {
    /// A resource failed to load.
    Load(LoadError),
    /// The fetched resource was not CSS.
    NotCss { url: String },
}

impl std::fmt::Display for CssLoadError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Load(e) => write!(f, "CSS load error: {e}"),
            Self::NotCss { url } => write!(f, "resource at {url} is not CSS"),
        }
    }
}

impl From<LoadError> for CssLoadError {
    fn from(e: LoadError) -> Self {
        Self::Load(e)
    }
}

/// Collect all CSS rules from a parsed DOM document.
///
/// Scans the DOM in document order for `<style>` elements and
/// `<link rel="stylesheet">` elements. Inline `<style>` content is parsed
/// directly; external stylesheets are fetched via the `ResourceLoader`.
///
/// All rules are merged into a single `Stylesheet` in document order,
/// preserving cascade source order. Failed loads are silently skipped
/// (graceful degradation).
pub fn collect_stylesheets(
    doc: &Document,
    loader: &mut ResourceLoader,
    base_url: &Url,
) -> Stylesheet {
    let mut all_rules: Vec<Rule> = Vec::new();
    let mut style_nodes = Vec::new();
    collect_style_nodes(doc, doc.root(), &mut style_nodes);

    for node in style_nodes {
        match classify_style_node(doc, node) {
            StyleSource::InlineStyle(css_text) => {
                let sheet = Parser::parse(&css_text);
                let resolved = resolve_imports(sheet, loader, base_url, 0);
                all_rules.extend(resolved.rules);
            }
            StyleSource::ExternalLink { href, media } => {
                if !media_matches(&media) {
                    continue;
                }
                match fetch_stylesheet(loader, &href, base_url, 0) {
                    Ok(sheet) => all_rules.extend(sheet.rules),
                    Err(_) => {
                        // Graceful degradation: skip failed stylesheet loads.
                    }
                }
            }
            StyleSource::NotStylesheet => {}
        }
    }

    Stylesheet { rules: all_rules }
}

/// Walk the DOM in document order and collect `<style>` and `<link>` nodes.
fn collect_style_nodes(doc: &Document, node: NodeId, result: &mut Vec<NodeId>) {
    if let NodeData::Element { tag_name, .. } = doc.node_data(node) {
        let tag = tag_name.as_str();
        if tag.eq_ignore_ascii_case("style") || tag.eq_ignore_ascii_case("link") {
            result.push(node);
        }
    }
    for child in doc.children(node) {
        collect_style_nodes(doc, child, result);
    }
}

/// Classification of a DOM node as a style source.
enum StyleSource {
    /// A `<style>` element with inline CSS text.
    InlineStyle(String),
    /// A `<link rel="stylesheet">` element with an `href`.
    ExternalLink { href: String, media: Option<String> },
    /// Not a stylesheet source.
    NotStylesheet,
}

/// Classify a DOM node as a style source.
fn classify_style_node(doc: &Document, node: NodeId) -> StyleSource {
    let tag = match doc.tag_name(node) {
        Some(t) => t,
        None => return StyleSource::NotStylesheet,
    };

    if tag.eq_ignore_ascii_case("style") {
        // Check type attribute — only text/css is valid (or omitted, which defaults to text/css)
        if let Some(type_attr) = doc.get_attribute(node, "type") {
            if !type_attr.eq_ignore_ascii_case("text/css") {
                return StyleSource::NotStylesheet;
            }
        }
        // Collect text content from child text nodes
        let css_text = collect_text_content(doc, node);
        StyleSource::InlineStyle(css_text)
    } else if tag.eq_ignore_ascii_case("link") {
        // Must have rel="stylesheet"
        let rel = doc.get_attribute(node, "rel").unwrap_or("");
        if !rel
            .split_ascii_whitespace()
            .any(|r| r.eq_ignore_ascii_case("stylesheet"))
        {
            return StyleSource::NotStylesheet;
        }
        // Check type attribute if present
        if let Some(type_attr) = doc.get_attribute(node, "type") {
            if !type_attr.eq_ignore_ascii_case("text/css") {
                return StyleSource::NotStylesheet;
            }
        }
        // Must have href
        match doc.get_attribute(node, "href") {
            Some(href) if !href.is_empty() => {
                let media = doc.get_attribute(node, "media").map(|m| m.to_string());
                StyleSource::ExternalLink {
                    href: href.to_string(),
                    media,
                }
            }
            _ => StyleSource::NotStylesheet,
        }
    } else {
        StyleSource::NotStylesheet
    }
}

/// Collect concatenated text content from child text nodes of an element.
fn collect_text_content(doc: &Document, node: NodeId) -> String {
    let mut text = String::new();
    for child in doc.children(node) {
        if let Some(data) = doc.text_content(child) {
            text.push_str(data);
        }
    }
    text
}

/// Check if a `media` attribute value matches the `screen` environment.
///
/// Per spec, if no media attribute is present (None), it defaults to `all`.
/// We support basic media types: `all`, `screen`.
fn media_matches(media: &Option<String>) -> bool {
    match media {
        None => true, // default is "all"
        Some(m) => {
            let m = m.trim();
            if m.is_empty() {
                return true;
            }
            // Split comma-separated media types and check if any matches
            m.split(',').any(|mt| {
                let mt = mt.trim();
                mt.eq_ignore_ascii_case("all") || mt.eq_ignore_ascii_case("screen")
            })
        }
    }
}

/// Fetch an external stylesheet and resolve its `@import` rules.
fn fetch_stylesheet(
    loader: &mut ResourceLoader,
    href: &str,
    base_url: &Url,
    depth: usize,
) -> Result<Stylesheet, CssLoadError> {
    let resource = loader.fetch_url(href, Some(base_url))?;

    let (css_text, resolved_url) = match resource {
        Resource::Css { text, url } => (text, url),
        // Some servers may return text/plain or text/html for CSS files.
        // Accept any text response gracefully.
        Resource::Html { text, base_url, .. } => (text, base_url),
        Resource::Other { data, url, .. } => {
            // Try to decode as UTF-8 text
            match String::from_utf8(data) {
                Ok(text) => (text, url),
                Err(_) => {
                    return Err(CssLoadError::NotCss {
                        url: href.to_string(),
                    })
                }
            }
        }
        Resource::Image { .. } => {
            return Err(CssLoadError::NotCss {
                url: href.to_string(),
            })
        }
    };

    let sheet = Parser::parse(&css_text);
    Ok(resolve_imports(sheet, loader, &resolved_url, depth))
}

/// Resolve `@import` rules in a stylesheet by fetching and inlining imported sheets.
///
/// Replaces `Rule::Import` entries with the imported stylesheet's rules.
/// Respects `MAX_IMPORT_DEPTH` to prevent infinite loops.
fn resolve_imports(
    sheet: Stylesheet,
    loader: &mut ResourceLoader,
    base_url: &Url,
    depth: usize,
) -> Stylesheet {
    if depth >= MAX_IMPORT_DEPTH {
        // Strip import rules at max depth to prevent cycles
        return Stylesheet {
            rules: sheet
                .rules
                .into_iter()
                .filter(|r| !matches!(r, Rule::Import(_)))
                .collect(),
        };
    }

    let mut resolved_rules: Vec<Rule> = Vec::new();

    for rule in sheet.rules {
        match rule {
            Rule::Import(ImportRule { ref url }) => {
                match fetch_stylesheet(loader, url, base_url, depth + 1) {
                    Ok(imported) => resolved_rules.extend(imported.rules),
                    Err(_) => {
                        // Graceful degradation: skip failed imports.
                    }
                }
            }
            other => resolved_rules.push(other),
        }
    }

    Stylesheet {
        rules: resolved_rules,
    }
}

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

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

    // -----------------------------------------------------------------------
    // Helper: build a DOM manually for testing
    // -----------------------------------------------------------------------

    fn make_doc_with_style(css: &str) -> Document {
        let mut doc = Document::new();
        let root = doc.root();

        let html = doc.create_element("html");
        doc.append_child(root, html);

        let head = doc.create_element("head");
        doc.append_child(html, head);

        let style = doc.create_element("style");
        doc.append_child(head, style);

        let text = doc.create_text(css);
        doc.append_child(style, text);

        let body = doc.create_element("body");
        doc.append_child(html, body);

        doc
    }

    fn make_doc_with_link(href: &str) -> Document {
        let mut doc = Document::new();
        let root = doc.root();

        let html = doc.create_element("html");
        doc.append_child(root, html);

        let head = doc.create_element("head");
        doc.append_child(html, head);

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.set_attribute(link, "href", href);
        doc.append_child(head, link);

        let body = doc.create_element("body");
        doc.append_child(html, body);

        doc
    }

    // -----------------------------------------------------------------------
    // collect_style_nodes
    // -----------------------------------------------------------------------

    #[test]
    fn collects_style_elements() {
        let doc = make_doc_with_style("body { color: red; }");
        let mut nodes = Vec::new();
        collect_style_nodes(&doc, doc.root(), &mut nodes);
        assert_eq!(nodes.len(), 1);
        assert_eq!(doc.tag_name(nodes[0]), Some("style"));
    }

    #[test]
    fn collects_link_elements() {
        let doc = make_doc_with_link("style.css");
        let mut nodes = Vec::new();
        collect_style_nodes(&doc, doc.root(), &mut nodes);
        assert_eq!(nodes.len(), 1);
        assert_eq!(doc.tag_name(nodes[0]), Some("link"));
    }

    #[test]
    fn collects_both_style_and_link() {
        let mut doc = Document::new();
        let root = doc.root();

        let html = doc.create_element("html");
        doc.append_child(root, html);

        let head = doc.create_element("head");
        doc.append_child(html, head);

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.set_attribute(link, "href", "a.css");
        doc.append_child(head, link);

        let style = doc.create_element("style");
        doc.append_child(head, style);
        let text = doc.create_text("p { margin: 0; }");
        doc.append_child(style, text);

        let mut nodes = Vec::new();
        collect_style_nodes(&doc, doc.root(), &mut nodes);
        assert_eq!(nodes.len(), 2);
        // Document order: link first, then style
        assert_eq!(doc.tag_name(nodes[0]), Some("link"));
        assert_eq!(doc.tag_name(nodes[1]), Some("style"));
    }

    #[test]
    fn ignores_non_style_elements() {
        let mut doc = Document::new();
        let root = doc.root();

        let html = doc.create_element("html");
        doc.append_child(root, html);

        let body = doc.create_element("body");
        doc.append_child(html, body);

        let p = doc.create_element("p");
        doc.append_child(body, p);

        let mut nodes = Vec::new();
        collect_style_nodes(&doc, doc.root(), &mut nodes);
        assert!(nodes.is_empty());
    }

    // -----------------------------------------------------------------------
    // classify_style_node
    // -----------------------------------------------------------------------

    #[test]
    fn classify_style_element() {
        let doc = make_doc_with_style("body { color: red; }");
        let mut nodes = Vec::new();
        collect_style_nodes(&doc, doc.root(), &mut nodes);
        match classify_style_node(&doc, nodes[0]) {
            StyleSource::InlineStyle(text) => {
                assert_eq!(text, "body { color: red; }");
            }
            _ => panic!("expected InlineStyle"),
        }
    }

    #[test]
    fn classify_link_stylesheet() {
        let doc = make_doc_with_link("style.css");
        let mut nodes = Vec::new();
        collect_style_nodes(&doc, doc.root(), &mut nodes);
        match classify_style_node(&doc, nodes[0]) {
            StyleSource::ExternalLink { href, media } => {
                assert_eq!(href, "style.css");
                assert!(media.is_none());
            }
            _ => panic!("expected ExternalLink"),
        }
    }

    #[test]
    fn classify_link_with_media() {
        let mut doc = Document::new();
        let root = doc.root();

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.set_attribute(link, "href", "screen.css");
        doc.set_attribute(link, "media", "screen");
        doc.append_child(root, link);

        match classify_style_node(&doc, link) {
            StyleSource::ExternalLink { href, media } => {
                assert_eq!(href, "screen.css");
                assert_eq!(media.as_deref(), Some("screen"));
            }
            _ => panic!("expected ExternalLink"),
        }
    }

    #[test]
    fn classify_link_without_rel_stylesheet() {
        let mut doc = Document::new();
        let root = doc.root();

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "icon");
        doc.set_attribute(link, "href", "favicon.ico");
        doc.append_child(root, link);

        assert!(matches!(
            classify_style_node(&doc, link),
            StyleSource::NotStylesheet
        ));
    }

    #[test]
    fn classify_link_without_href() {
        let mut doc = Document::new();
        let root = doc.root();

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.append_child(root, link);

        assert!(matches!(
            classify_style_node(&doc, link),
            StyleSource::NotStylesheet
        ));
    }

    #[test]
    fn classify_style_wrong_type() {
        let mut doc = Document::new();
        let root = doc.root();

        let style = doc.create_element("style");
        doc.set_attribute(style, "type", "text/javascript");
        doc.append_child(root, style);
        let text = doc.create_text("not css");
        doc.append_child(style, text);

        assert!(matches!(
            classify_style_node(&doc, style),
            StyleSource::NotStylesheet
        ));
    }

    #[test]
    fn classify_style_with_type_text_css() {
        let mut doc = Document::new();
        let root = doc.root();

        let style = doc.create_element("style");
        doc.set_attribute(style, "type", "text/css");
        doc.append_child(root, style);
        let text = doc.create_text("p { color: blue; }");
        doc.append_child(style, text);

        match classify_style_node(&doc, style) {
            StyleSource::InlineStyle(css) => assert_eq!(css, "p { color: blue; }"),
            _ => panic!("expected InlineStyle"),
        }
    }

    #[test]
    fn classify_link_wrong_type() {
        let mut doc = Document::new();
        let root = doc.root();

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.set_attribute(link, "href", "style.css");
        doc.set_attribute(link, "type", "text/plain");
        doc.append_child(root, link);

        assert!(matches!(
            classify_style_node(&doc, link),
            StyleSource::NotStylesheet
        ));
    }

    // -----------------------------------------------------------------------
    // collect_text_content
    // -----------------------------------------------------------------------

    #[test]
    fn collect_text_single_child() {
        let mut doc = Document::new();
        let root = doc.root();

        let style = doc.create_element("style");
        doc.append_child(root, style);
        let text = doc.create_text("body {}");
        doc.append_child(style, text);

        assert_eq!(collect_text_content(&doc, style), "body {}");
    }

    #[test]
    fn collect_text_multiple_children() {
        let mut doc = Document::new();
        let root = doc.root();

        let style = doc.create_element("style");
        doc.append_child(root, style);
        let t1 = doc.create_text("body { ");
        let t2 = doc.create_text("color: red; }");
        doc.append_child(style, t1);
        doc.append_child(style, t2);

        assert_eq!(collect_text_content(&doc, style), "body { color: red; }");
    }

    #[test]
    fn collect_text_empty_element() {
        let mut doc = Document::new();
        let root = doc.root();

        let style = doc.create_element("style");
        doc.append_child(root, style);

        assert_eq!(collect_text_content(&doc, style), "");
    }

    // -----------------------------------------------------------------------
    // media_matches
    // -----------------------------------------------------------------------

    #[test]
    fn media_none_matches() {
        assert!(media_matches(&None));
    }

    #[test]
    fn media_empty_matches() {
        assert!(media_matches(&Some(String::new())));
    }

    #[test]
    fn media_all_matches() {
        assert!(media_matches(&Some("all".to_string())));
    }

    #[test]
    fn media_screen_matches() {
        assert!(media_matches(&Some("screen".to_string())));
    }

    #[test]
    fn media_print_does_not_match() {
        assert!(!media_matches(&Some("print".to_string())));
    }

    #[test]
    fn media_comma_list_with_screen() {
        assert!(media_matches(&Some("print, screen".to_string())));
    }

    #[test]
    fn media_comma_list_without_screen() {
        assert!(!media_matches(&Some("print, handheld".to_string())));
    }

    #[test]
    fn media_case_insensitive() {
        assert!(media_matches(&Some("SCREEN".to_string())));
        assert!(media_matches(&Some("All".to_string())));
    }

    // -----------------------------------------------------------------------
    // collect_stylesheets with inline <style>
    // -----------------------------------------------------------------------

    #[test]
    fn collect_inline_style_rules() {
        let doc = make_doc_with_style("p { color: red; } div { margin: 0; }");
        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let sheet = collect_stylesheets(&doc, &mut loader, &base);
        assert_eq!(sheet.rules.len(), 2);
        // Both should be style rules
        assert!(matches!(sheet.rules[0], Rule::Style(_)));
        assert!(matches!(sheet.rules[1], Rule::Style(_)));
    }

    #[test]
    fn collect_empty_style_element() {
        let doc = make_doc_with_style("");
        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let sheet = collect_stylesheets(&doc, &mut loader, &base);
        assert!(sheet.rules.is_empty());
    }

    #[test]
    fn collect_multiple_style_elements() {
        let mut doc = Document::new();
        let root = doc.root();

        let html = doc.create_element("html");
        doc.append_child(root, html);

        let head = doc.create_element("head");
        doc.append_child(html, head);

        // First <style>
        let style1 = doc.create_element("style");
        doc.append_child(head, style1);
        let t1 = doc.create_text("p { color: red; }");
        doc.append_child(style1, t1);

        // Second <style>
        let style2 = doc.create_element("style");
        doc.append_child(head, style2);
        let t2 = doc.create_text("div { color: blue; }");
        doc.append_child(style2, t2);

        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let sheet = collect_stylesheets(&doc, &mut loader, &base);
        assert_eq!(sheet.rules.len(), 2);
    }

    #[test]
    fn collect_link_graceful_failure() {
        // External link will fail to load (no real server), but should not crash
        let doc = make_doc_with_link("http://nonexistent.test/style.css");
        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let sheet = collect_stylesheets(&doc, &mut loader, &base);
        // Should return empty stylesheet (graceful degradation)
        assert!(sheet.rules.is_empty());
    }

    #[test]
    fn link_with_print_media_skipped() {
        let mut doc = Document::new();
        let root = doc.root();

        let html = doc.create_element("html");
        doc.append_child(root, html);

        let head = doc.create_element("head");
        doc.append_child(html, head);

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.set_attribute(link, "href", "print.css");
        doc.set_attribute(link, "media", "print");
        doc.append_child(head, link);

        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let sheet = collect_stylesheets(&doc, &mut loader, &base);
        // Print media link should be skipped entirely
        assert!(sheet.rules.is_empty());
    }

    // -----------------------------------------------------------------------
    // resolve_imports
    // -----------------------------------------------------------------------

    #[test]
    fn resolve_imports_strips_at_max_depth() {
        let sheet = Stylesheet {
            rules: vec![
                Rule::Import(ImportRule {
                    url: "deep.css".to_string(),
                }),
                Rule::Style(StyleRule {
                    selectors: we_css::parser::SelectorList {
                        selectors: Vec::new(),
                    },
                    declarations: Vec::new(),
                }),
            ],
        };

        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let resolved = resolve_imports(sheet, &mut loader, &base, MAX_IMPORT_DEPTH);
        // Import should be stripped, style rule kept
        assert_eq!(resolved.rules.len(), 1);
        assert!(matches!(resolved.rules[0], Rule::Style(_)));
    }

    #[test]
    fn resolve_imports_failed_import_skipped() {
        let sheet = Stylesheet {
            rules: vec![
                Rule::Import(ImportRule {
                    url: "http://nonexistent.test/import.css".to_string(),
                }),
                Rule::Style(StyleRule {
                    selectors: we_css::parser::SelectorList {
                        selectors: Vec::new(),
                    },
                    declarations: Vec::new(),
                }),
            ],
        };

        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let resolved = resolve_imports(sheet, &mut loader, &base, 0);
        // Failed import should be skipped, style rule kept
        assert_eq!(resolved.rules.len(), 1);
        assert!(matches!(resolved.rules[0], Rule::Style(_)));
    }

    // -----------------------------------------------------------------------
    // CssLoadError display
    // -----------------------------------------------------------------------

    #[test]
    fn css_load_error_display_not_css() {
        let e = CssLoadError::NotCss {
            url: "test.png".to_string(),
        };
        assert_eq!(e.to_string(), "resource at test.png is not CSS");
    }

    #[test]
    fn css_load_error_display_load() {
        let e = CssLoadError::Load(LoadError::InvalidUrl("bad".to_string()));
        assert!(e.to_string().contains("CSS load error"));
    }

    // -----------------------------------------------------------------------
    // Integration: style + link document order
    // -----------------------------------------------------------------------

    #[test]
    fn style_and_link_document_order() {
        // When both <style> and <link> are present, inline styles should be
        // collected in document order (link will fail but style should work)
        let mut doc = Document::new();
        let root = doc.root();

        let html = doc.create_element("html");
        doc.append_child(root, html);

        let head = doc.create_element("head");
        doc.append_child(html, head);

        // Link first (will fail)
        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.set_attribute(link, "href", "http://nonexistent.test/first.css");
        doc.append_child(head, link);

        // Style second
        let style = doc.create_element("style");
        doc.append_child(head, style);
        let text = doc.create_text("p { color: green; }");
        doc.append_child(style, text);

        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let sheet = collect_stylesheets(&doc, &mut loader, &base);
        // Only the inline style should succeed
        assert_eq!(sheet.rules.len(), 1);
    }

    // -----------------------------------------------------------------------
    // Edge cases
    // -----------------------------------------------------------------------

    #[test]
    fn link_with_empty_href_skipped() {
        let mut doc = Document::new();
        let root = doc.root();

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.set_attribute(link, "href", "");
        doc.append_child(root, link);

        assert!(matches!(
            classify_style_node(&doc, link),
            StyleSource::NotStylesheet
        ));
    }

    #[test]
    fn style_in_body_is_collected() {
        // <style> in <body> should also be collected (browsers allow this)
        let mut doc = Document::new();
        let root = doc.root();

        let html = doc.create_element("html");
        doc.append_child(root, html);

        let body = doc.create_element("body");
        doc.append_child(html, body);

        let style = doc.create_element("style");
        doc.append_child(body, style);
        let text = doc.create_text("h1 { font-size: 2em; }");
        doc.append_child(style, text);

        let mut loader = ResourceLoader::new();
        let base = Url::parse("http://example.com/").unwrap();

        let sheet = collect_stylesheets(&doc, &mut loader, &base);
        assert_eq!(sheet.rules.len(), 1);
    }

    #[test]
    fn link_rel_case_insensitive() {
        // rel="Stylesheet" should work too (case-insensitive matching)
        let mut doc = Document::new();
        let root = doc.root();

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "Stylesheet");
        doc.set_attribute(link, "href", "style.css");
        doc.append_child(root, link);

        match classify_style_node(&doc, link) {
            StyleSource::ExternalLink { href, .. } => assert_eq!(href, "style.css"),
            _ => panic!("expected ExternalLink"),
        }
    }

    #[test]
    fn link_rel_with_extra_values() {
        // rel="alternate stylesheet" should NOT match as a regular stylesheet
        // (alternate stylesheets are disabled by default)
        // Actually, per spec, "stylesheet" in the token list means it IS a stylesheet
        // But "alternate stylesheet" is a disabled stylesheet. For simplicity,
        // we treat any rel containing "stylesheet" as a stylesheet.
        let mut doc = Document::new();
        let root = doc.root();

        let link = doc.create_element("link");
        doc.set_attribute(link, "rel", "stylesheet");
        doc.set_attribute(link, "href", "style.css");
        doc.append_child(root, link);

        assert!(matches!(
            classify_style_node(&doc, link),
            StyleSource::ExternalLink { .. }
        ));
    }
}