//! Dynamic CSS selectors for runtime evaluation based on OS, media queries, container queries, etc.

use crate::corety::{AzString, OptionString};

use crate::props::property::CssProperty;

/// State flags for pseudo-classes (used in DynamicSelectorContext)

/// Note: This is a CSS-only version. See azul_core::styled_dom::StyledNodeState for the main type.

#[repr(C)]

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

pub struct PseudoStateFlags {

    pub hover: bool,

    pub active: bool,

    pub focused: bool,

    pub disabled: bool,

    pub checked: bool,

    pub focus_within: bool,

    pub visited: bool,

    /// Window is not focused (equivalent to GTK :backdrop)

    pub backdrop: bool,

    /// Element is currently being dragged (:dragging)

    pub dragging: bool,

    /// A dragged element is over this drop target (:drag-over)

    pub drag_over: bool,

}

impl PseudoStateFlags {

    /// Check if a specific pseudo-state is active

        }

}

/// Dynamic selector that is evaluated at runtime

/// C-compatible: Tagged union with single field

#[repr(C, u8)]

#[derive(Debug, Clone, PartialEq)]

pub enum DynamicSelector {

    /// Operating system condition

    Os(OsCondition) = 0,

    /// Operating system version (e.g. macOS 14.0, Windows 11)

    OsVersion(OsVersionCondition) = 1,

    /// Media query (print/screen)

    Media(MediaType) = 2,

    /// Viewport width min/max (for @media)

    ViewportWidth(MinMaxRange) = 3,

    /// Viewport height min/max (for @media)

    ViewportHeight(MinMaxRange) = 4,

    /// Container width min/max (for @container)

    ContainerWidth(MinMaxRange) = 5,

    /// Container height min/max (for @container)

    ContainerHeight(MinMaxRange) = 6,

    /// Container name (for named @container queries)

    ContainerName(AzString) = 7,

    /// Theme (dark/light/custom)

    Theme(ThemeCondition) = 8,

    /// Aspect Ratio (min/max for @media and @container)

    AspectRatio(MinMaxRange) = 9,

    /// Orientation (portrait/landscape)

    Orientation(OrientationType) = 10,

    /// Reduced Motion (accessibility)

    PrefersReducedMotion(BoolCondition) = 11,

    /// High Contrast (accessibility)

    PrefersHighContrast(BoolCondition) = 12,

    /// Pseudo-State (hover, active, focus, etc.)

    PseudoState(PseudoStateType) = 13,

    /// Language/Locale (for @lang("de-DE"))

    /// Matches BCP 47 language tags (e.g., "de", "de-DE", "en-US")

    Language(LanguageCondition) = 14,

}

impl_option!(

    DynamicSelector,

    OptionDynamicSelector,

    copy = false,

    [Debug, Clone, PartialEq]

);

impl_vec!(DynamicSelector, DynamicSelectorVec, DynamicSelectorVecDestructor, DynamicSelectorVecDestructorType, DynamicSelectorVecSlice, OptionDynamicSelector);

impl_vec_clone!(

    DynamicSelector,

    DynamicSelectorVec,

    DynamicSelectorVecDestructor

);

impl_vec_debug!(DynamicSelector, DynamicSelectorVec);

impl_vec_partialeq!(DynamicSelector, DynamicSelectorVec);

/// Min/Max Range for numeric conditions (C-compatible)

#[repr(C)]

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

pub struct MinMaxRange {

    /// Minimum value (NaN = no minimum limit)

    pub min: f32,

    /// Maximum value (NaN = no maximum limit)

    pub max: f32,

}

impl MinMaxRange {

        Self {

        }

    /// Create a range with only a minimum value (>= min)

    /// Create a range with only a maximum value (<= max)

        } else {

        }

        } else {

        }

}

/// Boolean condition (C-compatible)

#[repr(C)]

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

pub enum BoolCondition {

    #[default]

    False,

    True,

}

impl From<bool> for BoolCondition {

        } else {

        }

}

impl From<BoolCondition> for bool {

}

/// Operating system condition for `@os` CSS selectors

#[repr(C)]

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

pub enum OsCondition {

