//! Types and methods used to describe the style of an application.

//!

//! This module defines the core CSS data model:

//!

//! - [`Css`] contains one or more [`Stylesheet`]s, each holding [`CssRuleBlock`]s.

//! - A [`CssRuleBlock`] pairs a [`CssPath`] (selector) with [`CssDeclaration`]s (properties).

//! - [`CssPropertyValue<T>`] wraps individual property values with CSS keywords

//!   (`auto`, `inherit`, `initial`, etc.).

//! - [`BoxOrStatic<T>`] is a smart-pointer enum for heap-allocated or static CSS values.

//! - [`NodeTypeTag`] enumerates all recognized HTML/SVG element types for selector matching.

use alloc::{string::String, vec::Vec};

use core::fmt;

use crate::{

    corety::OptionString,

    dynamic_selector::DynamicSelectorVec,

    props::property::{CssProperty, CssPropertyType},

    AzString,

};

/// Css stylesheet - contains a parsed CSS stylesheet in "rule blocks",

/// i.e. blocks of key-value pairs associated with a selector path.

///

/// Layer separation (UA / system / author / inline / runtime) is encoded

/// per-rule via `CssRuleBlock::priority`; see [`rule_priority`] for the

/// slot allocation. There is no separate `Stylesheet` wrapper — to merge

/// two CSS sources, concatenate their `rules` and re-sort.

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

#[repr(C)]

pub struct Css {

    /// All rule blocks, in source order. Sort by `(priority, specificity)`

    /// via `sort_by_specificity` to put them in cascade order.

    pub rules: CssRuleBlockVec,

}

impl_option!(

    Css,

    OptionCss,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl_vec!(Css, CssVec, CssVecDestructor, CssVecDestructorType, CssVecSlice, OptionCss);

impl_vec_mut!(Css, CssVec);

impl_vec_debug!(Css, CssVec);

impl_vec_partialord!(Css, CssVec);

impl_vec_clone!(Css, CssVec, CssVecDestructor);

impl_vec_partialeq!(Css, CssVec);

impl_vec!(CssRuleBlock, CssRuleBlockVec, CssRuleBlockVecDestructor, CssRuleBlockVecDestructorType, CssRuleBlockVecSlice, OptionCssRuleBlock);

impl_vec_mut!(CssRuleBlock, CssRuleBlockVec);

impl_vec_debug!(CssRuleBlock, CssRuleBlockVec);

impl_vec_partialord!(CssRuleBlock, CssRuleBlockVec);

impl_vec_clone!(CssRuleBlock, CssRuleBlockVec, CssRuleBlockVecDestructor);

impl_vec_partialeq!(CssRuleBlock, CssRuleBlockVec);

impl Css {

    #[cfg(feature = "parser")]

    /// Parse inline-style CSS (bare properties, pseudo blocks, @-rule blocks)

    /// and return a `Css` whose rules carry `rule_priority::INLINE`.

    ///

    /// Wraps the input in `* { ... }` so the main CSS parser can handle bare

    /// properties at the top level. Pseudo and at-rule blocks like

    /// `:hover { color: red; }` or `@os(linux) { font-size: 14px; }` work

    /// directly via CSS nesting.

    #[cfg(feature = "parser")]

        use alloc::string::ToString;

    #[cfg(feature = "parser")]

        (

        )

}

impl From<Vec<CssRuleBlock>> for Css {

}

// NodeData derives Eq + Ord and carries `Css` as its inline style. Provide

// length-based ordering so the derives keep working — the same pattern the

// previous `CssPropertyWithConditionsVec` used.

impl Eq for Css {}

impl Ord for Css {

}

impl Eq for CssRuleBlock {}

impl Ord for CssRuleBlock {

        // Match the existing PartialOrd: path first, then declarations.

        // Priority is intentionally not in the sort key — it's a layer label,

        // not a comparison primitive for callers.

}

/// Convert a flat list of `CssPropertyWithConditions` (the legacy inline-CSS form)

/// into a `Css`. Each property becomes a single-declaration `CssRuleBlock` with

/// `priority = INLINE`, an empty path (implicitly `:scope` — applies to the node it

/// lives on), and the original conditions intact.

///

/// This bridge lets widget code that built `&[CssPropertyWithConditions]` arrays

/// keep working through `.into()` while the storage on `NodeData` is the unified

/// `Css` type.

impl From<crate::dynamic_selector::CssPropertyWithConditionsVec> for Css {

}

/// Contains one parsed `key: value` pair, static or dynamic

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

#[repr(C, u8)]

pub enum CssDeclaration {

    /// Static key-value pair, such as `width: 500px`

    Static(CssProperty),

    /// Dynamic key-value pair with default value, such as `width: [[ my_id | 500px ]]`

    Dynamic(DynamicCssProperty),

}

impl_option!(

    CssDeclaration,

    OptionCssDeclaration,

    copy = false,

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

);

impl CssDeclaration {

    /// Returns the type of the property (i.e. the CSS key as a typed enum)

        use self::CssDeclaration::*;

        }

    /// Determines if the property will be inherited (applied to the children)

    /// during the recursive application of the style on the DOM tree

        use self::CssDeclaration::*;

        }

    /// Returns whether this rule affects only styling properties or layout

    /// properties (that could trigger a re-layout)

        use self::CssDeclaration::*;

        }

        use self::CssDeclaration::*;

        }

}

