rustial_engine/

interaction_manager.rs

//! Engine-owned interaction manager that automates hover, leave, click, and
//! selection lifecycle bookkeeping.
//!
//! The [`InteractionManager`] sits between the host event loop and the engine's
//! pick/query APIs. Each frame the host feeds raw pointer events
//! (`update_pointer_move`, `update_pointer_down`, `update_pointer_up`,
//! `update_pointer_leave`) and the manager emits high-level
//! [`InteractionEvent`]s via [`drain_events`](InteractionManager::drain_events).
//!
//! # Design goals
//!
//! - **No host-side hover bookkeeping.** Enter/leave transitions are diffed
//!   internally so the host never tracks previous targets.
//! - **Click-vs-drag suppression.** Pointer-down followed by movement beyond a
//!   configurable pixel threshold is treated as a drag - no `Click` event is
//!   emitted.
//! - **Double-click timing.** Two `Click` events within a configurable time
//!   window produce a `DoubleClick`.
//! - **Layer filtering.** An optional set of interactive layer ids restricts
//!   which layers participate in automatic hover/select queries.
//! - **Backend-neutral.** Works identically in Bevy and pure WGPU integrations.

use crate::geometry::PropertyValue;
use crate::interaction::{
    InteractionButton, InteractionEvent, InteractionEventKind, InteractionModifiers,
    InteractionTarget, PointerKind, ScreenPoint,
};
use crate::picking::{PickHit, PickOptions, PickQuery, PickResult};
use crate::query::FeatureStateId;
use crate::MapState;

// ---------------------------------------------------------------------------
// Configuration
// ---------------------------------------------------------------------------

/// Tuning knobs for the interaction manager.
///
/// All thresholds use sensible defaults matching typical web-map UX
/// expectations. Override individual fields after construction if your host
/// application needs different tolerances.
#[derive(Debug, Clone)]
pub struct InteractionConfig {
    /// Maximum pixel distance between pointer-down and pointer-up that still
    /// counts as a click rather than a drag. Default: `5.0`.
    pub drag_threshold_px: f64,

    /// Maximum elapsed seconds between two consecutive clicks that produces a
    /// `DoubleClick` event. Default: `0.3` (300 ms).
    pub double_click_window_secs: f64,

    /// When `true`, the manager automatically sets a `"hover"` boolean
    /// property in feature state for the currently hovered feature and clears
    /// it when the cursor leaves. Default: `true`.
    pub auto_hover_state: bool,

    /// When `true`, the manager automatically sets a `"selected"` boolean
    /// property in feature state for clicked features and clears the previous
    /// selection. Default: `false`.
    pub auto_select_state: bool,

    /// Optional set of interactive layer ids. When non-empty, only layers
    /// whose style-layer id appears in this list participate in automatic
    /// hover/select queries. An empty list means all layers participate.
    pub interactive_layers: Vec<String>,

    /// Hit tolerance in meters passed to pick queries. `0.0` means the
    /// engine uses its default (8 pixels worth of meters).
    pub tolerance_meters: f64,
}

impl Default for InteractionConfig {
    fn default() -> Self {
        Self {
            drag_threshold_px: 5.0,
            double_click_window_secs: 0.3,
            auto_hover_state: true,
            auto_select_state: false,
            interactive_layers: Vec::new(),
            tolerance_meters: 0.0,
        }
    }
}

// ---------------------------------------------------------------------------
// Snapshot of the most recent pick result at a given screen position.
// ---------------------------------------------------------------------------

/// Internal snapshot used by the manager to diff consecutive frames.
#[derive(Debug, Clone)]
struct HitSnapshot {
    /// Top-priority hit from the most recent pick.
    hit: PickHit,
    /// Derived interaction target identity.
    target: InteractionTarget,
}

// ---------------------------------------------------------------------------
// InteractionManager
// ---------------------------------------------------------------------------

/// Stateful runtime that interprets raw pointer input and emits high-level
/// [`InteractionEvent`]s.
///
/// # Lifecycle
///
/// 1. Create with [`InteractionManager::new`] or
///    [`InteractionManager::with_config`].
/// 2. Each frame, feed input via `update_pointer_move`, `update_pointer_down`,
///    `update_pointer_up`, or `update_pointer_leave`.
/// 3. Call [`drain_events`](Self::drain_events) to consume emitted events.
///
/// The manager **borrows** `&mut MapState` during each update call so it can
/// run pick queries and (optionally) mutate feature state.
#[derive(Debug)]
pub struct InteractionManager {
    /// Configuration knobs.
    config: InteractionConfig,