    Any,

    Apple, // macOS + iOS

    MacOS,

    IOS,

    Linux,

    Windows,

    Android,

    Web, // WASM

}

impl_option!(

    OsCondition,

    OptionOsCondition,

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

);

impl OsCondition {

    /// Convert from css::system::Platform

        use crate::system::Platform;

        }

}

#[repr(C, u8)]

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

pub enum OsVersionCondition {

    /// Minimum version: >= specified version

    /// Format: OsVersion { os, version_id }

    Min(OsVersion),

    /// Maximum version: <= specified version

    Max(OsVersion),

    /// Exact version match

    Exact(OsVersion),

    /// Desktop environment (Linux only)

    DesktopEnvironment(LinuxDesktopEnv),

    /// Desktop environment with min version (e.g. `@os(linux:gnome > 40)`)

    DesktopEnvMin(DesktopEnvVersion),

    /// Desktop environment with max version

    DesktopEnvMax(DesktopEnvVersion),

    /// Desktop environment with exact version

    DesktopEnvExact(DesktopEnvVersion),

}

/// A desktop environment together with a numeric version (e.g. GNOME 40).

/// Used by `OsVersionCondition::DesktopEnv{Min,Max,Exact}` for `@os(linux:gnome > 40)` style selectors.

#[repr(C)]

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

pub struct DesktopEnvVersion {

    pub env: LinuxDesktopEnv,

    pub version_id: u32,

}

/// OS version with ordering - only comparable within the same OS family

/// 

/// Each OS has its own version numbering system with named versions.

/// Comparisons between different OS families always return false.

#[repr(C)]

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

pub struct OsVersion {

    /// Which OS family this version belongs to

    pub os: OsFamily,

    /// Numeric version ID for ordering (higher = newer)

    /// Each OS has its own numbering scheme starting from 0

    pub version_id: u32,

}

impl Default for OsVersion {

}

impl OsVersion {

    /// Compare two versions - only meaningful within the same OS family

    /// Returns None if OS families don't match (comparison not meaningful)

        } else {

        }

    /// Check if self >= other (for Min conditions)

    /// Check if self <= other (for Max conditions)

}

impl_option!(

    OsVersion,

    OptionOsVersion,

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

);

impl OsVersion {

    /// Check if self == other

}

/// OS family for version comparisons

#[repr(C)]

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

pub enum OsFamily {

    Windows,

    MacOS,

    IOS,

    Linux,

    Android,

}

// ============================================================================

// Windows Version IDs (chronological order)

// ============================================================================

/// Windows version constants - use these in CSS like `@os(windows >= win-xp)`

impl OsVersion {

    // Windows versions (version_id = NT version * 100 + minor)

    pub const WIN_2000: Self = Self::new(OsFamily::Windows, 500);       // NT 5.0

    pub const WIN_XP: Self = Self::new(OsFamily::Windows, 501);         // NT 5.1

    pub const WIN_XP_64: Self = Self::new(OsFamily::Windows, 502);      // NT 5.2

    pub const WIN_VISTA: Self = Self::new(OsFamily::Windows, 600);      // NT 6.0

    pub const WIN_7: Self = Self::new(OsFamily::Windows, 601);          // NT 6.1

    pub const WIN_8: Self = Self::new(OsFamily::Windows, 602);          // NT 6.2

    pub const WIN_8_1: Self = Self::new(OsFamily::Windows, 603);        // NT 6.3

    pub const WIN_10: Self = Self::new(OsFamily::Windows, 1000);        // NT 10.0

    pub const WIN_10_1507: Self = Self::new(OsFamily::Windows, 1000);   // Initial release

    pub const WIN_10_1511: Self = Self::new(OsFamily::Windows, 1001);   // November Update

    pub const WIN_10_1607: Self = Self::new(OsFamily::Windows, 1002);   // Anniversary Update

    pub const WIN_10_1703: Self = Self::new(OsFamily::Windows, 1003);   // Creators Update

    pub const WIN_10_1709: Self = Self::new(OsFamily::Windows, 1004);   // Fall Creators Update

