//! Video-playback widget - a "dumb widget" identical in architecture to the

//! [`CameraWidget`](super::camera) / [`ScreenCaptureWidget`](super::screencap),

//! only the source differs (a video URL/file decoded via vk-video).

//! SUPER_PLAN_2 §4 P6, widget pivot.

//!

//! `VideoWidget::create(config).dom()` → an `<img>` a background decode thread

//! keeps fed; each frame goes through [`super::capture_common::present_frame`]

//! (GL-texture install-once / re-upload + recomposite). Shared core in

//! `capture_common`; this widget is its config + worker. Test-pattern worker

//! (scrolling SMPTE colour bars) stands in for the real vk-video decode worker.

use alloc::vec::Vec;

use azul_core::callbacks::{Update, VirtualViewCallbackInfo, VirtualViewReturn};

use azul_core::dom::{ComponentEventFilter, DatasetMergeCallbackType, Dom, EventFilter, OptionDom};

use azul_core::geom::LogicalPosition;

use azul_core::refany::{OptionRefAny, RefAny};

use azul_core::resources::{ImageRef, RawImage, RawImageData, RawImageFormat};

use azul_core::task::{ThreadId, ThreadReceiver, ThreadSendMsg};

use azul_core::video::{VideoConfig, VideoFrame};

use super::capture_common::{

    invoke_on_frame, OnVideoFrame, OnVideoFrameCallback, OptionOnVideoFrame,

};

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

use crate::thread::{

    Thread, ThreadCallback, ThreadReceiveMsg, ThreadSender, ThreadWriteBackMsg, WriteBackCallback,

};

/// Default decode size for the test pattern (the real decoder reports the

/// stream's actual size).

const DEFAULT_W: u32 = 1280;

const DEFAULT_H: u32 = 720;

/// Live state for one video widget, carried across relayout by

/// [`merge_video_state`].

#[derive(Debug)]

pub struct VideoWidgetState {

    /// The requested playback configuration (source + autoplay/loop).

    pub config: VideoConfig,

    /// `true` once the decode thread has been started.

    pub started: bool,

    /// The stable external GL texture id once installed.

    pub gl_texture_id: Option<u32>,

    /// Optional user hook invoked with each decoded frame (effects / save /

    /// send). Re-set on every fresh build (see [`merge_video_state`]).

    pub on_frame: OptionOnVideoFrame,

    /// Optional pre-decoded frames to replay (a `RefAny` holding a

    /// `Vec<VideoFrame>`); when set, the replay worker cycles these instead of

    /// the built-in test pattern. Carried forward by [`merge_video_state`].

    pub frames: OptionRefAny,

    /// The off-main-thread streaming decode worker (mirrors the map widget's

    /// `fetch_callback`). Set via [`VideoWidget::dom_with_decoder`]. When present,

    /// `AfterMount` spawns it on a background `Thread` instead of the replay /

    /// test-pattern workers, so the VK decode runs off the main thread.

    pub decode_callback: Option<ThreadCallback>,

    /// The latest decoded frame to display, as a CPU `ImageRef` (RGBA8). The

    /// `VirtualView` render callback ([`video_widget_render`]) reads this on each

    /// re-render; [`video_writeback`] stores it and triggers an in-place

    /// `VirtualView` re-render - so the frame renders on cpurender AND webrender,

    /// exactly like the map widget's tile cache. (Replaces the GL `present_frame`

    /// path for video; camera/screencap still use `present_frame`.)

    pub current_frame: Option<ImageRef>,

    /// The decode worker's `ThreadId` (set by `AfterMount`). Lets the resize callback

    /// message the running worker (`info.get_thread(id).sender.send(..)`) so it can

    /// re-target the decoder to the new physical-pixel size - a cheap image swap, no

    /// relayout. Carried across relayout by [`merge_video_state`].

    pub thread_id: Option<ThreadId>,

    /// Clone of the worker's main→worker `Sender` (set by `AfterMount`, carried by

    /// merge). Lets [`merge_video_state`] - which has no `CallbackInfo` - push a

    /// seek to the running worker when `config.timestamp` changes (scrubbing).

    pub seek_sender: Option<std::sync::mpsc::Sender<ThreadSendMsg>>,

}

/// A video-playback widget. `create(config).dom()` yields an `<img>` the

/// decode thread keeps fed.

#[repr(C)]

#[derive(Debug)]

pub struct VideoWidget {

    /// Source URL + autoplay/loop + format.

    pub config: VideoConfig,

    /// Optional per-frame user hook (effects / save / send - azul-meet).

    pub on_frame: OptionOnVideoFrame,

    /// Optional pre-decoded frames to replay (a `RefAny` holding a

    /// `Vec<VideoFrame>`); set via [`with_frames`](Self::with_frames). When

    /// present the widget cycles these instead of the test pattern.

    pub frames: OptionRefAny,

}

impl VideoWidget {

    /// Create a video widget for the given config.

    /// Set a hook invoked with every decoded frame - for live effects, saving

    /// frames into your data model, or sending them over the network

    /// (azul-meet). The backreference DI pattern (see `architecture.md`).

