//! Multi-line text input (text area) widget.

//!

//! A multi-line sibling of [`crate::widgets::text_input::TextInput`], built on

//! the same flow: the container is a `contenteditable` host carrying the tab

//! index and the focus callbacks, so the engine's `TextEditManager` owns the

//! caret, the selection and the buffer, and edits run through

//! `record_text_input` / `apply_text_changeset`. Caret and selection are

//! display-list items driven by that manager; the widget emits no cursor node.

//!

//! Value and placeholder are `<p>` blocks wrapping a bare text node — a

//! [`NodeType::Text`](azul_core::dom::NodeType::Text) node is always

//! inline-level and owns no rect, so box-model properties on one are inert.

//! Line wrapping relies on the text layout honouring `white-space: pre-wrap`.

//!

//! [`TextAreaState`] is a *mirror* of the engine's state, refreshed from its

//! changesets so the public callbacks keep the shape existing hosts bind

//! against. The widget reuses [`TextInput`]'s [`OnTextInputReturn`] /

//! [`TextInputValid`] return types for its `on_text_input` callback so existing

//! host bindings and validation logic apply unchanged; a `TextInputValid::No`

//! answer turns into `CallbackInfo::prevent_default`, which stops the engine

//! from applying the edit it recorded.

//!

//! KNOWN GAP: caret-relative *deletion* (Backspace/Delete) and Enter are engine

//! default actions and the mirror cannot see their result, because the engine

//! exposes no post-apply text for a node whose value sits under a block

//! wrapper. Enter in a contenteditable host records a structural block split

//! rather than inserting a `'\n'` into the buffer, so a multi-paragraph value

//! no longer round-trips through [`TextAreaState::get_text`] as newlines.

//!

//! Key types: [`TextArea`], [`TextAreaState`], [`TextAreaOnTextInput`],

//! [`TextAreaOnVirtualKeyDown`], [`TextAreaOnFocusLost`].

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

use azul_core::{

    callbacks::{CoreCallback, CoreCallbackData, Update},

    dom::{Dom, DomNodeId},

    refany::RefAny,

};

use azul_css::{

    dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec},

    props::{basic::{ColorU, StyleFontFamily, StyleFontFamilyVec, StyleFontSize}, layout::{LayoutPosition, LayoutBoxSizing, LayoutFlexGrow, LayoutMinHeight, LayoutPaddingLeft, LayoutPaddingRight, LayoutPaddingTop, LayoutPaddingBottom, LayoutOverflow, LayoutDisplay, LayoutTop, LayoutLeft}, property::{CssProperty, StyleWhiteSpaceValue}, style::{StyleBackgroundContent, StyleBackgroundContentVec, StyleOpacity, StyleCursor, StyleTextColor, LayoutBorderTopWidth, LayoutBorderBottomWidth, LayoutBorderLeftWidth, LayoutBorderRightWidth, StyleBorderTopStyle, BorderStyle, StyleBorderBottomStyle, StyleBorderLeftStyle, StyleBorderRightStyle, StyleBorderTopColor, StyleBorderBottomColor, StyleBorderLeftColor, StyleBorderRightColor, StyleTextAlign, StyleWhiteSpace}},

    impl_option_inner, AzString, U32Vec, OptionString,

};

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

use crate::widgets::text_input::{OnTextInputReturn, TextInputValid};

// ---- colours ----

const BACKGROUND_COLOR: ColorU = ColorU {

    r: 255,

    g: 255,

    b: 255,

    a: 255,

}; // white

const COLOR_9B9B9B: ColorU = ColorU {

    r: 155,

    g: 155,

    b: 155,

    a: 255,

}; // #9b9b9b border

const COLOR_4286F4: ColorU = ColorU {

    r: 66,

    g: 134,

    b: 244,

    a: 255,

}; // #4286f4 focus/hover

const COLOR_4C4C4C: ColorU = ColorU {

    r: 76,

    g: 76,

    b: 76,

    a: 255,

}; // #4C4C4C text

