//! Thread callback information and utilities for azul-layout

//!

//! This module provides thread-related callback structures for background tasks

//! that need to interact with the UI thread and query layout information.

#[cfg(feature = "std")]

use alloc::sync::Arc;

#[cfg(feature = "std")]

use std::sync::{

    mpsc::{channel, Receiver, Sender},

    Mutex,

};

#[cfg(feature = "std")]

use std::thread::{self, JoinHandle};

use azul_core::{

    callbacks::Update,

    refany::{OptionRefAny, RefAny},

    task::{

        CheckThreadFinishedCallback, CheckThreadFinishedCallbackType, LibrarySendThreadMsgCallback,

        LibrarySendThreadMsgCallbackType, OptionThreadSendMsg, ThreadId, ThreadReceiver,

        ThreadReceiverDestructorCallback, ThreadReceiverInner, ThreadRecvCallback, ThreadSendMsg,

    },

};

use crate::callbacks::CallbackInfo;

macro_rules! impl_callback_traits {

    ($name:ident) => {

        impl core::fmt::Debug for $name {

        }

        // generated for both Copy and non-Copy callback structs; the explicit field

        // copy works uniformly (a derive can't be emitted for an externally-defined struct).

        #[allow(clippy::expl_impl_clone_on_copy, clippy::non_canonical_clone_impl)]

        impl Clone for $name {

        }

        impl PartialEq for $name {

        }

        impl Eq for $name {}

        impl PartialOrd for $name {

        }

        impl Ord for $name {

        }

        impl core::hash::Hash for $name {

        }

    };

}

// Types that need to be defined locally (not in azul-core)

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

/// Message that is sent back from the running thread to the main thread

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

#[repr(C, u8)]

pub enum ThreadReceiveMsg {

    WriteBack(ThreadWriteBackMsg),

    Update(Update),

}

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

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

#[repr(C, u8)]

pub enum OptionThreadReceiveMsg {

    None,

    Some(ThreadReceiveMsg),

}

impl From<Option<ThreadReceiveMsg>> for OptionThreadReceiveMsg {

}

impl OptionThreadReceiveMsg {

        }

        }

}

/// Message containing writeback data and callback

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

#[repr(C)]

pub struct ThreadWriteBackMsg {

    pub refany: RefAny,

    pub callback: WriteBackCallback,

}

impl ThreadWriteBackMsg {

}

/// `ThreadSender` allows sending messages from the background thread to the main thread

#[derive(Debug)]

#[repr(C)]

pub struct ThreadSender {

    #[cfg(feature = "std")]

    pub ptr: Box<Arc<Mutex<ThreadSenderInner>>>,

    #[cfg(not(feature = "std"))]

    pub ptr: *const core::ffi::c_void,

    pub run_destructor: bool,

    /// For FFI: stores the foreign callable (e.g., `PyFunction`)

    pub ctx: OptionRefAny,

}

impl Clone for ThreadSender {

}

impl Drop for ThreadSender {

}

impl ThreadSender {

    #[cfg(not(feature = "std"))]

    pub fn new(_t: ThreadSenderInner) -> Self {

        Self {

            ptr: core::ptr::null(),

            run_destructor: false,

            ctx: OptionRefAny::None,

        }

    }

    #[cfg(feature = "std")]

    /// Get the FFI context (e.g., Python callable)

    #[cfg(not(feature = "std"))]

    pub fn send(&mut self, _msg: ThreadReceiveMsg) -> bool {

        false

    }

    #[cfg(feature = "std")]

        };

}

/// Inner state of a `ThreadSender`, holding the channel sender and associated callbacks

#[derive(Debug)]

#[cfg_attr(not(feature = "std"), derive(PartialEq, PartialOrd, Eq, Ord))]

#[repr(C)]

pub struct ThreadSenderInner {

    #[cfg(feature = "std")]

    pub ptr: Box<Sender<ThreadReceiveMsg>>,

    #[cfg(not(feature = "std"))]

    pub ptr: *const core::ffi::c_void,

    pub send_fn: ThreadSendCallback,