/// A `DynamicCssProperty` is a type of css property that can be changed on possibly

/// every frame by the Rust code - for example to implement an `On::Hover` behaviour.

///

/// The syntax for such a property looks like this:

///

/// ```no_run,ignore

/// #my_div {

///    padding: var(--my_dynamic_property_id, 400px);

/// }

/// ```

///

/// Azul will register a dynamic property with the key "my_dynamic_property_id"

/// and the default value of 400px. If the property gets overridden during one frame,

/// the overridden property takes precedence.

///

/// At runtime the style is immutable (which is a performance optimization - if we

/// can assume that the property never changes at runtime), we can do some optimizations on it.

/// Dynamic style properties can also be used for animations and conditional styles

/// (i.e. `hover`, `focus`, etc.), thereby leading to cleaner code, since all of these

/// special cases now use one single API.

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

#[repr(C)]

pub struct DynamicCssProperty {

    /// The stringified ID of this property, i.e. the `"my_id"` in `width: var(--my_id, 500px)`.

    pub dynamic_id: AzString,

    /// Default values for this properties - one single value can control multiple properties!

    pub default_value: CssProperty,

}

/// A value that is either heap-allocated (parsed at runtime) or a compile-time

/// static reference. Used to reduce enum size for large CSS property payloads

/// by storing them behind a pointer instead of inline.

///

/// - Size: 1 (tag) + 7 (padding) + 8 (pointer) = **16 bytes** on 64-bit

/// - `Static` variant: no allocation, just a `*const T` pointer to static data

/// - `Boxed` variant: heap-allocated via `Box::into_raw`, freed on Drop

#[repr(C, u8)]

pub enum BoxOrStatic<T> {

    /// Heap-allocated (parsed at runtime). Owned — freed on Drop.

    Boxed(*mut T),

    /// Compile-time constant (e.g. from `const` CSS defaults). Not freed.

    Static(*const T),

}

impl<T> BoxOrStatic<T> {

    /// Allocate `value` on the heap and return a `Boxed` variant.

    #[inline]

    /// Return a reference to the inner value.

    ///

    /// # Safety invariant

    /// The inner pointer must be non-null. This is guaranteed by [`heap`](Self::heap)

    /// and the `Static` constructor (which should always point to valid data).

