//! SVG Elements.

use markup5ever::{expanded_name, local_name, namespace_url, ns, QualName};

use std::collections::{HashMap, HashSet};

use std::fmt;

use std::sync::OnceLock;

use crate::accept_language::UserLanguage;

use crate::bbox::BoundingBox;

use crate::cond::{RequiredExtensions, RequiredFeatures, SystemLanguage};

use crate::css::{Declaration, Origin};

use crate::document::AcquiredNodes;

use crate::drawing_ctx::{DrawingCtx, Viewport};

use crate::error::*;

use crate::filter::Filter;

use crate::filters::{

    blend::FeBlend,

    color_matrix::FeColorMatrix,

    component_transfer::{FeComponentTransfer, FeFuncA, FeFuncB, FeFuncG, FeFuncR},

    composite::FeComposite,

    convolve_matrix::FeConvolveMatrix,

    displacement_map::FeDisplacementMap,

    drop_shadow::FeDropShadow,

    flood::FeFlood,

    gaussian_blur::FeGaussianBlur,

    image::FeImage,

    lighting::{FeDiffuseLighting, FeDistantLight, FePointLight, FeSpecularLighting, FeSpotLight},

    merge::{FeMerge, FeMergeNode},

    morphology::FeMorphology,

    offset::FeOffset,

    tile::FeTile,

    turbulence::FeTurbulence,

    FilterEffect,

};

use crate::gradient::{LinearGradient, RadialGradient, Stop};

use crate::image::Image;

use crate::marker::Marker;

use crate::node::*;

use crate::pattern::Pattern;

use crate::properties::{ComputedValues, SpecifiedValues};

use crate::rsvg_log;

use crate::session::Session;

use crate::shapes::{Circle, Ellipse, Line, Path, Polygon, Polyline, Rect};

use crate::structure::{ClipPath, Group, Link, Mask, NonRendering, Svg, Switch, Symbol, Use};

use crate::style::Style;

use crate::text::{TRef, TSpan, Text};

use crate::xml::Attributes;

pub trait ElementTrait {

    /// Sets per-element attributes.

    ///

    /// Each element is supposed to iterate the `attributes`, and parse any ones it needs.

    /// SVG specifies that unknown attributes should be ignored, and known attributes with invalid

    /// values should be ignored so that the attribute ends up with its "initial value".

    ///

    /// You can use the [`set_attribute`] function to do that.

    /// Draw an element.

    ///

    /// Each element is supposed to draw itself as needed.

        &self,

        _node: &Node,

        _acquired_nodes: &mut AcquiredNodes<'_>,

        _cascaded: &CascadedValues<'_>,

        _viewport: &Viewport,

        draw_ctx: &mut DrawingCtx,

        _clipping: bool,

    ) -> Result<BoundingBox, InternalRenderingError> {

        // by default elements don't draw themselves

}

/// Sets `dest` if `parse_result` is `Ok()`, otherwise just logs the error.

///

/// Implementations of the [`ElementTrait`] trait generally scan a list of attributes

/// for the ones they can handle, and parse their string values.  Per the SVG spec, an attribute

/// with an invalid value should be ignored, and it should fall back to the default value.

///

/// In librsvg, those default values are set in each element's implementation of the [`Default`] trait:

/// at element creation time, each element gets initialized to its `Default`, and then each attribute

/// gets parsed.  This function will set that attribute's value only if parsing was successful.

///

/// In case the `parse_result` is an error, this function will log an appropriate notice

/// via the [`Session`].

            // FIXME: this does not provide a clue of what was the problematic element.

            // We need tracking of the current parsing position to do that.

    }

pub struct Element {

    element_name: QualName,

    attributes: Attributes,

    specified_values: SpecifiedValues,

    important_styles: HashSet<QualName>,

    values: ComputedValues,

    required_extensions: Option<RequiredExtensions>,

    required_features: Option<RequiredFeatures>,

    system_language: Option<SystemLanguage>,

    pub element_data: ElementData,

}

impl fmt::Display for Element {

}

/// Parsed contents of an element node in the DOM.

///

/// This enum uses `Box<Foo>` in order to make each variant the size of

/// a pointer.

pub enum ElementData {

    Circle(Box<Circle>),

    ClipPath(Box<ClipPath>),

    Ellipse(Box<Ellipse>),

    Filter(Box<Filter>),

    Group(Box<Group>),

    Image(Box<Image>),

    Line(Box<Line>),

    LinearGradient(Box<LinearGradient>),

    Link(Box<Link>),

    Marker(Box<Marker>),

    Mask(Box<Mask>),

    NonRendering(Box<NonRendering>),

