//! Gesture and drag manager for multi-frame gestures and drag operations.

//!

//! Collects input samples, detects drags, double-clicks, long presses, swipes,

//! pinch/rotate gestures, and manages drag state for nodes, windows, and file drops.

//!

//! ## Unified Drag System

//!

//! This module uses the `DragContext` from `azul_core::drag` to provide a unified

//! interface for all drag operations:

//! - Text selection drag

//! - Scrollbar thumb drag

//! - Node drag-and-drop

//! - Window drag/resize

//! - File drop from OS

use alloc::vec::Vec;

#[cfg(feature = "std")]

use std::sync::atomic::{AtomicU64, Ordering};

use azul_core::{

    dom::{DomId, NodeId},

    drag::{ActiveDragType, DragContext, DragData},

    geom::{LogicalPosition, PhysicalPositionI32},

    hit_test::HitTest,

    task::{Duration as CoreDuration, Instant as CoreInstant},

    window::WindowPosition,

};

use azul_css::{impl_option, impl_option_inner};

#[cfg(feature = "std")]

static NEXT_EVENT_ID: AtomicU64 = AtomicU64::new(1);

/// Allocate a new unique event ID

#[cfg(feature = "std")]

/// Allocate a new unique event ID (no_std fallback: returns 0)

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

pub fn allocate_event_id() -> u64 {

    0

}

/// Helper function to convert `CoreDuration` to milliseconds

///

/// `CoreDuration` is an enum with System (`std::time::Duration`) and Tick variants.

/// Both go through `CoreDuration::as_millis_u64`, which converts ticks at the

/// nominal frame rate.

///

/// The Tick arm used to return the raw tick count and carried a WARNING that it

/// "assumes 1 tick = 1 ms ... will silently produce wrong timing on platforms

/// with a different tick resolution". A tick is a FRAME, so that assumption was

/// wrong by a factor of ~16 on every platform, and gesture thresholds

/// (double-click, long-press) read the result as milliseconds.

/// Maximum number of input samples to keep in memory

///

/// This prevents unbounded memory growth during long drags.

/// Older samples beyond this limit are automatically discarded.

pub const MAX_SAMPLES_PER_SESSION: usize = 1000;

/// Default timeout for clearing old gesture samples (milliseconds)

///

/// Samples older than this are automatically removed to prevent

/// memory leaks and stale gesture detection.

pub const DEFAULT_SAMPLE_TIMEOUT_MS: u64 = 2000;

/// Number of samples to drain at once when the session exceeds `MAX_SAMPLES_PER_SESSION`.

///

/// Batch draining avoids per-sample overhead on every new sample.

const DRAIN_BATCH_SIZE: usize = 100;

/// MWA-B4: button-state bitfield recorded for touch-contact samples.

///

/// A finger on the surface = primary contact, mirroring `BUTTON_STATE_LEFT` in

/// the dll's mouse path so drag heuristics treat touch like a held button.

pub const TOUCH_CONTACT_BUTTON_STATE: u8 = 0x01;

/// Configuration for gesture detection thresholds

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

pub struct GestureDetectionConfig {

    /// Minimum distance (pixels) to consider movement a drag, not a click

    pub drag_distance_threshold: f32,

    /// Maximum time between clicks for double-click detection (milliseconds)

    pub double_click_time_threshold_ms: u64,

    /// Maximum distance between clicks for double-click detection (pixels)

    pub double_click_distance_threshold: f32,

    /// Minimum time to hold button for long-press detection (milliseconds)

    pub long_press_time_threshold_ms: u64,

    /// Maximum distance to move while holding for long-press (pixels)

    pub long_press_distance_threshold: f32,

    /// Minimum samples needed to detect a gesture

    pub min_samples_for_gesture: usize,

    /// Minimum velocity for swipe detection (pixels per second)

    pub swipe_velocity_threshold: f32,

    /// Minimum scale change for pinch detection (e.g., 0.1 = 10% change)

    pub pinch_scale_threshold: f32,

    /// Minimum rotation angle for rotation detection (radians)

