//! CSS properties for backgrounds, including colors, images, and gradients.

use alloc::{

    string::{String, ToString},

    vec::Vec,

};

use core::fmt;

#[cfg(feature = "parser")]

use crate::props::basic::{

    error::{InvalidValueErr, InvalidValueErrOwned},

    parse::{

        parse_parentheses, parse_image, split_string_respect_comma,

        CssImageParseError, CssImageParseErrorOwned,

        ParenthesisParseError, ParenthesisParseErrorOwned,

    },

    color::parse_color_or_system,

};

use crate::{

    corety::AzString,

    codegen::format::GetHash,

    props::{

        basic::{

            angle::{

                parse_angle_value, AngleValue, CssAngleValueParseError,

                CssAngleValueParseErrorOwned, OptionAngleValue,

            },

            color::{ColorU, ColorOrSystem, SystemColorRef, CssColorParseError, CssColorParseErrorOwned},

            direction::{

                parse_direction, CssDirectionParseError, CssDirectionParseErrorOwned, Direction,

            },

            length::{

                parse_percentage_value, OptionPercentageValue, PercentageParseError,

                PercentageParseErrorOwned, PercentageValue,

            },

            pixel::{

                parse_pixel_value, CssPixelValueParseError, CssPixelValueParseErrorOwned,

                PixelValue,

            },

        },

        formatter::PrintAsCssValue,

    },

};

// --- TYPE DEFINITIONS ---

/// Whether a `gradient` should be repeated or clamped to the edges.

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

#[repr(C)]

#[derive(Default)]

pub enum ExtendMode {

    #[default]

    Clamp,

    Repeat,

}

// -- Main Background Content Type --

/// A single CSS background layer: a solid color, image URL, or gradient.

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

#[repr(C, u8)]

pub enum StyleBackgroundContent {

    LinearGradient(LinearGradient),

    RadialGradient(RadialGradient),

    ConicGradient(ConicGradient),

    Image(AzString),

    Color(ColorU),

    /// A theme-aware system color (e.g. `background: system:accent`), kept unresolved

    /// and resolved at render time. Mirrors the `ColorOrSystem::System` value that

    /// gradient color stops already accept.

    SystemColor(SystemColorRef),

}

impl_option!(

    StyleBackgroundContent,

    OptionStyleBackgroundContent,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_vec!(StyleBackgroundContent, StyleBackgroundContentVec, StyleBackgroundContentVecDestructor, StyleBackgroundContentVecDestructorType, StyleBackgroundContentVecSlice, OptionStyleBackgroundContent);

impl_vec_debug!(StyleBackgroundContent, StyleBackgroundContentVec);

impl_vec_partialord!(StyleBackgroundContent, StyleBackgroundContentVec);

impl_vec_ord!(StyleBackgroundContent, StyleBackgroundContentVec);

impl_vec_clone!(

    StyleBackgroundContent,

    StyleBackgroundContentVec,

    StyleBackgroundContentVecDestructor

);

impl_vec_partialeq!(StyleBackgroundContent, StyleBackgroundContentVec);

impl_vec_eq!(StyleBackgroundContent, StyleBackgroundContentVec);

impl_vec_hash!(StyleBackgroundContent, StyleBackgroundContentVec);

impl Default for StyleBackgroundContent {

}

impl PrintAsCssValue for StyleBackgroundContent {

                } else {

                };

            }

                } else {

                };

            }

                } else {

                };

            }

        }

}

// Formatting to Rust code for background-related vecs

impl crate::codegen::format::FormatAsRustCode for StyleBackgroundContent {

        // Delegate to the CSS value representation for single backgrounds

}

impl crate::codegen::format::FormatAsRustCode for StyleBackgroundSizeVec {

        )

}

impl crate::codegen::format::FormatAsRustCode for StyleBackgroundRepeatVec {

        )

}

impl crate::codegen::format::FormatAsRustCode for StyleBackgroundContentVec {

        )

}

impl PrintAsCssValue for StyleBackgroundContentVec {

}

// -- Gradient Types --

/// A CSS `linear-gradient()` or `repeating-linear-gradient()` value.

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

#[repr(C)]

pub struct LinearGradient {

    pub direction: Direction,

    pub extend_mode: ExtendMode,

    pub stops: NormalizedLinearColorStopVec,

}

impl Default for LinearGradient {

}

impl PrintAsCssValue for LinearGradient {

        } else {

        }

}

