cranpose_ui/

scroll.rs

//! Scroll state and node implementation for cranpose.
//!
//! This module provides the core scrolling components:
//! - `ScrollState`: Holds scroll position and provides scroll control methods
//! - `ScrollNode`: Layout modifier that applies scroll offset to content
//! - `ScrollElement`: Element for creating ScrollNode instances
//!
//! The actual `Modifier.horizontal_scroll()` and `Modifier.vertical_scroll()`
//! extension methods are defined in `modifier/scroll.rs`.

use std::{
    cell::{Cell, OnceCell, RefCell},
    hash::{Hash, Hasher},
    rc::{Rc, Weak},
};

use cranpose_core::{MutableState, NodeId, collections::map::HashMap};
use cranpose_foundation::{
    Constraints, DelegatableNode, LayoutModifierNode, Measurable, ModifierNode,
    ModifierNodeContext, ModifierNodeElement, NodeCapabilities, NodeState,
};
use cranpose_ui_graphics::Size;
use cranpose_ui_layout::LayoutModifierMeasureResult;

type InvalidationCallbackMap = HashMap<u64, Rc<dyn Fn()>>;

struct InvalidationCallbacks {
    callbacks: RefCell<Rc<InvalidationCallbackMap>>,
    next_id: Cell<u64>,
}

impl InvalidationCallbacks {
    fn new() -> Self {
        Self {
            callbacks: RefCell::new(Rc::new(HashMap::default())),
            next_id: Cell::new(1),
        }
    }

    fn add(&self, callback: Rc<dyn Fn()>) -> u64 {
        let id = self.next_id.get();
        self.next_id.set(id.saturating_add(1));
        let displaced = {
            let mut callbacks = self.callbacks.borrow_mut();
            Rc::make_mut(&mut callbacks).insert(id, callback)
        };
        drop(displaced);
        id
    }

    fn remove(&self, id: u64) {
        let removed = {
            let mut callbacks = self.callbacks.borrow_mut();
            Rc::make_mut(&mut callbacks).remove(&id)
        };
        drop(removed);
    }

    fn snapshot(&self) -> Rc<InvalidationCallbackMap> {
        Rc::clone(&self.callbacks.borrow())
    }
}

/// State object for scroll position tracking.
///
/// Holds the current scroll offset and provides methods to programmatically
/// control scrolling. Can be created with `rememberScrollState()`.
///
/// This is a pure scroll model - it does NOT store ephemeral gesture/pointer state.
/// Gesture state is managed locally in the scroll modifier.
#[derive(Clone, Copy)]
pub struct ScrollState {
    value: MutableState<f32>,
    in_progress: MutableState<bool>,
    inner: MutableState<Rc<ScrollStateInner>>,
}

pub(crate) struct ScrollStateInner {
    max_value: RefCell<f32>,
    viewport_extent: RefCell<f32>,
    invalidate_callbacks: InvalidationCallbacks,
    pending_invalidation: Cell<bool>,
    settle_policy: RefCell<Option<ScrollSettlePolicy>>,
}

/// A scroll position and the extents it is measured against, read together.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ScrollMetrics {
    /// How far the content has travelled, in logical pixels.
    pub offset: f32,
    /// The furthest it can travel. Zero when the content fits.
    pub max_offset: f32,
    /// How much of the content is on screen.
    pub viewport_extent: f32,
}

impl ScrollMetrics {
    /// The whole scrollable content along the main axis.
    pub fn content_extent(self) -> f32 {
        self.viewport_extent + self.max_offset
    }

    /// How far through the scroll the content is, in `0..=1`.
    pub fn progress(self) -> f32 {
        if self.max_offset <= 0.0 {
            0.0
        } else {
            (self.offset / self.max_offset).clamp(0.0, 1.0)
        }
    }

    /// The thumb an indicator of this scroll should draw, given how short its
    /// thumb may get, or `None` when the content fits.
    pub fn thumb(
        self,
        bounds: crate::scrollbar::ThumbBounds,
    ) -> Option<crate::scrollbar::ThumbGeometry> {
        crate::scrollbar::thumb_geometry(
            self.content_extent(),
            self.viewport_extent,
            self.offset,
            bounds,
        )
    }
}