    pub rotation_angle_threshold: f32,

    /// How often to clear old samples (milliseconds)

    pub sample_cleanup_interval_ms: u64,

}

impl Default for GestureDetectionConfig {

}

/// Single input sample with position and timestamp

#[derive(Debug, Clone, PartialEq)]

pub struct InputSample {

    /// Position in logical coordinates (window-local, Y=0 at top of window)

    pub position: LogicalPosition,

    /// Position in virtual screen coordinates (Y=0 at top of primary monitor).

    ///

    /// Computed as `window_position + position` at the time the sample is recorded.

    /// This is stable during window drags because `window_pos + cursor_local`

    /// always equals the true screen position, even when the window moves.

    ///

    /// All coordinates are in logical pixels (HiDPI-independent).

    /// On Wayland, this is an estimate (compositor does not expose global position).

    pub screen_position: LogicalPosition,

    /// Timestamp when this sample was recorded (from `ExternalSystemCallbacks`)

    pub timestamp: CoreInstant,

    /// Mouse button state (bitfield: 0x01 = left, 0x02 = right, 0x04 = middle)

    pub button_state: u8,

    /// Unique, monotonic event ID for ordering (atomic counter)

    pub event_id: u64,

    /// Pen/stylus pressure (0.0 to 1.0, 0.5 = default for mouse)

    pub pressure: f32,

    /// Pen/stylus tilt angles in degrees (`x_tilt`, `y_tilt`)

    /// Range: typically -90.0 to 90.0, (0.0, 0.0) = perpendicular

    pub tilt: (f32, f32),

    /// Touch contact radius in logical pixels (width, height)

    /// For mouse input, this is (0.0, 0.0)

    pub touch_radius: (f32, f32),

}

impl_option!(

    InputSample,

    OptionInputSample,

    copy = false,

    [Debug, Clone, PartialEq]

);

/// A sequence of input samples forming one button press session

#[derive(Debug, Clone, PartialEq)]

pub struct InputSession {

    /// All recorded samples for this session

    pub samples: Vec<InputSample>,

    /// Whether this session has ended (button released)

    pub ended: bool,

    /// Session ID for tracking (incremental counter)

    pub session_id: u64,

    /// Window position at the time this session started (mouse-down).

    /// Used by titlebar drag callbacks to compute new window position.

    pub window_position_at_start: WindowPosition,

}

impl InputSession {

    /// Create a new input session

    /// Get the first sample in this session

    /// Get the last sample in this session

    /// Get the duration of this session (first to last sample)

    /// Get the total distance traveled in this session

    /// Get the straight-line distance from first to last sample

}

/// Result of drag detection analysis

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

pub struct DetectedDrag {

    /// Position where drag started

    pub start_position: LogicalPosition,

    /// Current/end position of drag

    pub current_position: LogicalPosition,

    /// Direct distance dragged (straight line, pixels)

    pub direct_distance: f32,

    /// Total distance dragged (following path, pixels)

    pub total_distance: f32,

    /// Duration of the drag (milliseconds)

    pub duration_ms: u64,

    /// Number of position samples recorded

    pub sample_count: usize,

    /// Session ID this drag belongs to

    pub session_id: u64,

}

/// Result of long-press detection

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

#[repr(C)]

pub struct DetectedLongPress {

    /// Position where long press is happening

    pub position: LogicalPosition,

    /// How long the button has been held (milliseconds)

    pub duration_ms: u64,

    /// Whether the callback has already been invoked for this long press

    pub callback_invoked: bool,

    /// Session ID this long press belongs to

    pub session_id: u64,

}

/// Primary direction of a gesture

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

#[repr(C)]

pub enum GestureDirection {

    Up,

    Down,

    Left,

    Right,

}

impl_option!(

    GestureDirection,

    OptionGestureDirection,

    [Debug, Clone, Copy, PartialEq, Eq]

);

impl_option!(

    DetectedPinch,

    OptionDetectedPinch,

    [Debug, Clone, Copy, PartialEq]

);

