//! Toast / snackbar widget — a transient notification banner. A near-clone of

//! [`crate::widgets::alert::Alert`] (a coloured message box with a "x" dismiss

//! affordance and a `visible` state) that, instead of sitting inline, floats as

//! an overlay pinned to a corner of its positioned parent

//! (`position: absolute; bottom; right`).

//!

//! Like [`crate::widgets::alert::Alert`] / [`crate::widgets::check_box::CheckBox`]

//! it is stateful: it carries a [`ToastStateWrapper`] (`{ visible } + on_dismiss`)

//! in a [`RefAny`] attached to the "x" close button. Clicking "x" flips `visible`

//! to `false`, invokes the optional user `on_dismiss`, and hides the whole toast

//! by setting `display: none` on the container via `set_css_property` (mirroring

//! alert's / check_box's live restyle).

//!

//! TODO2 — **auto-dismiss is intentionally NOT implemented (be honest, don't fake

//! it).** A real toast disappears on its own after N seconds. That requires a

//! host-driven `Timer`/`Update` loop that re-enters the event loop on a clock

//! tick and flips `visible` to `false` — a widget handler cannot *start* such a

//! timer (it only runs in response to an input event, with no access to schedule

//! a future wakeup). This is the same limitation the spinner hit with CSS

//! animation: there is no widget-local timer. So this widget ships a **manually**

//! dismissable toast (the "x"); a host that wants auto-timeout must register a

//! `Timer` itself and call `set_css_property(display: none)` (or rebuild without

//! the toast) when it fires.

//!

//! TODO2 — covering sibling widgets relies on paint order (being a later sibling)

//! because there is no real stacking-context / z-index, and a drop `box-shadow`

//! elevation is omitted (it needs a runtime-heap shadow value — see

//! `progressbar.rs`); the border + radius over the page convey the floating card.

//! The `display:none` relayout itself is not GUI-verified in this build.

//!

//! Key types: [`Toast`], [`ToastKind`], [`ToastState`], [`ToastOnDismiss`].

use azul_core::{

    callbacks::{CoreCallbackData, Update},

    dom::{Dom, IdOrClass, IdOrClass::Class, IdOrClassVec, TabIndex},

    refany::RefAny,

};

use azul_css::dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec};

use azul_css::{

    props::{

        basic::{color::ColorU, font::{StyleFontFamily, StyleFontFamilyVec}, StyleFontSize},

        layout::{LayoutDisplay, LayoutFlexDirection, LayoutAlignItems, LayoutFlexGrow, LayoutPosition, LayoutInsetBottom, LayoutRight, LayoutMaxWidth, LayoutPaddingTop, LayoutPaddingBottom, LayoutPaddingLeft, LayoutPaddingRight, LayoutMarginLeft},

        property::{CssProperty, *},

        style::{StyleBackgroundContentVec, StyleBackgroundContent, LayoutBorderTopWidth, LayoutBorderBottomWidth, LayoutBorderLeftWidth, LayoutBorderRightWidth, StyleBorderTopStyle, BorderStyle, StyleBorderBottomStyle, StyleBorderLeftStyle, StyleBorderRightStyle, StyleBorderTopColor, StyleBorderBottomColor, StyleBorderLeftColor, StyleBorderRightColor, StyleBorderTopLeftRadius, StyleBorderTopRightRadius, StyleBorderBottomLeftRadius, StyleBorderBottomRightRadius, StyleTextColor, StyleTextAlign, StyleCursor, StyleUserSelect},

    },

    impl_option_inner, AzString,

};

use crate::callbacks::{Callback, CallbackInfo};

static TOAST_CONTAINER_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-toast"))];

static TOAST_MESSAGE_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-toast-message"))];

static TOAST_CLOSE_CLASS: &[IdOrClass] =

    &[Class(AzString::from_const_str("__azul-native-toast-close"))];

const SYSTEM_UI_STR: AzString = AzString::from_const_str("system:ui");

const SYSTEM_UI_FAMILIES: &[StyleFontFamily] = &[StyleFontFamily::System(SYSTEM_UI_STR)];

const SYSTEM_UI_FAMILY: StyleFontFamilyVec =

    StyleFontFamilyVec::from_const_slice(SYSTEM_UI_FAMILIES);

/// Distance (logical px) of the toast from the bottom / right edges of its parent.

const TOAST_INSET: isize = 24;

/// Maximum width (logical px) of the toast card.

const TOAST_MAX_WIDTH: isize = 360;

/// Callback function type invoked when a toast's "x" close button is clicked.

pub type ToastOnDismissCallbackType = extern "C" fn(RefAny, CallbackInfo, ToastState) -> Update;

impl_widget_callback!(

    ToastOnDismiss,

    OptionToastOnDismiss,

    ToastOnDismissCallback,

    ToastOnDismissCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        ToastOnDismissCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: TOAST_ON_DISMISS_INVOKER,

    invoker_ty:     AzToastOnDismissCallbackInvoker,

    thunk_fn:       az_toast_on_dismiss_callback_thunk,

    setter_fn:      AzApp_setToastOnDismissCallbackInvoker,

    from_handle_fn: AzToastOnDismissCallback_createFromHostHandle,

    extra_args:     [ state: ToastState ],

}