    pub const WIN_10_1803: Self = Self::new(OsFamily::Windows, 1005);   // April 2018 Update

    pub const WIN_10_1809: Self = Self::new(OsFamily::Windows, 1006);   // October 2018 Update

    pub const WIN_10_1903: Self = Self::new(OsFamily::Windows, 1007);   // May 2019 Update

    pub const WIN_10_1909: Self = Self::new(OsFamily::Windows, 1008);   // November 2019 Update

    pub const WIN_10_2004: Self = Self::new(OsFamily::Windows, 1009);   // May 2020 Update

    pub const WIN_10_20H2: Self = Self::new(OsFamily::Windows, 1010);   // October 2020 Update

    pub const WIN_10_21H1: Self = Self::new(OsFamily::Windows, 1011);   // May 2021 Update

    pub const WIN_10_21H2: Self = Self::new(OsFamily::Windows, 1012);   // November 2021 Update

    pub const WIN_10_22H2: Self = Self::new(OsFamily::Windows, 1013);   // 2022 Update

    pub const WIN_11: Self = Self::new(OsFamily::Windows, 1100);        // Windows 11 base

    pub const WIN_11_21H2: Self = Self::new(OsFamily::Windows, 1100);   // Initial release

    pub const WIN_11_22H2: Self = Self::new(OsFamily::Windows, 1101);   // 2022 Update

    pub const WIN_11_23H2: Self = Self::new(OsFamily::Windows, 1102);   // 2023 Update

    pub const WIN_11_24H2: Self = Self::new(OsFamily::Windows, 1103);   // 2024 Update

    // macOS versions (version_id = major * 100 + minor)

    pub const MACOS_CHEETAH: Self = Self::new(OsFamily::MacOS, 1000);       // 10.0

    pub const MACOS_PUMA: Self = Self::new(OsFamily::MacOS, 1001);          // 10.1

    pub const MACOS_JAGUAR: Self = Self::new(OsFamily::MacOS, 1002);        // 10.2

    pub const MACOS_PANTHER: Self = Self::new(OsFamily::MacOS, 1003);       // 10.3

    pub const MACOS_TIGER: Self = Self::new(OsFamily::MacOS, 1004);         // 10.4

    pub const MACOS_LEOPARD: Self = Self::new(OsFamily::MacOS, 1005);       // 10.5

    pub const MACOS_SNOW_LEOPARD: Self = Self::new(OsFamily::MacOS, 1006);  // 10.6

    pub const MACOS_LION: Self = Self::new(OsFamily::MacOS, 1007);          // 10.7

    pub const MACOS_MOUNTAIN_LION: Self = Self::new(OsFamily::MacOS, 1008); // 10.8

    pub const MACOS_MAVERICKS: Self = Self::new(OsFamily::MacOS, 1009);     // 10.9

    pub const MACOS_YOSEMITE: Self = Self::new(OsFamily::MacOS, 1010);      // 10.10

    pub const MACOS_EL_CAPITAN: Self = Self::new(OsFamily::MacOS, 1011);    // 10.11

    pub const MACOS_SIERRA: Self = Self::new(OsFamily::MacOS, 1012);        // 10.12

    pub const MACOS_HIGH_SIERRA: Self = Self::new(OsFamily::MacOS, 1013);   // 10.13

    pub const MACOS_MOJAVE: Self = Self::new(OsFamily::MacOS, 1014);        // 10.14

    pub const MACOS_CATALINA: Self = Self::new(OsFamily::MacOS, 1015);      // 10.15

    pub const MACOS_BIG_SUR: Self = Self::new(OsFamily::MacOS, 1100);       // 11.0

    pub const MACOS_MONTEREY: Self = Self::new(OsFamily::MacOS, 1200);      // 12.0

    pub const MACOS_VENTURA: Self = Self::new(OsFamily::MacOS, 1300);       // 13.0

    pub const MACOS_SONOMA: Self = Self::new(OsFamily::MacOS, 1400);        // 14.0

    pub const MACOS_SEQUOIA: Self = Self::new(OsFamily::MacOS, 1500);       // 15.0

    pub const MACOS_TAHOE: Self = Self::new(OsFamily::MacOS, 2600);         // 26.0