impl_option!(

    DetectedRotation,

    OptionDetectedRotation,

    [Debug, Clone, Copy, PartialEq]

);

impl_option!(

    DetectedLongPress,

    OptionDetectedLongPress,

    [Debug, Clone, Copy, PartialEq, Eq]

);

/// Result of pinch gesture detection

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

#[repr(C)]

pub struct DetectedPinch {

    /// Scale factor (< 1.0 for pinch in, > 1.0 for pinch out)

    pub scale: f32,

    /// Center point of the pinch gesture

    pub center: LogicalPosition,

    /// Initial distance between touch points

    pub initial_distance: f32,

    /// Current distance between touch points

    pub current_distance: f32,

    /// Duration of pinch (milliseconds)

    pub duration_ms: u64,

}

/// Result of rotation gesture detection

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

#[repr(C)]

pub struct DetectedRotation {

    /// Rotation angle in radians (positive = clockwise)

    pub angle_radians: f32,

    /// Center point of rotation

    pub center: LogicalPosition,

    /// Duration of rotation (milliseconds)

    pub duration_ms: u64,

}

/// State of pen/stylus input

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

#[repr(C)]

pub struct PenState {

    /// Current pen position

    pub position: LogicalPosition,

    /// Current pressure (0.0 to 1.0)

    pub pressure: f32,

    /// Current tilt angles (`x_tilt`, `y_tilt`) in degrees

    pub tilt: crate::callbacks::PenTilt,

    /// Whether pen is in contact with surface

    pub in_contact: bool,

    /// Whether pen is inverted (eraser mode)

    pub is_eraser: bool,

    /// Whether barrel button is pressed

    pub barrel_button_pressed: bool,

    /// Unique identifier for this pen device

    pub device_id: u64,

    /// Tangential / cylinder pressure (0.0 to 1.0). Wacom Air Brush wheel,

    /// Surface Slim Pen 2 secondary axis. `0.0` means "not reported".

    /// Maps to W3C `PointerEvent.tangentialPressure`.

    pub tangential_pressure: f32,

    /// Barrel roll angle in radians (–π to π). Wacom Art Pen rotation,

    /// Surface Pen barrel-roll axis. `0.0` means "not reported" (devices

    /// that do report it sweep through the full range as the user rolls

    /// the pen — the resting state isn't necessarily zero, so callers

    /// should compare deltas, not absolute values).

    /// Maps to W3C `PointerEvent.twist` (in radians, not degrees).

    pub barrel_roll_rad: f32,

    /// Per-tool identity for hand-held pens that report it (Wintab GUID,

    /// Apple Pencil session id, S-Pen serial). `0` means "not reported".

    /// Distinct from `device_id` so callers can both identify the

    /// hardware (`device_id`) *and* which tip / lead / button cluster is

    /// in use (`tool_id`).

    pub tool_id: u32,

}

impl_option!(PenState, OptionPenState, [Debug, Clone, Copy, PartialEq]);

impl Default for PenState {

}

/// State of a Wacom-style tablet **pad** — the tablet body's own hardware

/// controls, distinct from the pen ([`PenState`] already covers eraser /

/// barrel button / barrel roll / tilt / pressure).

///

/// Populated by the platform

/// backend (`dll/src/desktop/extra/wacom_pad/`: Wintab on Windows,

/// libwacom+libinput on Linux, the driver's `NSEvent` tablet events on macOS).

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

#[repr(C)]

pub struct WacomPadState {

    /// `ExpressKey` bitset — bit `n` set ⇔ hardware button `n` is held (up to

    /// 32). Read via [`WacomPadState::express_key`].

    pub express_keys: u32,

    /// Touch-ring / touch-strip absolute position, `0.0`–`1.0`. Only

    /// meaningful while [`WacomPadState::touch_ring_active`] is `true`.

    pub touch_ring: f32,

    /// Whether a finger is currently on the touch-ring / touch-strip.

    pub touch_ring_active: bool,

    /// Tablet device id (to distinguish pads on multi-tablet setups).

    pub device_id: u64,

}

