//! Event and callback filtering module

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

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

use alloc::{

    boxed::Box,

    collections::{btree_map::BTreeMap, btree_set::BTreeSet},

    vec::Vec,

};

use azul_css::AzString;

use crate::{

    callbacks::Update,

    dom::{DomId, DomNodeId, On},

    geom::{LogicalPosition, LogicalRect},

    hit_test::{FullHitTest, HitTestItem},

    id::NodeId,

    styled_dom::{ChangedCssProperty, NodeHierarchyItemId},

    task::Instant,

    OrderedMap,

};

/// Easing functions for smooth scroll animations

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

pub enum EasingFunction {

    Linear,

    EaseInOut,

    EaseOut,

}

pub type RestyleNodes = BTreeMap<NodeId, Vec<ChangedCssProperty>>;

pub type RelayoutNodes = BTreeMap<NodeId, Vec<ChangedCssProperty>>;

pub type RelayoutWords = BTreeMap<NodeId, AzString>;

#[derive(Debug, Clone, PartialEq)]

pub struct FocusChange {

    pub old: Option<DomNodeId>,

    pub new: Option<DomNodeId>,

}

#[derive(Debug, Clone, PartialEq)]

pub struct CallbackToCall {

    pub node_id: NodeId,

    pub hit_test_item: Option<HitTestItem>,

    pub event_filter: EventFilter,

}

impl CallbackToCall {

    /// Build a list of `CallbackToCall` entries for every node hit by the

    /// given hit test under the given DOM, tagged with `event_filter`.

    /// Returns an empty `Vec` when there is no hit test data for the DOM.

        };

}

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

#[must_use = "ProcessEventResult must be used to determine if relayout/repaint is needed"]

pub enum ProcessEventResult {

    DoNothing = 0,

    ShouldReRenderCurrentWindow = 1,

    ShouldUpdateDisplayListCurrentWindow = 2,

    // GPU transforms changed: do another hit-test and recurse

    // until nothing has changed anymore

    UpdateHitTesterAndProcessAgain = 3,

    // Restyle or runtime edit changed layout-affecting properties:

    // re-run layout on the EXISTING StyledDom (no DOM rebuild).

    ShouldIncrementalRelayout = 4,

    // Full DOM rebuild via user's layout_callback()

    ShouldRegenerateDomCurrentWindow = 5,

    ShouldRegenerateDomAllWindows = 6,

}

impl ProcessEventResult {

        use self::ProcessEventResult::*;

        }

}

impl PartialOrd for ProcessEventResult {

}

impl Ord for ProcessEventResult {

}

impl ProcessEventResult {

}

/// Tracks the origin of an event for proper handling.

///

/// This allows the system to distinguish between user input, programmatic

/// changes, and synthetic events generated by UI components.

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

#[repr(C)]

pub enum EventSource {

    /// Direct user input (mouse, keyboard, touch, gamepad)

    User,

    /// API call (programmatic scroll, focus change, etc.)

    Programmatic,

    /// Generated from UI interaction (scrollbar drag, synthetic events)

    Synthetic,

    /// Generated from lifecycle hooks (mount, unmount, resize)

    Lifecycle,

}

/// Event propagation phase (similar to DOM Level 2 Events).

///

/// Events can be intercepted at different phases:

/// - **Capture**: Event travels from root down to target (rarely used)

/// - **Target**: Event is at the target element

/// - **Bubble**: Event travels from target back up to root (most common)

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

#[repr(C)]

pub enum EventPhase {

    /// Event travels from root down to target

    Capture,

    /// Event is at the target element

    Target,

    /// Event bubbles from target back up to root

    Bubble,

}

impl Default for EventPhase {

}

/// Mouse button identifier for mouse events.

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

#[repr(C)]

pub enum MouseButton {

    Left,

    Middle,

    Right,

    Other(u8),

}

/// Scroll delta mode (how scroll deltas should be interpreted).

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

#[repr(C)]

pub enum ScrollDeltaMode {

    /// Delta is in pixels

    Pixel,

