//! SVG rendering and path tessellation.

//!

//! This module provides functionality for parsing, manipulating, and rendering SVG paths.

//! It includes:

//!

//! - **Path tessellation**: Converts SVG paths into triangle meshes for GPU rendering

//! - **Stroke generation**: Creates stroked paths with various line join and cap styles

//! - **Transform support**: Applies CSS transforms to SVG elements

//! - **Style parsing**: Handles SVG fill, stroke, opacity, and other attributes

//!

//! The module uses Lyon for geometric tessellation and generates vertex/index buffers

//! that can be uploaded to WebRender for hardware-accelerated rendering.

use alloc::{

    string::{String, ToString},

    vec::Vec,

};

use core::fmt;

use azul_css::{

    props::{

        basic::{

            ColorF, ColorU, OptionColorU, OptionLayoutSize, PixelValue, SvgCubicCurve, SvgPoint,

            SvgQuadraticCurve, SvgRect, SvgVector,

        },

        style::{StyleTransform, StyleTransformOrigin, StyleTransformVec},

    },

    AzString, OptionString, StringVec, U32Vec,

};

use crate::{

    geom::PhysicalSizeU32,

    gl::{

        GlContextPtr, GlShader, IndexBufferFormat, Texture, Uniform, UniformType, VertexAttribute,

        VertexAttributeType, VertexBuffer, VertexLayout, VertexLayoutDescription,

    },

    transform::{ComputedTransform3D, RotationMode},

    xml::XmlError,

};

/// Default miter limit for stroke joins (ratio of miter length to stroke width)

const DEFAULT_MITER_LIMIT: f32 = 4.0;

/// Default stroke width in pixels

const DEFAULT_LINE_WIDTH: f32 = 1.0;

/// Default tessellation tolerance in pixels (smaller = more vertices, higher quality)

const DEFAULT_TOLERANCE: f32 = 0.1;

/// Represents the dimensions of an SVG viewport or element.

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgSize {

    /// Width in SVG user units

    pub width: f32,

    /// Height in SVG user units

    pub height: f32,

}

/// A line segment in 2D space.

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgLine {

    /// Start point of the line

    pub start: SvgPoint,

    /// End point of the line

    pub end: SvgPoint,

}

impl SvgLine {

    /// Creates a new line segment from start to end point

    #[inline]

    /// Computes the inward-facing normal vector for this line.

    ///

    /// The normal points 90 degrees to the right of the line direction.

    /// Returns `None` if the line has zero length.

        } else {

        }

    /// Computes the outward-facing normal vector for this line (opposite of `inwards_normal`).

    /// Reverses the direction of the line by swapping start and end points.

    /// Returns the start point of the line.

    /// Returns the end point of the line.

    /// Returns the parametric `t` value (0.0–1.0) at the given arc-length offset.

    /// Returns the tangent vector of the line.

    /// For a line, the tangent is constant (same direction everywhere),

    /// so no `t` parameter is needed.

    /// Returns the X coordinate at parametric position `t` (0.0 = start, 1.0 = end).

    /// Returns the Y coordinate at parametric position `t` (0.0 = start, 1.0 = end).

    /// Returns the Euclidean length of the line segment.

    /// Returns the axis-aligned bounding rectangle of this line segment.

}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C, u8)]

pub enum SvgPathElement {

    Line(SvgLine),

    QuadraticCurve(SvgQuadraticCurve),

    CubicCurve(SvgCubicCurve),

}

impl_option!(

    SvgPathElement,

    OptionSvgPathElement,

    [Debug, Copy, Clone, PartialEq, PartialOrd]

);

impl SvgPathElement {

    /// Creates a line path element from a SvgLine

    #[inline]

    /// Creates a quadratic curve path element from a SvgQuadraticCurve

    #[inline]

    /// Creates a cubic curve path element from a SvgCubicCurve

    #[inline]

    /// Sets the end point of this path element.

        }

    /// Sets the start point of this path element.

        }

    /// Reverses the direction of this path element.

        }

    /// Returns the start point of this path element.

        }

    /// Returns the end point of this path element.

        }

    /// Returns the axis-aligned bounding rectangle of this path element.

        }

    /// Returns the arc length of this path element.

        }

    /// Returns the parametric `t` value at the given arc-length offset.

        }

    /// Returns the normalized tangent vector at parametric position `t`.

        }

    /// Returns the X coordinate at parametric position `t`.

        }

    /// Returns the Y coordinate at parametric position `t`.

        }

}