/// A CSS `radial-gradient()` or `repeating-radial-gradient()` value.

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

#[repr(C)]

pub struct RadialGradient {

    pub shape: Shape,

    pub size: RadialGradientSize,

    pub position: StyleBackgroundPosition,

    pub extend_mode: ExtendMode,

    pub stops: NormalizedLinearColorStopVec,

}

impl Default for RadialGradient {

}

impl PrintAsCssValue for RadialGradient {

            self.shape,

            self.size,

            stops_str

        )

}

/// A CSS `conic-gradient()` or `repeating-conic-gradient()` value.

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

#[repr(C)]

pub struct ConicGradient {

    pub extend_mode: ExtendMode,

    pub center: StyleBackgroundPosition,

    pub angle: AngleValue,

    pub stops: NormalizedRadialColorStopVec,

}

impl Default for ConicGradient {

}

impl PrintAsCssValue for ConicGradient {

            self.angle,

            stops_str

        )

}

// -- Gradient Sub-types --

/// The shape of a radial gradient: `circle` or `ellipse`.

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

#[repr(C)]

#[derive(Default)]

pub enum Shape {

    #[default]

    Ellipse,

    Circle,

}

impl fmt::Display for Shape {

            }

        )

}

/// The sizing keyword for a radial gradient (e.g. `closest-side`, `farthest-corner`).

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

#[repr(C)]

#[derive(Default)]

pub enum RadialGradientSize {

    ClosestSide,

    ClosestCorner,

    FarthestSide,

    #[default]

    FarthestCorner,

}

impl fmt::Display for RadialGradientSize {

            }

        )

}

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

#[repr(C)]

pub struct NormalizedLinearColorStop {

    pub offset: PercentageValue,

    /// Color for this gradient stop. Can be a concrete color or a system color reference.

    pub color: ColorOrSystem,

}

impl NormalizedLinearColorStop {

    /// Create a new normalized linear color stop with a concrete color.

    /// Resolve the color against system colors.

}

impl_option!(

    NormalizedLinearColorStop,

    OptionNormalizedLinearColorStop,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_vec!(NormalizedLinearColorStop, NormalizedLinearColorStopVec, NormalizedLinearColorStopVecDestructor, NormalizedLinearColorStopVecDestructorType, NormalizedLinearColorStopVecSlice, OptionNormalizedLinearColorStop);

impl_vec_debug!(NormalizedLinearColorStop, NormalizedLinearColorStopVec);

impl_vec_partialord!(NormalizedLinearColorStop, NormalizedLinearColorStopVec);

impl_vec_ord!(NormalizedLinearColorStop, NormalizedLinearColorStopVec);

impl_vec_clone!(

    NormalizedLinearColorStop,

    NormalizedLinearColorStopVec,

    NormalizedLinearColorStopVecDestructor

);

impl_vec_partialeq!(NormalizedLinearColorStop, NormalizedLinearColorStopVec);

impl_vec_eq!(NormalizedLinearColorStop, NormalizedLinearColorStopVec);

impl_vec_hash!(NormalizedLinearColorStop, NormalizedLinearColorStopVec);

impl PrintAsCssValue for NormalizedLinearColorStop {

        }

}

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

#[repr(C)]

pub struct NormalizedRadialColorStop {

    pub angle: AngleValue,

    /// Color for this gradient stop. Can be a concrete color or a system color reference.

    pub color: ColorOrSystem,

}

impl NormalizedRadialColorStop {

    /// Create a new normalized radial color stop with a concrete color.

    /// Resolve the color against system colors.

}

impl_option!(

    NormalizedRadialColorStop,

    OptionNormalizedRadialColorStop,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_vec!(NormalizedRadialColorStop, NormalizedRadialColorStopVec, NormalizedRadialColorStopVecDestructor, NormalizedRadialColorStopVecDestructorType, NormalizedRadialColorStopVecSlice, OptionNormalizedRadialColorStop);

impl_vec_debug!(NormalizedRadialColorStop, NormalizedRadialColorStopVec);

impl_vec_partialord!(NormalizedRadialColorStop, NormalizedRadialColorStopVec);

impl_vec_ord!(NormalizedRadialColorStop, NormalizedRadialColorStopVec);

impl_vec_clone!(

    NormalizedRadialColorStop,

    NormalizedRadialColorStopVec,

    NormalizedRadialColorStopVecDestructor

);

impl_vec_partialeq!(NormalizedRadialColorStop, NormalizedRadialColorStopVec);

impl_vec_eq!(NormalizedRadialColorStop, NormalizedRadialColorStopVec);

impl_vec_hash!(NormalizedRadialColorStop, NormalizedRadialColorStopVec);

impl PrintAsCssValue for NormalizedRadialColorStop {

        }

}