    #[inline]

            },

            },

        }

    /// Return a mutable reference to the inner value (only for Boxed).

    /// Panics if called on Static.

    #[inline]

        }

    /// Consume self and return the inner value.

    #[inline]

        // Don't double-free: std::mem::forget prevents Drop from running

}

impl<T> Drop for BoxOrStatic<T> {

}

impl<T: Clone> Clone for BoxOrStatic<T> {

            }

        }

}

impl<T: core::fmt::Debug> core::fmt::Debug for BoxOrStatic<T> {

}

impl<T: core::fmt::Display> core::fmt::Display for BoxOrStatic<T> {

}

impl<T: PartialEq> PartialEq for BoxOrStatic<T> {

}

impl<T: Eq> Eq for BoxOrStatic<T> {}

impl<T: core::hash::Hash> core::hash::Hash for BoxOrStatic<T> {

}

impl<T: PartialOrd> PartialOrd for BoxOrStatic<T> {

}

impl<T: Ord> Ord for BoxOrStatic<T> {

}

impl<T> core::ops::Deref for BoxOrStatic<T> {

    type Target = T;

    #[inline]

}

impl<T: Default> Default for BoxOrStatic<T> {

}

impl<T: PrintAsCssValue> PrintAsCssValue for BoxOrStatic<T> {

}

// Safety: BoxOrStatic<T> is Send if T is Send

unsafe impl<T: Send + 'static> Send for BoxOrStatic<T> {}

// Safety: BoxOrStatic<T> is Sync if T is Sync

unsafe impl<T: Sync + 'static> Sync for BoxOrStatic<T> {}

/// Type alias: `BoxOrStatic<StyleBoxShadow>` — used by codegen for FFI monomorphization.

pub type BoxOrStaticStyleBoxShadow = BoxOrStatic<crate::props::style::box_shadow::StyleBoxShadow>;

/// Type alias: `BoxOrStatic<AzString>` — used by NodeType::Text and NodeType::Icon.

pub type BoxOrStaticString = BoxOrStatic<crate::AzString>;

/// A CSS property value that may be an explicit value or a CSS-wide keyword

/// (`auto`, `none`, `initial`, `inherit`, `revert`, `unset`).

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

#[repr(C, u8)] // necessary for ABI stability

pub enum CssPropertyValue<T> {

    Auto,

    None,

    Initial,

    Inherit,

    Revert,

    Unset,

    Exact(T),

}

/// Trait for types that can format themselves as a CSS property value string.

pub trait PrintAsCssValue {

    fn print_as_css_value(&self) -> String;

}

impl<T: PrintAsCssValue> CssPropertyValue<T> {

        }

}

impl<T: fmt::Display> fmt::Display for CssPropertyValue<T> {

        use self::CssPropertyValue::*;

        }

}

impl<T> From<T> for CssPropertyValue<T> {

}

impl<T> CssPropertyValue<T> {

    /// Transforms a `CssPropertyValue<T>` into a `CssPropertyValue<U>` by applying a mapping

    /// function

    #[inline]

        }

    #[inline]

        }

    #[inline]

        }

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

}

impl<T: Default> CssPropertyValue<T> {

    #[inline]

            CssPropertyValue::None

            | CssPropertyValue::Inherit

            | CssPropertyValue::Revert

        }

}

impl<T: Default> Default for CssPropertyValue<T> {

    #[inline]

}

impl DynamicCssProperty {

        // Dynamic style properties should not be inheritable,

        // since that could lead to bugs - you set a property in Rust, suddenly

        // the wrong UI component starts to react because it was inherited.

}

/// Layer priority for `CssRuleBlock`. Lower numbers cascade first;

/// higher numbers override earlier layers at the same specificity.

///

/// `u8` leaves 256 slots, so a new layer can be inserted between any

/// two existing slots without renumbering consumers. The gaps between

/// named slots are intentional — fill them with custom intermediate

/// layers if/when `@layer` lands.

pub mod rule_priority {