const BACKGROUND_THEME_LIGHT: &[StyleBackgroundContent] =

    &[StyleBackgroundContent::Color(BACKGROUND_COLOR)];

const BACKGROUND_COLOR_LIGHT: StyleBackgroundContentVec =

    StyleBackgroundContentVec::from_const_slice(BACKGROUND_THEME_LIGHT);

const SANS_SERIF_STR: &str = "system:ui";

const SANS_SERIF: AzString = AzString::from_const_str(SANS_SERIF_STR);

const SANS_SERIF_FAMILIES: &[StyleFontFamily] = &[StyleFontFamily::System(SANS_SERIF)];

const SANS_SERIF_FAMILY: StyleFontFamilyVec =

    StyleFontFamilyVec::from_const_slice(SANS_SERIF_FAMILIES);

/// Minimum height of the editable area (~4 lines).

const MIN_HEIGHT_PX: isize = 64;

// -- container style (cross-platform single style) --

static TEXT_AREA_CONTAINER_PROPS: &[CssPropertyWithConditions] = &[

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

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

    CssPropertyWithConditions::simple(CssProperty::const_box_sizing(LayoutBoxSizing::BorderBox)),

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

    CssPropertyWithConditions::simple(CssProperty::const_min_height(LayoutMinHeight::const_px(

        MIN_HEIGHT_PX,

    ))),

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

    CssPropertyWithConditions::simple(CssProperty::const_background_content(BACKGROUND_COLOR_LIGHT)),

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

        inner: COLOR_4C4C4C,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_padding_left(LayoutPaddingLeft::const_px(

        4,

    ))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_right(

        LayoutPaddingRight::const_px(4),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_padding_top(LayoutPaddingTop::const_px(4))),

    CssPropertyWithConditions::simple(CssProperty::const_padding_bottom(

        LayoutPaddingBottom::const_px(4),

    )),

    // border: 1px inset #9b9b9b

    CssPropertyWithConditions::simple(CssProperty::const_border_top_width(

        LayoutBorderTopWidth::const_px(1),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_width(

        LayoutBorderBottomWidth::const_px(1),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_left_width(

        LayoutBorderLeftWidth::const_px(1),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_right_width(

        LayoutBorderRightWidth::const_px(1),

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_style(StyleBorderTopStyle {

        inner: BorderStyle::Inset,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_style(

        StyleBorderBottomStyle {

            inner: BorderStyle::Inset,

        },

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_left_style(StyleBorderLeftStyle {

        inner: BorderStyle::Inset,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_border_right_style(

        StyleBorderRightStyle {

            inner: BorderStyle::Inset,

        },

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_top_color(StyleBorderTopColor {

        inner: COLOR_9B9B9B,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_border_bottom_color(

        StyleBorderBottomColor {

            inner: COLOR_9B9B9B,

        },

    )),

    CssPropertyWithConditions::simple(CssProperty::const_border_left_color(StyleBorderLeftColor {

        inner: COLOR_9B9B9B,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_border_right_color(

        StyleBorderRightColor {

            inner: COLOR_9B9B9B,

        },

    )),

    CssPropertyWithConditions::simple(CssProperty::const_overflow_x(LayoutOverflow::Hidden)),

    CssPropertyWithConditions::simple(CssProperty::const_overflow_y(LayoutOverflow::Scroll)),

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

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

    // Preserve newlines + wrap long lines.

    CssPropertyWithConditions::simple(CssProperty::WhiteSpace(StyleWhiteSpaceValue::Exact(

        StyleWhiteSpace::PreWrap,

    ))),

    // Hover / focus border highlight.

    CssPropertyWithConditions::on_hover(CssProperty::const_border_top_color(StyleBorderTopColor {

        inner: COLOR_4286F4,

    })),

    CssPropertyWithConditions::on_hover(CssProperty::const_border_bottom_color(

        StyleBorderBottomColor {

            inner: COLOR_4286F4,

        },

    )),

    CssPropertyWithConditions::on_hover(CssProperty::const_border_left_color(StyleBorderLeftColor {

        inner: COLOR_4286F4,

    })),

    CssPropertyWithConditions::on_hover(CssProperty::const_border_right_color(

        StyleBorderRightColor {

            inner: COLOR_4286F4,

        },

    )),

    CssPropertyWithConditions::on_focus(CssProperty::const_border_top_color(StyleBorderTopColor {

        inner: COLOR_4286F4,

    })),

    CssPropertyWithConditions::on_focus(CssProperty::const_border_bottom_color(

        StyleBorderBottomColor {

            inner: COLOR_4286F4,

        },

    )),

    CssPropertyWithConditions::on_focus(CssProperty::const_border_left_color(StyleBorderLeftColor {

        inner: COLOR_4286F4,

    })),

    CssPropertyWithConditions::on_focus(CssProperty::const_border_right_color(

        StyleBorderRightColor {

            inner: COLOR_4286F4,

        },

    )),

];

// -- label style (the `<p>` block wrapping the multi-line value) --

static TEXT_AREA_LABEL_PROPS: &[CssPropertyWithConditions] = &[

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

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

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

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

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

        inner: COLOR_4C4C4C,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

    CssPropertyWithConditions::simple(CssProperty::WhiteSpace(StyleWhiteSpaceValue::Exact(

        StyleWhiteSpace::PreWrap,

    ))),

];

// -- placeholder style --

//

// An absolutely-positioned `<p>` overlay inside the editable container. It is

// marked `contenteditable="false"` so the engine's inheritance walk stops at it

// and the prompt never becomes part of the buffer, and it is toggled with

// `display` as well as `opacity`: a hidden-but-laid-out overlay would still own

// the container's first inline layout, which is what

// `LayoutWindow::reshape_text_node` picks up when it looks for the IFC to write

// an edit into.

static TEXT_AREA_PLACEHOLDER_PROPS: &[CssPropertyWithConditions] = &[

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

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

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

    CssPropertyWithConditions::simple(CssProperty::const_top(LayoutTop::const_px(4))),

    CssPropertyWithConditions::simple(CssProperty::const_left(LayoutLeft::const_px(4))),

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

    CssPropertyWithConditions::simple(CssProperty::const_text_color(StyleTextColor {

        inner: COLOR_9B9B9B,

    })),

    CssPropertyWithConditions::simple(CssProperty::const_font_family(SANS_SERIF_FAMILY)),

    CssPropertyWithConditions::simple(CssProperty::const_opacity(StyleOpacity::const_new(100))),

];

/// Multi-line text input widget.

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

#[repr(C)]

pub struct TextArea {

    pub text_area_state: TextAreaStateWrapper,

    pub placeholder_style: CssPropertyWithConditionsVec,

    pub container_style: CssPropertyWithConditionsVec,

    pub label_style: CssPropertyWithConditionsVec,

}

/// Editable state of a text area (text buffer + cursor position).

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

#[repr(C)]

pub struct TextAreaState {

    /// The text buffer as `Vec<char>` (newlines included).

    pub text: U32Vec,

    pub placeholder: OptionString,

    pub max_len: usize,

    pub cursor_pos: usize,

}

/// [`TextAreaState`] together with optional user callbacks.

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

#[repr(C)]

pub struct TextAreaStateWrapper {

    pub inner: TextAreaState,

    pub on_text_input: OptionTextAreaOnTextInput,

    pub on_focus_lost: OptionTextAreaOnFocusLost,

    pub update_text_area_before_calling_focus_lost_fn: bool,

    // appended at the END of the repr(C) struct for ABI stability

    pub on_virtual_key_down: OptionTextAreaOnVirtualKeyDown,

}

// -- callbacks --

/// Invoked on each text edit. Returns whether the edit is valid (reusing

/// [`TextInput`](crate::widgets::text_input::TextInput)'s [`OnTextInputReturn`]).

pub type TextAreaOnTextInputCallbackType =

    extern "C" fn(RefAny, CallbackInfo, TextAreaState) -> OnTextInputReturn;

impl_widget_callback!(

    TextAreaOnTextInput,

    OptionTextAreaOnTextInput,

    TextAreaOnTextInputCallback,

    TextAreaOnTextInputCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        TextAreaOnTextInputCallback,

    info_ty:        CallbackInfo,

    return_ty:      OnTextInputReturn,

    default_ret:    OnTextInputReturn { update: Update::DoNothing, valid: TextInputValid::Yes },

    invoker_static: TEXT_AREA_ON_TEXT_INPUT_INVOKER,

    invoker_ty:     AzTextAreaOnTextInputCallbackInvoker,

    thunk_fn:       az_text_area_on_text_input_callback_thunk,

    setter_fn:      AzApp_setTextAreaOnTextInputCallbackInvoker,

    from_handle_fn: AzTextAreaOnTextInputCallback_createFromHostHandle,

    extra_args:     [ state: TextAreaState ],

}

/// Invoked on every virtual-key press while the text area is focused (reusing

/// [`TextInput`](crate::widgets::text_input::TextInput)'s [`OnTextInputReturn`]).

pub type TextAreaOnVirtualKeyDownCallbackType =

    extern "C" fn(RefAny, CallbackInfo, TextAreaState) -> OnTextInputReturn;

impl_widget_callback!(

    TextAreaOnVirtualKeyDown,

    OptionTextAreaOnVirtualKeyDown,

    TextAreaOnVirtualKeyDownCallback,

    TextAreaOnVirtualKeyDownCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        TextAreaOnVirtualKeyDownCallback,

    info_ty:        CallbackInfo,

    return_ty:      OnTextInputReturn,

    default_ret:    OnTextInputReturn { update: Update::DoNothing, valid: TextInputValid::Yes },

    invoker_static: TEXT_AREA_ON_VIRTUAL_KEY_DOWN_INVOKER,

    invoker_ty:     AzTextAreaOnVirtualKeyDownCallbackInvoker,

    thunk_fn:       az_text_area_on_virtual_key_down_callback_thunk,

    setter_fn:      AzApp_setTextAreaOnVirtualKeyDownCallbackInvoker,

    from_handle_fn: AzTextAreaOnVirtualKeyDownCallback_createFromHostHandle,

    extra_args:     [ state: TextAreaState ],

}

/// Invoked when the text area loses focus.

pub type TextAreaOnFocusLostCallbackType =

    extern "C" fn(RefAny, CallbackInfo, TextAreaState) -> Update;

impl_widget_callback!(

    TextAreaOnFocusLost,

    OptionTextAreaOnFocusLost,

    TextAreaOnFocusLostCallback,

    TextAreaOnFocusLostCallbackType

);

azul_core::impl_managed_callback! {

    wrapper:        TextAreaOnFocusLostCallback,

    info_ty:        CallbackInfo,

    return_ty:      Update,

    default_ret:    Update::DoNothing,

    invoker_static: TEXT_AREA_ON_FOCUS_LOST_INVOKER,

    invoker_ty:     AzTextAreaOnFocusLostCallbackInvoker,

    thunk_fn:       az_text_area_on_focus_lost_callback_thunk,

    setter_fn:      AzApp_setTextAreaOnFocusLostCallbackInvoker,

    from_handle_fn: AzTextAreaOnFocusLostCallback_createFromHostHandle,

    extra_args:     [ state: TextAreaState ],

}

impl Default for TextAreaState {

}

impl TextAreaState {

    /// Reconstructs the (multi-line) string, including `'\n'` characters.

}

impl Default for TextAreaStateWrapper {

}

impl Default for TextArea {

}

impl TextArea {

    /// Sets the (multi-line) text. Newlines in `text` are preserved.

    #[allow(clippy::needless_pass_by_value)] // public by-value setter; builder with_text moves the arg in

    /// Renders the widget.

    ///

    /// The container is the `contenteditable` host — the flag, the tab index and

    /// the focus callbacks all sit on it, because focus events do not bubble and

    /// the engine records an edit against the *focused* node. Its two children

    /// are `<p>` blocks wrapping a bare text node each; nothing else is emitted,

    /// in particular no caret node.

        use azul_core::dom::{AttributeType, DomVec, EventFilter, FocusEventFilter, IdOrClass::Class, TabIndex};

                ]

            )

                        )

                        // appended, never `with_attributes`: that one replaces the

                        // whole vector, classes included

                        )

                ]

            )

}

/// `style` with the placeholder taken out of the flow: `display: none` on top

/// of `opacity: 0`, so a hidden prompt owns neither pixels nor an inline layout.

    )));

    )));

/// The placeholder `<p>` and the value `<p>`, in that order.

///

/// Both handlers and tests resolve them through the same hierarchy hops the

/// container's own layout guarantees; a subtree of any other shape yields

/// `None` and every handler bails out.

/// Shows or hides the placeholder prompt.

    } else {

    };

/// Adopts the engine's text for `node` into the widget's mirror.

///

/// The engine owns the buffer, so its answer wins — except that an empty answer

/// is ambiguous: `get_text_before_textinput` also yields nothing for a node

/// whose text sits under a block wrapper it does not descend into. An empty

/// read therefore never clears a non-empty mirror.

    };