/// Remaps where a scroll comes to rest once the user's interaction ends — the
/// `UIScrollView targetContentOffset` analog. Receives the naturally proposed
/// rest offset (the fling's predicted end, or the current offset for a plain
/// release/wheel idle) and the release velocity in offset units/sec; returns
/// the offset the scroll should settle at. Used e.g. by the liquid nav bar to
/// snap out of the large-title collapse band so the title never rests
/// half-faded.
pub type ScrollSettlePolicy = Rc<dyn Fn(f32, f32) -> f32>;

const RUBBER_BAND_COEFFICIENT: f32 = 0.55;

fn rubber_band(raw: f32, dimension: f32) -> f32 {
    if !dimension.is_finite() || dimension <= 0.0 {
        return raw;
    }
    let x = raw.abs();
    let c = RUBBER_BAND_COEFFICIENT;
    (x * dimension * c / (dimension + c * x)).copysign(raw)
}

fn rubber_band_inverse(visible: f32, dimension: f32) -> f32 {
    if !dimension.is_finite() || dimension <= 0.0 {
        return visible;
    }
    let c = RUBBER_BAND_COEFFICIENT;
    let v = visible.abs().min(dimension * 0.999_9);
    (v * dimension / (c * (dimension - v))).copysign(visible)
}

#[derive(Clone)]
pub(crate) struct OverscrollEffect {
    inner: Rc<OverscrollEffectInner>,
}

struct OverscrollEffectInner {
    raw: Cell<f32>,
    visible: Cell<f32>,
    dimension: Cell<f32>,
    invalidate_callbacks: InvalidationCallbacks,
}

impl OverscrollEffect {
    pub(crate) fn new() -> Self {
        Self {
            inner: Rc::new(OverscrollEffectInner {
                raw: Cell::new(0.0),
                visible: Cell::new(0.0),
                dimension: Cell::new(0.0),
                invalidate_callbacks: InvalidationCallbacks::new(),
            }),
        }
    }

    pub(crate) fn offset(&self) -> f32 {
        self.inner.visible.get()
    }

    pub(crate) fn set_dimension(&self, dimension: f32) {
        if !dimension.is_finite() || dimension <= 0.0 {
            return;
        }
        self.inner.dimension.set(dimension);
        self.set_visible(rubber_band(self.inner.raw.get(), dimension));
    }

    pub(crate) fn apply_drag_delta(&self, delta: f32) -> f32 {
        if !delta.is_finite() || delta.abs() <= f32::EPSILON {
            return 0.0;
        }
        let before = self.offset();
        let raw = self.inner.raw.get() + delta;
        self.inner.raw.set(raw);
        self.set_visible(rubber_band(raw, self.inner.dimension.get()));
        self.offset() - before
    }

    pub(crate) fn apply_settle_delta(&self, delta: f32) -> f32 {
        let offset = self.offset();
        if offset.abs() <= f32::EPSILON {
            return 0.0;
        }
        let proposed = offset + delta;
        let crosses_edge = proposed.signum() != offset.signum();
        let next = if crosses_edge { 0.0 } else { proposed };
        let applied = next - offset;
        self.inner
            .raw
            .set(rubber_band_inverse(next, self.inner.dimension.get()));
        self.set_visible(next);
        applied
    }

    pub(crate) fn apply_to_scroll<F>(&self, delta: f32, perform_scroll: F) -> f32
    where
        F: FnOnce(f32) -> f32,
    {
        if !delta.is_finite() || delta.abs() <= f32::EPSILON {
            return 0.0;
        }
        let mut remaining = delta;
        let mut consumed = 0.0;
        let offset = self.offset();
        if offset.abs() > f32::EPSILON && delta.signum() != offset.signum() {
            let release = delta.abs().min(offset.abs()) * delta.signum();
            let released = self.apply_settle_delta(release);
            consumed += released;
            remaining -= released;
        }
        if remaining.abs() > f32::EPSILON {
            let target_consumed = perform_scroll(remaining);
            consumed += target_consumed;
            let unconsumed = remaining - target_consumed;
            if unconsumed.abs() > f32::EPSILON {
                consumed += self.apply_drag_delta(unconsumed);
            }
        }
        consumed
    }