    /// User-Agent / framework defaults. Widget code that emits its

    /// own default CSS uses this. Lowest priority — anything else

    /// overrides it.

    pub const UA: u8 = 0;

    /// Stylesheets the host system reports (system fonts, theme CSS

    /// derived from `SystemStyle`). One step above UA so they win

    /// against framework defaults but lose against anything the app

    /// author writes.

    pub const SYSTEM: u8 = 10;

    /// Default for parser-produced rules: the app author's CSS.

    /// Everything coming out of `Css::from_string` lives here.

    pub const AUTHOR: u8 = 20;

    /// Inline `style="..."` / `NodeData::set_css(...)` rules — used

    /// once the inline-vs-component unification (separate plan) folds

    /// inline storage into the same Vec.

    pub const INLINE: u8 = 30;

    /// Reserved for direct-rule runtime overrides. Today the

    /// prop_cache handles runtime overrides via

    /// `user_overridden_properties`; this slot is reserved so a

    /// future "push a CssRuleBlock at runtime" path stays above

    /// inline. Used only when a callback writes a full rule, not a

    /// single property.

    pub const RUNTIME: u8 = 50;

}

/// One block of rules that applies a bunch of rules to a "path" in the style, i.e.

/// `div#myid.myclass -> { ("justify-content", "center") }`

///

/// The `conditions` field contains @media/@lang/etc. conditions that must ALL be

/// satisfied for this rule block to apply (from enclosing @-rule blocks).

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

#[repr(C)]

pub struct CssRuleBlock {

    /// The css path (full selector) of the style ruleset

    pub path: CssPath,

    /// `"justify-content: center"` =>

    /// `CssDeclaration::Static(CssProperty::JustifyContent(LayoutJustifyContent::Center))`

    pub declarations: CssDeclarationVec,

    /// Conditions from enclosing @-rules (@media, @lang, etc.) that must ALL be

    /// satisfied for this rule block to apply. Empty = unconditional.

    pub conditions: DynamicSelectorVec,

    /// Layer priority. See [`rule_priority`] for slot allocation.

    /// `0` = UA / framework, `20` = author CSS (default), higher = wins.

    /// Sort key combined with selector specificity in `sort_by_specificity`.

    pub priority: u8,

}

impl_option!(

    CssRuleBlock,

    OptionCssRuleBlock,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl PartialOrd for CssRuleBlock {

        // Compare by path and declarations only, conditions are not ordered

        }

}

impl_vec!(CssDeclaration, CssDeclarationVec, CssDeclarationVecDestructor, CssDeclarationVecDestructorType, CssDeclarationVecSlice, OptionCssDeclaration);

impl_vec_mut!(CssDeclaration, CssDeclarationVec);

impl_vec_debug!(CssDeclaration, CssDeclarationVec);

impl_vec_partialord!(CssDeclaration, CssDeclarationVec);

impl_vec_ord!(CssDeclaration, CssDeclarationVec);

impl_vec_clone!(

    CssDeclaration,

    CssDeclarationVec,

    CssDeclarationVecDestructor

);

impl_vec_partialeq!(CssDeclaration, CssDeclarationVec);

impl_vec_eq!(CssDeclaration, CssDeclarationVec);

impl_vec_hash!(CssDeclaration, CssDeclarationVec);

impl CssRuleBlock {

}

/// A group of CSS path selectors, used during selector matching.

pub type CssContentGroup<'a> = Vec<&'a CssPathSelector>;

/// Signifies the type of a DOM node without carrying any associated data

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

#[repr(C)]

pub enum NodeTypeTag {

    // Document structure

    Html,

    Head,

    Body,

    // Block-level elements

    Div,

    P,

    Article,

    Section,

    Nav,

    Aside,

    Header,

    Footer,

    Main,

    Figure,

    FigCaption,

    // Headings

    H1,

    H2,

    H3,

    H4,

    H5,

    H6,

    // Inline text

