//! Main SVG document structure.

use crate::io::{self, BinaryData};

use crate::limits;

use crate::node::{Node, NodeBorrow, NodeData};

static UA_STYLESHEETS: Lazy<Vec<Stylesheet>> = Lazy::new(|| {

    vec![Stylesheet::from_data(

        &UrlResolver::new(None),

        Origin::UserAgent,

        Session::default(),

    .expect("could not parse user agent stylesheet for librsvg, there's a bug!")]

});

#[derive(Debug, PartialEq, Clone)]

pub enum NodeId {

    /// element id

    Internal(String),

    External(String, String),

    pub fn parse(href: &str) -> Result<NodeId, NodeIdError> {

        let (url, id) = match href.rfind('#') {

            None => (Some(href), None),

            Some(p) if p == 0 => (None, Some(&href[1..])),

            Some(p) => (Some(&href[..p]), Some(&href[(p + 1)..])),

        match (url, id) {

            (None, Some(id)) if !id.is_empty() => Ok(NodeId::Internal(String::from(id))),

            (Some(url), Some(id)) if !id.is_empty() => {

                Ok(NodeId::External(String::from(url), String::from(id)))

            }

            _ => Err(NodeIdError::NodeIdRequired),

    }

}

impl fmt::Display for NodeId {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            NodeId::Internal(id) => write!(f, "#{id}"),

}

/// A loaded SVG file and its derived data.

pub struct Document {

    /// Tree of nodes; the root is guaranteed to be an `<svg>` element.

    tree: Node,

    /// Metadata about the SVG handle.

    // resources all over the place.  Eventually we'll be able to do this

    // once, at loading time, and keep this immutable.

    /// SVG documents referenced from this document.

    externs: RefCell<Resources>,

    /// Stylesheets defined in the document.

    stylesheets: Vec<Stylesheet>,

    pub fn load_from_stream(

        xml_load_from_possibly_compressed_stream(

            session.clone(),

            DocumentBuilder::new(session, load_options.clone()),

            load_options,

        )

    }

    pub fn load_from_bytes(input: &'static [u8]) -> Document {

        let bytes = glib::Bytes::from_static(input);

        let stream = gio::MemoryInputStream::from_bytes(&bytes);

        Document::load_from_stream(

            Session::new_for_test_suite(),

            Arc::new(LoadOptions::new(UrlResolver::new(None))),

            &stream.upcast(),

            None::<&gio::Cancellable>,

        )

        .unwrap()

    }

    /// Gets the root node.  This is guaranteed to be an `<svg>` element.

    pub fn root(&self) -> Node {

        self.tree.clone()

    }

    pub fn lookup_node(&self, node_id: &NodeId) -> Option<Node> {

        match node_id {

            NodeId::Internal(id) => self.lookup_internal_node(id),

            NodeId::External(url, id) => self

                .externs

                .borrow_mut()

                .lookup(&self.session, &self.load_options, url, id)

                .ok(),

        }

    }

    /// Looks up a node in this document by its `id` attribute.

    pub fn lookup_internal_node(&self, id: &str) -> Option<Node> {

        self.ids.get(id).map(|n| (*n).clone())

    }

    pub fn lookup_image(&self, url: &str) -> Result<SharedImageSurface, LoadingError> {

        let aurl = self

            .map_err(|_| LoadingError::BadUrl)?;

        self.images.borrow_mut().lookup(&self.load_options, &aurl)

    }

    pub fn cascade(&mut self, extra: &[Stylesheet], session: &Session) {

        css::cascade(

            &mut self.tree,

            &UA_STYLESHEETS,

            &self.stylesheets,

    }

    pub fn new() -> Resources {

        Resources {

            resources: Default::default(),

        }

    }

    pub fn lookup(

        self.get_extern_document(session, load_options, url)

            .and_then(|doc| doc.lookup_internal_node(id).ok_or(LoadingError::BadUrl))

    }

    fn get_extern_document(

        let aurl = load_options

            .map_err(|_| LoadingError::BadUrl)?;

        match self.resources.entry(aurl) {

            Entry::Occupied(e) => e.get().clone(),

            Entry::Vacant(e) => {

                let aurl = e.key();

                let doc = io::acquire_stream(aurl, None)

                    .and_then(|stream| {

                        Document::load_from_stream(

                            session.clone(),

                            Arc::new(load_options.copy_with_base_url(aurl)),

                            None,

                        )

                    })

                let res = e.insert(doc);

                res.clone()

            }

    }

struct Images {

    images: HashMap<AllowedUrl, Result<SharedImageSurface, LoadingError>>,

impl Images {

    fn new() -> Images {

        Images {

            images: Default::default(),

    }

    fn lookup(

        match self.images.entry(aurl.clone()) {

            Entry::Occupied(e) => e.get().clone(),

            Entry::Vacant(e) => {

                let surface = load_image(load_options, e.key());

                let res = e.insert(surface);

                res.clone()

            }

        }

    }

fn load_image(

    load_options: &LoadOptions,

    aurl: &AllowedUrl,

) -> Result<SharedImageSurface, LoadingError> {

    let BinaryData {

        data: bytes,

        mime_type,

    } = io::acquire_data(aurl, None)?;

    if bytes.is_empty() {

    let content_type = content_type_for_gdk_pixbuf(&mime_type);

    let loader = if let Some(ref content_type) = content_type {

        PixbufLoader::with_mime_type(content_type)?

    } else {

        PixbufLoader::new()

    };

    loader.write(&bytes)?;

    loader.close()?;

    let pixbuf = loader.pixbuf().ok_or_else(|| {

    let bytes = if load_options.keep_image_data {

        None

    let surface = SharedImageSurface::from_pixbuf(&pixbuf, content_type.as_deref(), bytes)

        .map_err(|e| image_loading_error_from_cairo(e, aurl))?;

    Ok(surface)

}

fn content_type_for_gdk_pixbuf(mime_type: &Mime) -> Option<String> {

    let unspecified_mime_type = Mime::from_str("text/plain;charset=US-ASCII").unwrap();

    if *mime_type == unspecified_mime_type {

        None

    } else {

        Some(format!("{}/{}", mime_type.type_, mime_type.subtype))

    }

}

fn human_readable_url(aurl: &AllowedUrl) -> &str {

        // avoid printing a huge data: URL for image data

        "data URL"

    } else {

}

fn image_loading_error_from_cairo(status: cairo::Error, aurl: &AllowedUrl) -> LoadingError {

    let url = human_readable_url(aurl);

    match status {

        _ => LoadingError::Other(format!("cairo error: {status}")),

}

pub struct AcquiredNode {

    node: Node,

}

impl Drop for AcquiredNode {

    fn drop(&mut self) {

        if let Some(ref stack) = self.stack {

            let mut stack = stack.borrow_mut();

            let last = stack.pop().unwrap();

            assert!(last == self.node);

        }

    }

}

    pub fn get(&self) -> &Node {

        &self.node

    }

}

/// Consider this fragment of SVG:

///

/// </pattern>

///

/// The pattern has a child element that references the pattern itself.  This kind of circular

/// reference is invalid.  The `AcquiredNodes` struct is passed around

///

/// Also, such constructs that reference other elements can be maliciously arranged like

/// in the [billion laughs attack][lol], to cause huge amounts of CPU to be consumed through

/// the number of references that can be resolved for typical, well-behaved SVG documents.

/// The [`Self::acquire()`] and [`Self::acquire_ref()`] methods return an [`AcquiredNode`], which

    pub fn new(document: &Document) -> AcquiredNodes<'_> {

        AcquiredNodes {

            node_stack: Rc::new(RefCell::new(NodeStack::new())),

    }

    pub fn lookup_image(&self, href: &str) -> Result<SharedImageSurface, LoadingError> {

        self.document.lookup_image(href)

    }

    ///

    /// This is typically used during an "early resolution" stage, when XML `id`s are being

    /// resolved to node references.

    pub fn acquire(&mut self, node_id: &NodeId) -> Result<AcquiredNode, AcquireError> {

        self.num_elements_acquired += 1;

        if self.num_elements_acquired > limits::MAX_REFERENCED_ELEMENTS {

            return Err(AcquireError::MaxReferencesExceeded);

        let node = self

            .ok_or_else(|| AcquireError::LinkNotFound(node_id.clone()))?;

        if !node.is_element() {

        if node.borrow_element().is_accessed_by_reference() {

            self.acquire_ref(&node)

            Ok(AcquiredNode { stack: None, node })

    }

    /// its child elements that reference other paint servers will be able to detect circular

    /// references to the pattern.

    pub fn acquire_ref(&self, node: &Node) -> Result<AcquiredNode, AcquireError> {

        if self.node_stack.borrow().contains(node) {

            Err(AcquireError::CircularReference(node.clone()))

            self.node_stack.borrow_mut().push(node);

            Ok(AcquiredNode {

                stack: Some(self.node_stack.clone()),

                node: node.clone(),

            })

    }

pub struct NodeStack(Vec<Node>);

impl NodeStack {

    pub fn new() -> NodeStack {

        NodeStack(Vec::new())

    }

    pub fn push(&mut self, node: &Node) {

        self.0.push(node.clone());

    }

    pub fn pop(&mut self) -> Option<Node> {

        self.0.pop()

    }

    pub fn contains(&self, node: &Node) -> bool {

        self.0.iter().any(|n| *n == *node)

    }

/// Used to build a tree of SVG nodes while an XML document is being read.

/// This struct holds the document-related state while loading an SVG document from XML:

/// appear while loading the document.

///

/// [`append_element`][DocumentBuilder::append_element],

/// [`append_characters`][DocumentBuilder::append_characters], etc.  When all the XML has

    ids: HashMap<String, Node>,

}

    pub fn new(session: Session, load_options: Arc<LoadOptions>) -> DocumentBuilder {

        DocumentBuilder {

            session,

            load_options,

            tree: None,

            ids: HashMap::new(),

            stylesheets: Vec::new(),

    }

    /// Adds a stylesheet in order to the document.

    ///

    /// Stylesheets will later be matched in the order in which they were added.

    pub fn append_stylesheet(&mut self, stylesheet: Stylesheet) {

        self.stylesheets.push(stylesheet);

    }

    ///

    ///

    /// `attrs` has the XML element's attributes, e.g. cx/cy/r for `<circle cx="0" cy="0"

    /// If `parent` is `None` it means that we are creating the root node in the tree of

    /// elements.  The code will later validate that this is indeed an `<svg>` element.

    pub fn append_element(

        let node = Node::new(NodeData::new_element(&self.session, name, attrs));

        if let Some(id) = node.borrow_element().get_id() {

            self.ids

                .entry(id.to_string())

                .or_insert_with(|| node.clone());

        }

        if let Some(parent) = parent {

            parent.append(node.clone());

        } else if self.tree.is_none() {

            self.tree = Some(node.clone());

        node

    }

    pub fn append_characters(&mut self, text: &str, parent: &mut Node) {

        if !text.is_empty() {

            if let Some(child) = parent.last_child().filter(|c| c.is_chars()) {

                child.borrow_chars().append(text);

            } else {

                parent.append(Node::new(NodeData::new_chars(text)));

            };

    }

    pub fn build(self) -> Result<Document, LoadingError> {

            load_options,

            session,

            tree,

            ids,

            stylesheets,

        match tree {

            Some(root) if root.is_element() => {

                if is_element_of_type!(root, Svg) {

                    let mut document = Document {

                        tree: root,

                        session: session.clone(),

                        ids,

                        externs: RefCell::new(Resources::new()),

                        images: RefCell::new(Images::new()),

                        load_options,

                        stylesheets,

                    document.cascade(&[], &session);

                    Ok(document)

                    Err(LoadingError::NoSvgRoot)

            }

    }

    fn parses_node_id() {

        assert_eq!(

            NodeId::parse("#foo").unwrap(),

            NodeId::Internal("foo".to_string())

        assert_eq!(

            NodeId::parse("uri#foo").unwrap(),

            NodeId::External("uri".to_string(), "foo".to_string())

        assert!(matches!(

            NodeId::parse("uri"),

    }

    fn unspecified_mime_type_yields_no_content_type() {

        let mime = Mime::from_str("text/plain;charset=US-ASCII").unwrap();

        assert!(content_type_for_gdk_pixbuf(&mime).is_none());

    }

    fn strips_mime_type_parameters() {

        let mime = Mime::from_str("image/png;charset=utf-8").unwrap();

        assert_eq!(

            content_type_for_gdk_pixbuf(&mime),

            Some(String::from("image/png"))

    }