    /// Builder form of [`set_on_frame`](Self::set_on_frame).

    #[must_use]

    /// Replay a list of already-decoded frames instead of the built-in test

    /// pattern: `frames` is a [`RefAny`] holding a `Vec<VideoFrame>`. The

    /// background worker cycles them through the shared GL presenter (the same

    /// `present_frame` path the camera/screencap widgets use), so callers that

    /// decode a clip up front (e.g. `decode_mp4_h264_bytes`) get real pixels on

    /// screen. The `RefAny` must carry a `Vec<VideoFrame>`, else playback is

    /// skipped and the test pattern shows instead.

        // The body is a VirtualView (exactly like the map widget): its render

        // callback re-reads `current_frame` from the dataset each re-render and

        // builds the `<img>`, so streamed frames render on BOTH cpurender and

        // webrender. The background decode worker is started on AfterMount and

        // `WriteBack`s frames into `current_frame` + triggers a VirtualView

        // re-render in place (no DOM rebuild) — see `video_writeback`. The caller

        // sizes the outer node via `.with_css(...)` on the returned Dom.

            )

            // Window/layout resize → re-target the decoder to the new physical size

            // (a cheap image swap, no relayout). See `video_on_resize`.

            )

                )

            )

    /// Build the widget's DOM: a single `<img>` node a background thread keeps

    /// fed. Replays pre-decoded [`with_frames`](Self::with_frames) if given, else

    /// shows the built-in test pattern.

    /// Build the widget's DOM and wire a background **streaming** decode worker -

    /// mirrors `MapWidget::dom_with_fetch`. `cb` runs on a framework `Thread` OFF

    /// the main thread: it reads the `VideoConfig` (its typed `VideoSource` -

    /// URL / file / bytes), runs the VK decode incrementally (no up-front decode),

    /// and `WriteBack`s frames to the `<img>` paced by wall-clock (dropping late

    /// frames). The standard worker is

    /// `azul_dll::desktop::extra::video_codec::stream::video_decode_worker`; wrap

    /// it in a `ThreadCallback` to pass it here.

}

/// `VirtualView` render callback (mirrors `map_widget_render`): build the `<img>`

/// for the latest decoded frame, re-read from the widget's dataset on every

/// re-render. The decode worker stores frames into `current_frame` and triggers

/// the re-render in place (see [`video_writeback`]), so this renders on both the

/// CPU and GPU renderers with no DOM rebuild.

    // Defensive (like map_widget_render): a non-finite / non-positive box (layout

    // not yet settled, e.g. flex-grow before the parent height resolves) would

    // produce a garbage `<img>` size — render nothing until it settles.

    {

    } else {

                    // Poster / "no signal" placeholder. Returning None here

                    // rendered NOTHING, so a decoder that never produced a

                    // frame (missing video-native feature, non-x86_64 target,

                    // Vulkan init failure, network stall) was

                    // indistinguishable from a black video — the shipped

                    // azul-video "black frame" bug. A dead pipeline must be

                    // visibly dead.

            )

    };

/// `AfterMount`: start the background decode thread exactly once.

    // Mark started exactly once; pull out the streaming decode worker (if any),

    // its source, and any pre-decoded replay frames.

        };

        };

    };

    // Priority: off-main streaming decode worker > replay pre-decoded frames >

    // built-in test pattern. All feed the same WriteBack -> video_writeback path.

        // The worker's thread-init is the `VideoConfig` itself: it matches on

        // `config.source` (typed — no RefAny downcast) and reads `config.timestamp`.

        // Grab the main→worker sender BEFORE add_thread moves the Thread, so the

        // merge callback can push seeks to the worker (scrubbing).

        // Remember the worker's id (resize messaging) + sender (seek messaging).

/// `NodeResized`: the video box changed physical size (window resize / relayout). Tell

/// the running decode worker the new target size via its `ThreadSender` so it scales

/// frames to fit OFF the main thread - the UI then does a cheap image swap with no

/// interpolation. This is a message, NOT a relayout: returns `DoNothing`.

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded layout/render numeric cast

    };

    };

    };

/// Background worker (test pattern): SMPTE-style colour bars scrolling

/// horizontally ~30x/s. Replaced by the real vk-video decode worker later.

#[allow(clippy::cast_possible_truncation)] // bounded layout/render numeric cast

    const BARS: [[u8; 3]; 7] = [

        [235, 235, 235],

        [235, 235, 16],

        [16, 235, 235],

        [16, 235, 16],

        [235, 16, 235],

        [235, 16, 16],

        [16, 16, 235],

    ];

    loop {

        }

    }

/// Background worker (replay): cycle a caller-supplied `Vec<VideoFrame>` (e.g. a

/// clip decoded up front via `decode_mp4_h264_bytes`) ~30x/s through the same

/// `WriteBack` -> [`video_writeback`] -> [`super::capture_common::present_frame`]

/// path as the test pattern, so real decoded pixels land in the shared GL

/// texture. `init` is the `RefAny` handed to

/// [`VideoWidget::with_frames`](VideoWidget::with_frames); if it doesn't hold a

