//! Main SVG document structure.

use data_url::mime::Mime;

use glib::prelude::*;

use markup5ever::QualName;

use std::collections::hash_map::Entry;

use std::collections::HashMap;

use std::fmt;

use std::include_str;

use std::io::Cursor;

use std::rc::Rc;

use std::str::FromStr;

use std::sync::Arc;

use std::{cell::RefCell, sync::OnceLock};

use crate::accept_language::UserLanguage;

use crate::bbox::BoundingBox;

use crate::borrow_element_as;

use crate::css::{self, Origin, Stylesheet};

use crate::dpi::Dpi;

use crate::drawing_ctx::{draw_tree, with_saved_cr, DrawingMode, SvgNesting};

use crate::error::{AcquireError, InternalRenderingError, LoadingError, NodeIdError};

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

use crate::is_element_of_type;

use crate::limits;

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

use crate::rect::Rect;

use crate::session::Session;

use crate::structure::IntrinsicDimensions;

use crate::surface_utils::shared_surface::SharedImageSurface;

use crate::url_resolver::{AllowedUrl, UrlResolver};

use crate::xml::{xml_load_from_possibly_compressed_stream, Attributes};

/// Identifier of a node

pub enum NodeId {

    /// element id

    /// url, element id

}

impl NodeId {

        };

        }

}

impl fmt::Display for NodeId {

        }

}

/// Loading options for SVG documents.

pub struct LoadOptions {

    /// Load url resolver; all references will be resolved with respect to this.

    pub url_resolver: UrlResolver,

    /// Whether to turn off size limits in libxml2.

    pub unlimited_size: bool,

    /// Whether to keep original (undecoded) image data to embed in Cairo PDF surfaces.

    pub keep_image_data: bool,

}

impl LoadOptions {

    /// Creates a `LoadOptions` with defaults, and sets the `url resolver`.

            url_resolver,

            unlimited_size: false,

            keep_image_data: false,

        }

    /// Sets whether libxml2's limits on memory usage should be turned off.

    ///

    /// This should only be done for trusted data.

    /// Sets whether to keep the original compressed image data from referenced JPEG/PNG images.

    ///

    /// This is only useful for rendering to Cairo PDF

    /// surfaces, which can embed the original, compressed image data instead of uncompressed

    /// RGB buffers.

    /// Creates a new `LoadOptions` with a different `url resolver`.

    ///

    /// This is used when loading a referenced file that may in turn cause other files

    /// to be loaded, for example `<image xlink:href="subimage.svg"/>`

        }

}

/// 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.

    session: Session,

    /// Mapping from `id` attributes to nodes.

    ids: HashMap<String, Node>,

    /// Othewr SVG documents and images referenced from this document.

    ///

    /// This requires requires interior mutability because we load resources all over the

    /// place.  Eventually we'll be able to do this once, at loading time, and keep this

    /// immutable.

    resources: RefCell<Resources>,

    /// Used to load referenced resources.

    load_options: Arc<LoadOptions>,

    /// Stylesheets defined in the document.

    stylesheets: Vec<Stylesheet>,

}

impl Document {

    /// Constructs a `Document` by loading it from a stream.

        session: Session,

        load_options: Arc<LoadOptions>,

        stream: &gio::InputStream,