    /// Delta is in lines (e.g., 3 lines of text)

    Line,

    /// Delta is in pages

    Page,

}

/// Scroll direction for conditional event filtering.

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

#[repr(C)]

pub enum ScrollDirection {

    Up,

    Down,

    Left,

    Right,

}

// ============================================================================

// W3C CSSOM View Module - Scroll Into View Types

// ============================================================================

/// W3C-compliant scroll-into-view options

///

/// These options control how an element is scrolled into view, following

/// the CSSOM View Module specification.

#[repr(C)]

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

pub struct ScrollIntoViewOptions {

    /// Vertical alignment: start, center, end, nearest (default: nearest)

    pub block: ScrollLogicalPosition,

    /// Horizontal alignment: start, center, end, nearest (default: nearest)

    /// Note: Named `inline_axis` to avoid conflict with C keyword `inline`

    pub inline_axis: ScrollLogicalPosition,

    /// Animation behavior: auto, instant, smooth (default: auto)

    pub behavior: ScrollIntoViewBehavior,

}

impl ScrollIntoViewOptions {

    /// Create options with "nearest" alignment for both axes

    /// Create options with "center" alignment for both axes

    /// Create options with "start" alignment for both axes

    /// Create options to align the end of the target with the end of the viewport

    /// Set instant scroll behavior

    /// Set smooth scroll behavior

}

/// Scroll alignment for vertical (block) or horizontal (inline) axis

///

/// Determines where the target element should be positioned within

/// the scroll container's visible area.

#[repr(C)]

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

pub enum ScrollLogicalPosition {

    /// Align target's start edge with container's start edge

    Start,

    /// Center target within container

    Center,

    /// Align target's end edge with container's end edge

    End,

    /// Minimum scroll distance to make target fully visible (default)

    #[default]

    Nearest,

}

/// Scroll animation behavior for scrollIntoView API

///

/// This is distinct from the CSS `scroll-behavior` property, as it also

/// supports the `Instant` option which CSS does not have.

#[repr(C)]

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

pub enum ScrollIntoViewBehavior {

    /// Respect CSS scroll-behavior property (default)

    #[default]

    Auto,

    /// Immediate jump without animation

    Instant,

    /// Animated smooth scroll

    Smooth,

}

/// Reason why a lifecycle event was triggered.

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

#[repr(C)]

pub enum LifecycleReason {

    /// First appearance in DOM

    InitialMount,

    /// Removed and re-added to DOM

    Remount,

    /// Layout bounds changed

    Resize,

    /// Props or state changed

    Update,

    /// Node was removed from DOM

    Unmount,

}

/// Keyboard modifier keys state.

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

#[repr(C)]

pub struct KeyModifiers {

    pub shift: bool,

    pub ctrl: bool,

    pub alt: bool,

    pub meta: bool,

}

impl KeyModifiers {

}

/// Type-specific event data for mouse events.

#[derive(Debug, Clone, PartialEq)]

pub struct MouseEventData {

    /// Position of the mouse cursor

    pub position: LogicalPosition,

    /// Which button was pressed/released

    pub button: MouseButton,

    /// Bitmask of currently pressed buttons

    pub buttons: u8,

    /// Modifier keys state

    pub modifiers: KeyModifiers,

}

/// Type-specific event data for keyboard events.

#[derive(Debug, Clone, PartialEq)]

pub struct KeyboardEventData {

    /// The virtual key code

    pub key_code: u32,

    /// The character produced (if any)

    pub char_code: Option<char>,

    /// Modifier keys state

    pub modifiers: KeyModifiers,

    /// Whether this is a repeat event

    pub repeat: bool,

}

/// Type-specific event data for scroll events.

#[derive(Debug, Clone, PartialEq)]

pub struct ScrollEventData {

    /// Scroll delta (dx, dy)

    pub delta: LogicalPosition,

    /// How the delta should be interpreted

    pub delta_mode: ScrollDeltaMode,

}

/// Type-specific event data for touch events.

#[derive(Debug, Clone, PartialEq)]