    pub destructor: ThreadSenderDestructorCallback,

}

#[cfg(not(feature = "std"))]

unsafe impl Send for ThreadSenderInner {}

#[cfg(feature = "std")]

impl core::hash::Hash for ThreadSenderInner {

}

#[cfg(feature = "std")]

impl PartialEq for ThreadSenderInner {

}

#[cfg(feature = "std")]

impl Eq for ThreadSenderInner {}

#[cfg(feature = "std")]

impl PartialOrd for ThreadSenderInner {

}

#[cfg(feature = "std")]

impl Ord for ThreadSenderInner {

}

impl Drop for ThreadSenderInner {

}

/// Callback for sending messages from thread to main thread

pub type ThreadSendCallbackType = extern "C" fn(*const core::ffi::c_void, ThreadReceiveMsg) -> bool;

#[allow(missing_copy_implementations)] // C-ABI fn-ptr wrapper; Clone is macro-generated (impl_callback_traits!), so Copy would trip expl_impl_clone_on_copy

#[repr(C)]

pub struct ThreadSendCallback {

    pub cb: ThreadSendCallbackType,

}

impl_callback_traits!(ThreadSendCallback);

/// Destructor callback for `ThreadSender`

pub type ThreadSenderDestructorCallbackType = extern "C" fn(*mut ThreadSenderInner);

#[allow(missing_copy_implementations)] // C-ABI fn-ptr wrapper; Clone is macro-generated (impl_callback_traits!), so Copy would trip expl_impl_clone_on_copy

#[repr(C)]

pub struct ThreadSenderDestructorCallback {

    pub cb: ThreadSenderDestructorCallbackType,

}

impl_callback_traits!(ThreadSenderDestructorCallback);

/// Callback that runs when a thread receives a `WriteBack` message

///

/// This callback runs on the main UI thread and has access to:

/// - The thread's original data

/// - Data sent back from the background thread

/// - Full `CallbackInfo` for DOM queries and UI updates

pub type WriteBackCallbackType = extern "C" fn(

    /* original thread data */ RefAny,

    /* data to write back */ RefAny,

    /* callback info */ CallbackInfo,

) -> Update;

/// Callback that can run when a thread receives a `WriteBack` message

#[repr(C)]

pub struct WriteBackCallback {

    pub cb: WriteBackCallbackType,

    /// For FFI: stores the foreign callable (e.g., `PyFunction`)

    /// Native Rust code sets this to None

    pub ctx: OptionRefAny,

}

impl WriteBackCallback {

    /// Create a new `WriteBackCallback`

    /// Invoke the callback

}

impl core::fmt::Debug for WriteBackCallback {

}

impl Clone for WriteBackCallback {

}

impl From<WriteBackCallbackType> for WriteBackCallback {

}

impl PartialEq for WriteBackCallback {

}

impl Eq for WriteBackCallback {}

impl PartialOrd for WriteBackCallback {

}

impl Ord for WriteBackCallback {

}

impl core::hash::Hash for WriteBackCallback {

}

/// Callback type for the function that runs in the background thread

pub type ThreadCallbackType = extern "C" fn(RefAny, ThreadSender, ThreadReceiver);

#[repr(C)]

pub struct ThreadCallback {

    pub cb: ThreadCallbackType,

    /// For FFI: stores the foreign callable (e.g., `PyFunction`)

    /// Native Rust code sets this to None

    pub ctx: OptionRefAny,

}

impl ThreadCallback {

    /// Create a new `ThreadCallback`

}

impl core::fmt::Debug for ThreadCallback {

}

impl Clone for ThreadCallback {

}

impl From<ThreadCallbackType> for ThreadCallback {

}

impl PartialEq for ThreadCallback {

}

impl Eq for ThreadCallback {}

impl PartialOrd for ThreadCallback {

}

impl Ord for ThreadCallback {

}

impl core::hash::Hash for ThreadCallback {

}

// Host-invoker plumbing for ThreadCallback. NOTE: this callback fires

// on a worker thread (spawned by `Thread::create`), not the main