/// Transient struct for parsing linear color stops before normalization.

///

/// Per W3C CSS Images Level 3, a color stop can have 0, 1, or 2 positions:

/// - `red` (no position)

/// - `red 50%` (one position)

/// - `red 10% 30%` (two positions - creates two stops at same color)

/// 

/// Supports system colors like `system:accent` for theme-aware gradients.

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

pub struct LinearColorStop {

    pub color: ColorOrSystem,

    /// First position (optional)

    pub offset1: OptionPercentageValue,

    /// Second position (optional, only valid if offset1 is Some)

    /// When present, creates two color stops at the same color.

    pub offset2: OptionPercentageValue,

}

/// Transient struct for parsing radial/conic color stops before normalization.

///

/// Per W3C CSS Images Level 3, a color stop can have 0, 1, or 2 positions:

/// - `red` (no position)

/// - `red 90deg` (one position)

/// - `red 45deg 90deg` (two positions - creates two stops at same color)

/// 

/// Supports system colors like `system:accent` for theme-aware gradients.

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

pub struct RadialColorStop {

    pub color: ColorOrSystem,

    /// First position (optional)

    pub offset1: OptionAngleValue,

    /// Second position (optional, only valid if offset1 is Some)

    /// When present, creates two color stops at the same color.

    pub offset2: OptionAngleValue,

}

// -- Other Background Properties --

/// The `background-position` property (horizontal + vertical components).

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

#[repr(C)]

pub struct StyleBackgroundPosition {

    pub horizontal: BackgroundPositionHorizontal,

    pub vertical: BackgroundPositionVertical,

}

impl_option!(

    StyleBackgroundPosition,

    OptionStyleBackgroundPosition,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_vec!(StyleBackgroundPosition, StyleBackgroundPositionVec, StyleBackgroundPositionVecDestructor, StyleBackgroundPositionVecDestructorType, StyleBackgroundPositionVecSlice, OptionStyleBackgroundPosition);

impl_vec_debug!(StyleBackgroundPosition, StyleBackgroundPositionVec);

impl_vec_partialord!(StyleBackgroundPosition, StyleBackgroundPositionVec);

impl_vec_ord!(StyleBackgroundPosition, StyleBackgroundPositionVec);

impl_vec_clone!(

    StyleBackgroundPosition,

    StyleBackgroundPositionVec,

    StyleBackgroundPositionVecDestructor

);

impl_vec_partialeq!(StyleBackgroundPosition, StyleBackgroundPositionVec);

impl_vec_eq!(StyleBackgroundPosition, StyleBackgroundPositionVec);

impl_vec_hash!(StyleBackgroundPosition, StyleBackgroundPositionVec);

impl Default for StyleBackgroundPosition {

}

impl StyleBackgroundPosition {

}

impl PrintAsCssValue for StyleBackgroundPosition {

        )

}

impl PrintAsCssValue for StyleBackgroundPositionVec {

}

// Formatting to Rust code for StyleBackgroundPositionVec

impl crate::codegen::format::FormatAsRustCode for StyleBackgroundPositionVec {

        )

}

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

/// Horizontal component of `background-position`: a keyword or exact pixel value.

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

#[repr(C, u8)]

pub enum BackgroundPositionHorizontal {

    Left,

    Center,

    Right,

    Exact(PixelValue),

}

impl BackgroundPositionHorizontal {

}

impl PrintAsCssValue for BackgroundPositionHorizontal {

        }

}

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

/// Vertical component of `background-position`: a keyword or exact pixel value.

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

#[repr(C, u8)]

pub enum BackgroundPositionVertical {

    Top,

    Center,

    Bottom,

    Exact(PixelValue),

}

impl BackgroundPositionVertical {

}

impl PrintAsCssValue for BackgroundPositionVertical {

        }

}

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

/// The `background-size` property: `contain`, `cover`, or an exact size.

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

#[repr(C, u8)]

#[derive(Default)]

pub enum StyleBackgroundSize {

    ExactSize(PixelValueSize),

    #[default]

    Contain,

