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

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

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

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

            },

        }

    };

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

    };

    };

    };

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

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

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

    };

        }

    }

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

    {

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

    }