    pub(crate) fn apply_to_fling<F>(&self, delta: f32, perform_scroll: F) -> f32
    where
        F: FnOnce(f32) -> f32,
    {
        let consumed = perform_scroll(delta);
        let unconsumed = delta - consumed;
        if unconsumed.abs() > f32::EPSILON {
            self.apply_drag_delta(-unconsumed);
        }
        consumed
    }

    pub(crate) fn add_invalidate_callback(&self, callback: Box<dyn Fn()>) -> u64 {
        self.inner
            .invalidate_callbacks
            .add(app_owned_invalidation_callback(callback))
    }

    pub(crate) fn remove_invalidate_callback(&self, id: u64) {
        self.inner.invalidate_callbacks.remove(id);
    }

    pub(crate) fn ptr_eq(&self, other: &Self) -> bool {
        Rc::ptr_eq(&self.inner, &other.inner)
    }

    fn set_visible(&self, visible: f32) {
        if (visible - self.offset()).abs() <= f32::EPSILON {
            return;
        }
        self.inner.visible.set(visible);
        let callbacks = self.inner.invalidate_callbacks.snapshot();
        for callback in callbacks.values() {
            callback();
        }
    }
}

impl PartialEq for ScrollState {
    fn eq(&self, other: &Self) -> bool {
        self.inner == other.inner
    }
}

impl ScrollState {
    /// Creates a new ScrollState with the given initial scroll position.
    pub fn new(initial: f32) -> Self {
        let runtime = cranpose_core::current_runtime_handle()
            .expect("ScrollState::new requires an active runtime");
        Self {
            value: MutableState::with_runtime(initial, runtime.clone()),
            in_progress: MutableState::with_runtime(false, runtime.clone()),
            inner: MutableState::with_runtime(
                Rc::new(ScrollStateInner {
                    max_value: RefCell::new(0.0),
                    viewport_extent: RefCell::new(0.0),
                    invalidate_callbacks: InvalidationCallbacks::new(),
                    pending_invalidation: Cell::new(false),
                    settle_policy: RefCell::new(None),
                }),
                runtime,
            ),
        }
    }

    fn inner(&self) -> Rc<ScrollStateInner> {
        self.inner.get_non_reactive()
    }

    /// Installs (or clears) the settle policy consulted when interactions end.
    pub fn set_settle_policy(&self, policy: Option<ScrollSettlePolicy>) {
        *self.inner().settle_policy.borrow_mut() = policy;
    }

    /// The currently installed settle policy, if any.
    pub fn settle_policy(&self) -> Option<ScrollSettlePolicy> {
        self.inner().settle_policy.borrow().clone()
    }

    /// Whether a drag, a fling or a settle moves the content now: Compose's
    /// `isScrollInProgress`. A composable that reads it recomposes when a
    /// scroll starts and when it ends.
    pub fn is_scroll_in_progress(&self) -> bool {
        self.in_progress.is_alive() && self.in_progress.get()
    }

    pub(crate) fn set_scroll_in_progress(&self, active: bool) {
        if self.in_progress.is_alive() && self.in_progress.get_non_reactive() != active {
            self.in_progress.set(active);
        }
    }

    /// Get the unique ID of this ScrollState
    pub fn id(&self) -> u64 {
        let mut hasher = cranpose_core::hash::default::new();
        self.inner.runtime_state_id().hash(&mut hasher);
        hasher.finish()
    }

    /// Gets the current scroll position in pixels (reactive - triggers recomposition).
    ///
    /// Use this in Composable functions when you want UI to update on scroll.
    /// Example: `Text("Scroll position: ${scrollState.value()}")`
    pub fn value(&self) -> f32 {
        self.value.value()
    }

    /// Gets the current scroll position in pixels (non-reactive).
    ///
    /// Use this in layout/measure phase to avoid triggering recomposition.
    /// This is called internally by ScrollNode::measure().
    pub fn value_non_reactive(&self) -> f32 {
        self.value.get_non_reactive()
    }