    Path(Box<Path>),

    Pattern(Box<Pattern>),

    Polygon(Box<Polygon>),

    Polyline(Box<Polyline>),

    RadialGradient(Box<RadialGradient>),

    Rect(Box<Rect>),

    Stop(Box<Stop>),

    Style(Box<Style>),

    Svg(Box<Svg>),

    Switch(Box<Switch>),

    Symbol(Box<Symbol>),

    Text(Box<Text>),

    TRef(Box<TRef>),

    TSpan(Box<TSpan>),

    Use(Box<Use>),

    // Filter primitives, these start with "Fe" as element names are e.g. "feBlend"

    FeBlend(Box<FeBlend>),

    FeColorMatrix(Box<FeColorMatrix>),

    FeComponentTransfer(Box<FeComponentTransfer>),

    FeComposite(Box<FeComposite>),

    FeConvolveMatrix(Box<FeConvolveMatrix>),

    FeDiffuseLighting(Box<FeDiffuseLighting>),

    FeDisplacementMap(Box<FeDisplacementMap>),

    FeDistantLight(Box<FeDistantLight>),

    FeDropShadow(Box<FeDropShadow>),

    FeFlood(Box<FeFlood>),

    FeFuncA(Box<FeFuncA>),

    FeFuncB(Box<FeFuncB>),

    FeFuncG(Box<FeFuncG>),

    FeFuncR(Box<FeFuncR>),

    FeGaussianBlur(Box<FeGaussianBlur>),

    FeImage(Box<FeImage>),

    FeMerge(Box<FeMerge>),

    FeMergeNode(Box<FeMergeNode>),

    FeMorphology(Box<FeMorphology>),

    FeOffset(Box<FeOffset>),

    FePointLight(Box<FePointLight>),

    FeSpecularLighting(Box<FeSpecularLighting>),

    FeSpotLight(Box<FeSpotLight>),

    FeTile(Box<FeTile>),

    FeTurbulence(Box<FeTurbulence>),

}

#[rustfmt::skip]

    use ElementCreateFlags::*;

        // Lines in comments are elements that we don't support.

            // name, supports_class, create_fn

            /* ("altGlyph",         ), */

            /* ("altGlyphDef",      ), */

            /* ("altGlyphItem",     ), */

            /* ("animate",          ), */

            /* ("animateColor",     ), */

            /* ("animateMotion",    ), */

            /* ("animateTransform", ), */

            /* ("color-profile",    ), */

            /* ("cursor",           ), */

            /* ("desc",             ), */

            /* ("font",             ), */

            /* ("font-face",        ), */

            /* ("font-face-format", ), */

            /* ("font-face-name",   ), */

            /* ("font-face-src",    ), */

            /* ("font-face-uri",    ), */

            /* ("foreignObject",    ), */

            /* ("glyph",            ), */

            /* ("glyphRef",         ), */

            /* ("hkern",            ), */

            /* ("metadata",         ), */

            /* ("missing-glyph",    ), */

            /* ("mpath",            ), */

            /* ("multiImage",       ), */

            /* ("script",           ), */

            /* ("set",              ), */

            /* ("subImage",         ), */

            /* ("subImageRef",      ), */

            /* ("textPath",         ), */

            /* ("title",            ), */

            /* ("view",             ), */

            /* ("vkern",            ), */

        ];

impl Element {

    /// Takes an XML element name and consumes a list of attribute/value pairs to create an [`Element`].

    ///

    /// This operation does not fail.  Unknown element names simply produce a [`NonRendering`]

    /// element.

                // hack in the SVG namespace for supported element names

                // Whenever we encounter a element name we don't understand, represent it as a

                // non-rendering element.  This is like a group, but it doesn't do any rendering

                // of children.  The effect is that we will ignore all children of unknown elements.

            }

        } else {

        };

        };

        &self.specified_values

            .as_ref()

            .unwrap_or(true)

                .required_features

                .as_ref()

                .unwrap_or(true)

                .system_language

                .as_ref()

                .unwrap_or(true)

                }

                }

                }

                _ => {}

            }

    /// Hands the `attrs` to the node's state, to apply the presentation attributes.

    // Applies a style declaration to the node's specified_values

            declaration,

            origin,

        );

    /// Applies CSS styles from the "style" attribute

            .attributes

            .iter()

                style,

                session,

            );

        }

    #[rustfmt::skip]

        use ElementData::*;

        }

    /// Returns whether an element of a particular type is only accessed by reference

    // from other elements' attributes.  The element could in turn cause other nodes

    // to get referenced, potentially causing reference cycles.

        use ElementData::*;

            ClipPath(_)

                | Filter(_)

                | LinearGradient(_)

                | Marker(_)

                | Mask(_)

                | Pattern(_)

                | RadialGradient(_)

        )

    /// The main drawing function for elements.

        &self,

        node: &Node,

        acquired_nodes: &mut AcquiredNodes<'_>,

        cascaded: &CascadedValues<'_>,

        viewport: &Viewport,

        draw_ctx: &mut DrawingCtx,

        clipping: bool,

    ) -> Result<BoundingBox, InternalRenderingError> {

                .draw(node, acquired_nodes, cascaded, viewport, draw_ctx, clipping)

        } else {

        }

}