/// non-empty `Vec<VideoFrame>` the worker just returns.

    };

    loop {

    }

/// Writeback (main thread): store the decoded frame as the widget's

/// `current_frame` (a CPU `ImageRef`) and re-render the `VirtualView` in place so it

/// re-reads it - exactly like `map_tile_writeback`.

///

/// Renders on cpurender AND

/// webrender (no GL `present_frame`, no DOM rebuild).

            // Guard against dimensions whose RGBA byte count overflows `usize`

            // before `ImageRef::new_rawimage` validates it against the buffer:

            // `width * height * 4` wraps in release (e.g. 2^31 x 2^31 -> 0) so an

            // empty buffer would spuriously "match" and store a bogus frame. A

            // `checked_mul` that overflows drops the frame — the hook is still

            // notified below, exactly as for a byte-count mismatch.

        }

    }

    // Re-render the VirtualView(s) in place so the content callback re-reads the

    // freshly-stored `current_frame` (NOT RefreshDom — that would rebuild the DOM

    // and orphan the worker's dataset clone). Same trick as `map_tile_writeback`.

/// Carry live state forward across relayout.

#[allow(clippy::float_cmp)] // intentional exact compare: change-detection / identity fast-path / cache-key match

    // Return the OLD allocation, adopting config forward — the same rule

    // `merge_map_tile_cache` documents. The decode worker holds a clone of

    // the OLD RefAny (handed over at spawn) and writes every decoded frame

    // into it; returning `new_data` re-pointed the DOM at a fresh allocation

    // nobody wrote to, so the picture froze on whatever frame existed at

    // merge time — the AzVideo demo hit it on the FIRST timeline click

    // (its callback returns RefreshDom).

            // Scrubbing: a changed `config.timestamp` across this relayout → tell the

            // worker to seek. Cheap wall-clock reposition (the worker already has the

            // decoded frames), result comes back as an image swap — no re-decode here.

            // Input-source change → tell the worker to re-init the decode (it

            // re-resolves/demuxes/decodes the new source); the frame swaps in when ready.

            // Adopt the app-driven config; keep every worker-facing field

            // (frames, current_frame, thread_id, seek_sender, started) in the

            // allocation the worker actually writes to.

        } else {

            // Foreign / mismatched payloads (one side is not this widget's

            // state): hand back the NEW payload untouched — there is no

            // persistent allocation to preserve, and returning a

            // wrong-typed old dataset would poison the node.

        }

    };

    } else {

    }

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

// Generated adversarial tests

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

#[cfg(test)]

#[allow(

    clippy::too_many_lines,

    clippy::cast_possible_truncation,

    clippy::float_cmp,

    clippy::items_after_statements,

    clippy::let_and_return

)]

mod autotest_generated {

    use std::{

        collections::BTreeMap,

        panic::{catch_unwind, AssertUnwindSafe},

        sync::{

            atomic::{AtomicUsize, Ordering},

            mpsc::{channel, Receiver, Sender},

            Arc, Mutex, PoisonError,

        },

    };

    use azul_core::{

        callbacks::{HidpiAdjustedBounds, VirtualViewCallbackReason},

        dom::{DomId, DomNodeId, NodeType},

        geom::{LogicalSize, OptionLogicalPosition},

        gl::OptionGlContextPtr,

        hit_test::ScrollPosition,

        resources::{DecodedImage, DpiScaleFactor, ImageCache, RendererResources},

        styled_dom::NodeHierarchyItemId,

        task::{

            OptionThreadSendMsg, ThreadReceiverDestructorCallback, ThreadReceiverInner,

            ThreadRecvCallback,

        },

        video::VideoSource,

        window::{MonitorVec, RawWindowHandle, WindowTheme},

    };

    use azul_css::{system::SystemStyle, AzString};

    use rust_fontconfig::FcFontCache;

    use super::*;

    #[cfg(feature = "icu")]

    use crate::icu::IcuLocalizerHandle;

    use crate::{

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

        thread::{

            ThreadCallbackType, ThreadSendCallback, ThreadSenderDestructorCallback,

            ThreadSenderInner,

        },

        widgets::capture_common::OnVideoFrameCallbackType,

        window::LayoutWindow,

        window_state::FullWindowState,

    };

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

    // Config fixtures

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

    /// A config with an explicit source + scrub position (everything else

    /// pinned so a test only varies what it names).

    fn config(source: VideoSource, timestamp: f32) -> VideoConfig {

        VideoConfig {

            source,

            timestamp,

            autoplay: true,

            looping: false,

            output_format: RawImageFormat::BGRA8,

        }

    }

    fn url_source(host: &str, path: &str) -> VideoSource {

        VideoSource::Url(azul_core::url::Url::from_parts("https", host, 443, path))

    }

    fn file_source(path: &'static str) -> VideoSource {

        VideoSource::File(AzString::from_const_str(path))

    }

    fn bytes_source(bytes: Vec<u8>) -> VideoSource {

        VideoSource::Bytes(bytes.into())

    }

    /// Representative + hostile configs: every `VideoSource` variant (empty and