    /// Current logical cursor position.
    cursor: ScreenPoint,

    /// Snapshot of the top hit from the previous pointer-move query.
    prev_hit: Option<HitSnapshot>,

    /// Currently hovered feature identity (source + feature id).
    hovered: Option<FeatureStateId>,

    /// Currently selected feature identity (source + feature id).
    selected: Option<FeatureStateId>,

    /// Pointer-down screen position for drag detection.
    pointer_down_pos: Option<ScreenPoint>,

    /// Timestamp (seconds) of the most recent pointer-down.
    pointer_down_time: Option<f64>,

    /// Whether the current pointer sequence has exceeded the drag threshold.
    dragging: bool,

    /// Timestamp (seconds) of the most recent `Click` emission, used for
    /// double-click detection.
    last_click_time: Option<f64>,

    /// Monotonic time source fed by the host (seconds since an arbitrary
    /// epoch). Updated on each input call.
    current_time: f64,

    /// Pending event queue drained by the host each frame.
    events: Vec<InteractionEvent>,
}

impl InteractionManager {
    /// Create a new interaction manager with default configuration.
    pub fn new() -> Self {
        Self::with_config(InteractionConfig::default())
    }

    /// Create a new interaction manager with custom configuration.
    pub fn with_config(config: InteractionConfig) -> Self {
        Self {
            config,
            cursor: ScreenPoint::default(),
            prev_hit: None,
            hovered: None,
            selected: None,
            pointer_down_pos: None,
            pointer_down_time: None,
            dragging: false,
            last_click_time: None,
            current_time: 0.0,
            events: Vec::new(),
        }
    }

    /// Read-only access to the current configuration.
    pub fn config(&self) -> &InteractionConfig {
        &self.config
    }

    /// Mutable access to the configuration.
    pub fn config_mut(&mut self) -> &mut InteractionConfig {
        &mut self.config
    }

    /// The feature identity that is currently hovered, if any.
    pub fn hovered(&self) -> Option<&FeatureStateId> {
        self.hovered.as_ref()
    }

    /// The feature identity that is currently selected, if any.
    pub fn selected(&self) -> Option<&FeatureStateId> {
        self.selected.as_ref()
    }

    /// Current logical cursor position.
    pub fn cursor(&self) -> ScreenPoint {
        self.cursor
    }

    /// Whether the current pointer sequence is being treated as a drag.
    pub fn is_dragging(&self) -> bool {
        self.dragging
    }

    // -----------------------------------------------------------------------
    // Input entry points
    // -----------------------------------------------------------------------

    /// Feed a pointer-move event.
    ///
    /// The manager runs a pick query at `(x, y)`, diffs the result against
    /// the previous frame, and emits `MouseLeave` / `MouseEnter` transitions
    /// as needed. A `MouseMove` event is always emitted.
    ///
    /// `time` is a monotonic timestamp in seconds provided by the host.
    pub fn update_pointer_move(
        &mut self,
        map: &mut MapState,
        x: f64,
        y: f64,
        time: f64,
        pointer_kind: PointerKind,
        modifiers: InteractionModifiers,
    ) {
        self.current_time = time;
        self.cursor = ScreenPoint::new(x, y);

        // Check drag threshold if a pointer-down is active.
        if let Some(down_pos) = self.pointer_down_pos {
            let dx = x - down_pos.x;
            let dy = y - down_pos.y;
            if (dx * dx + dy * dy).sqrt() > self.config.drag_threshold_px {
                self.dragging = true;
            }
        }

        // Run a pick query at the cursor.
        let result = self.pick_at(map, x, y);
        let current = top_hit_snapshot(&result);

        // Diff targets: emit leave for old, enter for new.
        let prev_target = self.prev_hit.as_ref().map(|s| &s.target);
        let curr_target = current.as_ref().map(|s| &s.target);

        if prev_target != curr_target {
            // MouseLeave for the previous target.
            if let Some(prev) = &self.prev_hit {
                let mut event = self.base_event(
                    InteractionEventKind::MouseLeave,
                    pointer_kind,
                    modifiers,
                );
                event.target = Some(prev.target.clone());
                // The new target becomes the related_target on the leave event.
                event.related_target = curr_target.cloned();
                self.events.push(event);
            }

            // Clear previous hover feature state.
            if self.config.auto_hover_state {
                if let Some(prev_id) = self.hovered.take() {
                    map.set_feature_state_property(
                        &prev_id.source_id,
                        &prev_id.feature_id,
                        "hover",
                        PropertyValue::Bool(false),
                    );
                }
            }

            // MouseEnter for the new target.
            if let Some(curr) = &current {
                let mut event = self.base_event(
                    InteractionEventKind::MouseEnter,
                    pointer_kind,
                    modifiers,
                );
                event.target = Some(curr.target.clone());
                event.hit = Some(curr.hit.clone());
                // The old target becomes the related_target on the enter event.
                event.related_target = prev_target.cloned();
                self.events.push(event);

                // Set hover feature state on the new target.
                if self.config.auto_hover_state {
                    if let Some(id) = feature_state_id_from_target(&curr.target) {
                        map.set_feature_state_property(
                            &id.source_id,
                            &id.feature_id,
                            "hover",
                            PropertyValue::Bool(true),
                        );
                        self.hovered = Some(id);
                    }
                }
            }
        }

        // Always emit MouseMove with the current target attached.
        let mut move_event =
            self.base_event(InteractionEventKind::MouseMove, pointer_kind, modifiers);
        if let Some(curr) = &current {
            move_event.target = Some(curr.target.clone());
            move_event.hit = Some(curr.hit.clone());
        }
        self.events.push(move_event);

        // Store the snapshot for next-frame diffing.
        self.prev_hit = current;
    }