        cancellable: Option<&gio::Cancellable>,

    ) -> Result<Document, LoadingError> {

            stream,

            cancellable,

    /// Utility function to load a document from a static string in tests.

    #[cfg(test)]

        .unwrap()

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

    /// Looks up a node in this document or one of its resources by its `id` attribute.

                .resources

                .borrow_mut()

        }

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

    /// Loads an image by URL, or returns a pre-loaded one.

            .load_options

            .url_resolver

            .resolve_href(url)

            .borrow_mut()

    /// Loads a resource by URL, or returns a pre-loaded one.

            .load_options

            .url_resolver

            .resolve_href(url)

        // FIXME: pass a cancellable to this.  This function is called

        // at rendering time, so probably the cancellable should come

        // from cancellability in CairoRenderer - see #429

            .borrow_mut()

    /// Runs the CSS cascade on the document tree

    ///

    /// This uses the default UserAgent stylesheet, the document's internal stylesheets,

    /// plus an extra set of stylesheets supplied by the caller.

        let stylesheets = {

            static UA_STYLESHEETS: OnceLock<Vec<Stylesheet>> = OnceLock::new();

                    include_str!("ua.css"),

                )

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

        };

            extra,

            session,

        );

        &self,

        session: &Session,

        cr: &cairo::Context,

        viewport: &cairo::Rectangle,

        user_language: &UserLanguage,

        dpi: Dpi,

        svg_nesting: SvgNesting,

        is_testing: bool,

    ) -> Result<(), InternalRenderingError> {

            session,

            cr,

            root,

            viewport,

            user_language,

            dpi,

            svg_nesting,

            is_testing,

        )

        &self,

        session: &Session,

        cr: &cairo::Context,

        node: Node,

        viewport: &cairo::Rectangle,

        user_language: &UserLanguage,

        dpi: Dpi,

        svg_nesting: SvgNesting,

        is_testing: bool,

    ) -> Result<(), InternalRenderingError> {

                false,

        &self,

        session: &Session,

        node: Node,

        viewport: Rect,

        user_language: &UserLanguage,

        dpi: Dpi,

        is_testing: bool,

    ) -> Result<(Rect, Rect), InternalRenderingError> {

            &cr,

            viewport,

            user_language,

            dpi,

            true,

            is_testing,

        &self,

        session: &Session,

        node: Node,

        viewport: &cairo::Rectangle,

        user_language: &UserLanguage,

        dpi: Dpi,

        is_testing: bool,

    ) -> Result<(cairo::Rectangle, cairo::Rectangle), InternalRenderingError> {

        ))

        &self,

        session: &Session,

        node: &Node,

        user_language: &UserLanguage,

        dpi: Dpi,

        is_testing: bool,

    ) -> Result<BoundingBox, InternalRenderingError> {

            &cr,

            user_language,

            dpi,

            true,

            is_testing,

    /// Returns (ink_rect, logical_rect)

        &self,

        session: &Session,

        node: Node,

        user_language: &UserLanguage,

        dpi: Dpi,

        is_testing: bool,

    ) -> Result<(cairo::Rectangle, cairo::Rectangle), InternalRenderingError> {

        // Translate so ink_rect is always at offset (0, 0)

        ))

        &self,

        session: &Session,

        cr: &cairo::Context,

        node: Node,

        element_viewport: &cairo::Rectangle,

        user_language: &UserLanguage,

        dpi: Dpi,

        is_testing: bool,

    ) -> Result<(), InternalRenderingError> {

            // Nothing to draw

        }

        }

        // Render, transforming so element is at the new viewport's origin

                false,

}

/// Any kind of resource loaded while processing an SVG document: images, or SVGs themselves.

pub enum Resource {

}

struct Resources {

    resources: HashMap<AllowedUrl, Result<Resource, LoadingError>>,

}

impl Resources {

        }

        &mut self,

        session: &Session,

        load_options: &LoadOptions,

        url: &str,

        id: &str,

    ) -> Result<Node, LoadingError> {

                _ => unreachable!("get_extern_document() should already have ensured the document"),

        &mut self,

        session: &Session,

        load_options: &LoadOptions,

        href: &str,

    ) -> Result<Resource, LoadingError> {

            .url_resolver

        // FIXME: pass a cancellable to this.  This function is called

        // at rendering time, so probably the cancellable should come

        // from cancellability in CairoRenderer - see #429

                "{href} is not an SVG document"

        }

        &mut self,

        session: &Session,

        load_options: &LoadOptions,

        aurl: &AllowedUrl,

    ) -> Result<SharedImageSurface, LoadingError> {

        // FIXME: pass a cancellable to this.  This function is called

        // at rendering time, so probably the cancellable should come

        // from cancellability in CairoRenderer - see #429

        }

        &mut self,

        session: &Session,

        load_options: &LoadOptions,

        aurl: &AllowedUrl,

        cancellable: Option<&gio::Cancellable>,

    ) -> Result<Resource, LoadingError> {

        }

}

    session: &Session,

    load_options: &LoadOptions,

    aurl: &AllowedUrl,

    cancellable: Option<&gio::Cancellable>,

) -> Result<Resource, LoadingError> {

    } else {

    }

    session: &Session,

    load_options: &LoadOptions,

    aurl: &AllowedUrl,

    data: BinaryData,

    cancellable: Option<&gio::Cancellable>,

) -> Result<Resource, LoadingError> {

    let BinaryData {

        cancellable,

    load_options: &LoadOptions,

    aurl: &AllowedUrl,

    data: BinaryData,

) -> Result<Resource, LoadingError> {

    let BinaryData {

    }

    match content_type {

        #[cfg(feature = "avif")]

        "image/avif" => Ok(image::ImageFormat::Avif),

            "unsupported image format {content_type}"

    }

    aurl: &AllowedUrl,

    bytes: Vec<u8>,

    content_type: Option<String>,

    load_options: &LoadOptions,

) -> Result<Resource, LoadingError> {

    } else {

            .with_guessed_format()

    };

        .decode()

    } else {

    };

    // See issue #548 - data: URLs without a MIME-type automatically

    // fall back to "text/plain;charset=US-ASCII".  Some (old?) versions of

    // Adobe Illustrator generate data: URLs without MIME-type for image

    // data.  We'll catch this and fall back to sniffing by unsetting the

    // content_type.

    } else {

    }

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

    } else {

    }

    }

