//! Unified drag context for all drag operations.

//!

//! This module provides a single, coherent way to handle all drag operations:

//! - Text selection drag

//! - Scrollbar thumb drag

//! - Node drag-and-drop

//! - Window drag/resize

//! - File drop from OS

//!

//! The `DragContext` struct tracks the current drag state and provides

//! a unified interface for event processing.

use alloc::vec::Vec;

use crate::dom::{DomId, DomNodeId, NodeId, OptionDomNodeId};

use crate::geom::LogicalPosition;

use crate::selection::TextCursor;

use crate::window::WindowPosition;

use azul_css::{AzString, StringVec, U8Vec};

/// Type of the active drag operation.

///

/// This enum unifies all drag types into a single discriminated union,

/// making it easy to handle different drag behaviors in one place.

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum ActiveDragType {

    /// Text selection drag - user is selecting text by dragging

    TextSelection(TextSelectionDrag),

    /// Scrollbar thumb drag - user is dragging a scrollbar thumb

    ScrollbarThumb(ScrollbarThumbDrag),

    /// Node drag-and-drop - user is dragging a DOM node

    Node(NodeDrag),

    /// Window drag - user is moving the window (titlebar drag)

    WindowMove(WindowMoveDrag),

    /// Window resize - user is resizing the window (edge/corner drag)

    WindowResize(WindowResizeDrag),

    /// File drop from OS - user is dragging file(s) from the OS

    FileDrop(FileDropDrag),

}

/// Text selection drag state.

///

/// Tracks the anchor point (where selection started) and current position.

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

#[repr(C)]

pub struct TextSelectionDrag {

    /// DOM ID where the selection started

    pub dom_id: DomId,

    /// The IFC root node where selection started (e.g., <p> element)

    pub anchor_ifc_node: NodeId,

    /// The anchor cursor position (fixed during drag)

    pub anchor_cursor: Option<TextCursor>,

    /// Mouse position where drag started

    pub start_mouse_position: LogicalPosition,

    /// Current mouse position

    pub current_mouse_position: LogicalPosition,

}

/// Scrollbar thumb drag state.

///

/// Tracks which scrollbar is being dragged and the current offset.

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

#[repr(C)]

pub struct ScrollbarThumbDrag {

    /// DOM ID that `scroll_container_node` belongs to. Used to scope

    /// `remap_node_ids` so a reconciliation of a *different* DOM can't remap

    /// this drag's node id against an unrelated DOM's old→new map.

    pub dom_id: DomId,

    /// The scroll container node being scrolled

    pub scroll_container_node: NodeId,

    /// Whether this is the vertical or horizontal scrollbar

    pub axis: ScrollbarAxis,

    /// Mouse Y position where drag started (for calculating delta)

    pub start_mouse_position: LogicalPosition,

    /// Scroll offset when drag started

    pub start_scroll_offset: f32,

    /// Current mouse position

    pub current_mouse_position: LogicalPosition,

    /// Track length in pixels (for calculating scroll ratio)

    pub track_length_px: f32,

    /// Content length in pixels (for calculating scroll ratio)

    pub content_length_px: f32,

    /// Viewport length in pixels (for calculating scroll ratio)

    pub viewport_length_px: f32,

}

/// Which scrollbar axis is being dragged

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

#[repr(C)]

pub enum ScrollbarAxis {

    Vertical,

    Horizontal,

}

/// Node drag-and-drop state.

///

/// Tracks a DOM node being dragged for reordering or moving.

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

#[repr(C)]

pub struct NodeDrag {

    /// DOM ID of the node being dragged

    pub dom_id: DomId,

    /// Node ID being dragged

    pub node_id: NodeId,

    /// Position where drag started

    pub start_position: LogicalPosition,

    /// Current drag position

    pub current_position: LogicalPosition,

    /// Offset from node origin to click point (for correct visual positioning)

    pub drag_offset: LogicalPosition,

    /// Optional: DOM node currently under cursor (drop target)

    pub current_drop_target: OptionDomNodeId,

    /// Previous drop target (for generating DragEnter/DragLeave events)