    /// The scroll position, or `None` once the slot that held this state was
    /// released. A saver reads it when the scroller leaves the composition.
    pub fn try_value(&self) -> Option<f32> {
        self.value.try_value()
    }

    /// Gets the maximum scroll value.
    pub fn max_value(&self) -> f32 {
        *self.inner().max_value.borrow()
    }

    /// Scrolls by the given delta, clamping to valid range [0, max_value].
    /// Returns the actual amount scrolled.
    pub fn dispatch_raw_delta(&self, delta: f32) -> f32 {
        let current = self.value_non_reactive();
        let max = self.max_value();
        let new_value = (current + delta).clamp(0.0, max);
        let actual_delta = new_value - current;

        if actual_delta.abs() > 0.001 {
            self.value.set(new_value);

            self.invalidate();
        }

        actual_delta
    }

    /// The main-axis extent of the scroll viewport, as the last measure pass
    /// resolved it.
    pub fn viewport_extent(&self) -> f32 {
        *self.inner().viewport_extent.borrow()
    }

    /// The whole scrollable content along the main axis.
    pub fn content_extent(&self) -> f32 {
        self.viewport_extent() + self.max_value()
    }

    /// Everything an indicator needs about this scroll, read together so it
    /// cannot mix a position from one frame with an extent from another.
    ///
    /// Read outside composition — during draw, or from a gesture — so following
    /// a scroll costs no recomposition.
    pub fn metrics(&self) -> ScrollMetrics {
        let inner = self.inner();
        let max_offset = *inner.max_value.borrow();
        let viewport_extent = *inner.viewport_extent.borrow();
        ScrollMetrics {
            offset: self.value_non_reactive(),
            max_offset,
            viewport_extent,
        }
    }

    pub(crate) fn set_max_value(&self, max: f32) {
        *self.inner().max_value.borrow_mut() = max;
    }

    pub(crate) fn set_viewport_extent(&self, extent: f32) {
        *self.inner().viewport_extent.borrow_mut() = extent;
    }

    /// Scrolls to the given position immediately.
    pub fn scroll_to(&self, position: f32) {
        let max = self.max_value();
        let clamped = position.clamp(0.0, max);

        self.value.set(clamped);

        self.invalidate();
    }

    pub(crate) fn add_invalidate_callback(&self, callback: Box<dyn Fn()>) -> u64 {
        let inner = self.inner();
        let callback = app_owned_invalidation_callback(callback);
        let id = inner.invalidate_callbacks.add(Rc::clone(&callback));
        if inner.pending_invalidation.replace(false) {
            callback();
        }
        id
    }

    pub(crate) fn remove_invalidate_callback(&self, id: u64) {
        self.inner().invalidate_callbacks.remove(id);
    }

    fn invalidate(&self) {
        let inner = self.inner();
        let callbacks = inner.invalidate_callbacks.snapshot();
        if callbacks.is_empty() {
            inner.pending_invalidation.set(true);
            return;
        }
        for callback in callbacks.values() {
            callback();
        }
    }
}

fn app_owned_invalidation_callback(callback: Box<dyn Fn()>) -> Rc<dyn Fn()> {
    let Some(owner) = crate::render_state::current_app_context() else {
        return Rc::from(callback);
    };
    let owner = Rc::downgrade(&owner);
    Rc::new(move || {
        if let Some(owner) = owner.upgrade() {
            owner.enter(&callback);
        }
    })
}

#[derive(Clone)]
pub(crate) struct ScrollMotionContext {
    inner: Rc<ScrollMotionContextInner>,
}

#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub(crate) enum ScrollMotionContextKey {
    ScrollState {
        state_id: u64,
        is_vertical: bool,
        reverse_scrolling: bool,
    },
    LazyList {
        state_identity: usize,
        is_vertical: bool,
        reverse_scrolling: bool,
    },
    Draggable {
        state_identity: usize,
        is_vertical: bool,
    },
}

struct ScrollMotionContextInner {
    active: Cell<bool>,
    /// Told when `active` changes: the scrolled state's
    /// `is_scroll_in_progress` follows it.
    activity_observer: OnceCell<Box<dyn Fn(bool)>>,
    transient_active: Cell<bool>,
    generation: Cell<u64>,
    invalidate_callbacks: InvalidationCallbacks,
    pending_invalidation: Cell<bool>,
    overscroll: OverscrollEffect,
}