// `App.run` thread. The per-language host-invoker thunk MUST acquire

// the host VM lock before dispatching to user code:

//   * CPython: PyGILState_Ensure / _Release

//   * MRI Ruby: rb_thread_call_with_gvl

//   * OpenJDK: AttachCurrentThread / DetachCurrentThread

//   * CLR / .NET: nothing ([UnmanagedCallersOnly] auto-trampolines)

//   * OCaml: caml_acquire_runtime_system / _release

//   * Lua / Perl / PHP / Pharo: cannot be called from worker thread

//     (single-threaded interpreter) — fall back to writeback-only

//     pattern (Rust extern "C" cb on worker, host fn on main via

//     WriteBackCallback).

// See `scripts/BINDING_STRATEGY_PER_LANGUAGE.md` for the lock-acquire

// table per VM.

azul_core::impl_managed_callback! {

    wrapper:        ThreadCallback,

    info_ty:        ThreadSender,

    return_ty:      (),

    // unit default-return; written via Default::default() so clippy's unused_unit

    // doesn't fire on a bare `()` in this macro-argument position.

    default_ret:    Default::default(),

    invoker_static: THREAD_CALLBACK_INVOKER,

    invoker_ty:     AzThreadCallbackInvoker,

    thunk_fn:       az_thread_callback_thunk,

    setter_fn:      AzApp_setThreadCallbackInvoker,

    from_handle_fn: AzThreadCallback_createFromHostHandle,

    extra_args:     [receiver: ThreadReceiver],

}

/// Callback type for receiving messages from a background thread

pub type LibraryReceiveThreadMsgCallbackType =

    extern "C" fn(*const core::ffi::c_void) -> OptionThreadReceiveMsg;

#[allow(missing_copy_implementations)] // C-ABI fn-ptr wrapper; Clone is macro-generated (impl_callback_traits!), so Copy would trip expl_impl_clone_on_copy

#[repr(C)]

pub struct LibraryReceiveThreadMsgCallback {

    pub cb: LibraryReceiveThreadMsgCallbackType,

}

impl_callback_traits!(LibraryReceiveThreadMsgCallback);

/// Callback type for the destructor that cleans up a `ThreadInner`

pub type ThreadDestructorCallbackType = extern "C" fn(*mut ThreadInner);

#[allow(missing_copy_implementations)] // C-ABI fn-ptr wrapper; Clone is macro-generated (impl_callback_traits!), so Copy would trip expl_impl_clone_on_copy

#[repr(C)]

pub struct ThreadDestructorCallback {

    pub cb: ThreadDestructorCallbackType,

}

impl_callback_traits!(ThreadDestructorCallback);

/// Wrapper around Thread because Thread needs to be clone-able

#[derive(Debug)]

#[repr(C)]

pub struct Thread {

    #[cfg(feature = "std")]

    pub ptr: Box<Arc<Mutex<ThreadInner>>>,

    #[cfg(not(feature = "std"))]

    pub ptr: *const core::ffi::c_void,

    pub run_destructor: bool,

}

impl Clone for Thread {

}

impl Drop for Thread {

}

impl Thread {

    #[cfg(feature = "std")]

    #[cfg(not(feature = "std"))]

    pub fn new(_ti: ThreadInner) -> Self {

        Self {

            ptr: core::ptr::null(),

            run_destructor: false,

        }

    }

    /// Creates a new thread that will execute the given callback function.

    ///

    /// # Arguments

    /// * `thread_initialize_data` - Data passed to the callback when the thread starts

    /// * `writeback_data` - Data that will be passed back when writeback messages are received

    /// * `callback` - The callback to execute in the background thread

    ///

    /// # Returns

    /// A new Thread handle that can be added to the event loop with `CallbackInfo::add_thread`

    /// Send a control message to the running worker. Interior-mutable (the worker

    /// state is behind a `Mutex`), so this takes `&self` and is callable from a

    /// callback that only holds `&Thread` via `CallbackInfo::get_thread`. Used to push