    pub previous_drop_target: OptionDomNodeId,

    /// Drag data (MIME types and content)

    pub drag_data: DragData,

    /// Whether the current drop target has accepted the drop via `accept_drop()`

    pub drop_accepted: bool,

    /// Drop effect set by the drop target

    pub drop_effect: DropEffect,

}

/// Window move drag state.

///

/// Tracks the window being moved via titlebar drag.

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

#[repr(C)]

pub struct WindowMoveDrag {

    /// Position where window drag started (in screen coordinates)

    pub start_position: LogicalPosition,

    /// Current drag position

    pub current_position: LogicalPosition,

    /// Initial window position before drag

    pub initial_window_position: WindowPosition,

}

/// Window resize drag state.

///

/// Tracks the window being resized via edge/corner drag.

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

#[repr(C)]

pub struct WindowResizeDrag {

    /// Which edge/corner is being dragged

    pub edge: WindowResizeEdge,

    /// Position where resize started

    pub start_position: LogicalPosition,

    /// Current drag position

    pub current_position: LogicalPosition,

    /// Initial window size before resize

    pub initial_width: u32,

    /// Initial window height before resize

    pub initial_height: u32,

}

/// Which edge or corner of the window is being resized

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

#[repr(C)]

pub enum WindowResizeEdge {

    Top,

    Bottom,

    Left,

    Right,

    TopLeft,

    TopRight,

    BottomLeft,

    BottomRight,

}

/// File drop from OS drag state.

///

/// Tracks files being dragged from the operating system.

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

#[repr(C)]

pub struct FileDropDrag {

    /// Files being dragged (as string paths)

    pub files: StringVec,

    /// Current position of drag cursor

    pub position: LogicalPosition,

    /// DOM node under cursor (potential drop target)

    pub drop_target: OptionDomNodeId,

    /// Allowed drop effect

    pub drop_effect: DropEffect,

}

/// Drop effect — the operation that will happen if the data is dropped

/// on the current target (HTML5 `DataTransfer.dropEffect`).

///

/// This is a strict subset of `DragEffect`: a drop target selects one of

/// these four outcomes, which must also be allowed by the source's

/// `effect_allowed`.

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

#[repr(C)]

pub enum DropEffect {

    /// No drop allowed / the drop is rejected. Default.

    #[default]

    None,

    /// Drop will copy the data (source retains its copy).

    Copy,

    /// Drop will create a link/shortcut to the data.

    Link,

    /// Drop will move the data (source should remove its copy).

    Move,

}

/// Allowed drag effects — the set of operations the drag source permits

/// (HTML5 `DataTransfer.effectAllowed`).

///

/// The drop target's `DropEffect` must be a member of this set for the

/// drop to succeed. Semantic superset of `DropEffect` that adds the

/// HTML5 combined-permission values (`CopyLink`, `CopyMove`, `LinkMove`,

/// `All`) and the pre-drag `Uninitialized` sentinel.

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

#[repr(C)]

pub enum DragEffect {

    /// Allowed set has not been initialized yet (equivalent to `All` in

    /// most user agents). Default for fresh drags.

    #[default]

    Uninitialized,

    /// No drop is permitted.

    None,

    /// Only Copy is permitted.

    Copy,

    /// Copy or Link is permitted.

    CopyLink,

    /// Copy or Move is permitted.

    CopyMove,

    /// Only Link is permitted.

    Link,

    /// Link or Move is permitted.

    LinkMove,

    /// Only Move is permitted.

    Move,

    /// Any of Copy, Link, or Move is permitted.

    All,

}

/// FFI-safe (`mime_type`, `data`) pair used by [`DragData`] in place of

/// a `BTreeMap<AzString, Vec<u8>>` entry.

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

#[repr(C)]

pub struct MimeTypeData {

    pub mime_type: AzString,

    pub data: U8Vec,

}

impl_option!(

    MimeTypeData,

    OptionMimeTypeData,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash]

);

impl_vec!(

    MimeTypeData,

    MimeTypeDataVec,

    MimeTypeDataVecDestructor,

    MimeTypeDataVecDestructorType,

    MimeTypeDataVecSlice,

    OptionMimeTypeData

);

