//! Iframe loading: discover iframe elements, fetch their content, parse into
//! nested Documents, and produce rendered surfaces for layout/rendering.

use std::collections::HashMap;

use we_dom::{Document, NodeData, NodeId};
use we_image::pixel::Image;
use we_layout::ReplacedContent;
use we_url::{Origin, Url};

use crate::browsing_context::{BrowsingContextId, BrowsingContextTree, SandboxFlags};
use crate::loader::{Resource, ResourceLoader};

/// Data about a loaded iframe for rendering.
pub struct IframeData {
    /// The browsing context ID for this iframe.
    pub context_id: BrowsingContextId,
    /// The NodeId of the iframe element in the parent document.
    pub node_id: NodeId,
    /// Display width (from attributes or default 300).
    pub width: f32,
    /// Display height (from attributes or default 150).
    pub height: f32,
}

/// Default iframe width per HTML spec.
const DEFAULT_IFRAME_WIDTH: f32 = 300.0;
/// Default iframe height per HTML spec.
const DEFAULT_IFRAME_HEIGHT: f32 = 150.0;

/// Scan a document for iframe elements and return their dimensions for layout.
/// Adds entries to the image_sizes map so layout treats iframes as replaced elements.
pub fn collect_iframe_sizes(doc: &Document, image_sizes: &mut HashMap<NodeId, ReplacedContent>) {
    collect_iframe_sizes_recursive(doc, doc.root(), image_sizes);
}

fn collect_iframe_sizes_recursive(
    doc: &Document,
    node: NodeId,
    sizes: &mut HashMap<NodeId, ReplacedContent>,
) {
    if let NodeData::Element { ref tag_name, .. } = *doc.node_data(node) {
        if tag_name == "iframe" {
            let width = doc
                .get_attribute(node, "width")
                .and_then(|v| v.parse::<f32>().ok())
                .unwrap_or(DEFAULT_IFRAME_WIDTH);
            let height = doc
                .get_attribute(node, "height")
                .and_then(|v| v.parse::<f32>().ok())
                .unwrap_or(DEFAULT_IFRAME_HEIGHT);
            sizes.insert(node, ReplacedContent::Size(width, height));
            return; // Don't recurse into iframe content.
        }
    }
    for child in doc.children(node) {
        collect_iframe_sizes_recursive(doc, child, sizes);
    }
}

/// Load all iframes found in a document. For each iframe with a `src` attribute,
/// fetches the HTML, parses it, and creates a nested browsing context.
///
/// Returns a list of loaded iframe data and adds rendered surfaces to the
/// iframe_images map.
pub fn load_iframes(
    doc: &Document,
    loader: &mut ResourceLoader,
    base_url: &Url,
    parent_origin: &Origin,
    parent_context_id: BrowsingContextId,
    context_tree: &mut BrowsingContextTree,
) -> Vec<IframeData> {
    let mut results = Vec::new();
    load_iframes_recursive(
        doc,
        doc.root(),
        loader,
        base_url,
        parent_origin,
        parent_context_id,
        context_tree,
        &mut results,
    );
    results
}

#[allow(clippy::too_many_arguments)]
fn load_iframes_recursive(
    doc: &Document,
    node: NodeId,
    loader: &mut ResourceLoader,
    base_url: &Url,
    parent_origin: &Origin,
    parent_context_id: BrowsingContextId,
    context_tree: &mut BrowsingContextTree,
    results: &mut Vec<IframeData>,
) {
    if let NodeData::Element { ref tag_name, .. } = *doc.node_data(node) {
        if tag_name == "iframe" {
            if let Some(iframe_data) = load_single_iframe(
                doc,
                node,
                loader,
                base_url,
                parent_origin,
                parent_context_id,
                context_tree,
            ) {
                results.push(iframe_data);
            }
            return; // Don't recurse into iframe content.
        }
    }
    for child in doc.children(node) {
        load_iframes_recursive(
            doc,
            child,
            loader,
            base_url,
            parent_origin,
            parent_context_id,
            context_tree,
            results,
        );
    }
}

/// Load a single iframe element.
fn load_single_iframe(
    doc: &Document,
    node: NodeId,
    loader: &mut ResourceLoader,
    base_url: &Url,
    parent_origin: &Origin,
    parent_context_id: BrowsingContextId,
    context_tree: &mut BrowsingContextTree,
) -> Option<IframeData> {
    let width = doc
        .get_attribute(node, "width")
        .and_then(|v| v.parse::<f32>().ok())
        .unwrap_or(DEFAULT_IFRAME_WIDTH);
    let height = doc
        .get_attribute(node, "height")
        .and_then(|v| v.parse::<f32>().ok())
        .unwrap_or(DEFAULT_IFRAME_HEIGHT);

    // Parse sandbox attribute.
    let sandbox = if doc.get_attribute(node, "sandbox").is_some() {
        SandboxFlags::parse(doc.get_attribute(node, "sandbox"))
    } else {
        SandboxFlags::NONE
    };

    let name = doc.get_attribute(node, "name").unwrap_or("").to_string();

    // Check for srcdoc first, then src.
    let (iframe_doc, iframe_origin, iframe_url) =
        if let Some(srcdoc) = doc.get_attribute(node, "srcdoc") {
            // srcdoc: parse the attribute value as HTML. Origin is parent's origin.
            let parsed = we_html::parse_html(srcdoc);
            (parsed, parent_origin.clone(), None)
        } else if let Some(src) = doc.get_attribute(node, "src") {
            let src = src.to_string();
            match load_iframe_src(&src, loader, base_url) {
                Some((parsed_doc, url)) => {
                    let origin = url.origin();
                    (parsed_doc, origin, Some(url))
                }
                None => {
                    // Failed to load: create empty document.
                    (Document::new(), Origin::Opaque, None)
                }
            }
        } else {
            // No src or srcdoc: empty iframe (about:blank).
            (Document::new(), parent_origin.clone(), None)
        };

    let context_id = context_tree.create_nested(
        parent_context_id,
        node,
        iframe_doc,
        iframe_origin,
        iframe_url,
        sandbox,
        name,
    );

    Some(IframeData {
        context_id,
        node_id: node,
        width,
        height,
    })
}