    /// resize / seek / source-change messages to a persistent worker. Returns false

    /// if the channel is closed (or always, on `no_std`).

    #[cfg(feature = "std")]

    #[cfg(not(feature = "std"))]

    pub fn send_message(&self, _msg: ThreadSendMsg) -> bool {

        false

    }

    /// Clone the main→worker `Sender` so a holder without a `CallbackInfo` (e.g. a

    /// dataset-merge callback) can message the running worker later — used for the

    /// scrub/seek path, where the merge callback compares the old/new `VideoConfig`

    /// and pushes a seek to the worker. `None` on `no_std`.

    #[cfg(feature = "std")]

    #[cfg(not(feature = "std"))]

    pub fn clone_sender(&self) -> Option<Sender<ThreadSendMsg>> {

        None

    }

}

/// A `Thread` is a separate thread that is owned by the framework.

///

/// In difference to a regular thread, you don't have to `await()` the result,

/// you can just hand the Thread to the framework and it will automatically

/// update the UI when the Thread is finished.

#[derive(Debug)]

#[repr(C)]

pub struct ThreadInner {

    #[cfg(feature = "std")]

    pub thread_handle: Box<Option<JoinHandle<()>>>,

    #[cfg(not(feature = "std"))]

    pub thread_handle: *const core::ffi::c_void,

    #[cfg(feature = "std")]

    pub sender: Box<Sender<ThreadSendMsg>>,

    #[cfg(not(feature = "std"))]

    pub sender: *const core::ffi::c_void,

    #[cfg(feature = "std")]

    pub receiver: Box<Receiver<ThreadReceiveMsg>>,

    #[cfg(not(feature = "std"))]

    pub receiver: *const core::ffi::c_void,

    #[cfg(feature = "std")]

    pub dropcheck: Box<alloc::sync::Weak<()>>,

    #[cfg(not(feature = "std"))]

    pub dropcheck: *const core::ffi::c_void,

    pub writeback_data: RefAny,

    pub check_thread_finished_fn: CheckThreadFinishedCallback,

    pub send_thread_msg_fn: LibrarySendThreadMsgCallback,

    pub receive_thread_msg_fn: LibraryReceiveThreadMsgCallback,

    pub thread_destructor_fn: ThreadDestructorCallback,

}

#[cfg(feature = "std")]

impl ThreadInner {

    /// Returns true if the Thread has been finished, false otherwise

    /// Send a message to the thread

    /// Try to receive a message from the thread (non-blocking)

}

#[cfg(not(feature = "std"))]

impl ThreadInner {

    /// Returns true if the Thread has been finished, false otherwise

    pub fn is_finished(&self) -> bool {

        true

    }

    /// Send a message to the thread (no-op in no_std)

    pub fn sender_send(&mut self, _msg: ThreadSendMsg) -> bool {

        false

    }

    /// Try to receive a message from the thread (always returns None in no_std)

    pub fn receiver_try_recv(&mut self) -> OptionThreadReceiveMsg {

        None.into()

    }

}

impl Drop for ThreadInner {

}

/// How long `default_thread_destructor_fn` waits for a worker to acknowledge

/// `TerminateThread` before detaching it: 200 steps x 10ms = 2s.

///

/// Module scope rather than inside the function because clippy's

/// `items_after_statements` is denied here — an item declared mid-body reads as

/// if it were scoped to that point when it is not.

#[cfg(feature = "std")]

const THREAD_TERMINATE_GRACE_STEPS: u32 = 200;

// Default callback implementations for std