    Cover,

}

impl_option!(

    StyleBackgroundSize,

    OptionStyleBackgroundSize,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

/// Two-dimensional size in `PixelValue` units (width, height)

/// Used for background-size and similar properties

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

#[repr(C)]

pub struct PixelValueSize {

    pub width: PixelValue,

    pub height: PixelValue,

}

impl_vec!(StyleBackgroundSize, StyleBackgroundSizeVec, StyleBackgroundSizeVecDestructor, StyleBackgroundSizeVecDestructorType, StyleBackgroundSizeVecSlice, OptionStyleBackgroundSize);

impl_vec_debug!(StyleBackgroundSize, StyleBackgroundSizeVec);

impl_vec_partialord!(StyleBackgroundSize, StyleBackgroundSizeVec);

impl_vec_ord!(StyleBackgroundSize, StyleBackgroundSizeVec);

impl_vec_clone!(

    StyleBackgroundSize,

    StyleBackgroundSizeVec,

    StyleBackgroundSizeVecDestructor

);

impl_vec_partialeq!(StyleBackgroundSize, StyleBackgroundSizeVec);

impl_vec_eq!(StyleBackgroundSize, StyleBackgroundSizeVec);

impl_vec_hash!(StyleBackgroundSize, StyleBackgroundSizeVec);

impl StyleBackgroundSize {

}

impl PrintAsCssValue for StyleBackgroundSize {

                )

            }

        }

}

impl PrintAsCssValue for StyleBackgroundSizeVec {

}

/// The `background-repeat` property.

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

#[repr(C)]

#[derive(Default)]

pub enum StyleBackgroundRepeat {

    NoRepeat,

    #[default]

    PatternRepeat,

    RepeatX,

    RepeatY,

}

impl_option!(

    StyleBackgroundRepeat,

    OptionStyleBackgroundRepeat,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_vec!(StyleBackgroundRepeat, StyleBackgroundRepeatVec, StyleBackgroundRepeatVecDestructor, StyleBackgroundRepeatVecDestructorType, StyleBackgroundRepeatVecSlice, OptionStyleBackgroundRepeat);

impl_vec_debug!(StyleBackgroundRepeat, StyleBackgroundRepeatVec);

impl_vec_partialord!(StyleBackgroundRepeat, StyleBackgroundRepeatVec);

impl_vec_ord!(StyleBackgroundRepeat, StyleBackgroundRepeatVec);

impl_vec_clone!(

    StyleBackgroundRepeat,

    StyleBackgroundRepeatVec,

    StyleBackgroundRepeatVecDestructor

);

impl_vec_partialeq!(StyleBackgroundRepeat, StyleBackgroundRepeatVec);

impl_vec_eq!(StyleBackgroundRepeat, StyleBackgroundRepeatVec);

impl_vec_hash!(StyleBackgroundRepeat, StyleBackgroundRepeatVec);

impl PrintAsCssValue for StyleBackgroundRepeat {

        }

}

impl PrintAsCssValue for StyleBackgroundRepeatVec {

}

// --- ERROR DEFINITIONS ---

#[derive(Clone, PartialEq)]