impl_option!(

    WacomPadState,

    OptionWacomPadState,

    [Debug, Clone, Copy, PartialEq]

);

impl Default for WacomPadState {

}

impl WacomPadState {

    /// Whether `ExpressKey` `index` (0-based, < 32) is currently held.

}

/// Manager for multi-frame gestures and drag operations

///

/// This collects raw input samples and analyzes them to detect gestures.

/// Designed for testability and clear separation of input collection

/// vs. detection.

///

/// ## Unified Drag System

///

/// The manager now uses `DragContext` to unify all drag types:

/// - `active_drag`: The unified drag context (replaces individual drag states)

///

/// For backwards compatibility, the old `node_drag`, `window_drag`, `file_drop`

/// fields are still accessible but deprecated.

#[derive(Debug, Clone, PartialEq)]

pub struct GestureAndDragManager {

    /// Configuration for gesture detection

    pub config: GestureDetectionConfig,

    /// All recorded input sessions (multiple button press sequences)

    pub input_sessions: Vec<InputSession>,

    /// **NEW**: Unified drag context for all drag types

    pub active_drag: Option<DragContext>,

    /// Current pen/stylus state

    pub pen_state: Option<PenState>,

    /// Pen state as of the previous determine-events pass (for diffing pen events).

    pub previous_pen_state: Option<PenState>,

    /// Set when pen state changed; gates one pen-event diff (cleared by the event loop).

    pub pen_event_pending: bool,

    /// Latest Wacom tablet-pad state (`ExpressKeys` + touch-ring), or `None`

    /// until a pad backend delivers one.

    pub pad_state: Option<WacomPadState>,

    /// Session IDs where long press callback has been invoked

    long_press_callbacks_invoked: Vec<u64>,

    /// Counter for generating unique session IDs

    next_session_id: u64,

    /// Native-platform gesture override slot.

    ///

    /// Platforms with first-class gesture recognizers (iOS `UIKit`,

    /// Android `GestureDetector` + `ScaleGestureDetector`, macOS

    /// `NSGestureRecognizer`) inject pre-detected gestures here via

    /// [`GestureAndDragManager::inject_native_gesture`]. The

    /// `detect_*` methods consult this slot before running their

    /// in-process heuristics, so callbacks observe consistent results

    /// regardless of the detection source.

    ///

    /// Cleared automatically at the start of every new input recording

    /// cycle so a single OS event doesn't keep firing.

    pub native_gesture: Option<NativeGestureEvent>,

    /// MWA-B4: OS touch id → session id. Desktop touch events previously

    /// only filled the window's `touch_state`, so no touch ever became an

    /// input session and `detect_pinch` / `detect_rotation` (which need two

    /// concurrent sessions) were structurally dead on Windows/X11/Wayland.

    /// The shells call [`touch_down`](Self::touch_down) /

    /// [`touch_move`](Self::touch_move) / [`touch_up`](Self::touch_up); each

    /// finger gets its own session (two fingers = two live sessions).

    touch_sessions: alloc::collections::btree_map::BTreeMap<u64, u64>,

}

/// Gesture detected by a platform-native recognizer.

///

/// Platform backends construct one of these in their gesture-recognizer

/// callbacks (iOS `UIKit`, Android `GestureDetector`, macOS

/// `NSGestureRecognizer`) and hand it to

/// [`GestureAndDragManager::inject_native_gesture`]. The in-process

/// `detect_*` methods then return the native result, sidestepping their

/// fallback heuristics. On platforms with poor native gesture support

/// (X11 / Wayland touch, headless), backends never inject and the

/// in-process detector remains authoritative.

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

#[repr(C, u8)]

pub enum NativeGestureEvent {

    /// Single tap / double-click detected natively.

    DoubleClick,

    /// Long-press detected natively (iOS `UILongPressGestureRecognizer`,

    /// Android `GestureDetector.OnGestureListener::onLongPress`).

    LongPress(DetectedLongPress),

    /// Swipe detected natively (iOS `UISwipeGestureRecognizer`,

    /// Android `GestureDetector.OnGestureListener::onFling`).