#[cfg(feature = "std")]

        // BOUNDED wait, then DETACH. This was an unconditional

        // `thread_handle.join()`, which hangs forever whenever the worker does

        // not observe `TerminateThread` — and a worker blocked in a device read

        // (v4l2, ALSA) or on a different channel never does.

        //

        // Measured on the published 0.2.0 azul-self-test-linux: after the

        // window closed and the Wayland display was disconnected, the main

        // thread sat in `pthread_join` on an unnamed worker while 22 other

        // threads idled. `App::run()` never returned, so the process never

        // reached `std::process::exit()` in main and had to be killed. The demo

        // advertises "exits on its own (~4s)".

        //

        // `dropcheck` already tells us what we need: the worker holds an Arc

        // whose Weak lives here, so `strong_count() == 0` means it has actually

        // finished and the join will return immediately. If it has not finished

        // within the grace period we DROP the handle instead, which detaches the

        // thread. A detached thread cannot block `process::exit`, and shutting

        // down is precisely when refusing to wait is correct: the alternative on

        // display is a hang, which users read as a crash.

        //

        // Spin on a sleep rather than `Instant`: this file is compiled for wasm

        // and the clockless targets, where the strict `Instant` gate is 0.

#[cfg(not(feature = "std"))]

extern "C" fn default_thread_destructor_fn(_thread: *mut ThreadInner) {}

#[cfg(feature = "std")]

#[cfg(not(feature = "std"))]

extern "C" fn library_send_thread_msg_fn(

    _sender: *const core::ffi::c_void,

    _msg: ThreadSendMsg,

) -> bool {

    false

}

#[cfg(feature = "std")]

#[cfg(not(feature = "std"))]

extern "C" fn library_receive_thread_msg_fn(

    _receiver: *const core::ffi::c_void,

) -> OptionThreadReceiveMsg {

    None.into()

}

#[cfg(feature = "std")]

#[cfg(not(feature = "std"))]

extern "C" fn default_send_thread_msg_fn(

    _sender: *const core::ffi::c_void,

    _msg: ThreadReceiveMsg,

) -> bool {

    false

}

#[cfg(feature = "std")]

#[cfg(not(feature = "std"))]

extern "C" fn default_receive_thread_msg_fn(

    _receiver: *const core::ffi::c_void,

) -> OptionThreadSendMsg {

    None.into()

}

#[cfg(feature = "std")]

#[cfg(not(feature = "std"))]

extern "C" fn default_check_thread_finished(_dropcheck: *const core::ffi::c_void) -> bool {

    true

}

#[cfg(feature = "std")]

#[cfg(not(feature = "std"))]

extern "C" fn thread_sender_drop(_: *mut ThreadSenderInner) {}

#[cfg(feature = "std")]

#[cfg(not(feature = "std"))]

extern "C" fn thread_receiver_drop(_: *mut ThreadReceiverInner) {}

/// Function that creates a new Thread object

pub type CreateThreadCallbackType = extern "C" fn(RefAny, RefAny, ThreadCallback) -> Thread;

#[repr(C)]

pub struct CreateThreadCallback {

    pub cb: CreateThreadCallbackType,

}

impl_callback_traits!(CreateThreadCallback);

impl Copy for CreateThreadCallback {}

/// Create a new thread using the standard library

#[cfg(feature = "std")]

    // Set the ctx from the callback for FFI

    // Set the ctx from the callback for FFI

        // Keep thread_check alive for the entire duration of the thread

        // by binding it to a named variable (not `_` which drops immediately)

        // _thread_check_guard gets dropped here, signals that the thread has finished

#[cfg(not(feature = "std"))]

pub extern "C" fn create_thread_libstd(

    _thread_initialize_data: RefAny,

    _writeback_data: RefAny,

    _callback: ThreadCallback,

) -> Thread {

    Thread {

        ptr: core::ptr::null(),

        run_destructor: false,

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    #[test]

}

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

/// Optional Thread type for API compatibility

#[derive(Debug, Clone)]

#[repr(C, u8)]

pub enum OptionThread {

    None,

    Some(Thread),

}

impl From<Option<Thread>> for OptionThread {

}

impl OptionThread {

        }

}

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

// Sleep utilities

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

/// Sleeps the current thread for the specified number of milliseconds.

///

/// This is a cross-platform utility that can be called from C/C++/Python.

///

/// # Arguments

/// * `milliseconds` - Number of milliseconds to sleep

#[cfg(feature = "std")]

/// Sleeps the current thread for the specified number of milliseconds (no-op on no_std).

#[cfg(not(feature = "std"))]