impl_vec_mut!(MimeTypeData, MimeTypeDataVec);

impl_vec_debug!(MimeTypeData, MimeTypeDataVec);

impl_vec_partialord!(MimeTypeData, MimeTypeDataVec);

impl_vec_ord!(MimeTypeData, MimeTypeDataVec);

impl_vec_clone!(MimeTypeData, MimeTypeDataVec, MimeTypeDataVecDestructor);

impl_vec_partialeq!(MimeTypeData, MimeTypeDataVec);

impl_vec_eq!(MimeTypeData, MimeTypeDataVec);

impl_vec_hash!(MimeTypeData, MimeTypeDataVec);

/// Drag data (HTML5 `DataTransfer`).

///

/// Holds the payload(s) being transferred during a drag operation, keyed

/// by MIME type, plus the set of operations the source allows.

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

#[repr(C)]

pub struct DragData {

    /// MIME type -> data mapping (vec-of-pairs for FFI compatibility).

    ///

    /// e.g., `"text/plain" -> "Hello World"`.

    pub data: MimeTypeDataVec,

    /// Set of drag operations the source permits for this drag.

    pub effect_allowed: DragEffect,

}

impl DragData {

    /// Create new empty drag data

    /// Set data for a MIME type. Replaces any existing entry for the

    /// same MIME type.

    /// Get data for a MIME type

    /// Set plain text data

    /// Get plain text data

}

/// The unified drag context.

///

/// This struct wraps `ActiveDragType` and provides common metadata

/// that applies to all drag operations.

///

/// Note: this type is Rust-only and not exposed through the C API.

#[derive(Debug, Clone, PartialEq)]

pub struct DragContext {

    /// The specific type of drag operation

    pub drag_type: ActiveDragType,

    /// Session ID from gesture detection (links back to `GestureManager`)

    pub session_id: u64,

    /// Whether the drag has been cancelled (e.g., Escape pressed)

    pub cancelled: bool,

}

impl DragContext {

    /// Create a new drag context

    /// Create a text selection drag

        )

    /// Create a scrollbar thumb drag

        )

    /// Create a node drag

        )

    /// Create a window move drag

        )

    /// Create a file drop drag

        )

    /// Update the current mouse position for all drag types

        }

    /// Get the current mouse position

        }

    /// Get the start position

        }

    /// Check if this is a text selection drag

    /// Check if this is a scrollbar thumb drag

    /// Check if this is a node drag

    /// Check if this is a window move drag

    /// Check if this is a file drop

    /// Get as text selection drag (if applicable)

        }

    /// Get as mutable text selection drag (if applicable)

        }

    /// Get as scrollbar thumb drag (if applicable)

        }

    /// Get as mutable scrollbar thumb drag (if applicable)

        }

    /// Get as node drag (if applicable)

        }

    /// Get as mutable node drag (if applicable)

        }

    /// Get as window move drag (if applicable)

        }

    /// Get as file drop (if applicable)

        }

    /// Get as mutable file drop (if applicable)

        }

    /// Calculate scroll delta for scrollbar thumb drag

    ///

    /// Returns the new scroll offset based on current mouse position.

        // Calculate mouse delta along the drag axis

            ScrollbarAxis::Vertical => {

            }

            ScrollbarAxis::Horizontal => {

            }

        };

        // Calculate the scrollable range

        // The explicit `is_nan()` (equivalent to the old `!(x > 0.0)`) catches a NaN

        // scrollable_range — from a NaN, or inf-minus-inf, content/viewport length —

        // so it never reaches the `clamp(0.0, scrollable_range)` below, whose

        // f32::clamp would panic (it asserts min <= max, and NaN fails every compare).

        // Calculate thumb length (proportional to viewport/content ratio)

        // Convert mouse delta to scroll delta

        // Calculate new scroll offset

        // Clamp to valid range

    /// Remap a drop target's `NodeId` using the old→new mapping.

    /// Clears the target if the old `NodeId` was removed.

        };

        };

    /// Remap `NodeIds` stored in this drag context after DOM reconciliation.

    ///

    /// When the DOM is regenerated during an active drag, `NodeIds` can change.

    /// This updates all stored `NodeIds` using the old→new mapping.

    /// Returns `false` if a critical `NodeId` was removed (drag should be cancelled).

                }

            }

                // Scope the remap to the DOM this drag belongs to: a different

                // DOM's reconciliation must not touch our scroll container id.

                } else {

                }

            }

                }

                // Drop target remap — both current AND previous, otherwise a

                // stale `previous_drop_target` keeps a pre-reconciliation NodeId

                // and later generates spurious DragEnter/DragLeave against a

                // node that no longer exists (or a different node reusing the id).

            }

            // WindowMove, WindowResize, and FileDrop don't reference DOM NodeIds

            }

        }

}