    /// large payloads), a non-ASCII path, and every f32 boundary a scrub

    /// position can take (NaN / ±inf / ±0 / MIN / MAX).

    fn all_configs() -> Vec<VideoConfig> {

        vec![

            VideoConfig::default(),

            config(url_source("example.com", "/clip.mp4"), 0.0),

            config(url_source("", ""), f32::MAX),

            config(file_source("/tmp/clip.mp4"), -1.0),

            // unicode: emoji + CJK + RTL + a combining mark in the path.

            config(

                file_source("/tmp/\u{1F3AC}-\u{5F71}\u{7247}-\u{0631}\u{0645}\u{0632}-e\u{0301}.mp4"),

                f32::NAN,

            ),

            config(bytes_source(Vec::new()), f32::INFINITY),

            config(bytes_source(vec![0xFF; 8192]), f32::NEG_INFINITY),

            config(bytes_source(vec![0x00]), f32::MIN),

            VideoConfig {

                source: file_source("x"),

                timestamp: -0.0,

                autoplay: false,

                looping: true,

                output_format: RawImageFormat::R8,

            },

        ]

    }

    /// `VideoConfig` is only `PartialEq`, so a NaN scrub position never compares

    /// equal to itself - compare the timestamp bit-exactly instead.

    fn assert_same_config(actual: &VideoConfig, expected: &VideoConfig) {

        assert_eq!(actual.source, expected.source, "source must round-trip");

        assert_eq!(

            actual.timestamp.to_bits(),

            expected.timestamp.to_bits(),

            "timestamp must survive bit-exactly (NaN included)"

        );

        assert_eq!(actual.autoplay, expected.autoplay);

        assert_eq!(actual.looping, expected.looping);

        assert_eq!(actual.output_format, expected.output_format);

    }

    const CONST_CONFIG: VideoConfig = VideoConfig {

        source: VideoSource::File(AzString::from_const_str("/tmp/const-clip.mp4")),

        timestamp: 2.5,

        autoplay: false,

        looping: true,

        output_format: RawImageFormat::RGBA8,

    };

    /// Compile-time proof that `create` really is a `const fn` - the `const`

    /// qualifier is part of the public API, so a non-const `create` must break

    /// this file.

    const CONST_WIDGET: VideoWidget = VideoWidget::create(CONST_CONFIG);

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

    // State fixtures

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

    /// A freshly-built widget state (exactly what `build_dom` stores).

    fn base_state(config: VideoConfig) -> VideoWidgetState {

        VideoWidgetState {

            config,

            started: false,

            gl_texture_id: None,

            on_frame: OptionOnVideoFrame::None,

            frames: OptionRefAny::None,

            decode_callback: None,

            current_frame: None,

            thread_id: None,

            seek_sender: None,

        }

    }

    fn state(config: VideoConfig) -> RefAny {

        RefAny::new(base_state(config))

    }

    /// Everything a test needs to know about a `VideoWidgetState`, read out in

    /// one borrow (`downcast_ref` takes `&mut self`, so overlapping reads would

    /// otherwise have to nest).

    #[derive(Debug, Clone, PartialEq)]

    struct StateSummary {

        started: bool,

        gl_texture_id: Option<u32>,

        has_hook: bool,

        has_frames: bool,

        decode_cb: Option<usize>,

        current_frame_id: Option<u64>,

        thread_id: Option<ThreadId>,

        has_seek_sender: bool,

    }

    fn read_state(data: &mut RefAny) -> StateSummary {

        let s = data

            .downcast_ref::<VideoWidgetState>()

            .expect("payload must still be a VideoWidgetState");

        StateSummary {

            started: s.started,

            gl_texture_id: s.gl_texture_id,

            has_hook: matches!(s.on_frame, OptionOnVideoFrame::Some(_)),

            has_frames: matches!(s.frames, OptionRefAny::Some(_)),

            decode_cb: s.decode_callback.as_ref().map(|c| c.cb as usize),

            current_frame_id: s.current_frame.as_ref().map(|i| i.id),

            thread_id: s.thread_id,

            has_seek_sender: s.seek_sender.is_some(),

        }

    }

    fn read_config(data: &mut RefAny) -> VideoConfig {

        data.downcast_ref::<VideoWidgetState>()

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

            .config

            .clone()

    }

    /// The `(width, height)` of every frame in the state's replay list, or

    /// `None` when there is no list / it does not hold a `Vec<VideoFrame>`.

    fn state_frames(data: &mut RefAny) -> Option<Vec<(u32, u32)>> {

        let inner = {

            let s = data.downcast_ref::<VideoWidgetState>()?;

            match &s.frames {

                OptionRefAny::Some(f) => Some(f.clone()),

                OptionRefAny::None => None,

            }

        };

        let mut inner = inner?;

        let v = inner.downcast_ref::<Vec<VideoFrame>>()?;

        Some(v.iter().map(|f| (f.width, f.height)).collect())

    }

    /// The `(width, height)` of a widget's `frames` `RefAny` (same shape as

    /// `state_frames`, but for the builder-side `VideoWidget`).