pub fn thread_sleep_ms(_milliseconds: u64) -> azul_css::corety::EmptyStruct {

    // No-op on no_std - can't sleep without OS

    azul_css::corety::EmptyStruct::new()

}

/// Sleeps the current thread for the specified number of microseconds.

///

/// # Arguments

/// * `microseconds` - Number of microseconds to sleep

#[cfg(feature = "std")]

/// Sleeps the current thread for the specified number of microseconds (no-op on no_std).

#[cfg(not(feature = "std"))]

pub fn thread_sleep_us(_microseconds: u64) -> azul_css::corety::EmptyStruct {

    // No-op on no_std - can't sleep without OS

    azul_css::corety::EmptyStruct::new()

}

/// Sleeps the current thread for the specified number of nanoseconds.

///

/// # Arguments

/// * `nanoseconds` - Number of nanoseconds to sleep

#[cfg(feature = "std")]

/// Sleeps the current thread for the specified number of nanoseconds (no-op on no_std).

#[cfg(not(feature = "std"))]

pub fn thread_sleep_ns(_nanoseconds: u64) -> azul_css::corety::EmptyStruct {

    // No-op on no_std - can't sleep without OS

    azul_css::corety::EmptyStruct::new()

}

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

// Generated adversarial tests

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

#[cfg(all(test, feature = "std"))]

#[allow(clippy::too_many_lines, clippy::unreadable_literal)]

mod autotest_generated {