pub struct TouchEventData {

    /// Touch identifier

    pub id: u64,

    /// Touch position

    pub position: LogicalPosition,

    /// Touch force/pressure (0.0 - 1.0)

    pub force: f32,

}

/// Type-specific event data for clipboard events.

#[derive(Debug, Clone, PartialEq)]

pub struct ClipboardEventData {

    /// The clipboard content (for paste events)

    pub content: Option<String>,

}

/// Type-specific event data for lifecycle events.

#[derive(Debug, Clone, PartialEq)]

pub struct LifecycleEventData {

    /// Why this lifecycle event was triggered

    pub reason: LifecycleReason,

    /// Previous layout bounds (for resize events)

    pub previous_bounds: Option<LogicalRect>,

    /// Current layout bounds

    pub current_bounds: LogicalRect,

}

/// Type-specific event data for window events.

#[derive(Debug, Clone, PartialEq)]

pub struct WindowEventData {

    /// Window size (for resize events)

    pub size: Option<LogicalRect>,

    /// Window position (for move events)

    pub position: Option<LogicalPosition>,

}

/// Union of all possible event data types.

#[derive(Debug, Clone, PartialEq)]

pub enum EventData {

    /// Mouse event data

    Mouse(MouseEventData),

    /// Keyboard event data

    Keyboard(KeyboardEventData),

    /// Scroll event data

    Scroll(ScrollEventData),

    /// Touch event data

    Touch(TouchEventData),

    /// Clipboard event data

    Clipboard(ClipboardEventData),

    /// Lifecycle event data

    Lifecycle(LifecycleEventData),

    /// Window event data

    Window(WindowEventData),

    /// No additional data

    None,

}

/// High-level event type classification.

///

/// This enum categorizes all possible events that can occur in the UI.

/// It extends the existing event system with new event types for

/// lifecycle, clipboard, media, and form handling.

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

#[repr(C)]

pub enum EventType {

    // Mouse Events

    /// Mouse cursor is over the element

    MouseOver,

    /// Mouse cursor entered the element

    MouseEnter,

    /// Mouse cursor left the element

    MouseLeave,

    /// Mouse left the element OR moved to a child element (W3C `mouseout`, bubbles)

    MouseOut,

    /// Mouse button pressed

    MouseDown,

    /// Mouse button released

    MouseUp,

    /// Mouse click (down + up on same element)

    Click,

    /// Mouse double-click

    DoubleClick,

    /// Right-click / context menu

    ContextMenu,

    // Keyboard Events

    /// Key pressed down

    KeyDown,

    /// Key released

    KeyUp,

    /// Character input (respects locale/keyboard layout)

    KeyPress,

    // IME Composition Events

    /// IME composition started

    CompositionStart,

    /// IME composition updated (intermediate text changed)

    CompositionUpdate,

    /// IME composition ended (final text committed)

    CompositionEnd,

    // Focus Events

    /// Element received focus

    Focus,

    /// Element lost focus

    Blur,

    /// Focus entered element or its children

    FocusIn,

    /// Focus left element and its children

    FocusOut,

    // Input Events

    /// Input value is being changed (fires on every keystroke)

    Input,

    /// Input value has changed (fires after editing complete)

    Change,

    /// Form submitted

    Submit,

    /// Form reset

    Reset,

    /// Form validation failed

    Invalid,

    // Scroll Events

    /// Element is being scrolled

    Scroll,

    /// Scroll started

    ScrollStart,

    /// Scroll ended

    ScrollEnd,

    // Drag Events

    /// Drag operation started

    DragStart,

    /// Element is being dragged

    Drag,

    /// Drag operation ended

    DragEnd,

    /// Dragged element entered drop target

    DragEnter,

    /// Dragged element is over drop target

    DragOver,

    /// Dragged element left drop target

    DragLeave,

    /// Element was dropped

    Drop,

    // Touch Events

    /// Touch started

    TouchStart,

    /// Touch moved

    TouchMove,

    /// Touch ended

    TouchEnd,

    /// Touch cancelled

    TouchCancel,