    Br,

    Hr,

    Pre,

    BlockQuote,

    Address,

    Details,

    Summary,

    Dialog,

    // Lists

    Ul,

    Ol,

    Li,

    Dl,

    Dt,

    Dd,

    Menu,

    MenuItem,

    Dir,

    // Tables

    Table,

    Caption,

    THead,

    TBody,

    TFoot,

    Tr,

    Th,

    Td,

    ColGroup,

    Col,

    // Forms

    Form,

    FieldSet,

    Legend,

    Label,

    Input,

    Button,

    Select,

    OptGroup,

    SelectOption,

    TextArea,

    Output,

    Progress,

    Meter,

    DataList,

    // Inline elements

    Span,

    A,

    Em,

    Strong,

    B,

    I,

    U,

    S,

    Mark,

    Del,

    Ins,

    Code,

    Samp,

    Kbd,

    Var,

    Cite,

    Dfn,

    Abbr,

    Acronym,

    Q,

    Time,

    Sub,

    Sup,

    Small,

    Big,

    Bdo,

    Bdi,

    Wbr,

    Ruby,

    Rt,

    Rtc,

    Rp,

    Data,

    // Embedded content

    Canvas,

    Object,

    Param,

    Embed,

    Audio,

    Video,

    Source,

    Track,

    Map,

    Area,

    Svg,

    /// SVG `<path>` element.

    SvgPath,

    /// SVG `<circle>` element.

    SvgCircle,

    /// SVG `<rect>` element.

    SvgRect,

    /// SVG `<ellipse>` element.

    SvgEllipse,

    /// SVG `<line>` element.

    SvgLine,

    /// SVG `<polygon>` element.

    SvgPolygon,

    /// SVG `<polyline>` element.

    SvgPolyline,

    /// SVG `<g>` group element.

    SvgG,

    // SVG container elements

    /// SVG `<defs>` element.

    SvgDefs,

    /// SVG `<symbol>` element.

    SvgSymbol,

    /// SVG `<use>` element.

    SvgUse,

    /// SVG `<switch>` element.

    SvgSwitch,

    // SVG text elements

    /// SVG `<text>` element.

    SvgText,

    /// SVG `<tspan>` element.

    SvgTspan,

    /// SVG `<textPath>` element.

    SvgTextPath,

    // SVG paint server elements

    /// SVG `<linearGradient>` element.

    SvgLinearGradient,

    /// SVG `<radialGradient>` element.

    SvgRadialGradient,

    /// SVG `<stop>` element.

    SvgStop,

    /// SVG `<pattern>` element.

    SvgPattern,

    // SVG clipping/masking elements

    /// SVG `<clipPath>` element.

    SvgClipPathElement,

    /// SVG `<mask>` element.

    SvgMask,

    // SVG filter elements

    /// SVG `<filter>` element.

    SvgFilter,

    /// SVG `<feBlend>` element.

    SvgFeBlend,

    /// SVG `<feColorMatrix>` element.

    SvgFeColorMatrix,

    /// SVG `<feComponentTransfer>` element.

    SvgFeComponentTransfer,

    /// SVG `<feComposite>` element.

    SvgFeComposite,

    /// SVG `<feConvolveMatrix>` element.

    SvgFeConvolveMatrix,

    /// SVG `<feDiffuseLighting>` element.

    SvgFeDiffuseLighting,

    /// SVG `<feDisplacementMap>` element.

    SvgFeDisplacementMap,

    /// SVG `<feDistantLight>` element.

    SvgFeDistantLight,

    /// SVG `<feDropShadow>` element.

    SvgFeDropShadow,

    /// SVG `<feFlood>` element.

    SvgFeFlood,

    /// SVG `<feFuncR>` element.

    SvgFeFuncR,

    /// SVG `<feFuncG>` element.

    SvgFeFuncG,

    /// SVG `<feFuncB>` element.

    SvgFeFuncB,

