User callback runs, calls CallbackInfo methods
    ↓ pushes to Arc<Mutex<Vec<CallbackChange>>>
Vec<CallbackChange>                          ← Enum, 40+ variants, exhaustive match
    ↓ apply_callback_changes() in LayoutWindow
CallbackChangeResult                         ← Struct, ~25 fields, NO exhaustive check
    ↓ merge_into() + resolve_focus_into()
CallCallbacksResult                          ← Struct, 27 fields, NO exhaustive check
    ↓ needs_processing() — manual field enumeration
    ↓ needs_redraw()     — manual field enumeration (subset!)
    ↓ process_callback_result_v2() — manual if-block per field
ProcessEventResult                           ← Enum, 7 ordered variants
    ↓ platform tick handler (8× copy-paste)
Platform redraw trigger                      ← setNeedsDisplay / InvalidateRect / etc

// Focus changed? → restyle, start blink timer, scroll into view
if focus_changed {
    layout_window.apply_focus_restyle();
    if needs_cursor_init {
        layout_window.finalize_pending_focus_changes();
        self.start_timer(CURSOR_BLINK_TIMER_ID, blink_timer);
    }
    result = result.max(ShouldReRenderCurrentWindow);
}

// Drag started? → set :dragging pseudo-state, activate GPU transform
if drag_started && has_draggable_node {
    layout_window.gesture_drag_manager.activate_node_drag(...);
    result = result.max(ShouldReRenderCurrentWindow);
}

// IDEMPOTENT: If an NSTimer already exists for this timer_id, invalidate
// it before creating a new one. This prevents duplicate NSTimers when
// invoke_expired_timers() already inserted the timer into layout_window
// and then process_callback_result_v2 calls start_timer() again.

// NOTE: These are ALSO processed by process_callback_result_v2 (called
// by the platform tick_timers handler), which calls start_timer()/
// stop_timer() to manage platform-specific timers (e.g. NSTimer).
// start_timer() is idempotent — it invalidates any existing NSTimer
// before creating a new one. stop_timer() is also idempotent.

// NOTE: We do NOT invoke the image callbacks here. The actual invocation
// happens in wr_translate2::process_image_callback_updates() during the
// WebRender transaction building phase. Invoking them here would cause:
//   1. Double callback invocation (once here, once during transaction build)
//   2. Double state mutation (e.g. rotation += 1 incremented twice per frame)
//   3. Wasted work (the textures produced here are never registered with
//      WebRender and are discarded)

// NOTE: We must save previous state BEFORE modifying current state
// so that process_window_events_recursive_v2 can detect the change

let timer_results = macos_window.invoke_expired_timers();
let mut needs_redraw = false;
for result in &timer_results {
    if result.needs_processing() {
        macos_window.previous_window_state = Some(macos_window.current_window_state.clone());
        let process_result = macos_window.process_callback_result_v2(result);
        macos_window.sync_window_state();
        if process_result >= ProcessEventResult::ShouldReRenderCurrentWindow {
            needs_redraw = true;
        }
    }
    if result.needs_redraw() {
        needs_redraw = true;
    }
}

/// Changes requested by user callbacks.
/// This enum is already mostly correct — just keep it through processing.
pub enum CallbackChange {
    // ~40 variants: AddTimer, RemoveTimer, ModifyWindowState,
    // InsertText, MoveCursorLeft, ChangeNodeText, ...
}

/// Changes determined by the framework/layout engine.
/// These are things the system decided to do, not things the user asked for.
pub enum SystemChange {
    // --- Focus ---
    FocusNode { target: DomNodeId },
    ClearFocus,
    StartCursorBlinkTimer,
    StopCursorBlinkTimer,
    RestyleForFocusChange { old: Option<DomNodeId>, new: Option<DomNodeId> },

    // --- Text ---
    ApplyTextChangeset,
    ScrollCursorIntoView,

    // --- Drag ---
    ActivateNodeDrag { target: DomNodeId, start_position: LogicalPosition },
    ActivateWindowDrag,
    SetDraggingPseudoState { target: NodeId, active: bool },
    SetDragOverPseudoState { target: NodeId, active: bool },
    UpdateDragGpuTransform { target: NodeId, delta: LogicalPosition },
    DeactivateDrag,