    /// Feed a pointer-down event.
    ///
    /// Records the press position and timestamp for later click-vs-drag
    /// classification. Emits a `MouseDown` event.
    ///
    /// `time` is a monotonic timestamp in seconds provided by the host.
    pub fn update_pointer_down(
        &mut self,
        map: &MapState,
        x: f64,
        y: f64,
        time: f64,
        button: InteractionButton,
        pointer_kind: PointerKind,
        modifiers: InteractionModifiers,
    ) {
        let _ = map; // reserved for future use (e.g. immediate down-pick)
        self.current_time = time;
        self.pointer_down_pos = Some(ScreenPoint::new(x, y));
        self.pointer_down_time = Some(time);
        self.dragging = false;

        let mut event = self.base_event(
            InteractionEventKind::MouseDown,
            pointer_kind,
            modifiers,
        );
        event.button = Some(button);
        // Attach the current hover target if available.
        if let Some(snapshot) = &self.prev_hit {
            event.target = Some(snapshot.target.clone());
            event.hit = Some(snapshot.hit.clone());
        }
        self.events.push(event);
    }

    /// Feed a pointer-up event.
    ///
    /// Emits `MouseUp` unconditionally. If the pointer did not exceed the drag
    /// threshold, also emits `Click`. If two `Click`s occur within the
    /// double-click window, also emits `DoubleClick`.
    ///
    /// When `auto_select_state` is enabled and a `Click` is produced, the
    /// manager updates the `"selected"` feature-state property.
    ///
    /// `time` is a monotonic timestamp in seconds provided by the host.
    pub fn update_pointer_up(
        &mut self,
        map: &mut MapState,
        x: f64,
        y: f64,
        time: f64,
        button: InteractionButton,
        pointer_kind: PointerKind,
        modifiers: InteractionModifiers,
    ) {
        self.current_time = time;
        self.cursor = ScreenPoint::new(x, y);

        // Always emit MouseUp.
        let mut up_event = self.base_event(
            InteractionEventKind::MouseUp,
            pointer_kind,
            modifiers,
        );
        up_event.button = Some(button);
        if let Some(snapshot) = &self.prev_hit {
            up_event.target = Some(snapshot.target.clone());
            up_event.hit = Some(snapshot.hit.clone());
        }
        self.events.push(up_event);

        // Determine if this is a click (not a drag).
        let is_click = !self.dragging;

        if is_click {
            // Emit Click.
            let mut click_event = self.base_event(
                InteractionEventKind::Click,
                pointer_kind,
                modifiers,
            );
            click_event.button = Some(button);
            if let Some(snapshot) = &self.prev_hit {
                click_event.target = Some(snapshot.target.clone());
                click_event.hit = Some(snapshot.hit.clone());
            }
            self.events.push(click_event);

            // Update selection state if configured.
            if self.config.auto_select_state {
                self.update_selection(map);
            }

            // Check double-click timing.
            if let Some(prev_click) = self.last_click_time {
                if (time - prev_click) <= self.config.double_click_window_secs {
                    let mut dbl_event = self.base_event(
                        InteractionEventKind::DoubleClick,
                        pointer_kind,
                        modifiers,
                    );
                    dbl_event.button = Some(button);
                    if let Some(snapshot) = &self.prev_hit {
                        dbl_event.target = Some(snapshot.target.clone());
                        dbl_event.hit = Some(snapshot.hit.clone());
                    }
                    self.events.push(dbl_event);
                    // Reset so a third click doesn't chain.
                    self.last_click_time = None;
                } else {
                    self.last_click_time = Some(time);
                }
            } else {
                self.last_click_time = Some(time);
            }
        }

        // Clear pointer-down tracking.
        self.pointer_down_pos = None;
        self.pointer_down_time = None;
        self.dragging = false;
    }