/// The semantic colour variant of a [`Toast`] (Bootstrap alert palette, mirroring

/// [`crate::widgets::alert::AlertKind`]).

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

#[repr(C)]

pub enum ToastKind {

    /// Blue informational toast — the default.

    #[default]

    Info,

    /// Green success toast.

    Success,

    /// Yellow warning toast.

    Warning,

    /// Red danger/error toast.

    Danger,

}

impl ToastKind {

    /// Returns the `(background, border, text)` colours for this toast kind.

    #[allow(clippy::trivially_copy_pass_by_ref)] // <=8B Copy param kept by-ref intentionally (hot pixel/coord path or to avoid churning call sites for a perf-neutral change)

        }

    /// CSS class name for this toast kind (mirrors `AlertKind::class_name`).

        }

}

/// A transient, floating notification banner with a "x" dismiss button.

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

#[repr(C)]

pub struct Toast {

    /// Runtime state (`visible`) plus the optional dismiss callback.

    pub toast_state: ToastStateWrapper,

    /// The message text shown inside the toast.

    pub message: AzString,

    /// The colour variant.

    pub kind: ToastKind,

    /// Whether to render the "x" close button (default `true` — the only way to

    /// dismiss; see the module-level auto-dismiss TODO2).

    pub dismissible: bool,

    /// The computed inline style for the (absolutely-positioned) container.

    pub container_style: CssPropertyWithConditionsVec,

}

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

#[repr(C)]

pub struct ToastStateWrapper {

    /// Whether the toast is currently visible.

    pub inner: ToastState,

    /// Optional: function to call when the toast is dismissed.

    pub on_dismiss: OptionToastOnDismiss,

}

/// The visible/hidden state of a [`Toast`].

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

#[repr(C)]

pub struct ToastState {

    /// `true` (default) = shown, `false` = dismissed/hidden.

    pub visible: bool,

}

impl Default for ToastState {

}

/// Builds the container style for a given [`ToastKind`]. Mirrors

/// `alert::build_alert_style` but pins the box to the bottom-right corner of its

/// positioned parent (`position: absolute`) and caps its width instead of

/// stretching to fill a flex column.

        )),

            0,

        ))),

        // Float pinned to the bottom-right corner of the positioned parent.

            TOAST_INSET,

        ))),

            TOAST_INSET,

        ))),

        // Cap the width so the toast hugs its content rather than spanning the page.

            TOAST_MAX_WIDTH,

        ))),

        // padding: 12px

            12,

        ))),

        )),

        )),

        )),

        // border: 1px solid <border>

        )),

        )),

        )),

        )),

        )),

        )),

        )),

        )),

        )),

        )),

        // border-radius: 6px

        )),

        )),

        )),

        )),

        // Text colour is inherited by the message + close children.

    ])

/// Message-text style: takes the remaining horizontal space, left-aligned.

static TOAST_MESSAGE_STYLE: &[CssPropertyWithConditions] = &[

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(1))),

    CssPropertyWithConditions::simple(CssProperty::const_text_align(StyleTextAlign::Left)),

];

/// Close-button ("x") style: a small pointer-cursor box on the right.

static TOAST_CLOSE_STYLE: &[CssPropertyWithConditions] = &[

    CssPropertyWithConditions::simple(CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))),

    CssPropertyWithConditions::simple(CssProperty::const_font_size(StyleFontSize::const_px(18))),

    CssPropertyWithConditions::simple(CssProperty::const_cursor(StyleCursor::Pointer)),

    CssPropertyWithConditions::simple(CssProperty::user_select(StyleUserSelect::None)),

    CssPropertyWithConditions::simple(CssProperty::const_margin_left(LayoutMarginLeft::const_px(

        12,

    ))),

];

impl Toast {

    /// Creates a new informational (blue) toast with the given message (visible,

    /// with a "x" close button).

    #[inline]

    /// Creates a new toast with the given message and colour variant.

    #[inline]

    /// Sets the colour variant, recomputing the container style.

    #[inline]

    /// Builder-style setter for the colour variant.

    #[inline]

    /// Sets whether the toast shows a "x" close button.

    #[inline]

    /// Builder-style setter for the dismissible flag.

    #[inline]

    /// Sets the dismiss callback. Implies `dismissible = true` so the close

    /// button is rendered.

    #[inline]

    /// Builder-style setter for the dismiss callback (implies dismissible).

    #[inline]

    /// Replaces `self` with a default (empty info) toast and returns the original.

    #[inline]

    /// Converts this toast into a DOM subtree with the `__azul-native-toast` class.

    #[inline]

        use azul_core::{

            callbacks::CoreCallback,

            dom::{EventFilter, HoverEventFilter},

            refany::OptionRefAny,

        };

}

impl Default for Toast {

}

/// Close-button click handler. The hit node is the close button (the

/// callback-bearing node, per `currentTarget` semantics — see `alert`); its