pub(crate) struct ScrollMotionContextStore {
    contexts: RefCell<HashMap<ScrollMotionContextKey, Weak<ScrollMotionContextInner>>>,
}

impl ScrollMotionContextStore {
    pub(crate) fn new() -> Self {
        Self {
            contexts: RefCell::new(HashMap::default()),
        }
    }

    fn context_for_key(&self, key: ScrollMotionContextKey) -> ScrollMotionContext {
        let mut contexts = self.contexts.borrow_mut();
        if let Some(inner) = contexts.get(&key).and_then(Weak::upgrade) {
            return ScrollMotionContext { inner };
        }

        let context = ScrollMotionContext::new();
        contexts.insert(key, Rc::downgrade(&context.inner));
        contexts.retain(|_, weak| weak.strong_count() > 0);
        context
    }

    pub(crate) fn clear_transient_after_frame(&self) {
        let contexts = {
            let mut contexts = self.contexts.borrow_mut();
            let live = contexts
                .values()
                .filter_map(Weak::upgrade)
                .collect::<Vec<_>>();
            contexts.retain(|_, weak| weak.strong_count() > 0);
            live
        };
        for inner in contexts {
            ScrollMotionContext { inner }.clear_transient_after_frame();
        }
    }
}

pub(crate) fn scroll_motion_context_for_key(key: ScrollMotionContextKey) -> ScrollMotionContext {
    crate::render_state::with_scroll_motion_context_store(|store| store.context_for_key(key))
}

impl ScrollMotionContext {
    pub(crate) fn new() -> Self {
        Self {
            inner: Rc::new(ScrollMotionContextInner {
                active: Cell::new(false),
                activity_observer: OnceCell::new(),
                transient_active: Cell::new(false),
                generation: Cell::new(0),
                invalidate_callbacks: InvalidationCallbacks::new(),
                pending_invalidation: Cell::new(false),
                overscroll: OverscrollEffect::new(),
            }),
        }
    }

    pub(crate) fn is_active(&self) -> bool {
        self.inner.active.get() || self.inner.transient_active.get()
    }

    pub(crate) fn ptr_eq(&self, other: &Self) -> bool {
        Rc::ptr_eq(&self.inner, &other.inner)
    }

    pub(crate) fn stable_key(&self) -> usize {
        Rc::as_ptr(&self.inner) as usize
    }

    pub(crate) fn overscroll(&self) -> OverscrollEffect {
        self.inner.overscroll.clone()
    }

    /// Installs the observer `make` builds unless one is installed: a context
    /// belongs to one scroll state, so its first observer stays right.
    pub(crate) fn observe_activity(&self, make: impl FnOnce() -> Box<dyn Fn(bool)>) {
        self.inner.activity_observer.get_or_init(make);
    }

    pub(crate) fn set_active(&self, active: bool) {
        let was_active = self.is_active();
        if self.inner.active.replace(active) != active
            && let Some(observer) = self.inner.activity_observer.get()
        {
            observer(active);
        }
        if !active {
            self.inner.transient_active.set(false);
        }
        if was_active != self.is_active() {
            self.bump_generation();
            self.invalidate();
        }
    }

    pub(crate) fn activate_for_current_frame(&self) {
        let was_active = self.is_active();
        self.inner.transient_active.set(true);
        self.bump_generation();
        if !was_active {
            self.invalidate();
        }
    }

    pub(crate) fn add_invalidate_callback(&self, callback: Box<dyn Fn()>) -> u64 {
        let callback = app_owned_invalidation_callback(callback);
        let id = self.inner.invalidate_callbacks.add(Rc::clone(&callback));
        if self.inner.pending_invalidation.replace(false) {
            callback();
        }
        id
    }

    pub(crate) fn remove_invalidate_callback(&self, id: u64) {
        self.inner.invalidate_callbacks.remove(id);
    }

    fn bump_generation(&self) -> u64 {
        let next = self.inner.generation.get().wrapping_add(1);
        self.inner.generation.set(next);
        next
    }