impl_vec!(SvgPathElement, SvgPathElementVec, SvgPathElementVecDestructor, SvgPathElementVecDestructorType, SvgPathElementVecSlice, OptionSvgPathElement);

impl_vec_debug!(SvgPathElement, SvgPathElementVec);

impl_vec_clone!(

    SvgPathElement,

    SvgPathElementVec,

    SvgPathElementVecDestructor

);

impl_vec_partialeq!(SvgPathElement, SvgPathElementVec);

impl_vec_partialord!(SvgPathElement, SvgPathElementVec);

#[derive(Debug, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgPath {

    pub items: SvgPathElementVec,

}

impl_option!(

    SvgPath,

    OptionSvgPath,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl SvgPath {

    /// Creates a new SvgPath from a vector of path elements

    #[inline]

    /// Returns the start point of the first element, or `None` if the path is empty.

    /// Returns the end point of the last element, or `None` if the path is empty.

    /// Closes the path by appending a line from the last point to the first point, if needed.

        };

        };

    /// Returns `true` if the path's first start point equals its last end point.

        }

    /// Reverses the order and direction of all elements in the path.

        // swap self.items with a default vec

        // reverse the order of items in the vec

        // reverse the order inside the item itself

        // i.e. swap line.start and line.end

        // swap back

    /// Joins another path onto the end of this one, interpolating the join point.

        // swap self.items with a default vec

        // swap back

    /// Returns the axis-aligned bounding rectangle of the entire path.

        };

}

#[derive(Debug, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgMultiPolygon {

    /// NOTE: If a ring represents a hole, simply reverse the order of points

    pub rings: SvgPathVec,

}

impl_option!(

    SvgMultiPolygon,

    OptionSvgMultiPolygon,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl SvgMultiPolygon {

    /// Creates a new SvgMultiPolygon from a vector of paths (rings)

    /// NOTE: If a ring represents a hole, simply reverse the order of points

    #[inline]

    /// Returns the axis-aligned bounding rectangle of all rings in this multi-polygon.

        {

            // Empty polygon has zero-sized bounds at origin

        };

        }

}

impl_vec!(SvgPath, SvgPathVec, SvgPathVecDestructor, SvgPathVecDestructorType, SvgPathVecSlice, OptionSvgPath);

impl_vec_debug!(SvgPath, SvgPathVec);

impl_vec_clone!(SvgPath, SvgPathVec, SvgPathVecDestructor);

impl_vec_partialeq!(SvgPath, SvgPathVec);

impl_vec_partialord!(SvgPath, SvgPathVec);

impl_vec!(SvgMultiPolygon, SvgMultiPolygonVec, SvgMultiPolygonVecDestructor, SvgMultiPolygonVecDestructorType, SvgMultiPolygonVecSlice, OptionSvgMultiPolygon);

impl_vec_debug!(SvgMultiPolygon, SvgMultiPolygonVec);

impl_vec_clone!(

    SvgMultiPolygon,

    SvgMultiPolygonVec,

    SvgMultiPolygonVecDestructor

);

impl_vec_partialeq!(SvgMultiPolygon, SvgMultiPolygonVec);

impl_vec_partialord!(SvgMultiPolygon, SvgMultiPolygonVec);

/// One `SvgNode` corresponds to one SVG `<path></path>` element

#[derive(Debug, Clone, PartialOrd, PartialEq)]

#[repr(C, u8)]

pub enum SvgNode {

    /// Multiple multipolygons, merged to one CPU buf for efficient drawing

    MultiPolygonCollection(SvgMultiPolygonVec),

    MultiPolygon(SvgMultiPolygon),

    MultiShape(SvgSimpleNodeVec),

    Path(SvgPath),

    Circle(SvgCircle),

    Rect(SvgRect),

}

/// One `SvgSimpleNode` is either a path, a rect or a circle

#[derive(Debug, Clone, PartialOrd, PartialEq)]

#[repr(C, u8)]

pub enum SvgSimpleNode {

    Path(SvgPath),

    Circle(SvgCircle),

    Rect(SvgRect),

    CircleHole(SvgCircle),

    RectHole(SvgRect),

}

impl_option!(

    SvgSimpleNode,

    OptionSvgSimpleNode,

    copy = false,

    [Debug, Clone, PartialOrd, PartialEq]

);

impl_vec!(SvgSimpleNode, SvgSimpleNodeVec, SvgSimpleNodeVecDestructor, SvgSimpleNodeVecDestructorType, SvgSimpleNodeVecSlice, OptionSvgSimpleNode);

impl_vec_debug!(SvgSimpleNode, SvgSimpleNodeVec);