azul_css::impl_option!(

    DragContext,

    OptionDragContext,

    copy = false,

    [Debug, Clone, PartialEq]

);

/// Drag offset from the cursor position at drag start (logical pixels).

/// `dx`/`dy` are the delta from drag start to current position.

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

#[repr(C)]

pub struct DragDelta {

    pub dx: f32,

    pub dy: f32,

}

impl DragDelta {

    #[inline]

    #[inline]

}

impl_option!(

    DragDelta,

    OptionDragDelta,

    [Debug, Copy, Clone, PartialEq, PartialOrd]

);

#[cfg(test)]

mod audit_tests {

    use super::*;

    use crate::styled_dom::NodeHierarchyItemId;

    #[test]

            0.0, 100.0, 300.0, 100.0,

            1,

        );

        // Reconciling a *different* DOM (id 1) must not touch our node id.

        // Reconciling our own DOM (id 0) remaps it.

    #[test]

            2,

        );

        // Map: dragged node 1->1, drop targets 5->50, 6->60.

}

#[cfg(test)]

mod autotest_generated {

    use alloc::collections::BTreeMap;

    use alloc::string::{String, ToString};

    use super::*;

    use crate::geom::PhysicalPosition;

    use crate::styled_dom::NodeHierarchyItemId;

    // ---------------------------------------------------------------- helpers

    fn dom(i: usize) -> DomId {

        DomId { inner: i }

    }

    fn dnid(dom_idx: usize, node: usize) -> DomNodeId {

        DomNodeId {

            dom: dom(dom_idx),

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

        }

    }

    /// A drop target that points at a DOM but carries *no* node id (the `None`

    /// encoding of `NodeHierarchyItemId`).

    fn dnid_no_node(dom_idx: usize) -> DomNodeId {

        DomNodeId {

            dom: dom(dom_idx),

            node: NodeHierarchyItemId::from_crate_internal(None),

        }

    }

    fn nid_map(pairs: &[(usize, usize)]) -> BTreeMap<NodeId, NodeId> {

        let mut m = BTreeMap::new();

        for (from, to) in pairs {

            m.insert(NodeId::new(*from), NodeId::new(*to));

        }

        m

    }

    /// Vertical scrollbar drag anchored at (0, 0), no mouse movement yet.

    fn vscroll(

        start_scroll_offset: f32,

        track_length_px: f32,

        content_length_px: f32,

        viewport_length_px: f32,

    ) -> DragContext {

        DragContext::scrollbar_thumb(

            dom(0),

            NodeId::new(1),

            ScrollbarAxis::Vertical,

            LogicalPosition::zero(),

            start_scroll_offset,

            track_length_px,

            content_length_px,

            viewport_length_px,

            7,

        )

    }

    fn resize_ctx() -> DragContext {

        DragContext::new(

            ActiveDragType::WindowResize(WindowResizeDrag {

                edge: WindowResizeEdge::BottomRight,

                start_position: LogicalPosition::new(1.0, 2.0),

                current_position: LogicalPosition::new(1.0, 2.0),

                initial_width: u32::MAX,

                initial_height: 0,

            }),

            u64::MAX,

        )

    }

    // ============================================================ DragData

    // parser-ish surface: get_data / set_data / set_text / get_text

    #[test]