    use core::{

        hash::{Hash, Hasher},

        sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrd},

    };

    use std::{

        collections::{hash_map::DefaultHasher, BTreeMap},

        sync::{Arc, Mutex},

        time::Instant as StdInstant,

    };

    use azul_core::{

        dom::{DomId, DomNodeId},

        geom::OptionLogicalPosition,

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        resources::RendererResources,

        styled_dom::NodeHierarchyItemId,

        window::{MonitorVec, RawWindowHandle},

    };

    use azul_css::{corety::EmptyStruct, system::SystemStyle};

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

        window::LayoutWindow,

        window_state::FullWindowState,

    };

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

    // Harness

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

    /// Upper bound on a worker's non-blocking poll loop: `ThreadReceiver::recv` is

    /// `try_recv` under the hood, so a worker that waits for `TerminateThread` MUST

    /// be bounded or a lost message would hang the whole test binary.

    const MAX_WORKER_POLLS: usize = 10_000;

    fn hash_of<T: Hash>(value: &T) -> u64 {

        let mut hasher = DefaultHasher::new();

        value.hash(&mut hasher);

        hasher.finish()

    }

    /// A live `ThreadSender` plus the receiving end of its channel.

    fn make_sender() -> (Receiver<ThreadReceiveMsg>, ThreadSender) {

        let (tx, rx) = channel::<ThreadReceiveMsg>();

        let sender = ThreadSender::new(ThreadSenderInner {

            ptr: Box::new(tx),

            send_fn: ThreadSendCallback {

                cb: default_send_thread_msg_fn,

            },

            destructor: ThreadSenderDestructorCallback {

                cb: thread_sender_drop,

            },

        });

        (rx, sender)

    }

    /// Drain every message currently queued on the main->worker side.

    fn drain(inner: &mut ThreadInner) -> Vec<ThreadReceiveMsg> {

        let mut out = Vec::new();

        while let OptionThreadReceiveMsg::Some(msg) = inner.receiver_try_recv() {

            out.push(msg);

        }

        out

    }

    /// Runs the thread destructor by hand (terminate + join), so every assertion

    /// after it observes a *finished* worker instead of racing one.

    fn join_worker(t: &Thread) {

        let mut guard = t.ptr.lock().expect("thread mutex must not be poisoned");

        default_thread_destructor_fn(core::ptr::from_mut::<ThreadInner>(&mut guard));

    }

    /// Builds a real `CallbackInfo` (the only way to exercise `WriteBackCallback::invoke`)

    /// over an otherwise-empty `LayoutWindow`.

    fn with_callback_info<R>(f: impl FnOnce(CallbackInfo) -> R) -> R {

        let layout_window =

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

        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::NONE,

            },

            OptionLogicalPosition::None,

            OptionLogicalPosition::None,

        );

        f(info)

    }

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

    // Callback fixtures

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

    static WB_THREAD_DATA: AtomicUsize = AtomicUsize::new(0);

    static WB_WRITEBACK_DATA: AtomicUsize = AtomicUsize::new(0);

    extern "C" fn wb_record(

        mut thread_data: RefAny,

        mut writeback_data: RefAny,

        _callback_info: CallbackInfo,

    ) -> Update {

        if let Some(v) = thread_data.downcast_ref::<usize>() {

            WB_THREAD_DATA.store(*v, AtomicOrd::SeqCst);

        }

        if let Some(v) = writeback_data.downcast_ref::<usize>() {

            WB_WRITEBACK_DATA.store(*v, AtomicOrd::SeqCst);

        }

        Update::RefreshDomAllWindows

    }

    extern "C" fn wb_do_nothing(

        _thread_data: RefAny,

        _writeback_data: RefAny,

        _callback_info: CallbackInfo,

    ) -> Update {

        Update::DoNothing

    }

    /// A worker that exits immediately without ever touching its channels.

    extern "C" fn worker_quiet(_d: RefAny, _s: ThreadSender, _r: ThreadReceiver) {}

    /// A worker that pushes exactly one `Update` back to the main thread, then exits.

    extern "C" fn worker_send_update(_d: RefAny, mut sender: ThreadSender, _r: ThreadReceiver) {

        let _sent = sender.send(ThreadReceiveMsg::Update(Update::RefreshDom));

    }

    /// A worker that pushes one `WriteBack` message (the RefAny-carrying variant).

    extern "C" fn worker_send_writeback(_d: RefAny, mut sender: ThreadSender, _r: ThreadReceiver) {

        let _sent = sender.send(ThreadReceiveMsg::WriteBack(ThreadWriteBackMsg::new(

            wb_do_nothing as WriteBackCallbackType,

            RefAny::new(77_usize),

        )));

    }

    /// Generates a worker that echoes `Tick`s back until it is told to terminate.

    /// Each instance gets its own statics so tests can run in parallel without racing.

    macro_rules! terminating_worker {

        ($fn_name:ident, $ticks:ident, $terminated:ident) => {

            static $ticks: AtomicUsize = AtomicUsize::new(0);

            static $terminated: AtomicBool = AtomicBool::new(false);

            extern "C" fn $fn_name(

                _d: RefAny,

                mut sender: ThreadSender,

                mut receiver: ThreadReceiver,

            ) {

                for _ in 0..MAX_WORKER_POLLS {

                    match receiver.recv() {

                        OptionThreadSendMsg::Some(ThreadSendMsg::TerminateThread) => {

                            $terminated.store(true, AtomicOrd::SeqCst);

                            break;

                        }

                        OptionThreadSendMsg::Some(ThreadSendMsg::Tick) => {

                            $ticks.fetch_add(1, AtomicOrd::SeqCst);

                            let _sent = sender.send(ThreadReceiveMsg::Update(Update::RefreshDom));

                        }

                        OptionThreadSendMsg::Some(ThreadSendMsg::Custom(_)) => {

                            $ticks.fetch_add(1, AtomicOrd::SeqCst);

                        }

                        OptionThreadSendMsg::None => {

                            let _slept = thread_sleep_ms(1);

                        }

                    }

                }

            }

        };

    }

    terminating_worker!(worker_wait_a, WAIT_A_TICKS, WAIT_A_TERMINATED);

    terminating_worker!(worker_wait_b, WAIT_B_TICKS, WAIT_B_TERMINATED);

    terminating_worker!(worker_wait_c, WAIT_C_TICKS, WAIT_C_TERMINATED);

    terminating_worker!(worker_wait_d, WAIT_D_TICKS, WAIT_D_TERMINATED);

    terminating_worker!(worker_wait_e, WAIT_E_TICKS, WAIT_E_TERMINATED);

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

    // OptionThreadReceiveMsg — getters / predicates

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

    #[test]

    fn option_thread_receive_msg_none_into_option_is_none() {

        assert!(OptionThreadReceiveMsg::None.into_option().is_none());

        assert!(OptionThreadReceiveMsg::None.as_ref().is_none());

    }

    #[test]

    fn option_thread_receive_msg_round_trips_through_from_and_into_option() {

        // Round-trip: Option -> OptionThreadReceiveMsg -> Option must be the identity.

        for update in [

            Update::DoNothing,

            Update::RefreshDom,

            Update::RefreshDomAllWindows,

        ] {

            let msg = ThreadReceiveMsg::Update(update);

            let ffi: OptionThreadReceiveMsg = Some(msg.clone()).into();

            assert_eq!(ffi.into_option(), Some(msg));

        }

        let empty: OptionThreadReceiveMsg = None.into();

        assert_eq!(empty, OptionThreadReceiveMsg::None);

        assert!(empty.into_option().is_none());

    }

    #[test]

    fn option_thread_receive_msg_as_ref_does_not_consume() {

        let opt = OptionThreadReceiveMsg::Some(ThreadReceiveMsg::Update(Update::RefreshDom));

        // as_ref() borrows: calling it repeatedly must keep returning the same payload.

        for _ in 0..3 {

            assert_eq!(

                opt.as_ref(),

                Some(&ThreadReceiveMsg::Update(Update::RefreshDom))

            );

        }

        // ... and the value is still intact afterwards.

        assert_eq!(

            opt.into_option(),

            Some(ThreadReceiveMsg::Update(Update::RefreshDom))

        );

    }

    #[test]

    fn option_thread_receive_msg_as_ref_handles_writeback_variant() {

        let opt = OptionThreadReceiveMsg::Some(ThreadReceiveMsg::WriteBack(

            ThreadWriteBackMsg::new(

                wb_do_nothing as WriteBackCallbackType,

                RefAny::new(1_usize),

            ),

        ));

        let Some(ThreadReceiveMsg::WriteBack(inner)) = opt.as_ref() else {

            panic!("as_ref() must expose the WriteBack payload");

        };

        assert_eq!(

            inner.callback.cb as *const () as usize,

            wb_do_nothing as *const () as usize

        );

        assert!(opt.into_option().is_some());

    }

    #[test]

    fn option_thread_receive_msg_ord_and_hash_are_consistent() {

        let none = OptionThreadReceiveMsg::None;

        let some = OptionThreadReceiveMsg::Some(ThreadReceiveMsg::Update(Update::DoNothing));

        // Declaration order: None < Some.

        assert!(none < some);

        assert_eq!(none.cmp(&none), core::cmp::Ordering::Equal);

        // Eq => equal hashes.

        assert_eq!(hash_of(&none), hash_of(&OptionThreadReceiveMsg::None));

        assert_eq!(

            hash_of(&some),

            hash_of(&OptionThreadReceiveMsg::Some(ThreadReceiveMsg::Update(

                Update::DoNothing

            )))

        );

    }

    #[test]

    fn thread_receive_msg_orders_writeback_before_update() {

        let wb = ThreadReceiveMsg::WriteBack(ThreadWriteBackMsg::new(

            wb_do_nothing as WriteBackCallbackType,

            RefAny::new(0_usize),

        ));

        let up = ThreadReceiveMsg::Update(Update::DoNothing);

        assert!(wb < up, "variant order (WriteBack=0, Update=1) must decide");

        assert!(

            ThreadReceiveMsg::Update(Update::DoNothing)

                < ThreadReceiveMsg::Update(Update::RefreshDom)

        );

    }

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

    // ThreadWriteBackMsg — constructor invariants

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

    #[test]

    fn thread_write_back_msg_new_stores_both_fields() {

        let mut msg = ThreadWriteBackMsg::new(

            wb_do_nothing as WriteBackCallbackType,

            RefAny::new(0xDEAD_BEEF_usize),

        );

        assert_eq!(