    // iOS versions (version_id = major * 100 + minor)

    pub const IOS_1: Self = Self::new(OsFamily::IOS, 100);

    pub const IOS_2: Self = Self::new(OsFamily::IOS, 200);

    pub const IOS_3: Self = Self::new(OsFamily::IOS, 300);

    pub const IOS_4: Self = Self::new(OsFamily::IOS, 400);

    pub const IOS_5: Self = Self::new(OsFamily::IOS, 500);

    pub const IOS_6: Self = Self::new(OsFamily::IOS, 600);

    pub const IOS_7: Self = Self::new(OsFamily::IOS, 700);

    pub const IOS_8: Self = Self::new(OsFamily::IOS, 800);

    pub const IOS_9: Self = Self::new(OsFamily::IOS, 900);

    pub const IOS_10: Self = Self::new(OsFamily::IOS, 1000);

    pub const IOS_11: Self = Self::new(OsFamily::IOS, 1100);

    pub const IOS_12: Self = Self::new(OsFamily::IOS, 1200);

    pub const IOS_13: Self = Self::new(OsFamily::IOS, 1300);

    pub const IOS_14: Self = Self::new(OsFamily::IOS, 1400);

    pub const IOS_15: Self = Self::new(OsFamily::IOS, 1500);

    pub const IOS_16: Self = Self::new(OsFamily::IOS, 1600);

    pub const IOS_17: Self = Self::new(OsFamily::IOS, 1700);

    pub const IOS_18: Self = Self::new(OsFamily::IOS, 1800);

    // Android versions (API level as version_id)

    pub const ANDROID_CUPCAKE: Self = Self::new(OsFamily::Android, 3);      // 1.5

    pub const ANDROID_DONUT: Self = Self::new(OsFamily::Android, 4);        // 1.6

    pub const ANDROID_ECLAIR: Self = Self::new(OsFamily::Android, 7);       // 2.1

    pub const ANDROID_FROYO: Self = Self::new(OsFamily::Android, 8);        // 2.2

    pub const ANDROID_GINGERBREAD: Self = Self::new(OsFamily::Android, 10); // 2.3

    pub const ANDROID_HONEYCOMB: Self = Self::new(OsFamily::Android, 13);   // 3.2

    pub const ANDROID_ICE_CREAM_SANDWICH: Self = Self::new(OsFamily::Android, 15); // 4.0

    pub const ANDROID_JELLY_BEAN: Self = Self::new(OsFamily::Android, 18);  // 4.3

    pub const ANDROID_KITKAT: Self = Self::new(OsFamily::Android, 19);      // 4.4

    pub const ANDROID_LOLLIPOP: Self = Self::new(OsFamily::Android, 22);    // 5.1

    pub const ANDROID_MARSHMALLOW: Self = Self::new(OsFamily::Android, 23); // 6.0

    pub const ANDROID_NOUGAT: Self = Self::new(OsFamily::Android, 25);      // 7.1

    pub const ANDROID_OREO: Self = Self::new(OsFamily::Android, 27);        // 8.1

    pub const ANDROID_PIE: Self = Self::new(OsFamily::Android, 28);         // 9.0

    pub const ANDROID_10: Self = Self::new(OsFamily::Android, 29);          // 10

    pub const ANDROID_11: Self = Self::new(OsFamily::Android, 30);          // 11

    pub const ANDROID_12: Self = Self::new(OsFamily::Android, 31);          // 12

    pub const ANDROID_12L: Self = Self::new(OsFamily::Android, 32);         // 12L

    pub const ANDROID_13: Self = Self::new(OsFamily::Android, 33);          // 13

    pub const ANDROID_14: Self = Self::new(OsFamily::Android, 34);          // 14

    pub const ANDROID_15: Self = Self::new(OsFamily::Android, 35);          // 15

    // Linux kernel versions (major * 1000 + minor * 10 + patch)

    pub const LINUX_2_6: Self = Self::new(OsFamily::Linux, 2060);

    pub const LINUX_3_0: Self = Self::new(OsFamily::Linux, 3000);