/// parent is the toast container. Flips `visible` to `false`, invokes the

/// optional user callback, then hides the whole toast via `display: none`.

    };

        };

        }

    };

    // TODO2: hides the toast by toggling `display: none` via set_css_property.

    // This follows the proven live-restyle pattern of alert/check_box (which

    // toggle display/opacity/background); the display:none relayout itself is not

    // GUI-verified in this build. (Auto-timeout dismissal is a host-driven Timer —

    // see the module-level TODO2 — and is intentionally not attempted here.)

impl From<Toast> for Dom {

}

#[cfg(test)]

// `assertions_on_constants`: these are deliberate invariant guards over sibling

// `const`s in this module. They are const-foldable *today*, which is exactly the

// point — they must go red the moment someone edits one of those constants into an

// inconsistent value. Deleting them (clippy's suggestion) would delete the check.

#[allow(clippy::assertions_on_constants)]

mod autotest_generated {

    use std::{

        collections::{BTreeMap, HashMap},

        sync::{Arc, Mutex},

    };

    use azul_core::{

        dom::{DomId, DomNodeId, EventFilter, HoverEventFilter, NodeId, NodeType},

        geom::{LogicalRect, OptionLogicalPosition},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        refany::OptionRefAny,

        resources::RendererResources,

        styled_dom::{NodeHierarchyItemId, StyledDom},

        window::{MonitorVec, RawWindowHandle},

    };

    use azul_css::{

        props::basic::{length::SizeMetric, pixel::PixelValue},

        system::SystemStyle,

    };

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

        solver3::{display_list::DisplayList, layout_tree::LayoutTree},

        window::{DomLayoutResult, LayoutWindow},

