//! 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::{collections::btree_map::BTreeMap, vec::Vec};

#[cfg(feature = "std")]

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

use azul_core::{

    dom::{DomId, NodeId, OptionDomNodeId},

    drag::{

        ActiveDragType, AutoScrollDirection, DragContext, DragData, DragEffect, DropEffect,

        FileDropDrag, NodeDrag, ScrollbarAxis, ScrollbarThumbDrag, TextSelectionDrag,

        WindowMoveDrag, WindowResizeDrag, WindowResizeEdge,

    },

    geom::{LogicalPosition, PhysicalPositionI32},

    hit_test::HitTest,

    selection::TextCursor,

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

    window::WindowPosition,

};

use azul_css::AzString;

use azul_css::{impl_option, impl_option_inner, StringVec};

// Re-export drag types for convenience

pub use azul_core::drag::{

    ActiveDragType as DragType, AutoScrollDirection as AutoScroll, DragContext as UnifiedDragContext,

    DragData as UnifiedDragData, DragEffect as UnifiedDragEffect, DropEffect as UnifiedDropEffect,

    ScrollbarAxis as ScrollAxis, ScrollbarThumbDrag as ScrollbarDrag,

};

#[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.

/// We need to handle both cases for proper time calculations.

        #[cfg(feature = "std")]

        }

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

        CoreDuration::System(system_diff) => {

            // Manual calculation: secs * 1000 + nanos / 1_000_000

            system_diff.secs * 1000 + (system_diff.nanos / 1_000_000) as u64

        }

            // WARNING: assumes 1 tick = 1 ms. This is correct for platforms

            // that use a millisecond tick counter, but will silently produce

            // wrong timing on platforms with a different tick resolution.

        }

    }

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

/// 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: azul_core::window::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)]

#[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]

);

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

}

// NOTE: NodeDragState, WindowDragState, FileDropState, DropEffect, DragData, DragEffect

// are now defined in azul_core::drag and imported above.

// The old types are kept as type aliases for backwards compatibility.

/// State of an active node drag (after detection)

/// DEPRECATED: Use `DragContext` with `ActiveDragType::Node` instead.

pub type NodeDragState = NodeDrag;

/// State of window being dragged (titlebar drag)

/// DEPRECATED: Use `DragContext` with `ActiveDragType::WindowMove` instead.

pub type WindowDragState = WindowMoveDrag;

/// State of file(s) being dragged from OS over the window

/// DEPRECATED: Use `DragContext` with `ActiveDragType::FileDrop` instead.

pub type FileDropState = FileDropDrag;

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

}

/// 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),

}

/// Type alias for backwards compatibility

pub type GestureManager = GestureAndDragManager;

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.

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

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

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

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

        // Need at least two active sessions for pinch

        // Get last two sessions (most recent touches)

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

        // Need at least two active sessions

        // Get last two sessions

        // Both must have samples

        // Calculate center (average of both touches)

        // Calculate initial angle between touches

        // Calculate current angle

        // Calculate angle difference (normalized to -π to π)

        // Normalize angle to -π to π range

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

        // Check if rotation is significant (threshold from config)

        // Calculate duration

    /// Get the current active input session (if any)

    /// Get current mouse position from latest sample

    /// Get the drag delta (current mouse position minus mouse-down position)

    /// from the current input session.

    ///

    /// Returns `None` if there is no active session or not enough samples.

    /// Get the drag delta in **screen-absolute** coordinates.

    ///

    /// Unlike `get_drag_delta()` which uses window-local coordinates (and therefore

    /// oscillates during window drags due to the window moving under the cursor),

    /// this method uses screen-absolute positions that are stable regardless of

    /// window movement.

    ///

    /// **Use this for window dragging (titlebar drag).**

    /// Use `get_drag_delta()` for in-window operations (node drag-and-drop, etc.).

    ///

    /// Returns `None` if there is no active session or not enough samples.

    /// Get the **incremental** (frame-to-frame) drag delta in screen coordinates.

    ///

    /// Returns `(dx, dy)` where `dx = last_screen.x - previous_screen.x` and

    /// `dy = last_screen.y - previous_screen.y`.

    ///

    /// Unlike `get_drag_delta_screen()` which returns the *total* delta since drag

    /// start, this returns only the delta since the previous sample. This is used

    /// by `titlebar_drag` to apply position changes incrementally:

    ///

    /// ```text

    /// new_pos = current_window_pos + incremental_delta

    /// ```

    ///

    /// This approach is more robust than `initial_pos + total_delta` because it

    /// automatically handles external window position changes (DPI change, OS

    /// clamping, compositor resize) that would make `initial_pos` stale.

    ///

    /// Returns `None` if there is no active session or fewer than 2 samples.