    pub const LINUX_4_0: Self = Self::new(OsFamily::Linux, 4000);

    pub const LINUX_5_0: Self = Self::new(OsFamily::Linux, 5000);

    pub const LINUX_6_0: Self = Self::new(OsFamily::Linux, 6000);

    /// Unknown OS version (for when detection fails or OS is unknown)

}

/// Parse a named or numeric OS version string

/// Returns None if the version string is not recognized

    }

    // Strip optional "win"/"windows" prefix (allowing -, _ separators).

    // This collapses "11", "win11", "win-11", "windows11", "windows-11", "windows_11" to "11".

        // Numeric NT versions

    }

/// If `s` starts with any of the given prefixes, strip the prefix plus an optional

/// trailing `-` or `_` separator. Otherwise return `s` unchanged. Matching is

/// case-insensitive (callers already lowercase, this just makes the helper safe).

    }

    }

    }

        _ => {

            // Try parsing as API level

        }

    }

    // Strip optional "linux" prefix so "linux6.1" / "linux-6.1" also work.

    // Parse kernel version like "5.4", "6.0", or bare major like "5" (== "5.0").

/// Linux desktop environment for `@os(linux:<de>)` CSS selectors.

///

/// Note: `from_system_desktop_env` currently only maps Gnome, KDE, and Other.

/// XFCE, Unity, Cinnamon, and MATE can be matched via CSS parsing (`@os(linux:xfce)`)

/// but will not be auto-detected from the system — they map to `Other` at runtime.

#[repr(C)]

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

pub enum LinuxDesktopEnv {

    Gnome,

    KDE,

    /// CSS-parse-only: not auto-detected from system (maps to `Other` at runtime)

    XFCE,

    /// CSS-parse-only: not auto-detected from system (maps to `Other` at runtime)

    Unity,

    /// CSS-parse-only: not auto-detected from system (maps to `Other` at runtime)

    Cinnamon,

    /// CSS-parse-only: not auto-detected from system (maps to `Other` at runtime)

    MATE,

    Other,

}

impl LinuxDesktopEnv {

    /// Convert from css::system::DesktopEnvironment

        use crate::system::DesktopEnvironment;

        }

}

/// Media type for `@media` CSS selectors (screen, print, all)

#[repr(C)]

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

pub enum MediaType {

    Screen,

    Print,

    All,

}

#[repr(C, u8)]

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

pub enum ThemeCondition {

    Light,

    Dark,

    Custom(AzString),

    /// System preference

    SystemPreferred,

}

impl_option!(

    ThemeCondition,

    OptionThemeCondition,

    copy = false,

    [Debug, Clone, PartialEq, Eq, Hash]

);

impl ThemeCondition {

    /// Convert from css::system::Theme

        use crate::system::Theme;

        }

}

/// Orientation type for `@media (orientation: ...)` CSS selectors

#[repr(C)]

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

pub enum OrientationType {

    Portrait,

    Landscape,

}

/// Language/Locale condition for @lang() CSS selector

/// Matches BCP 47 language tags with prefix matching

#[repr(C, u8)]

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

pub enum LanguageCondition {

    /// Exact match (e.g., "de-DE" matches only "de-DE")

    Exact(AzString),

    /// Prefix match (e.g., "de" matches "de", "de-DE", "de-AT", etc.)

    Prefix(AzString),

}

impl LanguageCondition {

    /// Check if this condition matches the given language tag

                // Check if language starts with prefix (case-insensitive)

                // Must be exact match or followed by '-'

            }

        }

}

#[repr(C)]

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

pub enum PseudoStateType {

    /// No special state (corresponds to "Normal" in NodeDataInlineCssProperty)

    Normal,

    /// Element is being hovered (:hover)

    Hover,

    /// Element is active/being clicked (:active)

    Active,

    /// Element has focus (:focus)

    Focus,

    /// Element is disabled (:disabled)

    Disabled,

    /// Element is checked/selected (:checked)

    CheckedTrue,

    /// Element is unchecked (:not(:checked))

    CheckedFalse,

    /// Element or child has focus (:focus-within)

    FocusWithin,