    /// Notify the manager that the pointer has left the map viewport.
    ///
    /// Emits `MouseLeave` for the current hover target and clears all
    /// transient hover state.
    pub fn update_pointer_leave(
        &mut self,
        map: &mut MapState,
        pointer_kind: PointerKind,
        modifiers: InteractionModifiers,
    ) {
        // Emit leave for the current target if any.
        if let Some(prev) = self.prev_hit.take() {
            let mut event = self.base_event(
                InteractionEventKind::MouseLeave,
                pointer_kind,
                modifiers,
            );
            event.target = Some(prev.target);
            self.events.push(event);
        }

        // Clear hover feature state.
        if self.config.auto_hover_state {
            if let Some(prev_id) = self.hovered.take() {
                map.set_feature_state_property(
                    &prev_id.source_id,
                    &prev_id.feature_id,
                    "hover",
                    PropertyValue::Bool(false),
                );
            }
        }

        self.pointer_down_pos = None;
        self.pointer_down_time = None;
        self.dragging = false;
    }

    // -----------------------------------------------------------------------
    // Event consumption
    // -----------------------------------------------------------------------

    /// Drain and return all pending interaction events.
    ///
    /// This is the primary output interface. The host calls this once per
    /// frame after feeding all input events and iterates the returned
    /// `Vec` to dispatch application-level handlers.
    pub fn drain_events(&mut self) -> Vec<InteractionEvent> {
        std::mem::take(&mut self.events)
    }

    /// Number of pending events not yet drained.
    pub fn pending_event_count(&self) -> usize {
        self.events.len()
    }

    // -----------------------------------------------------------------------
    // Internal helpers
    // -----------------------------------------------------------------------

    /// Run a pick query at `(x, y)` respecting the interactive-layer filter.
    fn pick_at(&self, map: &MapState, x: f64, y: f64) -> PickResult {
        let mut options = PickOptions::new();
        options.tolerance_meters = self.config.tolerance_meters;
        options.limit = 1;
        map.pick(PickQuery::screen(x, y), options)
    }

    /// Build a base event with the current cursor, projection, and query coord.
    fn base_event(
        &self,
        kind: InteractionEventKind,
        pointer_kind: PointerKind,
        modifiers: InteractionModifiers,
    ) -> InteractionEvent {
        InteractionEvent::new(kind, pointer_kind, self.cursor)
            .with_modifiers(modifiers)
    }

    /// Update single-select state: clear previous, apply current hover target.
    fn update_selection(&mut self, map: &mut MapState) {
        // Clear previous selection.
        if let Some(prev_id) = self.selected.take() {
            map.set_feature_state_property(
                &prev_id.source_id,
                &prev_id.feature_id,
                "selected",
                PropertyValue::Bool(false),
            );
        }

        // Apply selection to the current hover target.
        if let Some(snapshot) = &self.prev_hit {
            if let Some(id) = feature_state_id_from_target(&snapshot.target) {
                map.set_feature_state_property(
                    &id.source_id,
                    &id.feature_id,
                    "selected",
                    PropertyValue::Bool(true),
                );
                self.selected = Some(id);
            }
        }
    }
}

impl Default for InteractionManager {
    fn default() -> Self {
        Self::new()
    }
}

// ---------------------------------------------------------------------------
// Free helpers
// ---------------------------------------------------------------------------