impl ElementData {

    /// Dispatcher for the draw method of concrete element implementations.

    #[rustfmt::skip]

        &self,

        node: &Node,

        acquired_nodes: &mut AcquiredNodes<'_>,

        cascaded: &CascadedValues<'_>,

        viewport: &Viewport,

        draw_ctx: &mut DrawingCtx,

        clipping: bool,

    ) -> Result<BoundingBox, InternalRenderingError> {

        use ElementData::*;

        };

}

macro_rules! e {

    ($name:ident, $element_type:ident) => {

    };

}

#[rustfmt::skip]

mod creators {

    use super::*;

    e!(create_circle,                   Circle);

    e!(create_clip_path,                ClipPath);

    e!(create_defs,                     NonRendering);

    e!(create_ellipse,                  Ellipse);

    e!(create_fe_blend,                 FeBlend);

    e!(create_fe_color_matrix,          FeColorMatrix);

    e!(create_fe_component_transfer,    FeComponentTransfer);

    e!(create_fe_func_a,                FeFuncA);

    e!(create_fe_func_b,                FeFuncB);

    e!(create_fe_func_g,                FeFuncG);

    e!(create_fe_func_r,                FeFuncR);

    e!(create_fe_composite,             FeComposite);

    e!(create_fe_convolve_matrix,       FeConvolveMatrix);

    e!(create_fe_diffuse_lighting,      FeDiffuseLighting);

    e!(create_fe_displacement_map,      FeDisplacementMap);

    e!(create_fe_distant_light,         FeDistantLight);

    e!(create_fe_drop_shadow,           FeDropShadow);

    e!(create_fe_flood,                 FeFlood);

    e!(create_fe_gaussian_blur,         FeGaussianBlur);

    e!(create_fe_image,                 FeImage);

    e!(create_fe_merge,                 FeMerge);

    e!(create_fe_merge_node,            FeMergeNode);

    e!(create_fe_morphology,            FeMorphology);

    e!(create_fe_offset,                FeOffset);

    e!(create_fe_point_light,           FePointLight);

    e!(create_fe_specular_lighting,     FeSpecularLighting);

    e!(create_fe_spot_light,            FeSpotLight);

    e!(create_fe_tile,                  FeTile);

    e!(create_fe_turbulence,            FeTurbulence);

    e!(create_filter,                   Filter);

    e!(create_group,                    Group);

    e!(create_image,                    Image);

    e!(create_line,                     Line);

    e!(create_linear_gradient,          LinearGradient);

    e!(create_link,                     Link);

    e!(create_marker,                   Marker);

    e!(create_mask,                     Mask);

    e!(create_non_rendering,            NonRendering);

    e!(create_path,                     Path);

    e!(create_pattern,                  Pattern);

    e!(create_polygon,                  Polygon);

    e!(create_polyline,                 Polyline);

    e!(create_radial_gradient,          RadialGradient);

    e!(create_rect,                     Rect);

    e!(create_stop,                     Stop);

    e!(create_style,                    Style);

    e!(create_svg,                      Svg);

    e!(create_switch,                   Switch);

    e!(create_symbol,                   Symbol);

    e!(create_text,                     Text);

    e!(create_tref,                     TRef);

    e!(create_tspan,                    TSpan);

    e!(create_use,                      Use);

    /* Hack to make multiImage sort-of work

     *

     * disabled for now, as markup5ever doesn't have local names for

     * multiImage, subImage, subImageRef.  Maybe we can just... create them ourselves?

     *

     * Is multiImage even in SVG2?

     */

    /*

    e!(create_multi_image,              Switch);

    e!(create_sub_image,                Group);

    e!(create_sub_image_ref,            Image);

    */

}

use creators::*;

type ElementDataCreateFn = fn(session: &Session, attributes: &Attributes) -> ElementData;

enum ElementCreateFlags {

    Default,

    IgnoreClass,

}

static ELEMENT_CREATORS: OnceLock<

    HashMap<&'static str, (ElementDataCreateFn, ElementCreateFlags)>,

> = OnceLock::new();