    fn widget_frames(widget: &VideoWidget) -> Option<Vec<(u32, u32)>> {

        let OptionRefAny::Some(f) = &widget.frames else {

            return None;

        };

        let mut f = f.clone();

        let v = f.downcast_ref::<Vec<VideoFrame>>()?;

        Some(v.iter().map(|fr| (fr.width, fr.height)).collect())

    }

    // ---- frames / images --------------------------------------------------

    /// A tightly-packed RGBA frame (`width * height * 4` bytes).

    fn frame(width: u32, height: u32) -> VideoFrame {

        let px = (width as usize) * (height as usize);

        VideoFrame {

            width,

            height,

            bytes: vec![7u8; px * 4].into(),

        }

    }

    /// A frame whose declared dimensions need NOT match its byte count.

    fn frame_raw(width: u32, height: u32, bytes: Vec<u8>) -> VideoFrame {

        VideoFrame {

            width,

            height,

            bytes: bytes.into(),

        }

    }

    /// A zero-allocation stand-in for an already-decoded frame.

    fn placeholder_image(tag: &[u8]) -> ImageRef {

        ImageRef::null_image(4, 4, RawImageFormat::BGRA8, tag.to_vec())

    }

    /// `(width, height)` of the raw CPU image a writeback stored, or `None` if

    /// the stored image is not a raw one.

    fn raw_dims(img: &ImageRef) -> Option<(usize, usize)> {

        match img.get_data() {

            DecodedImage::Raw((descriptor, _)) => Some((descriptor.width, descriptor.height)),

            _ => None,

        }

    }

    fn current_frame_dims(data: &mut RefAny) -> Option<(usize, usize)> {

        let s = data.downcast_ref::<VideoWidgetState>()?;

        raw_dims(s.current_frame.as_ref()?)

    }

    // ---- frame hook -------------------------------------------------------

    /// Records every frame the widget's `on_frame` hook is handed, and answers

    /// with a caller-chosen `Update`.

    struct FrameLog {

        seen: Vec<(u32, u32, usize)>,

        reply: Update,

    }

    extern "C" fn record_frame(mut data: RefAny, _: CallbackInfo, frame: VideoFrame) -> Update {

        let mut reply = Update::DoNothing;

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

            log.seen

                .push((frame.width, frame.height, frame.bytes.as_ref().len()));

            reply = log.reply;

        }