pub enum CssBackgroundParseError<'a> {

    Error(&'a str),

    InvalidBackground(ParenthesisParseError<'a>),

    UnclosedGradient(&'a str),

    NoDirection(&'a str),

    TooFewGradientStops(&'a str),

    DirectionParseError(CssDirectionParseError<'a>),

    GradientParseError(CssGradientStopParseError<'a>),

    ConicGradient(CssConicGradientParseError<'a>),

    ShapeParseError(CssShapeParseError<'a>),

    ImageParseError(CssImageParseError<'a>),

    ColorParseError(CssColorParseError<'a>),

}

impl_debug_as_display!(CssBackgroundParseError<'a>);

impl_display! { CssBackgroundParseError<'a>, {

    Error(e) => e,

    InvalidBackground(val) => format!("Invalid background value: \"{}\"", val),

    UnclosedGradient(val) => format!("Unclosed gradient: \"{}\"", val),

    NoDirection(val) => format!("Gradient has no direction: \"{}\"", val),

    TooFewGradientStops(val) => format!("Failed to parse gradient due to too few gradient steps: \"{}\"", val),

    DirectionParseError(e) => format!("Failed to parse gradient direction: \"{}\"", e),

    GradientParseError(e) => format!("Failed to parse gradient: {}", e),

    ConicGradient(e) => format!("Failed to parse conic gradient: {}", e),

    ShapeParseError(e) => format!("Failed to parse shape of radial gradient: {}", e),

    ImageParseError(e) => format!("Failed to parse image() value: {}", e),

    ColorParseError(e) => format!("Failed to parse color value: {}", e),

}}

#[cfg(feature = "parser")]

impl_from!(

    ParenthesisParseError<'a>,

    CssBackgroundParseError::InvalidBackground

);

#[cfg(feature = "parser")]

impl_from!(

    CssDirectionParseError<'a>,

    CssBackgroundParseError::DirectionParseError

);

#[cfg(feature = "parser")]

impl_from!(

    CssGradientStopParseError<'a>,

    CssBackgroundParseError::GradientParseError

);

#[cfg(feature = "parser")]

impl_from!(

    CssShapeParseError<'a>,

    CssBackgroundParseError::ShapeParseError

);

#[cfg(feature = "parser")]

impl_from!(

    CssImageParseError<'a>,

    CssBackgroundParseError::ImageParseError

);

#[cfg(feature = "parser")]

impl_from!(

    CssColorParseError<'a>,

    CssBackgroundParseError::ColorParseError

);

#[cfg(feature = "parser")]

impl_from!(

    CssConicGradientParseError<'a>,

    CssBackgroundParseError::ConicGradient

);

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum CssBackgroundParseErrorOwned {

    Error(AzString),

    InvalidBackground(ParenthesisParseErrorOwned),

    UnclosedGradient(AzString),

    NoDirection(AzString),

    TooFewGradientStops(AzString),

    DirectionParseError(CssDirectionParseErrorOwned),

    GradientParseError(CssGradientStopParseErrorOwned),

    ConicGradient(CssConicGradientParseErrorOwned),

    ShapeParseError(CssShapeParseErrorOwned),

    ImageParseError(CssImageParseErrorOwned),

    ColorParseError(CssColorParseErrorOwned),

}

impl CssBackgroundParseError<'_> {

            }

            }

            }

            }

            }

            }

            }

            }

        }

}

impl CssBackgroundParseErrorOwned {

            }

            }

        }

}

#[derive(Clone, PartialEq)]

pub enum CssGradientStopParseError<'a> {

    Error(&'a str),

    Percentage(PercentageParseError),

    Angle(CssAngleValueParseError<'a>),

    ColorParseError(CssColorParseError<'a>),

}

impl_debug_as_display!(CssGradientStopParseError<'a>);

impl_display! { CssGradientStopParseError<'a>, {

    Error(e) => e,

    Percentage(e) => format!("Failed to parse offset percentage: {}", e),

    Angle(e) => format!("Failed to parse angle: {}", e),

    ColorParseError(e) => format!("{}", e),

}}

#[cfg(feature = "parser")]

impl_from!(

    CssColorParseError<'a>,

    CssGradientStopParseError::ColorParseError

);

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum CssGradientStopParseErrorOwned {

    Error(AzString),

    Percentage(PercentageParseErrorOwned),

    Angle(CssAngleValueParseErrorOwned),

    ColorParseError(CssColorParseErrorOwned),

}

impl CssGradientStopParseError<'_> {

            }

        }

}

impl CssGradientStopParseErrorOwned {

        }

}

#[derive(Clone, PartialEq, Eq)]

pub enum CssConicGradientParseError<'a> {

    Position(CssBackgroundPositionParseError<'a>),

    Angle(CssAngleValueParseError<'a>),

    NoAngle(&'a str),

}

impl_debug_as_display!(CssConicGradientParseError<'a>);

impl_display! { CssConicGradientParseError<'a>, {

    Position(val) => format!("Invalid position attribute: \"{}\"", val),

    Angle(val) => format!("Invalid angle value: \"{}\"", val),

    NoAngle(val) => format!("Expected angle: \"{}\"", val),

}}

#[cfg(feature = "parser")]

impl_from!(

    CssAngleValueParseError<'a>,

    CssConicGradientParseError::Angle

);

#[cfg(feature = "parser")]

impl_from!(

    CssBackgroundPositionParseError<'a>,

    CssConicGradientParseError::Position

);

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

#[repr(C, u8)]

pub enum CssConicGradientParseErrorOwned {

    Position(CssBackgroundPositionParseErrorOwned),

    Angle(CssAngleValueParseErrorOwned),

    NoAngle(AzString),

}

impl CssConicGradientParseError<'_> {

        }

}