    // --- Auto-Scroll ---
    StartAutoScrollTimer,
    CancelAutoScrollTimer,

    // --- Scrollbar ---
    ScrollbarTrackClick { dom_id: DomId, node_id: NodeId, click_ratio: f32 },
    ScrollbarThumbDragStart { hit_id: ScrollbarHitId, mouse_pos: LogicalPosition },
    ScrollbarThumbDragUpdate { delta: LogicalPosition },

    // --- Hover/Restyle ---
    RestyleNodes { changes: Vec<(NodeId, Vec<ChangedCssProperty>)> },
    DispatchSyntheticEvents { events: Vec<SyntheticEvent> },
}

/// All changes from one event processing cycle.
/// The platform layer MUST process both user and system changes.
///
/// Note: This is NOT a struct with two Vec fields (which would let you
/// forget one). The `process()` method is the ONLY way to consume this.
pub struct FrameChanges {
    user_changes: Vec<CallbackChange>,
    system_changes: Vec,
    update_screen: Update,
}

impl FrameChanges {
    pub fn is_empty(&self) -> bool {
        self.user_changes.is_empty()
            && self.system_changes.is_empty()
            && self.update_screen == Update::DoNothing
    }

    /// Process all changes. Returns the required redraw level.
    ///
    /// This is the ONLY public method. You can't extract user_changes or
    /// system_changes separately — you must process them together.
    pub fn process(self, window: &mut dyn PlatformWindowV2) -> ProcessEventResult {
        let mut result = ProcessEventResult::DoNothing;

        // Process user changes (exhaustive match)
        for change in &self.user_changes {
            let r = window.apply_user_change(change);
            result = result.max(r);
        }

        // Process system changes (exhaustive match)
        for change in &self.system_changes {
            let r = window.apply_system_change(change);
            result = result.max(r);
        }

        // Apply callback return value
        match self.update_screen {
            Update::RefreshDomAllWindows => {
                result = result.max(ProcessEventResult::ShouldRegenerateDomAllWindows);
            }
            Update::RefreshDom => {
                result = result.max(ProcessEventResult::ShouldRegenerateDomCurrentWindow);
            }
            Update::DoNothing => {}
        }

        result
    }
}

trait PlatformWindowV2 {
    /// Process a single user-initiated change.
    /// Adding a new CallbackChange variant → compile error here.
    fn apply_user_change(&mut self, change: &CallbackChange) -> ProcessEventResult {
        match change {
            // === LayoutWindow-only (apply directly) ===
            CallbackChange::InsertText { .. } => {
                if let Some(lw) = self.get_layout_window_mut() {
                    lw.text_input_manager.insert_text(..);
                }
                ProcessEventResult::ShouldReRenderCurrentWindow
            }
            CallbackChange::MoveCursorLeft { .. } => {
                if let Some(lw) = self.get_layout_window_mut() {
                    lw.cursor_manager.move_left(..);
                }
                ProcessEventResult::ShouldReRenderCurrentWindow
            }
            // ... all immediate changes ...

            // === Platform-level (need OS APIs) ===
            CallbackChange::AddTimer { timer_id, timer } => {
                if let Some(lw) = self.get_layout_window_mut() {
                    lw.timers.insert(*timer_id, timer.clone());
                }
                self.start_timer(timer_id.id, timer.clone());
                ProcessEventResult::DoNothing
            }
            CallbackChange::ModifyWindowState { state } => {
                self.apply_window_state_modification(state);
                ProcessEventResult::ShouldReRenderCurrentWindow
            }
            CallbackChange::OpenMenu { menu, position } => {
                self.show_menu_from_callback(menu, *position);
                ProcessEventResult::DoNothing
            }
            // ... all platform changes ...

            // === Content changes ===
            CallbackChange::ChangeNodeText { .. } => {
                if let Some(lw) = self.get_layout_window_mut() {
                    lw.apply_text_change(..);
                }
                ProcessEventResult::ShouldIncrementalRelayout
            }
            CallbackChange::UpdateAllImageCallbacks => {
                ProcessEventResult::ShouldReRenderCurrentWindow
            }

            // === Propagation control (consumed by dispatch loop, no-op here) ===
            CallbackChange::StopPropagation
            | CallbackChange::StopImmediatePropagation
            | CallbackChange::PreventDefault => ProcessEventResult::DoNothing,
        }
    }