    Swipe(GestureDirection),

    /// Pinch detected natively (iOS `UIPinchGestureRecognizer`,

    /// Android `ScaleGestureDetector`, macOS magnification gesture).

    Pinch(DetectedPinch),

    /// Rotation detected natively (iOS `UIRotationGestureRecognizer`,

    /// macOS rotation gesture).

    Rotation(DetectedRotation),

}

impl Default for GestureAndDragManager {

}

impl GestureAndDragManager {

    /// (`input_sessions`, `long_press_callbacks_invoked`). Used by

    /// `AZ_E2E_TEST` to watch for unbounded growth.

    /// Create a new gesture and drag manager

    /// Inject a native gesture-recognizer result, overriding the

    /// in-process detector for the current event frame. Called by the

    /// iOS / Android / macOS platform backend from their gesture

    /// recognizer callbacks. The override is read once by the next

    /// `detect_*` call.

    /// Clear any pending native-gesture override. Called by the event

    /// loop after each frame's detections have been consumed so a

    /// stale OS gesture doesn't keep firing.

    /// Create with custom configuration

    // Input Recording Methods (called from event loop / system timer)

    /// Start a new input session (mouse button pressed down)

    ///

    /// This begins recording samples for gesture detection.

    /// Call this when receiving mouse button down event.

    ///

    /// `window_position` is the current OS window position at the time of mouse-down.

    /// It is stored so that drag callbacks can compute the new window position.

    ///

    /// Returns the session ID for this new session.