    /// SVG `<feFuncA>` element.

    SvgFeFuncA,

    /// SVG `<feGaussianBlur>` element.

    SvgFeGaussianBlur,

    /// SVG `<feImage>` element.

    SvgFeImage,

    /// SVG `<feMerge>` element.

    SvgFeMerge,

    /// SVG `<feMergeNode>` element.

    SvgFeMergeNode,

    /// SVG `<feMorphology>` element.

    SvgFeMorphology,

    /// SVG `<feOffset>` element.

    SvgFeOffset,

    /// SVG `<fePointLight>` element.

    SvgFePointLight,

    /// SVG `<feSpecularLighting>` element.

    SvgFeSpecularLighting,

    /// SVG `<feSpotLight>` element.

    SvgFeSpotLight,

    /// SVG `<feTile>` element.

    SvgFeTile,

    /// SVG `<feTurbulence>` element.

    SvgFeTurbulence,

    // SVG marker/image elements

    /// SVG `<marker>` element.

    SvgMarker,

    /// SVG `<image>` element.

    SvgImage,

    /// SVG `<foreignObject>` element.

    SvgForeignObject,

    // SVG descriptive elements

    /// SVG `<title>` element.

    SvgTitle,

    /// SVG `<desc>` element.

    SvgDesc,

    /// SVG `<metadata>` element.

    SvgMetadata,

    /// SVG `<a>` element.

    SvgA,

    /// SVG `<view>` element.

    SvgView,

    /// SVG `<style>` element.

    SvgStyle,

    /// SVG `<script>` element.

    SvgScript,

    // SVG animation elements

    /// SVG `<animate>` element.

    SvgAnimate,

    /// SVG `<animateMotion>` element.

    SvgAnimateMotion,

    /// SVG `<animateTransform>` element.

    SvgAnimateTransform,

    /// SVG `<set>` element.

    SvgSet,

    /// SVG `<mpath>` element.

    SvgMpath,

    // Metadata

    Title,

    Meta,

    Link,

    Script,

    Style,

    Base,

    // Special

    Text,

    Img,

    VirtualView,

    /// Icon element - resolved to actual content by IconProvider

    Icon,

    /// Invisible probe — `NodeType::GeolocationProbe`. Zero-size in

    /// layout, skipped in the display list. CSS tag: `geolocation-probe`.

    GeolocationProbe,

    // Pseudo-elements

    Before,

    After,

    Marker,

    Placeholder,

}

/// Error returned when a CSS tag name string cannot be mapped to a [`NodeTypeTag`].

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

pub enum NodeTypeTagParseError<'a> {

    Invalid(&'a str),

}

impl<'a> fmt::Display for NodeTypeTagParseError<'a> {

        }

}

/// Owned version of [`NodeTypeTagParseError`] for storage across lifetime boundaries.

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

#[repr(C, u8)]

pub enum NodeTypeTagParseErrorOwned {

    Invalid(AzString),

}

impl<'a> NodeTypeTagParseError<'a> {

        }

}

impl NodeTypeTagParseErrorOwned {

        }

}

/// Parses the node type from a CSS string such as `"div"` => `NodeTypeTag::Div`

impl NodeTypeTag {

            // Document structure

            // Block-level elements

            // Headings

            // Inline text

            // Lists

            // Tables

            // Forms

            // Inline elements

            // Embedded content

            // SVG shape elements

            // SVG container elements

            // SVG text elements

            // SVG paint server elements

            // SVG clipping/masking elements

            // SVG filter elements

            // SVG marker/image elements

            // SVG descriptive elements

            // SVG animation elements

            // Metadata

            // Special

            // Pseudo-elements (usually prefixed with ::)

        }

}

impl fmt::Display for NodeTypeTag {

            // Document structure

            // Block elements

            // Headings

            // Text formatting

            // List elements

            // Table elements

            // Form elements

            // Inline elements