/// Mirrors the insertion the engine is about to apply.

///

/// The engine inserts at the caret, so the mirror does too whenever the caret

/// is readable and lands on a character boundary; otherwise it appends, which

/// is where the caret sits for every append-only path. `cursor_pos` stays a

/// byte offset, as it has always been.

/// The caret's byte offset inside the edited node, if the engine has one.

    };

    };

    // hide the placeholder text

    // The engine seeds the caret at the end of the value when focus lands on a

    // contenteditable host; the mirror follows it.

    };

    };

    // show the placeholder text

    }

    // The engine records the edit before the callbacks run and applies it after

    // them; this handler only observes it and mirrors it into the widget state.

    // An `Input` WITHOUT a pending record is a post-edit NOTIFICATION: an edit

    // committed outside the record pipeline (deletion, the Enter line break,

    // programmatic edit) that is already applied — adopt it and inform the

    // user hook; `valid` cannot veto what already happened.

        // Idempotent: a notification that changed nothing observable stays a

        // strict no-op, so the no-changeset pins keep holding.

                }

            }

        };

        // inner_clone has the new (would-be) text

            }

        }

    };

    // Editing keys (Backspace, Delete, the arrows, Enter) are the engine's

    // default actions; this handler only forwards the key to the user's hook

    // and lets a rejection stop the default from running.

        // rustc doesn't understand the borrowing lifetime here

            }

        }

    };