    fn dragdata_new_is_empty_and_matches_default() {

        let d = DragData::new();

        assert_eq!(d.data.len(), 0);

        assert!(d.data.is_empty());

        assert_eq!(d.effect_allowed, DragEffect::Uninitialized);

        assert_eq!(d, DragData::default());

        assert!(d.get_data("text/plain").is_none());

        assert!(d.get_text().is_none());

    }

    #[test]

    fn get_data_valid_minimal_positive_control() {

        let mut d = DragData::new();

        d.set_data("text/plain", b"hi".to_vec());

        assert_eq!(d.get_data("text/plain"), Some(&b"hi"[..]));

    }

    #[test]

    fn get_data_empty_key_on_empty_and_populated_returns_none() {

        let empty = DragData::new();

        assert!(empty.get_data("").is_none());

        let mut d = DragData::new();

        d.set_data("text/plain", b"x".to_vec());

        assert!(d.get_data("").is_none());

    }

    #[test]

    fn get_data_empty_key_is_a_real_key_when_stored() {

        // "" is not special-cased: it is a perfectly good (if silly) map key.

        let mut d = DragData::new();

        d.set_data("", b"empty-key".to_vec());

        assert_eq!(d.get_data(""), Some(&b"empty-key"[..]));

        assert!(d.get_data("text/plain").is_none());

    }

    #[test]

    fn get_data_whitespace_only_keys_return_none() {

        let mut d = DragData::new();

        d.set_data("text/plain", b"x".to_vec());

        for k in ["   ", "\t\n", "\r\n", "\u{a0}", "\u{2028}"] {

            assert!(d.get_data(k).is_none(), "whitespace key {k:?} matched");

        }

    }

    #[test]

    fn get_data_garbage_bytes_return_none_without_panicking() {

        let mut d = DragData::new();

        d.set_data("text/plain", b"x".to_vec());

        for k in [

            "\u{0}",

            "\u{0}\u{1}\u{2}\u{7f}",

            "\u{feff}",

            "%%%;;;///",

            "text/plain\u{0}",

            "\u{0}text/plain",

        ] {

            assert!(d.get_data(k).is_none(), "garbage key {k:?} matched");

        }

    }

    #[test]

    fn get_data_leading_trailing_junk_is_not_trimmed() {

        let mut d = DragData::new();

        d.set_data("text/plain", b"x".to_vec());

        // Lookup is an exact byte-for-byte match: no trimming, no tolerance.

        assert!(d.get_data("  text/plain  ").is_none());

        assert!(d.get_data("text/plain;garbage").is_none());

        assert!(d.get_data("text/plain ").is_none());

        assert!(d.get_data(" text/plain").is_none());

        assert_eq!(d.get_data("text/plain"), Some(&b"x"[..]));

    }

    #[test]

    fn get_data_is_case_sensitive() {

        // MIME types are case-insensitive per RFC 2045, but this map is not.

        let mut d = DragData::new();

        d.set_data("text/plain", b"x".to_vec());

        assert!(d.get_data("TEXT/PLAIN").is_none());

        assert!(d.get_data("Text/Plain").is_none());

    }

    #[test]

    fn get_data_boundary_number_strings_return_none() {

        let mut d = DragData::new();

        d.set_data("text/plain", b"x".to_vec());

        for k in [

            "0",

            "-0",

            "9223372036854775807",  // i64::MAX

            "-9223372036854775808", // i64::MIN

            "18446744073709551615", // u64::MAX

            "1e400",

            "NaN",

            "inf",

            "-inf",

            "1.7976931348623157e308",

            "5e-324",

        ] {

            assert!(d.get_data(k).is_none(), "numeric key {k:?} matched");

        }

    }

    #[test]

    fn get_data_unicode_keys_round_trip() {

        let mut d = DragData::new();

        let emoji = "application/x-\u{1F600};charset=utf-8";

        let combining = "text/e\u{0301}"; // e + combining acute

        d.set_data(emoji, b"grin".to_vec());

        d.set_data(combining, b"acute".to_vec());

        assert_eq!(d.get_data(emoji), Some(&b"grin"[..]));

        assert_eq!(d.get_data(combining), Some(&b"acute"[..]));

        // NFC-equivalent but byte-distinct key must NOT match (no normalization).

        assert!(d.get_data("text/\u{e9}").is_none());

        assert_eq!(d.data.len(), 2);

    }