    // Pen / Stylus Events (W3C PointerEvent, pointerType "pen")

    /// Pen tip made contact (or pen entered while down)

    PenDown,

    /// Pen moved (in contact or hovering in range)

    PenMove,

    /// Pen tip lifted

    PenUp,

    /// Pen entered hover/sensing range (proximity in)

    PenEnter,

    /// Pen left hover/sensing range (proximity out)

    PenLeave,

    // Gesture Events

    /// Long press detected (touch or mouse held down)

    LongPress,

    /// Swipe gesture to the left

    SwipeLeft,

    /// Swipe gesture to the right

    SwipeRight,

    /// Swipe gesture upward

    SwipeUp,

    /// Swipe gesture downward

    SwipeDown,

    /// Pinch-in gesture (zoom out)

    PinchIn,

    /// Pinch-out gesture (zoom in)

    PinchOut,

    /// Clockwise rotation gesture

    RotateClockwise,

    /// Counter-clockwise rotation gesture

    RotateCounterClockwise,

    // Clipboard Events

    /// Content copied to clipboard

    Copy,

    /// Content cut to clipboard

    Cut,

    /// Content pasted from clipboard

    Paste,

    // Media Events

    /// Media playback started

    Play,

    /// Media playback paused

    Pause,

    /// Media playback ended

    Ended,

    /// Media time updated

    TimeUpdate,

    /// Media volume changed

    VolumeChange,

    /// Media error occurred

    MediaError,

    // Lifecycle Events

    /// Component was mounted to the DOM

    Mount,

    /// Component will be unmounted from the DOM

    Unmount,

    /// Component was updated

    Update,

    /// Component layout bounds changed

    Resize,

    // Window Events

    /// Window resized

    WindowResize,

    /// Window moved

    WindowMove,

    /// Window close requested

    WindowClose,

    /// Window received focus

    WindowFocusIn,

    /// Window lost focus

    WindowFocusOut,

    /// System theme changed

    ThemeChange,

    /// Window DPI/scale factor changed (moved to different monitor)

    WindowDpiChanged,

    /// Window moved to a different monitor

    WindowMonitorChanged,

    // Application Events

    /// A monitor/display was connected

    MonitorConnected,

    /// A monitor/display was disconnected

    MonitorDisconnected,

    // File Events

    /// File is being hovered

    FileHover,

    /// File was dropped

    FileDrop,

    /// File hover cancelled

    FileHoverCancel,

    // Hardware input-device Events (P6 sensors / gamepad)

    /// A motion-sensor reading (accelerometer / gyroscope / magnetometer)

    /// changed. Read the value with `CallbackInfo::get_sensor_reading`.

    SensorChanged,

    /// A gamepad's buttons / axes changed, or one was (dis)connected. Read it

    /// with `CallbackInfo::get_primary_gamepad` / `get_gamepad_state`.

    GamepadInput,

}

/// Unified event wrapper (similar to React's SyntheticEvent).

///

/// All events in the system are wrapped in this structure, providing

/// a consistent interface and enabling event propagation control.

#[derive(Debug, Clone, PartialEq)]

pub struct SyntheticEvent {

    /// The type of event

    pub event_type: EventType,

    /// Where the event came from

    pub source: EventSource,

    /// Current propagation phase

    pub phase: EventPhase,

    /// Target node that the event was dispatched to

    pub target: DomNodeId,

    /// Current node in the propagation path

    pub current_target: DomNodeId,

    /// Timestamp when event was created

    pub timestamp: Instant,

    /// Type-specific event data

    pub data: EventData,

    /// Whether propagation has been stopped

    pub stopped: bool,

    /// Whether immediate propagation has been stopped

    pub stopped_immediate: bool,

    /// Whether default action has been prevented

    pub prevented_default: bool,

}

impl SyntheticEvent {

    /// Create a new synthetic event.

    ///

    /// # Parameters

    /// - `timestamp`: Current time from `(system_callbacks.get_system_time_fn.cb)()`

    /// Stop event propagation after the current phase completes.