impl From<TextArea> for Dom {

}

#[cfg(test)]

// `redundant_closure`: NOT redundant here. `run()` takes

// `impl FnOnce(RefAny, CallbackInfo) -> R`; `CallbackInfo` carries an elided

// lifetime, so the bound is higher-ranked (`for<'a> FnOnce(_, CallbackInfo<'a>)`).

// The handlers are `extern "C" fn` items, which do NOT satisfy a higher-ranked

// `FnOnce` bound — passing one bare fails to compile with E0277. The `|r, ci| f(r, ci)`

// wrapper is what makes the coercion happen and must stay.

#[allow(clippy::redundant_closure)]

mod autotest_generated {

    use std::{

        collections::{BTreeMap, HashMap},

        sync::{Arc, Mutex},

    };

    use azul_core::{

        dom::{

            AttributeType, DomId, DomNodeId, EventFilter, FocusEventFilter, NodeId, NodeType,

            TabIndex,

        },

        geom::{LogicalRect, OptionLogicalPosition},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        refany::OptionRefAny,

        resources::RendererResources,

        styled_dom::{NodeHierarchyItemId, StyledDom},

        window::{MonitorVec, RawWindowHandle, VirtualKeyCode},

    };

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

        managers::text_input::PendingTextEdit,

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

        window::{DomLayoutResult, LayoutWindow},