    #[test]

    fn get_data_extremely_long_key_does_not_panic_or_hang() {

        let huge: String = "a".repeat(1_000_000);

        let mut d = DragData::new();

        d.set_data("text/plain", b"x".to_vec());

        // Miss against a 1M-char key.

        assert!(d.get_data(&huge).is_none());

        // Round-trip the 1M-char key itself.

        d.set_data(huge.as_str(), b"huge-key".to_vec());

        assert_eq!(d.get_data(&huge), Some(&b"huge-key"[..]));

        // A 1M-char key that differs only in the last byte must miss.

        let mut nearly = huge.clone();

        let _ = nearly.pop();

        nearly.push('b');

        assert!(d.get_data(&nearly).is_none());

    }

    #[test]

    fn get_data_deeply_nested_brackets_do_not_stack_overflow() {

        // The lookup is a linear scan, not a recursive-descent parse: 10k

        // nested brackets must be inert.

        let nested: String = "[".repeat(10_000);

        let mut d = DragData::new();

        assert!(d.get_data(&nested).is_none());

        d.set_data(nested.as_str(), b"nested".to_vec());

        assert_eq!(d.get_data(&nested), Some(&b"nested"[..]));

    }

    #[test]

    fn set_data_replaces_existing_entry_for_same_mime() {

        let mut d = DragData::new();

        d.set_data("text/plain", b"first".to_vec());

        d.set_data("text/plain", b"second".to_vec());

        assert_eq!(d.data.len(), 1, "duplicate MIME key was appended");

        assert_eq!(d.get_data("text/plain"), Some(&b"second"[..]));

    }

    #[test]

    fn set_data_empty_payload_is_some_empty_not_none() {

        let mut d = DragData::new();

        d.set_data("application/octet-stream", Vec::new());

        // Presence and emptiness are distinguishable.

        assert_eq!(d.get_data("application/octet-stream"), Some(&b""[..]));

        assert!(d.get_data("application/octet-stream").is_some());

    }

    #[test]

    fn set_data_huge_payload_round_trips() {

        let mut d = DragData::new();

        let payload = alloc::vec![0xABu8; 1 << 20]; // 1 MiB

        d.set_data("application/octet-stream", payload);

        let got = d.get_data("application/octet-stream").unwrap();

        assert_eq!(got.len(), 1 << 20);

        assert!(got.iter().all(|b| *b == 0xAB));

    }

    #[test]

    fn set_data_binary_payload_is_not_utf8_validated() {

        let mut d = DragData::new();

        d.set_data("application/octet-stream", alloc::vec![0xFF, 0x00, 0xFE]);

        assert_eq!(d.get_data("application/octet-stream"), Some(&[0xFFu8, 0x00, 0xFE][..]));

    }

    #[test]

    fn set_data_many_distinct_mime_types_all_retrievable() {

        let mut d = DragData::new();

        for i in 0..1_000usize {

            let mut key = String::from("application/x-");

            key.push_str(&i.to_string());

            d.set_data(key.as_str(), alloc::vec![(i % 251) as u8]);

        }

        assert_eq!(d.data.len(), 1_000);

        assert_eq!(d.get_data("application/x-0"), Some(&[0u8][..]));

        assert_eq!(d.get_data("application/x-999"), Some(&[(999 % 251) as u8][..]));

        assert!(d.get_data("application/x-1000").is_none());

    }

    #[test]

    fn set_text_get_text_round_trip_unicode() {

        for s in [

            "hello",

            "",

            "\u{1F600}\u{1F4A9}",

            "e\u{0301}\u{0300}\u{0308}", // stacked combining marks

            "\u{200B}zero-width",

            "line1\nline2\r\n\ttab",

            "\u{0}interior nul\u{0}",

        ] {

            let mut d = DragData::new();

            d.set_text(s);

            let got = d.get_text().expect("text/plain must be present");

            assert_eq!(got.as_str(), s, "round-trip failed for {s:?}");

        }

    }