        window_state::FullWindowState,

    };

    // ------------------------------------------------------------------

    // Helpers

    // ------------------------------------------------------------------

    const ALL_KINDS: [ToastKind; 4] = [

        ToastKind::Info,

        ToastKind::Success,

        ToastKind::Warning,

        ToastKind::Danger,

    ];

    /// The text of a text node, looking through the `<p>` block wrapper the

    /// label convention mandates (`p > text`).

    fn text_of(node: &Dom) -> Option<&str> {

        match node.root.get_node_type() {

            NodeType::Text(s) => Some(s.as_ref().as_str()),

            NodeType::P => match node.children.as_ref() {

                [only] => match only.root.get_node_type() {

                    NodeType::Text(s) => Some(s.as_ref().as_str()),

                    _ => None,

                },

                _ => None,

            },

            _ => None,

        }

    }

    /// The inline (static) CSS properties actually attached to a DOM node.

    fn inline_props(node: &Dom) -> Vec<CssProperty> {

        node.root

            .style

            .iter_inline_properties()

            .map(|(p, _)| p.clone())

            .collect()

    }

    /// The `background-color` of a style vec (first background layer only).

    fn background_color(style: &CssPropertyWithConditionsVec) -> Option<ColorU> {

        style.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::BackgroundContent(v) => match v.get_property()?.as_ref().first()? {

                StyleBackgroundContent::Color(c) => Some(*c),

                _ => None,

            },

            _ => None,

        })

    }

    /// Every `border-*-color` in a style vec, in declaration order.

    fn border_colors(style: &CssPropertyWithConditionsVec) -> Vec<ColorU> {

        style

            .as_ref()

            .iter()

            .filter_map(|p| match &p.property {

                CssProperty::BorderTopColor(v) => v.get_property().map(|c| c.inner),

                CssProperty::BorderBottomColor(v) => v.get_property().map(|c| c.inner),

                CssProperty::BorderLeftColor(v) => v.get_property().map(|c| c.inner),

                CssProperty::BorderRightColor(v) => v.get_property().map(|c| c.inner),

                _ => None,

            })

            .collect()

    }

    /// The `color` (text colour) of a style vec.

    fn text_color(style: &CssPropertyWithConditionsVec) -> Option<ColorU> {

        style.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::TextColor(v) => v.get_property().map(|c| c.inner),

            _ => None,

        })

    }

    /// The declared `position` of a style vec.

    fn position_of(style: &CssPropertyWithConditionsVec) -> Option<LayoutPosition> {

        style.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::Position(v) => v.get_property().copied(),

            _ => None,

        })

    }

    /// The `bottom` offset of a style vec, as a raw `PixelValue`.

    fn bottom_px(style: &CssPropertyWithConditionsVec) -> Option<PixelValue> {

        style.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::Bottom(v) => v.get_property().map(|b| b.inner),

            _ => None,

        })

    }

    /// The `right` offset of a style vec, as a raw `PixelValue`.

    fn right_px(style: &CssPropertyWithConditionsVec) -> Option<PixelValue> {

        style.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::Right(v) => v.get_property().map(|r| r.inner),

            _ => None,

        })

    }

    /// The `max-width` of a style vec, as a raw `PixelValue`.

    fn max_width_px(style: &CssPropertyWithConditionsVec) -> Option<PixelValue> {

        style.as_ref().iter().find_map(|p| match &p.property {

            CssProperty::MaxWidth(v) => v.get_property().map(|w| w.inner),

            _ => None,

        })

    }

    /// The *kind* of every declared property, in order (ignores the values).

    fn property_types(

        style: &CssPropertyWithConditionsVec,

    ) -> Vec<core::mem::Discriminant<CssProperty>> {

        style

            .as_ref()

            .iter()

            .map(|p| core::mem::discriminant(&p.property))

            .collect()

    }

    /// A `RefAny` payload recording every `ToastState` a user `on_dismiss` sees.

    struct DismissLog {

        calls: Vec<bool>,

    }

    extern "C" fn record_dismiss(mut data: RefAny, _: CallbackInfo, state: ToastState) -> Update {

        if let Some(mut log) = data.downcast_mut::<DismissLog>() {

            log.calls.push(state.visible);

        }

        Update::RefreshDom

    }

    extern "C" fn dismiss_do_nothing(_: RefAny, _: CallbackInfo, _: ToastState) -> Update {

        Update::DoNothing

    }

    fn dismiss_cb(f: ToastOnDismissCallbackType) -> ToastOnDismissCallback {

        f.into()

    }

    /// `visible` of a `ToastStateWrapper` payload.

    fn wrapper_visible(data: &mut RefAny) -> bool {

        data.downcast_ref::<ToastStateWrapper>()

            .expect("payload must still be a ToastStateWrapper")

            .inner

            .visible

    }

    /// The `visible` flags recorded by a `DismissLog` payload.

    fn log_calls(data: &mut RefAny) -> Vec<bool> {

        data.downcast_ref::<DismissLog>()

            .expect("payload must still be a DismissLog")

            .calls

            .clone()

    }

    /// A `DomLayoutResult` with an *empty* layout tree: the dismiss handler only

    /// walks `styled_dom.node_hierarchy`, so no real layout (and no font) is needed.

    fn layout_result(styled_dom: StyledDom) -> DomLayoutResult {

        DomLayoutResult {

            styled_dom,

            layout_tree: LayoutTree {

                nodes: Vec::new(),

                warm: Vec::new(),

                cold: Vec::new(),

                root: 0,

                dom_to_layout: BTreeMap::new(),

                children_arena: Vec::new(),

                children_offsets: Vec::new(),

                subtree_needs_intrinsic: Vec::new(),

            },

            calculated_positions: Vec::new(),

            viewport: LogicalRect::zero(),

            display_list: Arc::new(DisplayList::default()),

            scroll_ids: HashMap::new(),

            scroll_id_to_node_id: HashMap::new(),

        }

    }

    /// The flattened DOM of a default toast: `container(0)`, `message(1)`,

    /// `close(2)` — i.e. exactly the hierarchy `default_on_toast_dismiss` walks

    /// (hit node -> parent).

    fn dismissible_styled_dom() -> StyledDom {

        let toast = Toast::create(AzString::from("msg"));

        assert!(

            toast.dismissible,

            "a fresh toast must already carry a close button"

        );

        let styled = StyledDom::create_from_dom(toast.dom());

        assert_eq!(

            styled.node_hierarchy.as_ref().len(),

            5,

            "fixture must flatten to container / message <p> + text / close <p> + text"

        );

        styled

    }

    /// Invokes `default_on_toast_dismiss` against a `LayoutWindow` holding

    /// `styled` (or nothing at all, when `styled` is `None`), with `hit` as the

    /// hit node. Returns the `Update` plus every recorded `CallbackChange`.

    /// Flat indices in `dismissible_styled_dom`, depth-first pre-order:

    /// `0 container / 1 message <p> / 2 message text / 3 close <p> / 4 close text`.

    /// Both callbacks and styles sit on the `<p>`s, never on the text nodes.

    const MESSAGE_NODE: usize = 1;

    const CLOSE_NODE: usize = 3;

    fn run_dismiss(

        styled: Option<StyledDom>,

        hit: usize,

        data: RefAny,

    ) -> (Update, Vec<CallbackChange>) {

        let mut layout_window =

            LayoutWindow::new(FcFontCache::default()).expect("LayoutWindow::new failed");

        if let Some(sd) = styled {

            layout_window

                .layout_results

                .insert(DomId::ROOT_ID, layout_result(sd));

        }

        let renderer_resources = RendererResources::default();

        let previous_window_state: Option<FullWindowState> = None;

        let current_window_state = FullWindowState::default();

        let gl_context = OptionGlContextPtr::None;

        let scroll_states: BTreeMap<DomId, BTreeMap<NodeHierarchyItemId, ScrollPosition>> =

            BTreeMap::new();

        let window_handle = RawWindowHandle::Unsupported;

        let system_callbacks = ExternalSystemCallbacks::rust_internal();

        let ref_data = CallbackInfoRefData {

            layout_window: &layout_window,

            renderer_resources: &renderer_resources,

            previous_window_state: &previous_window_state,

            current_window_state: &current_window_state,

            gl_context: &gl_context,

            current_scroll_manager: &scroll_states,

            current_window_handle: &window_handle,

            system_callbacks: &system_callbacks,

            system_style: Arc::new(SystemStyle::default()),

            monitors: Arc::new(Mutex::new(MonitorVec::from_const_slice(&[]))),

            #[cfg(feature = "icu")]

            icu_localizer: IcuLocalizerHandle::default(),

            ctx: OptionRefAny::None,

        };

        let changes: Arc<Mutex<Vec<CallbackChange>>> = Arc::new(Mutex::new(Vec::new()));

        let info = CallbackInfo::new(

            &ref_data,

            &changes,

            DomNodeId {

                dom: DomId::ROOT_ID,

                node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::new(hit))),

            },

            OptionLogicalPosition::None,

            OptionLogicalPosition::None,

        );

        let update = default_on_toast_dismiss(data, info);

        let recorded = core::mem::take(&mut *changes.lock().expect("change log poisoned"));

        (update, recorded)

    }

    /// Every `display` write recorded in the change log, as `(node index, display)`.

    fn display_writes(changes: &[CallbackChange]) -> Vec<(usize, LayoutDisplay)> {

        let mut out = Vec::new();

        for change in changes {

            if let CallbackChange::ChangeNodeCssProperties {

                node_id, properties, ..

            } = change

            {

                for p in properties.as_ref() {

                    if let CssProperty::Display(v) = p {

                        if let Some(d) = v.get_property() {

                            out.push((node_id.index(), *d));

                        }

                    }

                }

            }

        }

        out

    }

    // ------------------------------------------------------------------

    // ToastKind::colors  (getter)

    // ------------------------------------------------------------------

    #[test]

    fn kind_colors_are_the_documented_bootstrap_palette() {

        let expect = |(r, g, b): (u8, u8, u8)| ColorU { r, g, b, a: 255 };

        assert_eq!(

            ToastKind::Info.colors(),

            (

                expect((207, 244, 252)), // #cff4fc

                expect((182, 239, 251)), // #b6effb

                expect((5, 81, 96)),     // #055160

            )

        );

        assert_eq!(

            ToastKind::Success.colors(),

            (

                expect((209, 231, 221)), // #d1e7dd

                expect((186, 219, 204)), // #badbcc

                expect((15, 81, 50)),    // #0f5132

            )

        );

        assert_eq!(

            ToastKind::Warning.colors(),

            (

                expect((255, 243, 205)), // #fff3cd

                expect((255, 236, 181)), // #ffecb5

                expect((102, 77, 3)),    // #664d03

            )

        );

        assert_eq!(

            ToastKind::Danger.colors(),

            (

                expect((248, 215, 218)), // #f8d7da

                expect((245, 194, 199)), // #f5c2c7

                expect((132, 32, 41)),   // #842029

            )

        );

    }

    #[test]

    fn kind_colors_are_fully_opaque_and_pairwise_distinct() {

        for kind in ALL_KINDS {

            let (bg, border, text) = kind.colors();

            for (name, c) in [("bg", bg), ("border", border), ("text", text)] {

                assert_eq!(c.a, 255, "{kind:?}.{name} must be fully opaque");

            }

            // a floating card is only legible if bg != text

            assert_ne!(bg, text, "{kind:?}: background must differ from text");

            // ... and only visible against the page if bg != border

            assert_ne!(bg, border, "{kind:?}: the border must be visible on the card");

        }

        for (i, a) in ALL_KINDS.iter().enumerate() {

            for b in &ALL_KINDS[i + 1..] {

                assert_ne!(

                    a.colors(),

                    b.colors(),

                    "{a:?} and {b:?} must be visually distinguishable"

                );

            }

        }

    }

    #[test]

    fn kind_colors_default_is_info_and_the_call_is_pure() {

        assert_eq!(ToastKind::default(), ToastKind::Info);

        assert_eq!(ToastKind::default().colors(), ToastKind::Info.colors());

        // repeated calls on the same (Copy) receiver must be stable

        let k = ToastKind::Danger;

        assert_eq!(k.colors(), k.colors());

        assert_eq!(k.colors(), k.colors());

    }

    #[test]

    fn kind_colors_is_const_evaluable() {

        const INFO: (ColorU, ColorU, ColorU) = ToastKind::Info.colors();

        assert_eq!(

            INFO.0,

            ColorU {

                r: 207,

                g: 244,

                b: 252,

                a: 255

            }

        );

    }

    // ------------------------------------------------------------------

    // ToastKind::class_name  (getter)

    // ------------------------------------------------------------------

    #[test]

    fn class_name_exact_values_and_shape() {

        assert_eq!(ToastKind::Info.class_name(), "__azul-toast-info");

        assert_eq!(ToastKind::Success.class_name(), "__azul-toast-success");

        assert_eq!(ToastKind::Warning.class_name(), "__azul-toast-warning");

        assert_eq!(ToastKind::Danger.class_name(), "__azul-toast-danger");

        for kind in ALL_KINDS {

            let name = kind.class_name();

            assert!(

                name.starts_with("__azul-toast-"),

                "{kind:?} -> {name:?} must keep the widget prefix"

            );

            assert!(

                !name.contains(char::is_whitespace),

                "{name:?} must be a single CSS class token"

            );

            assert!(name.is_ascii(), "{name:?} must stay ASCII");

            // stable across calls, and equal for equal kinds

            assert_eq!(name, kind.class_name());

        }

    }

    #[test]

    fn class_name_is_unique_per_kind() {

        let mut names: Vec<&str> = ALL_KINDS.iter().map(|k| k.class_name()).collect();

        names.sort_unstable();

        names.dedup();

        assert_eq!(names.len(), 4, "every kind needs its own class name");

    }

    #[test]

    fn class_name_never_collides_with_the_structural_classes() {

        // the kind classes live in a different namespace than the three

        // `__azul-native-toast*` structural classes emitted by `dom()`

        let structural = ["__azul-native-toast", "__azul-native-toast-message",

                          "__azul-native-toast-close"];

        for kind in ALL_KINDS {

            for s in structural {

                assert_ne!(kind.class_name(), s, "{kind:?} must not shadow {s:?}");

            }

        }

    }

    #[test]

    fn class_name_is_const_evaluable() {

        const DANGER: &str = ToastKind::Danger.class_name();

        assert_eq!(DANGER, "__azul-toast-danger");

    }

    // ------------------------------------------------------------------

    // build_toast_style

    // ------------------------------------------------------------------

    #[test]

    fn build_toast_style_declares_the_same_properties_for_every_kind() {

        let info = property_types(&build_toast_style(ToastKind::Info));

        assert_eq!(

            info.len(),

            32,

            "the container style declares 32 properties (pin: adding/removing one is a \

             deliberate change)"

        );

        for kind in ALL_KINDS {

            let style = build_toast_style(kind);

            assert_eq!(

                property_types(&style),

                info,

                "{kind:?} must declare the same properties, in the same order, as Info"

            );

            // the style is unconditional: nothing is gated behind :hover/@media/...

            for p in style.as_ref() {

                assert!(

                    p.apply_if.as_ref().is_empty(),

                    "{kind:?}: {:?} must be unconditional",

                    p.property

                );

            }

        }

    }

    #[test]

    fn build_toast_style_declares_no_property_twice() {

        // a duplicated property would silently shadow the earlier declaration

        for kind in ALL_KINDS {

            let types = property_types(&build_toast_style(kind));

            for (i, a) in types.iter().enumerate() {

                for b in &types[i + 1..] {

                    assert_ne!(

                        a, b,

                        "{kind:?}: the container style declares the same property twice"

                    );

                }

            }

        }

    }

    #[test]

    fn build_toast_style_colors_track_the_kind_palette() {

        for kind in ALL_KINDS {

            let style = build_toast_style(kind);

            let (bg, border, text) = kind.colors();

            assert_eq!(background_color(&style), Some(bg), "{kind:?}: background");

            assert_eq!(text_color(&style), Some(text), "{kind:?}: text colour");

            let borders = border_colors(&style);

            assert_eq!(borders.len(), 4, "{kind:?}: all four edges must be coloured");

            assert!(

                borders.iter().all(|c| *c == border),

                "{kind:?}: every edge must use the kind's border colour, got {borders:?}"

            );

        }

    }

    #[test]

    fn build_toast_style_pins_the_card_to_the_bottom_right_corner() {

        // This is what makes a toast a toast (rather than an inline alert):

        // position:absolute + bottom/right insets + a width cap.

        for kind in ALL_KINDS {

            let style = build_toast_style(kind);

            assert_eq!(

                position_of(&style),

                Some(LayoutPosition::Absolute),

                "{kind:?}: a toast must float out of flow"

            );

            assert_eq!(

                bottom_px(&style),

                Some(LayoutInsetBottom::const_px(TOAST_INSET).inner),

                "{kind:?}: bottom inset"

            );

            assert_eq!(

                right_px(&style),

                Some(LayoutRight::const_px(TOAST_INSET).inner),

                "{kind:?}: right inset"

            );

            assert_eq!(

                max_width_px(&style),

                Some(LayoutMaxWidth::const_px(TOAST_MAX_WIDTH).inner),

                "{kind:?}: width cap"

            );

            // an absolutely-positioned card must not also try to grow in a flex row

            assert!(

                style.as_ref().contains(&CssPropertyWithConditions::simple(

                    CssProperty::const_flex_grow(LayoutFlexGrow::const_new(0))

                )),

                "{kind:?}: the container must not flex-grow"

            );

        }

    }

    #[test]

    fn toast_inset_and_max_width_survive_the_fixed_point_encoding_exactly() {

        // The `isize`-backed `FloatValue` encoding must reproduce the constants

        // bit-exactly — a drifting inset silently mis-places every toast.

        assert_eq!(TOAST_INSET, 24);

        assert_eq!(TOAST_MAX_WIDTH, 360);

        assert!(

            TOAST_INSET > 0 && TOAST_MAX_WIDTH > TOAST_INSET,

            "an inset must push the card inward, and the cap must exceed the inset"

        );

        let style = build_toast_style(ToastKind::Info);

        for (name, got, want) in [

            ("bottom", bottom_px(&style), TOAST_INSET),

            ("right", right_px(&style), TOAST_INSET),

            ("max-width", max_width_px(&style), TOAST_MAX_WIDTH),

        ] {

            let pv = got.unwrap_or_else(|| panic!("{name} must be declared"));

            assert_eq!(

                pv.metric,

                SizeMetric::Px,

                "{name} must be an absolute px length, not a %/em"

            );

            assert!(

                (pv.number.get() - want as f32).abs() < f32::EPSILON,

                "{name}: {} px decoded back as {}",

                want,

                pv.number.get()

            );

            assert!(

                pv.number.get().is_finite(),

                "{name} must never decode to NaN/inf"

            );

        }

    }

    #[test]

    fn build_toast_style_geometry_is_kind_independent() {

        // Everything that is *not* a colour must be identical for all kinds.

        let expected = [

            CssPropertyWithConditions::simple(CssProperty::const_display(LayoutDisplay::Flex)),

            CssPropertyWithConditions::simple(CssProperty::const_flex_direction(

                LayoutFlexDirection::Row,

            )),

            CssPropertyWithConditions::simple(CssProperty::const_align_items(

                LayoutAlignItems::Start,

            )),

            CssPropertyWithConditions::simple(CssProperty::const_position(LayoutPosition::Absolute)),

            CssPropertyWithConditions::simple(CssProperty::const_padding_top(

                LayoutPaddingTop::const_px(12),

            )),

            CssPropertyWithConditions::simple(CssProperty::const_border_top_width(

                LayoutBorderTopWidth::const_px(1),

            )),

            CssPropertyWithConditions::simple(CssProperty::const_border_top_left_radius(

                StyleBorderTopLeftRadius::const_px(6),

            )),

            CssPropertyWithConditions::simple(CssProperty::const_font_size(

                StyleFontSize::const_px(14),

            )),

        ];

        for kind in ALL_KINDS {

            let style = build_toast_style(kind);

            for want in &expected {

                assert!(

                    style.as_ref().contains(want),

                    "{kind:?}: missing {:?}",

                    want.property

                );

            }

        }

    }

    #[test]

    fn build_toast_style_differs_only_in_the_colours() {

        let info = build_toast_style(ToastKind::Info);

        for kind in [ToastKind::Success, ToastKind::Warning, ToastKind::Danger] {

            let other = build_toast_style(kind);

            let differing: Vec<_> = info

                .as_ref()

                .iter()

                .zip(other.as_ref().iter())

                .filter(|(a, b)| a != b)

                .map(|(a, _)| core::mem::discriminant(&a.property))

                .collect();

            // background + 4 border colours + text colour = 6 kind-dependent props

            assert_eq!(

                differing.len(),

                6,

                "{kind:?}: only bg + 4 border colours + text colour may depend on the kind"

            );

        }

    }

    #[test]

    fn build_toast_style_is_pure_and_repeatable() {

        for kind in ALL_KINDS {

            assert_eq!(

                build_toast_style(kind),

                build_toast_style(kind),

                "{kind:?}: the builder must be deterministic"

            );

        }

    }

    // ------------------------------------------------------------------

    // Toast::create / with_kind / Default

    // ------------------------------------------------------------------

    #[test]

    fn create_is_an_info_toast_that_is_dismissible_by_default() {

        let toast = Toast::create(AzString::from("hello"));

        assert_eq!(toast.message.as_str(), "hello");

        assert_eq!(toast.kind, ToastKind::Info);

        assert!(

            toast.dismissible,

            "unlike Alert, a fresh Toast ships the close button (the only way to dismiss it)"

        );

        assert!(toast.toast_state.inner.visible, "a fresh toast is visible");

        assert!(toast.toast_state.on_dismiss.is_none());

        assert_eq!(toast.container_style, build_toast_style(ToastKind::Info));

    }

    #[test]

    fn toast_state_defaults_to_visible_not_to_the_bool_default() {

        // `bool::default()` is false — `ToastState` must *override* that, else

        // every default-constructed toast would start out already dismissed.

        assert!(ToastState::default().visible);

        assert!(ToastStateWrapper::default().inner.visible);

        assert!(ToastStateWrapper::default().on_dismiss.is_none());

        assert!(Toast::default().toast_state.inner.visible);

    }

    #[test]

    fn create_with_empty_message_equals_default_and_is_value_comparable() {

        assert_eq!(Toast::create(AzString::from("")), Toast::default());

        // equality is structural, not pointer-based

        assert_eq!(

            Toast::create(AzString::from("a")),

            Toast::create(AzString::from("a"))

        );

        assert_ne!(

            Toast::create(AzString::from("a")),

            Toast::create(AzString::from("b"))

        );

        assert_ne!(

            Toast::create(AzString::from("a")),

            Toast::with_kind(AzString::from("a"), ToastKind::Danger)

        );

    }

    #[test]

    fn create_survives_extreme_messages_and_round_trips_them_into_the_dom() {

        let long = "ab".repeat(50_000);

        let cases: Vec<AzString> = alloc::vec![

            AzString::from(""),

            AzString::from(" "),

            AzString::from("a\0b"),                                  // interior NUL

            AzString::from("line\nbreak\ttab"),                      // control chars

            AzString::from("👨‍👩‍👧‍👦 e\u{0301}\u{0327} مرحبا שלום 🇩🇪"), // ZWJ + combining + RTL

            AzString::from("\u{feff}\u{202e}rtl-override"),          // BOM + bidi override

            AzString::from("×"),                                     // same glyph as the close button

            AzString::from("\u{00D7}\u{00D7}\u{00D7}"),              // three close glyphs

            AzString::from(long.as_str()),                           // 100k chars

        ];

        for message in cases {

            let toast = Toast::create(message.clone());

            assert_eq!(toast.message.as_str(), message.as_str());

            // the message must survive the trip through the DOM byte-for-byte

            let dom = toast.dom();

            let children = dom.children.as_ref();

            assert_eq!(

                children.len(),

                2,

                "message content must never change the child count"

            );

            assert_eq!(text_of(&children[0]), Some(message.as_str()));

            // a "×" in the *message* must not be mistaken for the close button

            assert!(

                children[0].root.has_class("__azul-native-toast-message"),

                "the first child is always the message"

            );

            assert!(

                children[1].root.has_class("__azul-native-toast-close"),

                "the close button is always last"

            );

        }

    }

    #[test]

    fn with_kind_stores_both_args_for_every_kind() {

        for kind in ALL_KINDS {

            let toast = Toast::with_kind(AzString::from("m"), kind);

            assert_eq!(toast.kind, kind);

            assert_eq!(toast.message.as_str(), "m");

            assert!(toast.dismissible);

            assert!(toast.toast_state.on_dismiss.is_none());

            assert!(toast.toast_state.inner.visible);

            assert_eq!(

                toast.container_style,

                build_toast_style(kind),

                "{kind:?}: the container style must match the kind it was built with"

            );

        }

    }

    #[test]

    fn create_is_with_kind_info() {

        assert_eq!(

            Toast::create(AzString::from("m")),

            Toast::with_kind(AzString::from("m"), ToastKind::Info)

        );

        assert_eq!(

            Toast::create(AzString::from("m")),

            Toast::with_kind(AzString::from("m"), ToastKind::default())

        );

    }

    // ------------------------------------------------------------------

    // set_kind / with_toast_kind

    // ------------------------------------------------------------------

    #[test]

    fn set_kind_recomputes_the_style_and_is_idempotent() {

        let mut toast = Toast::create(AzString::from("m"));

        for kind in ALL_KINDS {

            toast.set_kind(kind);

            assert_eq!(toast.kind, kind);

            assert_eq!(toast.container_style, build_toast_style(kind));

            // applying the same kind twice must not append/duplicate anything

            let before = toast.container_style.clone();

            toast.set_kind(kind);

            assert_eq!(

                toast.container_style, before,

                "{kind:?}: set_kind must be idempotent"

            );

            assert_eq!(

                toast.container_style.len(),

                32,

                "{kind:?}: restyling must not grow the property vec"

            );

        }

        // a full cycle back to the original kind restores the original toast

        let original = Toast::create(AzString::from("m"));

        let mut cycled = original.clone();

        for kind in ALL_KINDS {

            cycled.set_kind(kind);

        }

        cycled.set_kind(ToastKind::Info);

        assert_eq!(cycled, original, "kind cycling must not accumulate state");

    }

    #[test]

    fn set_kind_leaves_message_dismissible_and_callback_alone() {

        let log = RefAny::new(DismissLog { calls: Vec::new() });

        let mut toast = Toast::create(AzString::from("keep me"));

        toast.set_on_dismiss(log, dismiss_cb(dismiss_do_nothing));

        toast.toast_state.inner.visible = false;

        toast.set_kind(ToastKind::Warning);

        assert_eq!(toast.message.as_str(), "keep me");

        assert!(toast.dismissible, "set_kind must not clear the close button");

        assert!(

            toast.toast_state.on_dismiss.is_some(),

            "set_kind must not drop the callback"

        );

        assert!(

            !toast.toast_state.inner.visible,

            "set_kind must not resurrect a dismissed toast"

        );

    }

    #[test]

    fn with_toast_kind_matches_set_kind_and_last_write_wins() {

        for kind in ALL_KINDS {

            let built = Toast::create(AzString::from("m")).with_toast_kind(kind);

            let mut mutated = Toast::create(AzString::from("m"));

            mutated.set_kind(kind);

            assert_eq!(built, mutated, "{kind:?}: builder and setter must agree");

        }

        let toast = Toast::create(AzString::from("m"))

            .with_toast_kind(ToastKind::Danger)

            .with_toast_kind(ToastKind::Success);

        assert_eq!(toast.kind, ToastKind::Success);

        assert_eq!(toast.container_style, build_toast_style(ToastKind::Success));

    }