        window_state::FullWindowState,

    };

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

    // Sample data

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

    /// Strings the buffer must round-trip verbatim through `set_text` ->

    /// `get_text`. Every entry is a valid Rust `str`, so none of them can be

    /// lost to the `char::from_u32` filter in `get_text` — anything that does

    /// not come back is real damage, not an encoding limit.

    const ROUND_TRIP: [&str; 22] = [

        "",

        " ",

        "a",

        "hello",

        "\n",

        "\n\n\n",

        "a\nb",

        "a\r\nb",           // CRLF: *both* units have to survive

        "trailing\n",

        "\nleading",

        "\t\ttabbed",

        "\0",               // NUL is a perfectly good `char`

        "line1\nline2\nline3",

        "ünïcödé",

        "e\u{301}",         // combining acute: 2 chars, 1 grapheme

        "😀",               // astral plane: 1 char, 4 bytes

        "👩‍👩‍👧‍👦",     // ZWJ family: 7 chars, 25 bytes

        "🇩🇪",              // regional-indicator pair

        "مرحبا",            // RTL

        "日本語",

        "a\u{200b}b",       // zero-width space wedged between two letters

        "\u{10FFFF}",       // the largest scalar value there is

    ];

    /// `u32` values that are *not* Unicode scalar values. The buffer is a

    /// `U32Vec`, not a `String`, so it can hold them — `get_text` has to drop

    /// them rather than panic.

    const NON_SCALAR: [u32; 6] = [

        0xD800,      // lone high surrogate

        0xDBFF,

        0xDC00,      // lone low surrogate

        0xDFFF,

        0x0011_0000, // one past the last scalar value

        u32::MAX,

    ];

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

    // Fixtures

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

    /// A state buffer built from a `&str` exactly the way `set_text` builds it.

    fn buffer(text: &str) -> U32Vec {

        text.chars().map(|c| c as u32).collect::<Vec<_>>().into()

    }

    /// A `TextAreaStateWrapper` with no user hooks, holding `text`.

    fn wrapper(text: &str) -> TextAreaStateWrapper {

        TextAreaStateWrapper {

            inner: TextAreaState {

                text: buffer(text),

                ..TextAreaState::default()

            },

            ..TextAreaStateWrapper::default()

        }

    }

    /// The state currently stored behind a `TextAreaStateWrapper` payload.

    fn read(state: &RefAny) -> TextAreaState {

        let mut handle = state.clone();

        let w = handle

            .downcast_ref::<TextAreaStateWrapper>()

            .expect("the payload must still be a TextAreaStateWrapper");

        w.inner.clone()

    }

    /// Mutates the shared state behind a payload (the borrow is released before

    /// this returns, so a handler may be invoked right afterwards).

    fn poke(state: &RefAny, f: impl FnOnce(&mut TextAreaStateWrapper)) {

        let mut handle = state.clone();

        let mut w = handle

            .downcast_mut::<TextAreaStateWrapper>()

            .expect("the payload must still be a TextAreaStateWrapper");

        f(&mut w);

    }

    /// `n` properties lifted off the default container style — an easy way to

    /// mint pairwise-distinct style vectors without hard-coding CSS.

    fn style(n: usize) -> CssPropertyWithConditionsVec {

        let all: Vec<CssPropertyWithConditions> =

            TextArea::default().container_style.as_ref().to_vec();

        assert!(n <= all.len(), "not enough default properties to slice");

        CssPropertyWithConditionsVec::from_vec(all.into_iter().take(n).collect())

    }

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

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

        }

    }

    // ---- recording hooks -------------------------------------------------

    //

    // NOTE: each hook below has a deliberately *different* body. Identical

    // function bodies can be folded onto a single symbol by the linker, and

    // these callbacks are compared by function-pointer identity.

    /// Records every `TextAreaState` an `on_text_input` / `on_virtual_key_down`

    /// hook is handed, and answers with a fixed verdict.

    struct EditLog {

        seen: Vec<TextAreaState>,

        ret: OnTextInputReturn,

    }

    /// Records every `TextAreaState` an `on_focus_lost` hook is handed.

    struct FocusLog {

        seen: Vec<TextAreaState>,

        ret: Update,

    }

    extern "C" fn record_text_input(

        mut data: RefAny,

        _: CallbackInfo,

        state: TextAreaState,

    ) -> OnTextInputReturn {

        let Some(mut log) = data.downcast_mut::<EditLog>() else {

            return OnTextInputReturn {

                update: Update::DoNothing,

                valid: TextInputValid::Yes,

            };

        };

        log.seen.push(state);

        log.ret

    }

    extern "C" fn record_virtual_key(

        mut data: RefAny,

        _: CallbackInfo,

        state: TextAreaState,

    ) -> OnTextInputReturn {

        match data.downcast_mut::<EditLog>() {

            Some(mut log) => {

                log.seen.push(state.clone());

                log.ret

            }

            None => OnTextInputReturn {

                update: Update::RefreshDom,

                valid: TextInputValid::Yes,

            },

        }

    }

    extern "C" fn record_focus_lost(

        mut data: RefAny,

        _: CallbackInfo,

        state: TextAreaState,

    ) -> Update {

        let mut update = Update::DoNothing;

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

            log.seen.push(state);

            update = log.ret;

        }

        update

    }

    fn edit_log(ret: OnTextInputReturn) -> RefAny {

        RefAny::new(EditLog {

            seen: Vec::new(),

            ret,

        })

    }

    fn focus_log(ret: Update) -> RefAny {

        RefAny::new(FocusLog {

            seen: Vec::new(),

            ret,

        })

    }

    fn edits_seen(log: &RefAny) -> Vec<TextAreaState> {

        let mut handle = log.clone();

        let l = handle

            .downcast_ref::<EditLog>()

            .expect("the payload must still be an EditLog");

        l.seen.clone()

    }

    fn focus_seen(log: &RefAny) -> Vec<TextAreaState> {

        let mut handle = log.clone();

        let l = handle

            .downcast_ref::<FocusLog>()

            .expect("the payload must still be a FocusLog");

        l.seen.clone()

    }

    const ACCEPT: OnTextInputReturn = OnTextInputReturn {

        update: Update::RefreshDom,

        valid: TextInputValid::Yes,

    };

    const REJECT: OnTextInputReturn = OnTextInputReturn {

        update: Update::RefreshDomAllWindows,

        valid: TextInputValid::No,

    };

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

    // CallbackInfo harness

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

    /// Flattened node indices of a `TextArea::dom()`.

    #[derive(Copy, Clone, Debug)]

    struct Nodes {

        container: usize,

        placeholder: usize,

        label: usize,

        label_text: usize,

    }

    /// Which node the event hit.

    #[derive(Copy, Clone, Debug)]

    enum Hit {

        /// `NodeHierarchyItemId::NONE` — no node was hit at all.

        Nothing,

        Container,

        Placeholder,

        /// The value's bare text leaf: it has no children, so every handler

        /// must bail out.

        TextLeaf,

    }

    /// Flattened indices of every node carrying `class`, in tree order.

    fn nodes_with_class(styled: &StyledDom, class: &str) -> Vec<usize> {

        styled

            .node_data

            .as_ref()

            .iter()

            .enumerate()

            .filter(|(_, nd)| nd.has_class(class))

            .map(|(i, _)| i)

            .collect()

    }

    /// A styled, but never laid out, `TextArea::dom()` — the handlers only walk

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

    /// The DOM here is a pure *navigation skeleton*: the state a handler edits

    /// is always the `RefAny` passed to it, never this DOM's own dataset.

    fn skeleton() -> (StyledDom, Nodes) {

        let styled = StyledDom::create_from_dom(TextArea::create().dom());

        fn one(styled: &StyledDom, class: &str) -> usize {

            let found = nodes_with_class(styled, class);

            assert_eq!(found.len(), 1, "expected exactly one `{class}` node");

            found[0]

        }

        let label = one(&styled, "__azul-native-text-area-label");

        let nodes = Nodes {

            container: one(&styled, "__azul-native-text-area-container"),

            placeholder: one(&styled, "__azul-native-text-area-placeholder"),

            label,

            label_text: first_child(&styled, label),

        };

        (styled, nodes)

    }

    /// The flattened index of `node`'s first child.

    fn first_child(styled: &StyledDom, node: usize) -> usize {

        styled

            .node_hierarchy

            .as_ref()

            .get(node)

            .and_then(|item| item.first_child_id(NodeId::new(node)))

            .expect("expected a child node")

            .index()

    }

    fn dom_node(idx: usize) -> DomNodeId {

        DomNodeId {

            dom: DomId::ROOT_ID,

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

        }

    }

    /// A `DomLayoutResult` with an empty layout tree and no display list.

    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(),

        }

    }

    /// Everything the handlers read out of the window.

    struct Env {

        /// `false` installs a `LayoutWindow` with no layout result at all — the

        /// "callback fired before the first layout" case.

        with_dom: bool,

        changeset: Option<PendingTextEdit>,

        keycode: Option<VirtualKeyCode>,

        hit: Hit,

    }

    impl Default for Env {

        fn default() -> Self {

            Self {

                with_dom: true,

                changeset: None,

                keycode: None,

                hit: Hit::Container,

            }

        }

    }

    impl Env {

        fn typed(text: &str) -> Self {

            Self {

                changeset: Some(PendingTextEdit {

                    node: dom_node(0),

                    inserted_text: AzString::from(text),

                    old_text: AzString::from(""),

                }),

                ..Self::default()

            }

        }

        fn key(code: VirtualKeyCode) -> Self {

            Self {

                keycode: Some(code),

                ..Self::default()

            }

        }

        fn hitting(mut self, hit: Hit) -> Self {

            self.hit = hit;

            self

        }

    }

    /// Invokes `call` against a `LayoutWindow` built from `env`. Returns the

    /// handler's value, every recorded `CallbackChange`, and the node indices.

    fn run<R>(

        env: Env,

        data: &RefAny,

        call: impl FnOnce(RefAny, CallbackInfo) -> R,

    ) -> (R, Vec<CallbackChange>, Nodes) {

        let (styled, nodes) = skeleton();

        let mut layout_window =

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

        if env.with_dom {

            layout_window

                .layout_results

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

        }

        if let Some(changeset) = env.changeset {

            layout_window.text_input_manager.set_changeset(changeset);

        }

        let renderer_resources = RendererResources::default();

        let previous_window_state: Option<FullWindowState> = None;

        let mut current_window_state = FullWindowState::default();

        current_window_state.keyboard_state.current_virtual_keycode = env.keycode.into();

        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(azul_css::system::SystemStyle::default()),

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

            #[cfg(feature = "icu")]

            icu_localizer: IcuLocalizerHandle::default(),

            ctx: OptionRefAny::None,

        };

        let hit = match env.hit {

            Hit::Nothing => DomNodeId {

                dom: DomId::ROOT_ID,

                node: NodeHierarchyItemId::NONE,

            },

            Hit::Container => dom_node(nodes.container),

            Hit::Placeholder => dom_node(nodes.placeholder),

            Hit::TextLeaf => dom_node(nodes.label_text),

        };

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

        let info = CallbackInfo::new(

            &ref_data,

            &changes,

            hit,

            OptionLogicalPosition::None,

            OptionLogicalPosition::None,

        );

        let out = call(data.clone(), info);