    fn clear_transient_after_frame(&self) {
        let was_active = self.is_active();
        if self.inner.transient_active.replace(false) {
            self.bump_generation();
            if was_active != self.is_active() {
                self.invalidate();
            }
        }
    }

    fn invalidate(&self) {
        let callbacks = self.inner.invalidate_callbacks.snapshot();
        if callbacks.is_empty() {
            self.inner.pending_invalidation.set(true);
            return;
        }
        for callback in callbacks.values() {
            callback();
        }
    }
}

/// Element for creating a ScrollNode.
#[derive(Clone)]
pub struct ScrollElement {
    state: ScrollState,
    overscroll: OverscrollEffect,
    is_vertical: bool,
    reverse_scrolling: bool,
}

impl ScrollElement {
    pub(crate) fn new(
        state: ScrollState,
        overscroll: OverscrollEffect,
        is_vertical: bool,
        reverse_scrolling: bool,
    ) -> Self {
        Self {
            state,
            overscroll,
            is_vertical,
            reverse_scrolling,
        }
    }
}

impl std::fmt::Debug for ScrollElement {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ScrollElement")
            .field("is_vertical", &self.is_vertical)
            .field("reverse_scrolling", &self.reverse_scrolling)
            .finish()
    }
}

impl PartialEq for ScrollElement {
    fn eq(&self, other: &Self) -> bool {
        self.state == other.state
            && self.is_vertical == other.is_vertical
            && self.reverse_scrolling == other.reverse_scrolling
    }
}

impl Eq for ScrollElement {}

impl Hash for ScrollElement {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.state.inner.runtime_state_id().hash(state);
        self.is_vertical.hash(state);
        self.reverse_scrolling.hash(state);
    }
}

impl ModifierNodeElement for ScrollElement {
    type Node = ScrollNode;

    fn create(&self) -> Self::Node {
        ScrollNode::new(
            self.state,
            self.overscroll.clone(),
            self.is_vertical,
            self.reverse_scrolling,
        )
    }

    fn key(&self) -> Option<u64> {
        let mut hasher = cranpose_core::hash::default::new();
        self.state.id().hash(&mut hasher);
        self.reverse_scrolling.hash(&mut hasher);
        self.is_vertical.hash(&mut hasher);
        Some(hasher.finish())
    }

    fn update(&self, node: &mut Self::Node) {
        let needs_invalidation = node.state != self.state
            || node.is_vertical != self.is_vertical
            || node.reverse_scrolling != self.reverse_scrolling
            || !node.overscroll.ptr_eq(&self.overscroll);

        if needs_invalidation {
            node.state = self.state;
            node.is_vertical = self.is_vertical;
            node.reverse_scrolling = self.reverse_scrolling;
            node.overscroll = self.overscroll.clone();
        }
    }

    fn capabilities(&self) -> NodeCapabilities {
        NodeCapabilities::LAYOUT
    }
}

/// ScrollNode layout modifier that physically moves content based on scroll position.
/// This is the component that actually reads ScrollState and applies the visual offset.
pub struct ScrollNode {
    state: ScrollState,
    overscroll: OverscrollEffect,
    is_vertical: bool,
    reverse_scrolling: bool,
    node_state: NodeState,
    invalidation_callback_id: Option<u64>,
    overscroll_callback_id: Option<u64>,
    node_id: Option<NodeId>,
}

impl ScrollNode {
    pub(crate) fn new(
        state: ScrollState,
        overscroll: OverscrollEffect,
        is_vertical: bool,
        reverse_scrolling: bool,
    ) -> Self {
        Self {
            state,
            overscroll,
            is_vertical,
            reverse_scrolling,
            node_state: NodeState::default(),
            invalidation_callback_id: None,
            overscroll_callback_id: None,
            node_id: None,
        }
    }

    /// Returns a reference to the ScrollState.
    pub fn state(&self) -> &ScrollState {
        &self.state
    }
}

impl DelegatableNode for ScrollNode {
    fn node_state(&self) -> &NodeState {
        &self.node_state
    }
}

