//! 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.

//

// TODO(superplan g8 item 3): unify with `azul_core::styled_dom::StyledNodeState`

// (core/src/styled_dom.rs:190). The two structs now carry the *identical* 10 fields

// (hover/active/focused/disabled/checked/focus_within/visited/backdrop/dragging/

// drag_over) and core already bridges them via `StyledNodeState::from_pseudo_state_flags`.

// `azul_css` cannot depend on `azul_core`, so the merge must land core-side (e.g. move

// the shared struct into `azul_css` and re-export from core, or delete one type). This is

// a cross-crate change touching core/, left as a TODO per group ownership.

#[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, Eq]

);

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

impl_vec_clone!(

    DynamicSelector,

    DynamicSelectorVec,

    DynamicSelectorVecDestructor

);

impl_vec_debug!(DynamicSelector, DynamicSelectorVec);

impl_vec_partialeq!(DynamicSelector, DynamicSelectorVec);

impl DynamicSelector {

    /// Stable per-variant tag (mirrors the `#[repr(C, u8)]` discriminants), used as

    /// the primary key for both `Ord` and `Hash` so the two stay consistent.

        }

}

// `DynamicSelector` carries `f32` ranges (`MinMaxRange`), so `Eq`/`Ord`/`Hash`

// cannot be derived. They are implemented by hand here: every non-float payload

// already provides them, and the float ranges are compared/hashed by their bit

// pattern so the resulting order is *total* and consistent with `Hash`. (Bit

// comparison means NaN sentinels sort deterministically instead of being

// incomparable.)

impl Eq for DynamicSelector {}

impl PartialOrd for DynamicSelector {

}

impl Ord for DynamicSelector {

    // Order-dependent tie-break arms with identical bodies can't merge without

    // changing the ordering (clippy::match_same_arms false positive).

    #[allow(clippy::match_same_arms)]

        use core::cmp::Ordering;

        }

        // Same variant on both sides (tags are equal): compare the payloads.

            }

            }

            }

            // Unreachable: tags are equal, so both sides are the same variant.

        }

}

impl core::hash::Hash for DynamicSelector {

    // Per-variant dispatch: each `x` is a different type, so the identical

    // `x.hash(state)` bodies can't merge (clippy::match_same_arms false positive).

    #[allow(clippy::match_same_arms)]

        }

}

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

#[repr(C)]

#[derive(Debug, Clone, Copy)]

pub struct MinMaxRange {

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

    pub min: f32,

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

    pub max: f32,

}

// The f32 fields use NaN as the "no bound" sentinel, so equality and order compare by

// BIT PATTERN (via to_bits), NOT raw float `==`/`<`. Deriving them used raw float, under

// which a NaN-bounded range — i.e. EVERY single-sided `(min-width: …)` / `(max-width: …)`

// selector — was not equal to itself, breaking the `Eq` contract that `DynamicSelector`

// asserts, and disagreeing with `DynamicSelector::cmp` (which already orders these fields

// via to_bits). PartialEq and PartialOrd must move together: a to_bits PartialEq with a

// raw-float PartialOrd would itself be inconsistent (NaN == NaN true, partial_cmp None).

// The sentinel is always the canonical `f32::NAN`, so all sentinels share one bit pattern.

impl PartialEq for MinMaxRange {

}

impl Eq for MinMaxRange {}

// NB: deliberately NO `impl Ord` — `Ord::min`/`Ord::max` take `self` by value and would

// shadow the inherent `min(&self)`/`max(&self)` getters in method resolution (the by-value

// receiver is tried before autoref to `&self`), breaking every `range.min()` call.

// `PartialOrd` is fine (it adds no `min`/`max` method) and gives a total, to_bits-based

// order consistent with `PartialEq`. `DynamicSelector::cmp` orders these fields directly,

// so it never needed `MinMaxRange: Ord` anyway.

impl PartialOrd for MinMaxRange {

}

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, PartialOrd, Ord)]

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, PartialOrd, Ord)]

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, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

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, PartialOrd, Ord)]

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, PartialOrd, Ord)]

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, PartialOrd, Ord)]

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".

        // Each version groups its named alias with the numeric NT version.

    }

/// 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").

    // Checked: this string comes straight from CSS text via parse_os_at_rule_content

    // (`@os(linux >= 5000000)` parses fine), and there is no digit-count precondition.

    // Unchecked `major * 1000 + minor * 10 + patch` overflowed u32 and panicked.

/// 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, PartialOrd, Ord)]

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, PartialOrd, Ord)]

pub enum MediaType {

    Screen,

    Print,

    All,

}

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

#[repr(C, u8)]

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

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, PartialOrd, Ord)]

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, PartialOrd, Ord)]

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).

                // `get` (not a raw index): the byte-LENGTH guard above says nothing

                // about char boundaries, so a multi-byte language tag -- which `:lang()`

                // accepts, it is arbitrary UTF-8 -- would slice mid-character and panic.

                // A split inside a character is never a prefix match anyway.

                };

                // 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

///

/// `PartialEq` is IMPLEMENTED MANUALLY (not derived): `container_width`

/// / `container_height` use `f32::NAN` as the "no container" sentinel,

/// and derived float equality makes NaN != NaN — so two identical

/// contexts never compared equal, `set_dynamic_selector_context`'s

/// early return never fired, and EVERY context set paid a full author

/// restyle (~2-4 ms at document scale, measured by the

/// `media_restyle_cost` workbench). The manual impl compares the f32

/// fields by bit pattern, which treats the NaN sentinel as equal to

/// itself and is exactly the "did anything change" question this

/// equality exists to answer.

#[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 PartialEq for DynamicSelectorContext {

        // f32 fields by BIT pattern: the NaN "no container" sentinel must

        // equal itself (see the struct doc — derived float equality made

        // every context set pay a full restyle).

}

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.

                // `de_version != 0` like the Min/Max arms: 0 is the "unknown" sentinel,

                // so a DE-version constraint (including `= 0`) must fail until detection

                // is wired up — otherwise `@os(linux:gnome = 0)` matched every session.

        }

        }

        }

}

/// 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,

}