    /// Link has been visited (:visited)

    Visited,

    /// Window is not focused (:backdrop) - GTK compatibility

    Backdrop,

    /// Element is currently being dragged (:dragging)

    Dragging,

    /// A dragged element is over this drop target (:drag-over)

    DragOver,

}

impl_option!(

    LinuxDesktopEnv,

    OptionLinuxDesktopEnv,

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

);

/// Default viewport width used when actual window size is not yet known.

pub const DEFAULT_VIEWPORT_WIDTH: f32 = 800.0;

/// Default viewport height used when actual window size is not yet known.

pub const DEFAULT_VIEWPORT_HEIGHT: f32 = 600.0;

/// Context for evaluating dynamic selectors

#[repr(C)]

#[derive(Debug, Clone)]

pub struct DynamicSelectorContext {

    /// Operating system info

    pub os: OsCondition,

    pub os_version: OsVersion,

    pub desktop_env: OptionLinuxDesktopEnv,

    /// Numeric version of the active desktop environment (0 = unknown).

    /// Used by `@os(linux:gnome > 40)` style selectors. A value of 0 never

    /// satisfies any DE-version constraint, so detection can be wired up

    /// later without breaking parsed rules.

    pub de_version: u32,

    /// Theme info

    pub theme: ThemeCondition,

    /// Media info (from WindowState)

    pub media_type: MediaType,

    pub viewport_width: f32,

    pub viewport_height: f32,

    /// Container info (from parent node)

    /// NaN = no container

    pub container_width: f32,

    pub container_height: f32,

    pub container_name: OptionString,

    /// Accessibility preferences

    pub prefers_reduced_motion: BoolCondition,

    pub prefers_high_contrast: BoolCondition,

    /// Orientation

    pub orientation: OrientationType,

    /// Node state (hover, active, focus, disabled, checked, focus_within, visited)

    pub pseudo_state: PseudoStateFlags,

    /// Language/Locale (BCP 47 tag, e.g., "en-US", "de-DE")

    pub language: AzString,

    /// Whether the window currently has focus (for :backdrop pseudo-class)

    /// When false, :backdrop styles should be applied

    pub window_focused: bool,

}

impl Default for DynamicSelectorContext {

}

impl DynamicSelectorContext {

    /// Create a context from SystemStyle

        } else {

        };

    /// Update viewport dimensions (e.g., on window resize)

        } else {

        };

    /// Update container dimensions (for @container queries)

    /// Update pseudo-state (hover, active, focus, etc.)

    /// Check if viewport changed significantly (for breakpoint detection)

        }

}

impl DynamicSelector {

    /// Check if this selector matches in the given context

            }

            }

            }

            }

            }

        }

        }

        // de_version == 0 means the runtime hasn't reported a version,

        // so any DE-version constraint fails until detection is wired up.

        }

        }

        }

}

/// Parse the content of an `@os(...)` at-rule into a list of dynamic-selector conditions.

///

/// Accepts both bare-identifier and parenthesized forms:

///

/// - `linux`                       → `[Os(Linux)]`

/// - `(linux)`                     → `[Os(Linux)]`

/// - `(linux:gnome)`               → `[Os(Linux), OsVersion(DesktopEnvironment(Gnome))]`

/// - `(windows >= win-11)`         → `[Os(Windows), OsVersion(Min(WIN_11))]`

/// - `(linux:gnome > 40)`          → `[Os(Linux), OsVersion(DesktopEnvMin{ env: Gnome, version_id: 40 })]`

/// - `(any)` / `(*)` / `(all)`     → `[]` (always-match, no conditions emitted)

///

/// Returns `None` only when the content is a parse error.

/// `Some(vec![])` means "always match" (the rule applies unconditionally).

#[cfg(feature = "parser")]

    // Split off the operator + version, if any.

    // subject is "family" or "family:de"

    };

    };

    // Always emit the family selector, even for `Any` — `Os(Any)` is matched as

    // unconditionally true, but keeping it in the conditions list makes the rule

    // structure visible to introspection.

        // Bare DE with no version: just "is the DE this one"

        // DE + version: emit a DesktopEnv* condition

            };

        }

        // OS family + version

                // Apple, Web, Any have no version line — reject.

            };

            };

        }

        // Family only — already pushed above (or empty for `any`).

    }