pub struct AcquiredNode {

    stack: Option<Rc<RefCell<NodeStack>>>,

    node: Node,

}

impl Drop for AcquiredNode {

}

impl AcquiredNode {

        &self.node

}

/// Detects circular references between nodes, and enforces referencing limits.

///

/// Consider this fragment of SVG:

///

/// ```xml

/// <pattern id="foo">

///   <rect width="1" height="1" fill="url(#foo)"/>

/// </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

/// wherever it may be necessary to resolve references to nodes, or to access nodes

/// "elsewhere" in the DOM that is not the current subtree.

///

/// 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

/// creating an exponential number of references.  `AcquiredNodes` imposes a hard limit on

/// 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

/// acts like a smart pointer for a [`Node`].  Once a node has been acquired, it cannot be

/// acquired again until its [`AcquiredNode`] is dropped.  In the example above, a graphic element

/// would acquire the `pattern`, which would then acquire its `rect` child, which then would fail

/// to re-acquired the `pattern` — thus signaling a circular reference.

///

/// Those methods return an [`AcquireError`] to signal circular references.  Also, they

/// can return [`AcquireError::MaxReferencesExceeded`] if the aforementioned referencing limit

/// is exceeded.

///

/// [lol]: https://bitbucket.org/tiran/defusedxml

pub struct AcquiredNodes<'i> {

    document: &'i Document,

    num_elements_acquired: usize,

    node_stack: Rc<RefCell<NodeStack>>,

}

impl<'i> AcquiredNodes<'i> {

            document,

            num_elements_acquired: 0,

        }

    /// Acquires a node by its id.

    ///

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

    /// resolved to node references.

        // This is a mitigation for SVG files that try to instance a huge number of

        // elements via <use>, recursive patterns, etc.  See limits.rs for details.

        }

        // FIXME: callers shouldn't have to know that get_node() can initiate a file load.

        // Maybe we should have the following stages:

        //   - load main SVG XML

        //

        //   - load secondary resources: SVG XML and other files like images

        //

        //   - Now that all files are loaded, resolve URL references

            .document

            .lookup_node(node_id)

        } else {

        }

    /// Acquires a node whose reference is already known.

    ///

    /// This is useful for cases where a node is initially referenced by its id with

    /// [`Self::acquire`] and kept around for later use.  During the later use, the node

    /// needs to be re-acquired with this method.  For example:

    ///

    /// * At an "early resolution" stage, `acquire()` a pattern by its id, and keep around its

    /// [`Node`] reference.

    ///

    /// * At the drawing stage, `acquire_ref()` the pattern node that we already had, so that

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

    /// references to the pattern.

        } else {

        }

}

/// Keeps a stack of nodes and can check if a certain node is contained in the stack

///

/// Sometimes parts of the code cannot plainly use the implicit stack of acquired

/// nodes as maintained by DrawingCtx::acquire_node(), and they must keep their

/// own stack of nodes to test for reference cycles.  NodeStack can be used to do that.

pub struct NodeStack(Vec<Node>);

impl NodeStack {

}

/// 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:

/// the loading options, the partially-built tree of nodes, the CSS stylesheets that

/// appear while loading the document.

///

/// The XML loader asks a `DocumentBuilder` to

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

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

/// been consumed, the caller can use [`build`][DocumentBuilder::build] to get a

/// fully-loaded [`Document`].

pub struct DocumentBuilder {

    /// Metadata for the document's lifetime.

    session: Session,

    /// Loading options; mainly the URL resolver.

    load_options: Arc<LoadOptions>,

    /// Root node of the tree.

    tree: Option<Node>,

    /// Mapping from `id` attributes to nodes.

    ids: HashMap<String, Node>,

    /// Stylesheets defined in the document.

    stylesheets: Vec<Stylesheet>,

}

impl DocumentBuilder {

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

    ///

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

    /// Creates an element of the specified `name` as a child of `parent`.

    ///

    /// This is the main function to create new SVG elements while parsing XML.

    ///

    /// `name` is the XML element's name, for example `rect`.

    ///

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

    /// r="5">`.

    ///

    /// 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.

        &mut self,

        name: &QualName,

        attrs: Attributes,

        parent: Option<Node>,

    ) -> Node {

            // This is so we don't overwrite an existing id

        } else {

        }

    /// Creates a node for an XML text element as a child of `parent`.

            // When the last child is a Chars node we can coalesce

            // the text and avoid screwing up the Pango layouts

        }

    /// Does the final validation on the `Document` being read, and returns it.

        let DocumentBuilder {

            ..

                }

        }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

        );

        );

            Err(NodeIdError::NodeIdRequired)

        ));

    #[test]

        // Issue #548

    #[test]

        // Issue #699

        );

}