        reply

    }

    extern "C" fn frame_do_nothing(_: RefAny, _: CallbackInfo, _: VideoFrame) -> Update {

        // A distinct body so the linker cannot fold this onto `record_frame`

        // and make the fn-pointer identity assertions vacuous.

        core::hint::black_box(Update::DoNothing)

    }

    fn frame_log(reply: Update) -> RefAny {

        RefAny::new(FrameLog {

            seen: Vec::new(),

            reply,

        })

    }

    fn logged_frames(data: &mut RefAny) -> Vec<(u32, u32, usize)> {

        data.downcast_ref::<FrameLog>()

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

            .seen

            .clone()

    }

    fn hook_into(log: &RefAny) -> OptionOnVideoFrame {

        Some(OnVideoFrame {

            refany: log.clone(),

            callback: (record_frame as OnVideoFrameCallbackType).into(),

        })

        .into()

    }

    // ---- thread workers ---------------------------------------------------

    /// A decode worker that returns immediately. Used wherever a test must let

    /// `AfterMount` really spawn a `Thread`: the framework's thread destructor

    /// *joins*, so only a worker that returns on its own can be joined safely.

    extern "C" fn noop_decode_worker(_: RefAny, _: ThreadSender, _: ThreadReceiver) {}

    extern "C" fn other_noop_worker(_: RefAny, _: ThreadSender, _: ThreadReceiver) {

        core::hint::black_box(());

    }

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

    // CallbackInfo harness

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

    /// Runs `f` against a real `CallbackInfo` over an empty `LayoutWindow` (no

    /// GL context, no laid-out nodes). Returns `f`'s value plus every

    /// `CallbackChange` the callback recorded.

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

        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,

        );

        let out = f(info);

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

        (out, recorded)

    }

    fn count_virtual_view_rerenders(changes: &[CallbackChange]) -> usize {

        changes

            .iter()

            .filter(|c| matches!(c, CallbackChange::UpdateAllVirtualViews))

            .count()

    }

    /// The `ThreadId` of the single `AddThread` change, or `None`.

    fn added_thread_id(changes: &[CallbackChange]) -> Option<ThreadId> {

        changes.iter().find_map(|c| match c {

            CallbackChange::AddThread { thread_id, .. } => Some(*thread_id),

            _ => None,

        })

    }

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

    // VirtualViewCallbackInfo harness

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

    /// Runs `f` against a `VirtualViewCallbackInfo` reporting `w x h` bounds.

    fn with_virtual_view_info<R>(w: f32, h: f32, f: impl FnOnce(VirtualViewCallbackInfo) -> R) -> R {

        let fonts = FcFontCache::default();

        let images = ImageCache::default();

        let size = LogicalSize::new(w, h);

        let info = VirtualViewCallbackInfo::new(

            VirtualViewCallbackReason::InitialRender,

            &fonts,

            &images,

            WindowTheme::LightMode,

            HidpiAdjustedBounds {

                logical_size: size,

                hidpi_factor: DpiScaleFactor::new(1.0),

            },

            azul_core::geom::LogicalRect::new(LogicalPosition::zero(), size),

            azul_core::geom::LogicalRect::new(LogicalPosition::zero(), size),

            LogicalPosition::zero(),

        );

        f(info)

    }

    /// The `ImageRef` id of the `<img>` a render pass emitted, or `None` when it

    /// emitted no DOM at all.

    fn rendered_image_id(ret: &VirtualViewReturn) -> Option<u64> {

        let OptionDom::Some(dom) = &ret.dom else {

            return None;

        };

        match dom.root.get_node_type() {

            NodeType::Image(img) => Some(img.id),

            other => panic!("the video VirtualView must render an <img>, got {other:?}"),

        }

    }

    fn rendered_nothing(ret: &VirtualViewReturn) -> bool {

        matches!(ret.dom, OptionDom::None)

    }

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

    // Worker harness

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

    /// One frame a worker pushed, summarised so the (multi-megabyte) pixel

    /// buffer never has to be cloned into the log.

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

    struct SentFrame {

        width: u32,

        height: u32,

        len: usize,

        /// Distinct RGBA pixels in the first scanline, in first-seen order

        /// (capped, so a pathological frame cannot blow up the log).

        row0_palette: Vec<[u8; 4]>,

        /// Every scanline is byte-identical to the first.

        rows_identical: bool,

        /// The whole pixel buffer - captured only for frames small enough to

        /// compare byte-for-byte (the replay fixtures).

        small_bytes: Option<Vec<u8>>,

    }

    fn summarise(f: &VideoFrame) -> SentFrame {

        let bytes = f.bytes.as_ref();

        let row_len = (f.width as usize).saturating_mul(4);

        let mut row0_palette: Vec<[u8; 4]> = Vec::new();

        if row_len > 0 && bytes.len() >= row_len {

            for px in bytes[..row_len].chunks_exact(4) {

                let px = [px[0], px[1], px[2], px[3]];

                if row0_palette.len() < 32 && !row0_palette.contains(&px) {

                    row0_palette.push(px);

                }

            }

        }

        let rows_identical = row_len == 0

            || bytes.len() < row_len

            || bytes.chunks_exact(row_len).all(|row| row == &bytes[..row_len]);

        SentFrame {

            width: f.width,

            height: f.height,

            len: bytes.len(),

            row0_palette,

            rows_identical,

            small_bytes: (bytes.len() <= 4096).then(|| bytes.to_vec()),

        }

    }

    /// Guarded by `WORKER_GATE`: a worker's send callback is a plain C fn

    /// pointer, so it has nowhere but a static to put its result.

    static WORKER_LOG: Mutex<Vec<SentFrame>> = Mutex::new(Vec::new());

    static WORKER_GATE: Mutex<()> = Mutex::new(());

    /// How many more sends are accepted before the harness reports "the main

    /// thread is gone" - the only signal these workers ever stop on.

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

    extern "C" fn record_then_maybe_stop(

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

        msg: ThreadReceiveMsg,

    ) -> bool {

        let ThreadReceiveMsg::WriteBack(mut wb) = msg else {

            return false;

        };

        if let Some(f) = wb.refany.downcast_ref::<VideoFrame>() {

            WORKER_LOG

                .lock()

                .unwrap_or_else(PoisonError::into_inner)

                .push(summarise(&f));

        }

        let left = ACCEPT_BUDGET.load(Ordering::SeqCst);

        if left == 0 {

            return false;

        }

        ACCEPT_BUDGET.store(left - 1, Ordering::SeqCst);

        true

    }

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

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

    extern "C" fn recv_nothing(_: *const core::ffi::c_void) -> OptionThreadSendMsg {

        OptionThreadSendMsg::None

    }

    /// A receiver that answers *every* poll with "terminate now".

    extern "C" fn recv_terminate(_: *const core::ffi::c_void) -> OptionThreadSendMsg {

        OptionThreadSendMsg::Some(ThreadSendMsg::TerminateThread)

    }

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

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

        let sender = ThreadSender::new(ThreadSenderInner {

            ptr: Box::new(tx),

            send_fn: ThreadSendCallback {

                cb: record_then_maybe_stop,

            },

            destructor: ThreadSenderDestructorCallback {

                cb: sender_drop_noop,

            },

        });

        (rx, sender)

    }

    fn receiver(terminate: bool) -> (Sender<ThreadSendMsg>, ThreadReceiver) {

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

        let cb: extern "C" fn(*const core::ffi::c_void) -> OptionThreadSendMsg =

            if terminate { recv_terminate } else { recv_nothing };

        let receiver = ThreadReceiver::new(ThreadReceiverInner {

            ptr: Box::new(rx),

            recv_fn: ThreadRecvCallback { cb },

            destructor: ThreadReceiverDestructorCallback {

                cb: receiver_drop_noop,

            },

        });

        (tx, receiver)

    }

    /// Runs `worker` in-process against a sender that accepts `accept` frames

    /// and then reports failure, and returns everything it managed to send.

    /// `terminate` decides whether its receiver answers every poll with

    /// `TerminateThread`.

    fn run_worker(

        worker: ThreadCallbackType,

        init: RefAny,

        accept: usize,

        terminate: bool,

    ) -> Vec<SentFrame> {

        let _gate = WORKER_GATE

            .lock()

            .unwrap_or_else(PoisonError::into_inner);

        WORKER_LOG

            .lock()

            .unwrap_or_else(PoisonError::into_inner)

            .clear();

        ACCEPT_BUDGET.store(accept, Ordering::SeqCst);

        let (_rx, sender) = logging_sender();

        let (_tx, recv) = receiver(terminate);

        worker(init, sender, recv);

        WORKER_LOG

            .lock()

            .unwrap_or_else(PoisonError::into_inner)

            .clone()

    }

    /// The SMPTE bars `video_test_worker` hard-codes (duplicated here on

    /// purpose: the palette is observable output, so a silent change to it must

    /// break a test).

    const EXPECTED_BARS: [[u8; 4]; 7] = [

        [235, 235, 235, 255],

        [235, 235, 16, 255],

        [16, 235, 235, 255],

        [16, 235, 16, 255],

        [235, 16, 235, 255],

        [235, 16, 16, 255],

        [16, 16, 235, 255],

    ];

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

    // Seek-channel helpers (merge_video_state)

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

    fn custom_f32(msg: &ThreadSendMsg) -> Option<f32> {

        let ThreadSendMsg::Custom(r) = msg else {

            return None;

        };

        let mut r = r.clone();

        let out = r.downcast_ref::<f32>().map(|v| *v);

        out

    }

    fn custom_source(msg: &ThreadSendMsg) -> Option<VideoSource> {

        let ThreadSendMsg::Custom(r) = msg else {

            return None;

        };

        let mut r = r.clone();

        let out = r.downcast_ref::<VideoSource>().map(|v| (*v).clone());

        out

    }

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

    // VideoWidget::create  (constructor)

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

    #[test]

    fn create_stores_the_config_verbatim_and_leaves_every_hook_unset() {

        for cfg in all_configs() {

            let widget = VideoWidget::create(cfg.clone());

            assert_same_config(&widget.config, &cfg);

            assert!(

                matches!(widget.on_frame, OptionOnVideoFrame::None),

                "a fresh widget has no frame hook"

            );

            assert!(

                matches!(widget.frames, OptionRefAny::None),

                "a fresh widget has no replay list"

            );

        }

    }

    #[test]

    fn create_is_usable_in_a_const_context() {

        let widget = CONST_WIDGET;

        assert_same_config(&widget.config, &CONST_CONFIG);

        assert!(matches!(widget.on_frame, OptionOnVideoFrame::None));

        assert!(matches!(widget.frames, OptionRefAny::None));

    }

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

    // VideoWidget::set_on_frame / with_on_frame  (constructor)

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

    #[test]

    fn with_on_frame_installs_the_hook_and_keeps_the_config() {

        for cfg in all_configs() {

            let widget = VideoWidget::create(cfg.clone())

                .with_on_frame(frame_log(Update::DoNothing), record_frame as OnVideoFrameCallbackType);

            assert_same_config(&widget.config, &cfg);

            let OptionOnVideoFrame::Some(hook) = &widget.on_frame else {

                panic!("with_on_frame must install a hook");

            };

            assert_eq!(

                hook.callback.cb as usize,

                record_frame as OnVideoFrameCallbackType as usize,

                "the installed hook must be exactly the one handed in"

            );

            assert!(

                matches!(widget.frames, OptionRefAny::None),

                "with_on_frame must not invent a replay list"

            );

        }

    }

    #[test]

    fn set_on_frame_twice_keeps_only_the_last_hook() {

        let mut widget = VideoWidget::create(VideoConfig::default());

        widget.set_on_frame(

            RefAny::new(0_usize),

            record_frame as OnVideoFrameCallbackType,

        );

        widget.set_on_frame(

            RefAny::new(1_usize),

            frame_do_nothing as OnVideoFrameCallbackType,

        );

        let OptionOnVideoFrame::Some(hook) = &widget.on_frame else {

            panic!("hook must still be set");

        };

        assert_eq!(

            hook.callback.cb as usize,

            frame_do_nothing as OnVideoFrameCallbackType as usize,

            "the second set_on_frame must replace the first"

        );

        let mut data = hook.refany.clone();

        assert_eq!(

            data.downcast_ref::<usize>().map(|v| *v),

            Some(1),

            "the second hook's data must replace the first hook's, not merge with it"

        );

    }

    #[test]

    fn set_on_frame_accepts_a_refany_that_is_also_the_widgets_replay_list() {

        // Aliasing the same RefAny into two slots must not panic or deadlock -

        // both are plain shared handles.

        let shared = RefAny::new(vec![frame(1, 1)]);

        let widget = VideoWidget::create(VideoConfig::default())

            .with_frames(shared.clone())

            .with_on_frame(shared, record_frame as OnVideoFrameCallbackType);

        assert!(matches!(widget.on_frame, OptionOnVideoFrame::Some(_)));

        assert_eq!(widget_frames(&widget), Some(vec![(1, 1)]));

    }

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

    // VideoWidget::with_frames  (constructor)

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

    #[test]

    fn with_frames_stores_the_list_and_keeps_everything_else() {

        for cfg in all_configs() {

            let widget = VideoWidget::create(cfg.clone())

                .with_frames(RefAny::new(vec![frame(2, 3), frame(4, 5)]));

            assert_same_config(&widget.config, &cfg);

            assert_eq!(widget_frames(&widget), Some(vec![(2, 3), (4, 5)]));

            assert!(

                matches!(widget.on_frame, OptionOnVideoFrame::None),

                "with_frames must not invent a hook"

            );

        }

    }

    #[test]

    fn with_frames_twice_keeps_only_the_last_list() {

        let widget = VideoWidget::create(VideoConfig::default())

            .with_frames(RefAny::new(vec![frame(1, 1)]))

            .with_frames(RefAny::new(vec![frame(9, 9), frame(8, 8)]));

        assert_eq!(widget_frames(&widget), Some(vec![(9, 9), (8, 8)]));

    }

    #[test]

    fn with_frames_accepts_an_empty_and_a_wrong_typed_payload_without_complaint() {

        // Documented: a `RefAny` that does not carry a `Vec<VideoFrame>` is

        // accepted here and only *skipped* later, by the replay worker.

        let empty = VideoWidget::create(VideoConfig::default())

            .with_frames(RefAny::new(Vec::<VideoFrame>::new()));

        assert_eq!(widget_frames(&empty), Some(Vec::new()));

        let foreign =

            VideoWidget::create(VideoConfig::default()).with_frames(RefAny::new(0_u32));

        assert!(

            matches!(foreign.frames, OptionRefAny::Some(_)),

            "the builder stores whatever it is given"

        );

        assert_eq!(

            widget_frames(&foreign),

            None,

            "...but it is not a frame list"

        );

    }

    #[test]

    fn builder_order_does_not_matter() {

        let a = VideoWidget::create(config(file_source("/a.mp4"), 1.0))

            .with_frames(RefAny::new(vec![frame(3, 3)]))

            .with_on_frame(frame_log(Update::DoNothing), record_frame as OnVideoFrameCallbackType);

        let b = VideoWidget::create(config(file_source("/a.mp4"), 1.0))

            .with_on_frame(frame_log(Update::DoNothing), record_frame as OnVideoFrameCallbackType)

            .with_frames(RefAny::new(vec![frame(3, 3)]));

        assert_same_config(&a.config, &b.config);

        assert_eq!(widget_frames(&a), widget_frames(&b));

        assert!(matches!(a.on_frame, OptionOnVideoFrame::Some(_)));

        assert!(matches!(b.on_frame, OptionOnVideoFrame::Some(_)));

    }

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

    // VideoWidget::dom / dom_with_decoder / build_dom

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

    #[test]

    fn dom_builds_a_div_with_one_virtual_view_child() {

        let dom = VideoWidget::create(VideoConfig::default()).dom();

        assert!(

            matches!(dom.root.get_node_type(), NodeType::Div),

            "the widget root is a plain div (the <img> lives in the VirtualView)"

        );

        assert_eq!(dom.children.as_slice().len(), 1, "one VirtualView child");

        assert!(

            matches!(

                dom.children.as_slice()[0].root.get_node_type(),

                NodeType::VirtualView

            ),

            "the child must be the VirtualView the decode worker re-renders"

        );

    }

    #[test]

    fn dom_wires_after_mount_node_resized_a_dataset_and_a_merge_callback() {

        let dom = VideoWidget::create(VideoConfig::default()).dom();

        let events: Vec<EventFilter> = dom

            .root

            .get_callbacks()

            .as_ref()

            .iter()

            .map(|c| c.event)

            .collect();

        assert_eq!(events.len(), 2, "exactly two component callbacks");

        assert!(events.contains(&EventFilter::Component(ComponentEventFilter::AfterMount)));

        assert!(events.contains(&EventFilter::Component(ComponentEventFilter::NodeResized)));

        assert!(

            dom.root.get_merge_callback().is_some(),

            "live state must survive relayout"

        );

        assert!(

            dom.root.get_dataset().is_some(),

            "the widget div must carry its VideoWidgetState"

        );

    }

    #[test]

    fn dom_stores_a_pristine_state_for_every_config() {

        for cfg in all_configs() {

            let dom = VideoWidget::create(cfg.clone()).dom();

            let mut dataset = dom

                .root

                .get_dataset()

                .cloned()

                .expect("the node must carry its VideoWidgetState");

            assert_same_config(&read_config(&mut dataset), &cfg);

            assert_eq!(

                read_state(&mut dataset),

                StateSummary {

                    started: false,

                    gl_texture_id: None,

                    has_hook: false,

                    has_frames: false,