/// Fetch and parse an iframe's src URL.
fn load_iframe_src(
    src: &str,
    loader: &mut ResourceLoader,
    base_url: &Url,
) -> Option<(Document, Url)> {
    // about:blank is handled specially.
    if src == "about:blank" || src.is_empty() {
        return Some((Document::new(), Url::parse("about:blank").ok()?));
    }

    // Resolve relative URL against base.
    let url = Url::parse_with_base(src, base_url).ok()?;

    // Fetch the iframe content as a navigation (always allowed cross-origin).
    match loader.fetch_navigation(&url) {
        Ok(resource) => {
            let html_text = match resource {
                Resource::Html { text, .. } => text,
                Resource::Other { data, .. } => {
                    // Try to decode as text.
                    String::from_utf8(data).unwrap_or_default()
                }
                _ => return None,
            };
            let doc = we_html::parse_html(&html_text);
            Some((doc, url))
        }
        Err(e) => {
            eprintln!("[we] iframe load error for {src}: {e}");
            None
        }
    }
}

/// Render an iframe's content to a BGRA pixel buffer.
///
/// Creates a mini rendering pipeline for the iframe document (resolve styles →
/// layout → build display list → render) using the production Metal renderer
/// offscreen. Returns a white image if styling fails or Metal is unavailable.
pub fn render_iframe_to_image(
    doc: &Document,
    width: u32,
    height: u32,
    font: &we_text::font::Font,
) -> Image {
    use we_css::parser::Stylesheet;
    use we_layout::layout;
    use we_platform::metal::{ClearColor, Device};
    use we_render::{build_display_list, GpuRenderer, RenderFonts};

    let white = || Image {
        width,
        height,
        data: vec![255u8; (width * height * 4) as usize],
    };

    let stylesheet = Stylesheet { rules: Vec::new() };
    let image_sizes = HashMap::new();
    let viewport = (width as f32, height as f32);
    let styled = match we_style::computed::resolve_styles(
        doc,
        std::slice::from_ref(&stylesheet),
        viewport,
    ) {
        Some(s) => s,
        None => return white(),
    };
    let tree = layout(
        &styled,
        doc,
        width as f32,
        height as f32,
        font,
        &image_sizes,
    );
    let display_list = build_display_list(&tree);

    // Clear the iframe canvas to its document's propagated background color
    // (CSS2 §14.2), matching the main-document behavior.
    let clear = match we_render::canvas_background_color(&tree) {
        Some(c) => ClearColor::new(
            c.r as f64 / 255.0,
            c.g as f64 / 255.0,
            c.b as f64 / 255.0,
            1.0,
        ),
        None => ClearColor::new(1.0, 1.0, 1.0, 1.0),
    };

    // Render offscreen through the production Metal pipeline.
    let image_refs = HashMap::new();
    let rendered = Device::system_default()
        .and_then(GpuRenderer::new)
        .and_then(|mut backend| {
            backend.render_to_pixels(
                &display_list,
                RenderFonts::new(font, None),
                &image_refs,
                width,
                height,
                clear,
            )
        });

    match rendered {
        Some(data) => Image {
            width,
            height,
            data,
        },
        None => white(),
    }
}

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

    #[test]
    fn collect_iframe_sizes_default() {
        let mut doc = Document::new();
        let root = doc.root();
        let html = doc.create_element("html");
        let body = doc.create_element("body");
        let iframe = doc.create_element("iframe");
        doc.append_child(root, html);
        doc.append_child(html, body);
        doc.append_child(body, iframe);

        let mut sizes = HashMap::new();
        collect_iframe_sizes(&doc, &mut sizes);

        assert_eq!(
            sizes.get(&iframe),
            Some(&ReplacedContent::Size(300.0, 150.0))
        );
    }

    #[test]
    fn collect_iframe_sizes_custom() {
        let mut doc = Document::new();
        let root = doc.root();
        let html = doc.create_element("html");
        let body = doc.create_element("body");
        let iframe = doc.create_element("iframe");
        doc.set_attribute(iframe, "width", "500");
        doc.set_attribute(iframe, "height", "400");
        doc.append_child(root, html);
        doc.append_child(html, body);
        doc.append_child(body, iframe);

        let mut sizes = HashMap::new();
        collect_iframe_sizes(&doc, &mut sizes);

        assert_eq!(
            sizes.get(&iframe),
            Some(&ReplacedContent::Size(500.0, 400.0))
        );
    }

    #[test]
    fn collect_iframe_sizes_multiple() {
        let mut doc = Document::new();
        let root = doc.root();
        let html = doc.create_element("html");
        let body = doc.create_element("body");
        let iframe1 = doc.create_element("iframe");
        let iframe2 = doc.create_element("iframe");
        doc.set_attribute(iframe2, "width", "200");
        doc.append_child(root, html);
        doc.append_child(html, body);
        doc.append_child(body, iframe1);
        doc.append_child(body, iframe2);

        let mut sizes = HashMap::new();
        collect_iframe_sizes(&doc, &mut sizes);

        assert_eq!(sizes.len(), 2);
        assert_eq!(
            sizes.get(&iframe1),
            Some(&ReplacedContent::Size(300.0, 150.0))
        );
        assert_eq!(
            sizes.get(&iframe2),
            Some(&ReplacedContent::Size(200.0, 150.0))
        );
    }
}