    #[test]

    fn set_text_empty_is_some_not_none() {

        let mut d = DragData::new();

        d.set_text("");

        assert!(d.get_text().is_some());

        assert_eq!(d.get_text().unwrap().as_str(), "");

        assert_eq!(d.get_data("text/plain"), Some(&b""[..]));

    }

    #[test]

    fn set_text_huge_string_round_trips() {

        let huge: String = "\u{1F600}".repeat(100_000); // 400_000 bytes

        let mut d = DragData::new();

        d.set_text(huge.as_str());

        let got = d.get_text().unwrap();

        assert_eq!(got.as_str().len(), 400_000);

        assert_eq!(got.as_str(), huge.as_str());

        assert_eq!(d.data.len(), 1);

    }

    #[test]

    fn set_text_twice_replaces_and_does_not_grow() {

        let mut d = DragData::new();

        d.set_text("one");

        d.set_text("two");

        assert_eq!(d.data.len(), 1);

        assert_eq!(d.get_text().unwrap().as_str(), "two");

    }

    #[test]

    fn set_text_then_set_data_on_same_mime_wins() {

        let mut d = DragData::new();

        d.set_text("text");

        d.set_data("text/plain", b"raw".to_vec());

        assert_eq!(d.data.len(), 1);

        assert_eq!(d.get_text().unwrap().as_str(), "raw");

    }

    #[test]

    fn get_text_on_invalid_utf8_yields_empty_string_not_panic() {

        // Documents the `unwrap_or("")` fallback: invalid UTF-8 under

        // "text/plain" is silently reported as an EMPTY string, not None and

        // not a panic. (Lossy data: the bytes are still there via get_data.)

        let mut d = DragData::new();

        d.set_data("text/plain", alloc::vec![0xFF, 0xFE, 0x80]);

        let got = d.get_text().expect("entry exists, so Some");

        assert_eq!(got.as_str(), "");

        assert_eq!(d.get_data("text/plain"), Some(&[0xFFu8, 0xFE, 0x80][..]));

    }

    #[test]

    fn get_text_truncated_utf8_yields_empty_string() {

        let mut d = DragData::new();

        // First 3 bytes of a 4-byte emoji.

        d.set_data("text/plain", alloc::vec![0xF0, 0x9F, 0x98]);

        assert_eq!(d.get_text().unwrap().as_str(), "");

    }

    #[test]

    fn get_text_is_none_when_only_other_mimes_present() {

        let mut d = DragData::new();

        d.set_data("text/html", b"<b>x</b>".to_vec());

        assert!(d.get_text().is_none());

    }

    // ==================================================== DragContext ctors

    #[test]

    fn drag_context_new_preserves_session_id_and_is_not_cancelled() {

        for sid in [0u64, 1, u64::MAX] {

            let ctx = DragContext::new(

                ActiveDragType::WindowMove(WindowMoveDrag {

                    start_position: LogicalPosition::zero(),

                    current_position: LogicalPosition::zero(),

                    initial_window_position: WindowPosition::Uninitialized,

                }),

                sid,

            );

            assert_eq!(ctx.session_id, sid);

            assert!(!ctx.cancelled);

        }

    }

    #[test]

    fn text_selection_invariants_at_extremes() {

        let pos = LogicalPosition::new(f32::MIN, f32::MAX);

        let ctx = DragContext::text_selection(

            dom(usize::MAX),

            NodeId::new(usize::MAX),

            pos,

            u64::MAX,

        );

        let ts = ctx.as_text_selection().expect("must be a text selection");

        assert_eq!(ts.dom_id, dom(usize::MAX));

        assert_eq!(ts.anchor_ifc_node, NodeId::new(usize::MAX));

        assert!(ts.anchor_cursor.is_none());

        // start == current at construction, bit-for-bit (quantized PartialEq

        // would happily accept a saturated mismatch here, so compare raw bits).

        assert_eq!(ts.start_mouse_position.x.to_bits(), f32::MIN.to_bits());

        assert_eq!(ts.start_mouse_position.y.to_bits(), f32::MAX.to_bits());

        assert_eq!(

            ts.current_mouse_position.x.to_bits(),

            ts.start_mouse_position.x.to_bits()

        );

        assert_eq!(ctx.session_id, u64::MAX);

    }