    ///

    /// This prevents the event from reaching handlers in subsequent phases

    /// (e.g., stopping during capture prevents bubble phase).

    /// Stop event propagation immediately.

    ///

    /// This prevents any further handlers from being called, even on the

    /// current target element.

    /// Prevent the default action associated with this event.

    ///

    /// For example, prevents form submission on Enter key, or prevents

    /// text selection on drag.

    /// Check if propagation was stopped.

    /// Check if immediate propagation was stopped.

    /// Check if default action was prevented.

}

/// Result of event propagation through DOM tree.

#[derive(Debug, Clone)]

pub struct PropagationResult {

    /// Callbacks that should be invoked, in order

    pub callbacks_to_invoke: Vec<(NodeId, EventFilter)>,

    /// Whether default action should be prevented

    pub default_prevented: bool,

}

/// Get the path from root to target node in the DOM tree.

///

/// This is used for event propagation - we need to know which nodes

/// are ancestors of the target to implement capture/bubble phases.

///

/// Returns nodes in order from root to target (inclusive).

    };

    // Build path from target to root

    }

    // Reverse to get root → target order

/// Propagate event through DOM tree with capture and bubble phases.

///

/// This implements DOM Level 2 event propagation:

/// 1. **Capture Phase**: Event travels from root down to target

/// 2. **Target Phase**: Event is at the target element

/// 3. **Bubble Phase**: Event travels from target back up to root

///

/// The event can be stopped at any point via `stopPropagation()` or

/// `stopImmediatePropagation()`.

    // Phase 1: Capture (root → target)

    );

    // Phase 2: Target

    // Phase 3: Bubble (target → root)

/// Process a single propagation phase (Capture or Bubble)

    }

/// Process the target phase

/// Collect callbacks that match the current phase for a node

    };

impl Default for PropagationResult {

}

// =============================================================================

// DEFAULT ACTIONS (W3C UI Events / HTML5 Activation Behavior)

// =============================================================================

/// Default actions are built-in behaviors that occur in response to events.

///

/// Per W3C DOM Event specification:

/// > A default action is an action that the implementation is expected to take

/// > in response to an event, unless that action is cancelled by the script.

///

/// Examples:

/// - Tab key → move focus to next focusable element

/// - Enter/Space on button → activate (click) the button

/// - Escape → clear focus or close modal

/// - Arrow keys in listbox → move selection

///

/// Default actions are processed AFTER all event callbacks have been invoked,

/// and only if `event.prevent_default()` was NOT called.

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

#[repr(C, u8)]

pub enum DefaultAction {

    /// Move focus to the next focusable element (Tab key)

    FocusNext,

    /// Move focus to the previous focusable element (Shift+Tab)

    FocusPrevious,

    /// Move focus to the first focusable element

    FocusFirst,

    /// Move focus to the last focusable element

    FocusLast,

    /// Clear focus from the currently focused element (Escape key)

    ClearFocus,

    /// Activate the focused element (Enter/Space on activatable elements)

    /// This generates a synthetic Click event on the target

    ActivateFocusedElement {

        target: DomNodeId,

    },

    /// Submit the form containing the focused element (Enter in form input)

    SubmitForm {

        form_node: DomNodeId,

    },

    /// Close the current modal/dialog (Escape key when modal is open)

    CloseModal {

        modal_node: DomNodeId,

    },

    /// Scroll the focused scrollable container

    ScrollFocusedContainer {

        direction: ScrollDirection,

        amount: ScrollAmount,

    },

    /// Select all text in the focused text input (Ctrl+A / Cmd+A)

    SelectAllText,

    /// No default action for this event

    None,

}

/// Amount to scroll for keyboard-based scrolling

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

#[repr(C)]

pub enum ScrollAmount {

    /// Scroll by one line (arrow keys)

    Line,

    /// Scroll by one page (Page Up/Down)

    Page,

    /// Scroll to start/end (Home/End)

    Document,

}

/// Result of determining what default action should occur for an event.

///

/// This is computed AFTER event dispatch, based on:

/// 1. The event type

/// 2. The target element's type/role

/// 3. Whether `prevent_default()` was called

#[derive(Debug, Clone)]

#[repr(C)]

pub struct DefaultActionResult {

    /// The default action to perform (if any)

    pub action: DefaultAction,

    /// Whether the action was prevented by a callback

    pub prevented: bool,

}

impl Default for DefaultActionResult {

}

impl DefaultActionResult {

    /// Create a new result with a specific action

    /// Create a prevented result (callback called prevent_default)

    /// Check if there's an action to perform

}

/// Trait for elements that have activation behavior (can be "clicked" via keyboard).

///

/// Per HTML5 spec, elements with activation behavior include:

/// - `<button>` elements

/// - `<input type="submit">`, `<input type="button">`, `<input type="reset">`

/// - `<a>` elements with href

/// - `<area>` elements with href

/// - Any element with a click handler (implicit activation)

///

/// When an element with activation behavior is focused and the user presses

/// Enter or Space, a synthetic click event is generated.

pub trait ActivationBehavior {

    /// Returns true if this element can be activated via keyboard (Enter/Space)

    fn has_activation_behavior(&self) -> bool;

    /// Returns true if this element is currently activatable

    /// (e.g., not disabled, not aria-disabled="true")

    fn is_activatable(&self) -> bool;

}

/// Trait to query if a node is focusable for tab navigation

pub trait Focusable {

    /// Returns the tabindex value for this element (-1, 0, or positive)

    fn get_tabindex(&self) -> Option<i32>;

    /// Returns true if this element can receive focus

    fn is_focusable(&self) -> bool;

    /// Returns true if this element should be in the tab order

        }

    /// Returns true if this element type is naturally focusable

    /// (button, input, select, textarea, a[href])

    fn is_naturally_focusable(&self) -> bool;

}

/// Check if an event filter matches the given event in the current phase.

///

/// This is used during event propagation to determine which callbacks

/// should be invoked at each phase.

    // For now, we match based on the filter type

    // In the future, this will also check EventPhase and EventConditions

        }

        }

        }

        }

        EventFilter::Application(_) => {

            // Application events - will be implemented in future

        }

    }

/// Check if a component (lifecycle) filter matches the event.

///

/// Lifecycle events produced by `diff::reconcile_dom` carry the target node in

/// `SyntheticEvent.target`, so dispatchers that bypass `propagate_event` and

/// invoke the target directly also need a way to compare. This predicate is

/// the single source of truth for that comparison; changing it without

/// updating `event_type_to_filters` will de-sync dispatch.

        (ComponentEventFilter::AfterMount, EventType::Mount)

            | (ComponentEventFilter::BeforeUnmount, EventType::Unmount)

            | (ComponentEventFilter::Updated, EventType::Update)

            | (ComponentEventFilter::NodeResized, EventType::Resize)

    )

/// Check if the event data contains a mouse event with the expected button.

    } else {

    }

/// Check if a hover filter matches the event.

    use HoverEventFilter::*;

        (RightMouseDown, EventType::MouseDown) => {

        }

        (MiddleMouseDown, EventType::MouseDown) => {

        }

    }

/// Check if a focus filter matches the event.

    use FocusEventFilter::*;

        (RightMouseDown, EventType::MouseDown) => {

        }

        (MiddleMouseDown, EventType::MouseDown) => {

        }

    }

/// Check if a window filter matches the event.

    use WindowEventFilter::*;

        (RightMouseDown, EventType::MouseDown) => {

        }

        (MiddleMouseDown, EventType::MouseDown) => {

        }

    }

/// Detect lifecycle events by comparing old and new DOM state.

///

/// This is the simple, index-based lifecycle detection that doesn't account for

/// node reordering. For more sophisticated reconciliation that can detect moves,

/// use `detect_lifecycle_events_with_reconciliation`.

///

/// Generates Mount, Unmount, and Resize events by comparing DOM hierarchies.

    // Mount events: nodes in new but not in old

    // Unmount events: nodes in old but not in new