impl_vec_clone!(SvgSimpleNode, SvgSimpleNodeVec, SvgSimpleNodeVecDestructor);

impl_vec_partialeq!(SvgSimpleNode, SvgSimpleNodeVec);

impl_vec_partialord!(SvgSimpleNode, SvgSimpleNodeVec);

impl SvgSimpleNode {

    /// Returns the axis-aligned bounding rectangle of this node.

        }

    /// Returns `true` if this node represents a closed shape.

        }

}

impl SvgNode {

    /// Returns the axis-aligned bounding rectangle of this SVG node.

                };

            }

                };

            }

        }

    /// Returns `true` if all sub-paths in this node are closed.

                    }

                }

            }

                }

            }

                }

            }

        }

}

/// An SVG node paired with its visual style (fill or stroke).

#[derive(Debug, Clone, PartialOrd, PartialEq)]

#[repr(C)]

pub struct SvgStyledNode {

    pub geometry: SvgNode,

    pub style: SvgStyle,

}

/// A 2D vertex used in tessellated SVG geometry.

#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]

#[repr(C)]

pub struct SvgVertex {

    pub x: f32,

    pub y: f32,

}

impl_option!(

    SvgVertex,

    OptionSvgVertex,

    [Debug, Copy, Clone, PartialOrd, PartialEq]

);

impl VertexLayoutDescription for SvgVertex {

}

/// A 3D vertex with per-vertex RGBA color, used in multi-colored SVG tessellation.

#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]

#[repr(C)]

pub struct SvgColoredVertex {

    pub x: f32,

    pub y: f32,

    pub z: f32,

    pub r: f32,

    pub g: f32,

    pub b: f32,

    pub a: f32,

}

impl_option!(

    SvgColoredVertex,

    OptionSvgColoredVertex,

    [Debug, Copy, Clone, PartialOrd, PartialEq]

);

impl VertexLayoutDescription for SvgColoredVertex {

}

/// A circle defined by center coordinates and radius.

#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]

#[repr(C)]

pub struct SvgCircle {

    pub center_x: f32,

    pub center_y: f32,

    pub radius: f32,

}

impl SvgCircle {

    /// Returns `true` if the given point lies inside the circle.

    /// Returns the axis-aligned bounding rectangle of this circle.

}

#[derive(Debug, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct TessellatedSvgNode {

    pub vertices: SvgVertexVec,

    pub indices: U32Vec,

}

impl_option!(

    TessellatedSvgNode,

    OptionTessellatedSvgNode,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl Default for TessellatedSvgNode {

}

impl_vec!(TessellatedSvgNode, TessellatedSvgNodeVec, TessellatedSvgNodeVecDestructor, TessellatedSvgNodeVecDestructorType, TessellatedSvgNodeVecSlice, OptionTessellatedSvgNode);

impl_vec_debug!(TessellatedSvgNode, TessellatedSvgNodeVec);

impl_vec_partialord!(TessellatedSvgNode, TessellatedSvgNodeVec);

impl_vec_clone!(

    TessellatedSvgNode,

    TessellatedSvgNodeVec,

    TessellatedSvgNodeVecDestructor

);

impl_vec_partialeq!(TessellatedSvgNode, TessellatedSvgNodeVec);

impl TessellatedSvgNode {

}

impl TessellatedSvgNodeVec {

}

impl fmt::Debug for TessellatedSvgNodeVecRef {

}

// C ABI wrapper over &[TessellatedSvgNode]

#[repr(C)]

pub struct TessellatedSvgNodeVecRef {

    pub ptr: *const TessellatedSvgNode,

    pub len: usize,

}

impl Clone for TessellatedSvgNodeVecRef {

}

impl TessellatedSvgNodeVecRef {

}

#[derive(Debug, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct TessellatedColoredSvgNode {

    pub vertices: SvgColoredVertexVec,

    pub indices: U32Vec,

}