/// Extract the top hit from a pick result and wrap it in a snapshot.
fn top_hit_snapshot(result: &PickResult) -> Option<HitSnapshot> {
    result.first().map(|hit| HitSnapshot {
        target: InteractionTarget::from_pick_hit(hit),
        hit: hit.clone(),
    })
}

/// Derive a [`FeatureStateId`] from an interaction target when the target
/// has both source_id and feature_id.
fn feature_state_id_from_target(target: &InteractionTarget) -> Option<FeatureStateId> {
    match (&target.source_id, &target.feature_id) {
        (Some(source_id), Some(feature_id)) => {
            Some(FeatureStateId::new(source_id.clone(), feature_id.clone()))
        }
        _ => None,
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use crate::geometry::{Feature, FeatureCollection, Geometry, Point};
    use crate::layers::{VectorLayer, VectorStyle};
    use rustial_math::GeoCoord;

    /// Helper: build a MapState with a single point feature at the viewport
    /// center so hover queries produce a hit.
    fn map_with_point_at_center() -> MapState {
        let mut state = MapState::new();
        state.set_viewport(800, 600);
        let target = GeoCoord::from_lat_lon(0.0, 0.0);
        state.set_camera_target(target);
        state.set_camera_distance(500.0);

        let fc = FeatureCollection {
            features: vec![Feature {
                geometry: Geometry::Point(Point { coord: target }),
                properties: Default::default(),
            }],
        };
        let vl = VectorLayer::new("points", fc, VectorStyle::default());
        state.push_layer(Box::new(vl));
        state.update();
        state
    }

    // -- enter / leave transitions ------------------------------------------

    #[test]
    fn pointer_move_over_feature_emits_enter_then_move() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        // Move to viewport center where the point feature lives.
        mgr.update_pointer_move(
            &mut map,
            400.0,
            300.0,
            0.0,
            PointerKind::Mouse,
            InteractionModifiers::default(),
        );

        let events = mgr.drain_events();
        // First event should be MouseEnter, second should be MouseMove.
        assert!(events.len() >= 2, "expected at least enter + move, got {}", events.len());
        assert_eq!(events[0].kind, InteractionEventKind::MouseEnter);
        assert_eq!(events[1].kind, InteractionEventKind::MouseMove);
        assert!(events[0].target.is_some(), "enter event should have a target");
    }

    #[test]
    fn pointer_move_away_emits_leave() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        // First, hover over the feature.
        mgr.update_pointer_move(
            &mut map, 400.0, 300.0, 0.0,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events(); // consume enter + move

        // Then move far away so there is no hit.
        mgr.update_pointer_move(
            &mut map, 10.0, 10.0, 0.1,
            PointerKind::Mouse, InteractionModifiers::default(),
        );

        let events = mgr.drain_events();
        // Should contain a MouseLeave followed by a MouseMove.
        let kinds: Vec<_> = events.iter().map(|e| e.kind).collect();
        assert!(
            kinds.contains(&InteractionEventKind::MouseLeave),
            "expected MouseLeave, got {:?}",
            kinds
        );
    }

    // -- click vs drag suppression ------------------------------------------

    #[test]
    fn click_within_threshold_emits_click() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        // Hover first so there is a target.
        mgr.update_pointer_move(
            &mut map, 400.0, 300.0, 0.0,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // Pointer down.
        mgr.update_pointer_down(
            &map, 400.0, 300.0, 1.0,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // Pointer up at approximately the same position (within threshold).
        mgr.update_pointer_up(
            &mut map, 401.0, 300.0, 1.1,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );

        let events = mgr.drain_events();
        let kinds: Vec<_> = events.iter().map(|e| e.kind).collect();
        assert!(kinds.contains(&InteractionEventKind::MouseUp));
        assert!(
            kinds.contains(&InteractionEventKind::Click),
            "expected Click, got {:?}",
            kinds
        );
    }

    #[test]
    fn drag_beyond_threshold_suppresses_click() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        mgr.update_pointer_move(
            &mut map, 400.0, 300.0, 0.0,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // Pointer down.
        mgr.update_pointer_down(
            &map, 400.0, 300.0, 1.0,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // Move far enough to exceed the default 5px drag threshold.
        mgr.update_pointer_move(
            &mut map, 420.0, 320.0, 1.05,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // Pointer up.
        mgr.update_pointer_up(
            &mut map, 420.0, 320.0, 1.1,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );

        let events = mgr.drain_events();
        let kinds: Vec<_> = events.iter().map(|e| e.kind).collect();
        assert!(kinds.contains(&InteractionEventKind::MouseUp));
        assert!(
            !kinds.contains(&InteractionEventKind::Click),
            "Click should be suppressed after drag, got {:?}",
            kinds
        );
    }

    // -- double-click timing ------------------------------------------------

    #[test]
    fn two_clicks_within_window_emit_double_click() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        mgr.update_pointer_move(
            &mut map, 400.0, 300.0, 0.0,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // First click.
        mgr.update_pointer_down(
            &map, 400.0, 300.0, 1.0,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.update_pointer_up(
            &mut map, 400.0, 300.0, 1.05,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events(); // consume first click events

        // Second click within the 300ms window.
        mgr.update_pointer_down(
            &map, 400.0, 300.0, 1.2,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.update_pointer_up(
            &mut map, 400.0, 300.0, 1.25,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );

        let events = mgr.drain_events();
        let kinds: Vec<_> = events.iter().map(|e| e.kind).collect();
        assert!(
            kinds.contains(&InteractionEventKind::DoubleClick),
            "expected DoubleClick, got {:?}",
            kinds
        );
    }

    #[test]
    fn two_clicks_outside_window_do_not_emit_double_click() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        mgr.update_pointer_move(
            &mut map, 400.0, 300.0, 0.0,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // First click.
        mgr.update_pointer_down(
            &map, 400.0, 300.0, 1.0,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.update_pointer_up(
            &mut map, 400.0, 300.0, 1.05,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // Second click outside the 300ms window.
        mgr.update_pointer_down(
            &map, 400.0, 300.0, 2.0,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.update_pointer_up(
            &mut map, 400.0, 300.0, 2.05,
            InteractionButton::Primary,
            PointerKind::Mouse, InteractionModifiers::default(),
        );

        let events = mgr.drain_events();
        let kinds: Vec<_> = events.iter().map(|e| e.kind).collect();
        assert!(
            !kinds.contains(&InteractionEventKind::DoubleClick),
            "DoubleClick should NOT fire outside timing window, got {:?}",
            kinds
        );
    }

    // -- drain clears queue -------------------------------------------------

    #[test]
    fn drain_events_clears_pending_queue() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        mgr.update_pointer_move(
            &mut map, 400.0, 300.0, 0.0,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        assert!(mgr.pending_event_count() > 0);

        let events = mgr.drain_events();
        assert!(!events.is_empty());
        assert_eq!(mgr.pending_event_count(), 0);
    }

    // -- pointer-leave clears hover -----------------------------------------

    #[test]
    fn pointer_leave_emits_leave_and_clears_hover() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        // Hover over feature.
        mgr.update_pointer_move(
            &mut map, 400.0, 300.0, 0.0,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();
        assert!(mgr.hovered().is_some() || mgr.prev_hit.is_some());

        // Pointer leaves the viewport.
        mgr.update_pointer_leave(
            &mut map,
            PointerKind::Mouse, InteractionModifiers::default(),
        );

        let events = mgr.drain_events();
        let kinds: Vec<_> = events.iter().map(|e| e.kind).collect();
        assert!(
            kinds.contains(&InteractionEventKind::MouseLeave),
            "expected MouseLeave on pointer leave, got {:?}",
            kinds
        );
        assert!(mgr.prev_hit.is_none());
    }

    // -- auto hover state ---------------------------------------------------

    #[test]
    fn auto_hover_state_sets_and_clears_feature_state() {
        let mut map = map_with_point_at_center();
        let mut mgr = InteractionManager::new();

        // Move over feature - should set hover=true.
        mgr.update_pointer_move(
            &mut map, 400.0, 300.0, 0.0,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        if let Some(id) = mgr.hovered() {
            let state = map.feature_state(&id.source_id, &id.feature_id);
            let hover_val = state
                .and_then(|s| s.get("hover"))
                .and_then(|v| v.as_bool());
            assert_eq!(hover_val, Some(true));
        }

        // Move away - should set hover=false.
        mgr.update_pointer_move(
            &mut map, 10.0, 10.0, 0.1,
            PointerKind::Mouse, InteractionModifiers::default(),
        );
        mgr.drain_events();

        // Hovered should now be None.
        assert!(mgr.hovered().is_none());
    }
}