            0.5,        // default pressure for mouse

        )

    /// Start a new input session with pen/touch data

        // Clear old ended sessions, but keep the most recent ended session

        // for double-click detection. detect_double_click() needs two ended

        // sessions to compare timing and distance.

    /// Record an input sample to the current session

    ///

    /// Call this on every mouse move event while button is pressed,

    /// and also periodically from a system timer to track long presses.

    ///

    /// Returns true if sample was recorded, false if no active session.

            0.5,        // default pressure for mouse

        )

    /// Record an input sample with pen/touch data

        };

        // Enforce max samples limit

    /// End the current input session (mouse button released)

    ///

    /// Call this when receiving mouse button up event.

    /// The session is kept for analysis but marked as ended.

    // --- Per-touch-id input sessions (MWA-B4) ---

    /// A finger made contact: open a dedicated session for `touch_id`.

            TOUCH_CONTACT_BUTTON_STATE,

        );

    /// A finger moved: record into ITS OWN session — never `last_mut()`,

    /// two concurrent fingers must not interleave into one session (that

    /// would corrupt both the drag heuristics and pinch/rotate distances).

    /// Returns `true` if a sample was recorded.

        };

    /// A finger lifted (or the OS cancelled the touch): final sample + end

    /// the session and drop the id mapping.

        };

    /// The OS cancelled the whole touch sequence (e.g. the compositor took

    /// the gesture over): end every touch session and drop the id map.

        }

    /// Record a sample into the session with `session_id` (MWA-B4 helper —

    /// the by-id sibling of `record_input_sample_with_pen`, which only ever

    /// writes to the LAST session).

        else {

        };

    /// Clear old input sessions that have timed out

    ///

    /// Call this periodically (e.g., every frame) to prevent memory leaks.

    /// Sessions older than `config.sample_cleanup_interval_ms` are removed.

    // CoreInstant is a ref-counted FFI clock handle threaded through the event loop by value;

    // &-converting would cascade through the loop call chain and across all dll backends.

    #[allow(clippy::needless_pass_by_value)]

            } else {

            }

        // Also clear long press callback tracking for removed sessions

    /// Clear all input sessions

    ///

    /// Call this when you want to reset all gesture detection state.

    /// Update pen/stylus state

    ///

    /// Call this when receiving pen events from the platform. The

    /// extended fields (`tangential_pressure`, `barrel_roll_rad`,

    /// `tool_id`) default to `0` — pass [`update_pen_state_full`] when

    /// the platform reports them.

            0.0,

            0.0,

            0,

        );

    /// Update pen/stylus state including the extended axes (W3C

    /// `PointerEvent.tangentialPressure` + `twist`) and per-tool id.

    /// Clear pen state (when pen leaves proximity)

    /// Get current pen state (read-only)

    /// Get the previous pen state (for event diffing).

    /// Clear the pen-event-pending flag (called by the event loop after a pass).

    /// Set the latest Wacom tablet-pad state (called by the pad backend).

    /// The latest tablet-pad state, or `None` if no pad backend delivered one.

    /// Clear the tablet-pad state (pad disconnected / proximity left).

    // Gesture Detection Methods (query state without mutation)

    /// Detect if current input represents a drag gesture

    ///

    /// Returns Some(DetectedDrag) if a drag is detected based on distance threshold.

            Some(DetectedDrag {

            })

        } else {

        }

    /// Detect if current input represents a long press

    ///

    /// Returns Some(DetectedLongPress) if button has been held long enough

    /// without moving much.

        } else {

        }

    /// Mark long press callback as invoked for a session

    ///

    /// Call this after invoking the long press callback to prevent

    /// repeated invocations.

    /// MWA-B12: mark the CURRENT session's long-press as delivered. The

    /// event pass calls this right after emitting `EventType::LongPress` —

    /// nothing ever called `mark_long_press_callback_invoked`, so `LongPress`

    /// re-fired on every subsequent pass of the same hold.

    /// Detect if last two sessions form a double-click.

    ///

    /// Returns true if timing and distance match double-click criteria.

        // Both sessions must have ended (button released)

        };

    /// Detect click count (1=single, 2=double, 3=triple) by examining

    /// the recent ended sessions.  Uses only timestamps and positions

    /// from the session history, so the result is fully deterministic

    /// for any given sequence of `InputSession`s (easy to unit-test

    /// with synthetic `CoreInstant`/`CoreDuration` values).

        // We need at least 2 ended sessions for double-click,

        // 3 ended sessions for triple-click.

        // Walk backwards from the most recent ended session and count

        // how many consecutive clicks fall within the time+distance

        // thresholds.

        // Collect the last up-to-3 ended sessions (most-recent first).

        }

        // recent[0] = most recent ended session

        // recent[1] = previous ended session (if any)

        // recent[2] = one before that (if any)

            };

            };

        }

        // Cap at 3 (triple-click selects paragraph, beyond that cycles back)

    /// Get the primary direction of current drag.

        };

    /// Get average velocity of current gesture (pixels per second)

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

    /// Check if current gesture is a swipe (fast directional movement).

    /// Detect swipe with specific direction

    ///

    /// Returns Some(dir) if gesture is a fast swipe in a clear direction

        // Must be a fast swipe first

        // Get direction

    /// Detect pinch gesture (two-touch zoom in/out)

    ///

    /// Returns Some if two touch points are active and distance is changing

    /// significantly. Scale < 1.0 = pinch in, scale > 1.0 = pinch out.

    #[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

        // Need at least two active sessions for pinch

        // Get last two sessions (most recent touches)

        // A pinch is a TWO-finger gesture: both contacts must be concurrently

        // active. A desktop mouse produces *sequential* sessions (the previous one

        // is `ended` on button-up before the next begins), so without this guard a

        // stale ended session (e.g. a prior click on a button) pairs with the

        // current drag and is misread as a pinch — the map zooms on a plain click.

        // Both must have samples

        // Calculate initial distance between touches

        // Calculate current distance

        // Avoid division by zero

        // Calculate scale factor

        // Check if scale change is significant (threshold from config)

        // Calculate center point

        // Calculate duration

    /// Detect rotation gesture (two-touch rotate)

    ///

    /// Returns Some if two touch points are rotating around center.

    /// Positive angle = clockwise, negative = counterclockwise.

    #[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

        const PI: f32 = core::f32::consts::PI;

        // Need at least two active sessions

        // Get last two sessions

        // Two-finger rotation requires both contacts concurrently active; a desktop

        // mouse yields sequential sessions, so a stale ended session must not pair

        // with the current one (see detect_pinch).