impl_option!(

    TessellatedColoredSvgNode,

    OptionTessellatedColoredSvgNode,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl Default for TessellatedColoredSvgNode {

}

impl_vec!(TessellatedColoredSvgNode, TessellatedColoredSvgNodeVec, TessellatedColoredSvgNodeVecDestructor, TessellatedColoredSvgNodeVecDestructorType, TessellatedColoredSvgNodeVecSlice, OptionTessellatedColoredSvgNode);

impl_vec_debug!(TessellatedColoredSvgNode, TessellatedColoredSvgNodeVec);

impl_vec_partialord!(TessellatedColoredSvgNode, TessellatedColoredSvgNodeVec);

impl_vec_clone!(

    TessellatedColoredSvgNode,

    TessellatedColoredSvgNodeVec,

    TessellatedColoredSvgNodeVecDestructor

);

impl_vec_partialeq!(TessellatedColoredSvgNode, TessellatedColoredSvgNodeVec);

impl TessellatedColoredSvgNode {

}

impl TessellatedColoredSvgNodeVec {

}

impl fmt::Debug for TessellatedColoredSvgNodeVecRef {

}

// C ABI wrapper over &[TessellatedColoredSvgNode]

#[repr(C)]

pub struct TessellatedColoredSvgNodeVecRef {

    pub ptr: *const TessellatedColoredSvgNode,

    pub len: usize,

}

impl Clone for TessellatedColoredSvgNodeVecRef {

}

impl TessellatedColoredSvgNodeVecRef {

}

impl_vec!(SvgVertex, SvgVertexVec, SvgVertexVecDestructor, SvgVertexVecDestructorType, SvgVertexVecSlice, OptionSvgVertex);

impl_vec_debug!(SvgVertex, SvgVertexVec);

impl_vec_partialord!(SvgVertex, SvgVertexVec);

impl_vec_clone!(SvgVertex, SvgVertexVec, SvgVertexVecDestructor);

impl_vec_partialeq!(SvgVertex, SvgVertexVec);

impl_vec!(SvgColoredVertex, SvgColoredVertexVec, SvgColoredVertexVecDestructor, SvgColoredVertexVecDestructorType, SvgColoredVertexVecSlice, OptionSvgColoredVertex);

impl_vec_debug!(SvgColoredVertex, SvgColoredVertexVec);

impl_vec_partialord!(SvgColoredVertex, SvgColoredVertexVec);

impl_vec_clone!(

    SvgColoredVertex,

    SvgColoredVertexVec,

    SvgColoredVertexVecDestructor

);

impl_vec_partialeq!(SvgColoredVertex, SvgColoredVertexVec);

/// Computes the bbox size and transform matrix uniforms shared by SVG draw methods.

///

/// Converts `StyleTransform` list into column-major `[f32; 16]` for OpenGL,

/// and packages it along with the bbox size uniform.

    );

    // NOTE: OpenGL draws are column-major, while ComputedTransform3D

    // is row-major! Need to transpose the matrix!

#[derive(Debug, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct TessellatedGPUSvgNode {

    pub vertex_index_buffer: VertexBuffer,

}

impl TessellatedGPUSvgNode {

    /// Uploads the tesselated SVG node to GPU memory

    /// Draw the vertex buffer to the texture with the given color and transform

        );

}

#[derive(Debug, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct TessellatedColoredGPUSvgNode {

    pub vertex_index_buffer: VertexBuffer,

}

impl TessellatedColoredGPUSvgNode {

    /// Uploads the tesselated SVG node to GPU memory

    /// Draw the vertex buffer to the texture with the given color and transform

        );

}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C, u8)]

pub enum SvgStyle {

    Fill(SvgFillStyle),

    Stroke(SvgStrokeStyle),

}

impl SvgStyle {

        }

        }

        }

}

/// SVG fill rule for determining the interior of a shape.

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub enum SvgFillRule {

    Winding,

    EvenOdd,

}

impl Default for SvgFillRule {

}

#[derive(Default, Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgTransform {

    pub sx: f32,

    pub kx: f32,

    pub ky: f32,

    pub sy: f32,

    pub tx: f32,

    pub ty: f32,

}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgFillStyle {

    /// See the SVG specification.

    ///

    /// Default value: `LineJoin::Miter`.

    pub line_join: SvgLineJoin,

    /// See the SVG specification.

    ///

    /// Must be greater than or equal to 1.0.

    /// Default value: `StrokeOptions::DEFAULT_MITER_LIMIT`.

    pub miter_limit: f32,

    /// Maximum allowed distance to the path when building an approximation.

    ///

    /// See [Flattening and tolerance](index.html#flattening-and-tolerance).

    /// Default value: `StrokeOptions::DEFAULT_TOLERANCE`.

    pub tolerance: f32,

    /// Whether to use the "winding" or "even / odd" fill rule when tesselating the path

    pub fill_rule: SvgFillRule,

    /// Whether to apply a transform to the points in the path (warning: will be done on the CPU -

    /// expensive)

    pub transform: SvgTransform,

    /// Whether the fill is intended to be anti-aliased (default: true)

    pub anti_alias: bool,

    /// Whether the anti-aliasing has to be of high quality (default: false)

    pub high_quality_aa: bool,

}