#[cfg(feature = "parser")]

#[derive(Copy, Clone)]

enum VersionOp { Min, Max, Exact }

/// Find the first comparison operator (`>=`, `<=`, `=`, `>`, `<`) in `s` and split.

/// `>` and `<` are treated as `>=` / `<=` because version IDs are discrete integers.

#[cfg(feature = "parser")]

    // Earliest match wins; on a tie, the longer operator wins (so ">=" beats "=" at the same position).

            });

    }

    }

#[cfg(feature = "parser")]

    }

#[cfg(feature = "parser")]

    }

// ============================================================================

// CssPropertyWithConditions - Replacement for NodeDataInlineCssProperty

// ============================================================================

/// A CSS property with optional conditions for when it should be applied.

/// This replaces `NodeDataInlineCssProperty` with a more flexible system.

///

/// If `apply_if` is empty, the property always applies.

/// If `apply_if` contains conditions, ALL conditions must be satisfied for the property to apply.

#[repr(C)]

#[derive(Debug, Clone, PartialEq)]

pub struct CssPropertyWithConditions {

    /// The actual CSS property value

    pub property: CssProperty,

    /// Conditions that must all be satisfied for this property to apply.

    /// Empty means unconditional (always apply).

    pub apply_if: DynamicSelectorVec,

}

impl_option!(

    CssPropertyWithConditions,

    OptionCssPropertyWithConditions,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl Eq for CssPropertyWithConditions {}

impl PartialOrd for CssPropertyWithConditions {

}

impl Ord for CssPropertyWithConditions {

        // Compare by condition count only (simple stable ordering)

}

impl CssPropertyWithConditions {

    /// Create an unconditional property (always applies) - const version

    /// Create a property with a single condition (const version using slice reference)

    /// Create a property with a single condition (non-const, allocates)

    /// Create a property with multiple conditions (all must match)

    /// Create a property that applies only on hover (const version)

        )

    /// Create a property that applies only when active (const version)

        )

    /// Create a property that applies only when focused (const version)

        )

    /// Create a property that applies only when disabled (const version)

        )

    /// Create a property that applies only on a specific OS (non-const, needs runtime value)

    /// Create a property that applies only in dark theme (const version)

    /// Create a property that applies only in light theme (const version)

    /// Create a property for Windows only (const version)

    /// Create a property for macOS only (const version)

    /// Create a property for Linux only (const version)

    /// Check if this property matches in the given context

        // Empty conditions = always matches

        // All conditions must match

    /// Check if this property has any conditions

    /// Check if this property is a pseudo-state conditional only

    /// (hover, active, focus, etc.)

    /// Check if this property affects layout (width, height, margin, etc.)

    /// 

    /// Returns `true` for layout-affecting properties like width, height, margin, padding,

    /// font-size, etc. Returns `false` for paint-only properties like color, background,

    /// box-shadow, opacity, transform, etc.

}

impl_vec!(CssPropertyWithConditions, CssPropertyWithConditionsVec, CssPropertyWithConditionsVecDestructor, CssPropertyWithConditionsVecDestructorType, CssPropertyWithConditionsVecSlice, OptionCssPropertyWithConditions);

impl_vec_debug!(CssPropertyWithConditions, CssPropertyWithConditionsVec);

impl_vec_partialeq!(CssPropertyWithConditions, CssPropertyWithConditionsVec);

impl_vec_partialord!(CssPropertyWithConditions, CssPropertyWithConditionsVec);

impl_vec_clone!(

    CssPropertyWithConditions,

    CssPropertyWithConditionsVec,

    CssPropertyWithConditionsVecDestructor

);

// Manual implementations for Eq and Ord (required for NodeData derives)

impl Eq for CssPropertyWithConditionsVec {}

impl Ord for CssPropertyWithConditionsVec {

}

impl core::hash::Hash for CssPropertyWithConditions {

        // DynamicSelectorVec doesn't implement Hash, so we hash the length

}