    /// Process a single system-initiated change.
    /// Adding a new SystemChange variant → compile error here.
    fn apply_system_change(&mut self, change: &SystemChange) -> ProcessEventResult {
        match change {
            SystemChange::FocusNode { target } => {
                if let Some(lw) = self.get_layout_window_mut() {
                    lw.focus_manager.set_focus(*target);
                }
                ProcessEventResult::ShouldReRenderCurrentWindow
            }
            SystemChange::StartCursorBlinkTimer => {
                if let Some(lw) = self.get_layout_window() {
                    let timer = lw.create_cursor_blink_timer(self.get_current_window_state());
                    self.start_timer(CURSOR_BLINK_TIMER_ID.id, timer);
                }
                ProcessEventResult::DoNothing
            }
            SystemChange::StopCursorBlinkTimer => {
                self.stop_timer(CURSOR_BLINK_TIMER_ID.id);
                ProcessEventResult::DoNothing
            }
            SystemChange::ActivateWindowDrag => {
                self.handle_begin_interactive_move();
                ProcessEventResult::DoNothing
            }
            SystemChange::StartAutoScrollTimer => {
                let timer = create_autoscroll_timer();
                if let Some(lw) = self.get_layout_window_mut() {
                    lw.add_timer(DRAG_AUTOSCROLL_TIMER_ID, timer.clone());
                }
                self.start_timer(DRAG_AUTOSCROLL_TIMER_ID.id, timer);
                ProcessEventResult::ShouldReRenderCurrentWindow
            }
            SystemChange::RestyleNodes { changes } => {
                if let Some(lw) = self.get_layout_window_mut() {
                    lw.apply_restyle(changes);
                }
                ProcessEventResult::ShouldReRenderCurrentWindow
            }
            // ... exhaustive ...
        }
    }
}

/// In process_window_events_recursive_v2:
fn process_window_events_recursive_v2(&mut self, depth: u32) -> ProcessEventResult {
    let mut frame_changes = FrameChanges::empty();

    // 1. Pre-callback system events (text selection, etc.)
    let pre_events = self.compute_pre_callback_system_events(&synthetic_events);
    frame_changes.add_system_changes(pre_events);

    // 2. Dispatch user callbacks
    let (user_changes, prevent_default) = self.dispatch_callbacks(&events);
    frame_changes.add_user_changes(user_changes);

    // 3. Post-callback system events (focus, drag, auto-scroll)
    let post_events = self.compute_post_callback_system_events(prevent_default, ..);
    frame_changes.add_system_changes(post_events);

    // 4. Process everything — COMPILER ENFORCED
    let result = frame_changes.process(self);

    // 5. Recurse if needed (synthetic events from window state changes)
    if needs_recursion {
        let recursive_result = self.process_window_events_recursive_v2(depth + 1);
        result = result.max(recursive_result);
    }

    result
}

trait PlatformWindowV2 {
    fn process_timers_and_threads(&mut self) -> ProcessEventResult {
        let mut result = ProcessEventResult::DoNothing;

        // Timers produce user changes (from timer callbacks)
        let timer_frame_changes = self.invoke_expired_timers(); // returns Vec<FrameChanges>
        for fc in timer_frame_changes {
            self.save_previous_window_state();
            let r = fc.process(self);
            self.sync_window_state();
            result = result.max(r);
        }

        // Threads produce user changes (from writeback callbacks)
        if let Some(thread_fc) = self.invoke_thread_callbacks() {
            self.save_previous_window_state();
            let r = thread_fc.process(self);
            self.sync_window_state();
            result = result.max(r);
        }

        result
    }
}

// macOS tick_timers, Windows WM_TIMER, X11 select timeout, Wayland timerfd
let result = self.process_timers_and_threads();
if result >= ProcessEventResult::ShouldReRenderCurrentWindow {
    self.frame_needs_regeneration = true;
    self.trigger_platform_redraw();
}

enum Change {
    // User changes
    AddTimer { .. },
    ModifyWindowState { .. },
    // System changes
    FocusNode { .. },
    StartCursorBlinkTimer,
    ActivateWindowDrag,
}