impl Default for SvgFillStyle {

}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgStrokeStyle {

    /// Dash pattern

    pub dash_pattern: OptionSvgDashPattern,

    /// Whether to apply a transform to the points in the path (warning: will be done on the CPU -

    /// expensive)

    pub transform: SvgTransform,

    /// What cap to use at the start of each sub-path.

    ///

    /// Default value: `LineCap::Butt`.

    pub start_cap: SvgLineCap,

    /// What cap to use at the end of each sub-path.

    ///

    /// Default value: `LineCap::Butt`.

    pub end_cap: SvgLineCap,

    /// See the SVG specification.

    ///

    /// Default value: `LineJoin::Miter`.

    pub line_join: SvgLineJoin,

    /// Line width

    ///

    /// Default value: `StrokeOptions::DEFAULT_LINE_WIDTH`.

    pub line_width: f32,

    /// See the SVG specification.

    ///

    /// Must be greater than or equal to 1.0.

    /// Default value: `StrokeOptions::DEFAULT_MITER_LIMIT`.

    pub miter_limit: f32,

    /// Maximum allowed distance to the path when building an approximation.

    ///

    /// See [Flattening and tolerance](index.html#flattening-and-tolerance).

    /// Default value: `StrokeOptions::DEFAULT_TOLERANCE`.

    pub tolerance: f32,

    /// Apply line width

    ///

    /// When set to false, the generated vertices will all be positioned in the centre

    /// of the line. The width can be applied later on (eg in a vertex shader) by adding

    /// the vertex normal multiplied by the line with to each vertex position.

    ///

    /// Default value: `true`. NOTE: currently unused!

    pub apply_line_width: bool,

    /// Whether the fill is intended to be anti-aliased (default: true)

    pub anti_alias: bool,

    /// Whether the anti-aliasing has to be of high quality (default: false)

    pub high_quality_aa: bool,

}

impl Default for SvgStrokeStyle {

}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgDashPattern {

    pub offset: f32,

    pub length_1: f32,

    pub gap_1: f32,

    pub length_2: f32,

    pub gap_2: f32,

    pub length_3: f32,

    pub gap_3: f32,

}

impl_option!(

    SvgDashPattern,

    OptionSvgDashPattern,

    [Debug, Copy, Clone, PartialEq, PartialOrd]

);

/// The shape used at the end of open sub-paths when they are stroked.

#[derive(Debug, Copy, Clone, PartialEq, Hash, Eq, PartialOrd, Ord)]

#[repr(C)]

pub enum SvgLineCap {

    Butt,

    Square,

    Round,

}

impl Default for SvgLineCap {

}

/// The shape used at the corners of stroked paths.

#[derive(Debug, Copy, Clone, PartialEq, Hash, Eq, PartialOrd, Ord)]

#[repr(C)]

pub enum SvgLineJoin {

    Miter,

    MiterClip,

    Round,

    Bevel,

}

impl Default for SvgLineJoin {

}

pub use core::ffi::c_void;

#[derive(Debug, Clone)]

#[repr(C)]

pub struct SvgXmlNode {

    pub node: *const c_void, // usvg::Node

    pub run_destructor: bool,

}

#[derive(Debug, Clone)]

#[repr(C)]

pub struct Svg {

    pub tree: *const c_void, // *mut usvg::Tree,

    pub run_destructor: bool,

}

/// SVG `shape-rendering` property controlling quality vs speed tradeoffs.

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[repr(C)]

pub enum ShapeRendering {

    OptimizeSpeed,

    CrispEdges,

    GeometricPrecision,

}

/// SVG `image-rendering` property controlling image quality vs speed.

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[repr(C)]

pub enum ImageRendering {

    OptimizeQuality,

    OptimizeSpeed,

}

/// SVG `text-rendering` property controlling text quality vs speed.

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[repr(C)]

pub enum TextRendering {

    OptimizeSpeed,

    OptimizeLegibility,

    GeometricPrecision,

}

/// Font database source for SVG text rendering.

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[repr(C)]

pub enum FontDatabase {

    Empty,

    System,

}

#[derive(Debug, Default, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgRenderOptions {

    pub target_size: OptionLayoutSize,

    pub background_color: OptionColorU,

    pub fit: SvgFitTo,

    pub transform: SvgRenderTransform,

}

#[derive(Debug, Default, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct SvgRenderTransform {

    pub sx: f32,

    pub kx: f32,

    pub ky: f32,

    pub sy: f32,

    pub tx: f32,

    pub ty: f32,

}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C, u8)]

pub enum SvgFitTo {

    Original,

    Width(u32),