impl ModifierNode for ScrollNode {
    fn on_attach(&mut self, context: &mut dyn ModifierNodeContext) {
        let node_id = context.node_id();
        self.node_id = node_id;

        if let Some(node_id) = node_id {
            let callback_id = self.state.add_invalidate_callback(Box::new(move || {
                crate::schedule_layout_repass(node_id);
            }));
            self.invalidation_callback_id = Some(callback_id);
            let callback_id = self.overscroll.add_invalidate_callback(Box::new(move || {
                crate::schedule_layout_repass(node_id);
            }));
            self.overscroll_callback_id = Some(callback_id);
        } else {
            log::debug!(
                "ScrollNode attached without a NodeId; deferring invalidation registration."
            );
        }

        context.invalidate(cranpose_foundation::InvalidationKind::Layout);
    }

    fn on_detach(&mut self) {
        if let Some(id) = self.invalidation_callback_id.take() {
            self.state.remove_invalidate_callback(id);
        }
        if let Some(id) = self.overscroll_callback_id.take() {
            self.overscroll.remove_invalidate_callback(id);
        }
    }

    fn as_layout_node(&self) -> Option<&dyn LayoutModifierNode> {
        Some(self)
    }

    fn as_layout_node_mut(&mut self) -> Option<&mut dyn LayoutModifierNode> {
        Some(self)
    }
}

impl LayoutModifierNode for ScrollNode {
    fn measure(
        &self,
        _context: &mut dyn ModifierNodeContext,
        measurable: &dyn Measurable,
        constraints: Constraints,
    ) -> LayoutModifierMeasureResult {
        // The content keeps the incoming minimum and loses only the maximum
        // along the scroll, as Compose's `ScrollingLayoutNode` measures it
        // with `constraints.copy(maxHeight = Infinity)`: under
        // `fill_max_size()` it is at least as tall as the viewport.
        let scroll_constraints = if self.is_vertical {
            Constraints {
                max_height: f32::INFINITY,
                ..constraints
            }
        } else {
            Constraints {
                max_width: f32::INFINITY,
                ..constraints
            }
        };

        let placeable = measurable.measure(scroll_constraints);

        let width = placeable.width().min(constraints.max_width);
        let height = placeable.height().min(constraints.max_height);

        let max_scroll = if self.is_vertical {
            (placeable.height() - height).max(0.0)
        } else {
            (placeable.width() - width).max(0.0)
        };

        if (self.is_vertical && constraints.max_height.is_finite())
            || (!self.is_vertical && constraints.max_width.is_finite())
        {
            self.state.set_max_value(max_scroll);
            self.state
                .set_viewport_extent(if self.is_vertical { height } else { width });
            self.overscroll
                .set_dimension(if self.is_vertical { height } else { width });
        }

        let scroll = self.state.value_non_reactive().clamp(0.0, max_scroll);

        let abs_scroll = if self.reverse_scrolling {
            scroll - max_scroll
        } else {
            -scroll
        };
        let abs_scroll = abs_scroll + self.overscroll.offset();

        let (x_offset, y_offset) = if self.is_vertical {
            (0.0, abs_scroll)
        } else {
            (abs_scroll, 0.0)
        };

        LayoutModifierMeasureResult::new(Size { width, height }, x_offset, y_offset)
    }

    fn min_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, _density: f32) -> f32 {
        measurable.min_intrinsic_width(height)
    }

    fn max_intrinsic_width(&self, measurable: &dyn Measurable, height: f32, _density: f32) -> f32 {
        measurable.max_intrinsic_width(height)
    }

    fn min_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, _density: f32) -> f32 {
        measurable.min_intrinsic_height(width)
    }

    fn max_intrinsic_height(&self, measurable: &dyn Measurable, width: f32, _density: f32) -> f32 {
        measurable.max_intrinsic_height(width)
    }
}

/// Creates a remembered ScrollState.
///
/// This is a convenience function for use in composable functions.
#[macro_export]
macro_rules! rememberScrollState {
    ($initial:expr) => {
        cranpose_core::remember(|| $crate::scroll::ScrollState::new($initial))
            .with(|state| state.clone())
    };
    () => {
        rememberScrollState!(0.0)
    };
}

#[cfg(test)]
#[path = "tests/scroll_tests.rs"]
mod tests;