    #[test]

    fn text_selection_with_nan_position_does_not_panic() {

        let ctx = DragContext::text_selection(

            dom(0),

            NodeId::ZERO,

            LogicalPosition::new(f32::NAN, f32::NEG_INFINITY),

            0,

        );

        let ts = ctx.as_text_selection().unwrap();

        assert!(ts.start_mouse_position.x.is_nan());

        assert!(ts.current_mouse_position.x.is_nan());

        assert_eq!(ts.start_mouse_position.y, f32::NEG_INFINITY);

    }

    #[test]

    fn scrollbar_thumb_stores_all_float_metrics_verbatim_incl_nan_inf() {

        let ctx = DragContext::scrollbar_thumb(

            dom(3),

            NodeId::new(9),

            ScrollbarAxis::Horizontal,

            LogicalPosition::new(f32::INFINITY, f32::NEG_INFINITY),

            f32::NAN,

            f32::INFINITY,

            -0.0,

            f32::MAX,

            0,

        );

        let sb = ctx.as_scrollbar_thumb().unwrap();

        assert_eq!(sb.dom_id, dom(3));

        assert_eq!(sb.scroll_container_node, NodeId::new(9));

        assert_eq!(sb.axis, ScrollbarAxis::Horizontal);

        assert!(sb.start_scroll_offset.is_nan(), "NaN was mangled at construction");

        assert_eq!(sb.track_length_px, f32::INFINITY);

        assert!(sb.content_length_px.is_sign_negative(), "-0.0 lost its sign");

        assert_eq!(sb.content_length_px, 0.0);

        assert_eq!(sb.viewport_length_px, f32::MAX);

        assert_eq!(sb.current_mouse_position.x, f32::INFINITY);

    }

    #[test]

    fn scrollbar_thumb_all_zero_is_constructible() {

        let ctx = vscroll(0.0, 0.0, 0.0, 0.0);

        assert!(ctx.is_scrollbar_thumb());

        let sb = ctx.as_scrollbar_thumb().unwrap();

        assert_eq!(sb.start_scroll_offset, 0.0);

        assert_eq!(sb.track_length_px, 0.0);

    }

    #[test]

    fn node_drag_invariants_hold_after_construction() {

        let mut data = DragData::new();

        data.set_text("payload");

        let ctx = DragContext::node_drag(

            dom(2),

            NodeId::new(usize::MAX),

            LogicalPosition::new(-1.5, 2.5),

            data,

            u64::MAX,

        );

        let nd = ctx.as_node_drag().unwrap();

        assert_eq!(nd.dom_id, dom(2));

        assert_eq!(nd.node_id, NodeId::new(usize::MAX));

        assert_eq!(nd.start_position, nd.current_position);

        assert_eq!(nd.drag_offset, LogicalPosition::zero());

        assert!(nd.current_drop_target.into_option().is_none());

        assert!(nd.previous_drop_target.into_option().is_none());

        assert!(!nd.drop_accepted);

        assert_eq!(nd.drop_effect, DropEffect::None);

        assert_eq!(nd.drag_data.get_text().unwrap().as_str(), "payload");

    }

    #[test]

    fn node_drag_with_empty_drag_data_is_fine() {

        let ctx = DragContext::node_drag(

            dom(0),

            NodeId::ZERO,

            LogicalPosition::new(f32::NAN, f32::NAN),

            DragData::new(),

            0,

        );

        let nd = ctx.as_node_drag().unwrap();

        assert!(nd.drag_data.data.is_empty());

        assert!(nd.start_position.x.is_nan());

        assert!(nd.current_position.x.is_nan());

    }

    #[test]

    fn window_move_preserves_initial_window_position_extremes() {

        for wp in [

            WindowPosition::Uninitialized,

            WindowPosition::Initialized(PhysicalPosition {

                x: i32::MIN,

                y: i32::MAX,