impl CssConicGradientParseErrorOwned {

        }

}

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

pub enum CssShapeParseError<'a> {

    ShapeErr(InvalidValueErr<'a>),

}

impl_display! {CssShapeParseError<'a>, {

    ShapeErr(e) => format!("\"{}\"", e.0),

}}

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

#[repr(C, u8)]

pub enum CssShapeParseErrorOwned {

    ShapeErr(InvalidValueErrOwned),

}

impl CssShapeParseError<'_> {

        }

}

impl CssShapeParseErrorOwned {

        }

}

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

pub enum CssBackgroundPositionParseError<'a> {

    NoPosition(&'a str),

    TooManyComponents(&'a str),

    FirstComponentWrong(CssPixelValueParseError<'a>),

    SecondComponentWrong(CssPixelValueParseError<'a>),

}

impl_display! {CssBackgroundPositionParseError<'a>, {

    NoPosition(e) => format!("First background position missing: \"{}\"", e),

    TooManyComponents(e) => format!("background-position can only have one or two components, not more: \"{}\"", e),

    FirstComponentWrong(e) => format!("Failed to parse first component: \"{}\"", e),

    SecondComponentWrong(e) => format!("Failed to parse second component: \"{}\"", e),

}}

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

#[repr(C, u8)]

pub enum CssBackgroundPositionParseErrorOwned {

    NoPosition(AzString),

    TooManyComponents(AzString),

    FirstComponentWrong(CssPixelValueParseErrorOwned),

    SecondComponentWrong(CssPixelValueParseErrorOwned),

}

impl CssBackgroundPositionParseError<'_> {

            }

            }

            }

        }

}

impl CssBackgroundPositionParseErrorOwned {

            }

            }

        }

}

// --- PARSERS ---

#[cfg(feature = "parser")]

pub mod parser {

    #[allow(clippy::wildcard_imports)] // parser submodule reuses the parent module's value types

    use super::*;

    // the `*Gradient` suffix mirrors the CSS gradient function names this enum

    // parses (linear-gradient, radial-gradient, conic-gradient, …).

    #[allow(clippy::enum_variant_names)]

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

    enum GradientType {

        LinearGradient,

        RepeatingLinearGradient,

        RadialGradient,

        RepeatingRadialGradient,

        ConicGradient,

        RepeatingConicGradient,

    }

    impl GradientType {

                Self::LinearGradient | Self::RadialGradient | Self::ConicGradient => {

                }

                Self::RepeatingLinearGradient

                | Self::RepeatingRadialGradient

            }

    }

    // -- Top-level Parsers for background-* properties --

    /// Parses multiple backgrounds, such as "linear-gradient(red, green), url(image.png)".

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `background-content-multiple` value.

    /// Parses a single background value, which can be a color, image, or gradient.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `background-content` value.

                        return Ok(StyleBackgroundContent::Image(

                        ))

                    }

                };

            }

            // A bare `background:` value is a color. Accept system colors here too

            // (`system:accent`, `system:text`, ...), matching the gradient color stops

            // (which use `parse_color_or_system`). System colors stay unresolved and are

            // theme-resolved at render time. `parse_color_or_system` is a superset of

            // `parse_css_color`, so ordinary colors keep parsing exactly as before.

            }),

        }

    /// Parses multiple `background-position` values.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `background-position-multiple` value.

    /// Parses a single `background-position` value.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `background-position` value.

        // Try to parse as horizontal first, if that fails, maybe it's a vertical keyword

            };

        // If the first part wasn't a horizontal keyword, maybe it's a vertical one

            };

    /// Parses multiple `background-size` values.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `background-size-multiple` value.

    /// Parses a single `background-size` value.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `background-size` value.

                };

            }

        }

    /// Parses multiple `background-repeat` values.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `background-repeat-multiple` value.

    /// Parses a single `background-repeat` value.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `background-repeat` value.

        }

    // -- Gradient Parsing Logic --

    /// Parses the contents of a gradient function.

            GradientType::LinearGradient | GradientType::RepeatingLinearGradient => {

                }

                }

            }

            GradientType::RadialGradient | GradientType::RepeatingRadialGradient => {

                // Simplified parsing: assumes shape/size/position come first, then stops.

                // A more robust parser would handle them in any order.

                // Greedily consume shape, size, position keywords

                loop {