armas_basic/components/

range_slider.rs

//! Range Slider Component
//!
//! Horizontal slider with two thumbs for selecting a range (min/max).

use crate::ext::ArmasContextExt;
use egui::{pos2, vec2, Color32, Rect, Response, Sense, Stroke, Ui};

/// Which thumb is being dragged
#[derive(Clone, Copy, Debug, PartialEq, Default)]
enum DragTarget {
    #[default]
    None,
    Min,
    Max,
    Both,
}

/// Persisted drag state for range slider
#[derive(Clone, Default)]
struct RangeSliderDragState {
    target: DragTarget,
    drag_start_min: f32,
    drag_start_max: f32,
    drag_start_x: f32,
}

/// Geometry parameters for slider layout
struct SliderGeometry<'a> {
    track_rect: &'a Rect,
    thumb_radius: f32,
    min_x: f32,
    max_x: f32,
}

/// Range slider with two thumbs for min/max selection
///
/// # Example
///
/// ```rust,no_run
/// # use egui::Ui;
/// # fn example(ui: &mut Ui) {
/// use armas_basic::components::RangeSlider;
///
/// let mut min = 20.0;
/// let mut max = 80.0;
/// RangeSlider::new(0.0, 100.0)
///     .label("Price range")
///     .show(ui, &mut min, &mut max);
/// # }
/// ```
pub struct RangeSlider {
    id: Option<egui::Id>,
    range_min: f32,
    range_max: f32,
    width: f32,
    height: f32,
    show_value: bool,
    label: Option<String>,
    suffix: Option<String>,
    step: Option<f32>,
    min_gap: f32,
    allow_range_drag: bool,
}

impl RangeSlider {
    /// Create a new range slider
    #[must_use]
    pub const fn new(range_min: f32, range_max: f32) -> Self {
        Self {
            id: None,
            range_min,
            range_max,
            width: 200.0,
            height: 20.0,
            show_value: true,
            label: None,
            suffix: None,
            step: None,
            min_gap: 0.0,
            allow_range_drag: true,
        }
    }

    /// Set ID for state persistence
    #[must_use]
    pub fn id(mut self, id: impl Into<egui::Id>) -> Self {
        self.id = Some(id.into());
        self
    }

    /// Set the slider width
    #[must_use]
    pub const fn width(mut self, width: f32) -> Self {
        self.width = width;
        self
    }

    /// Set the slider height
    #[must_use]
    pub const fn height(mut self, height: f32) -> Self {
        self.height = height;
        self
    }

    /// Show or hide the value label
    #[must_use]
    pub const fn show_value(mut self, show: bool) -> Self {
        self.show_value = show;
        self
    }

    /// Set a label for the slider
    #[must_use]
    pub fn label(mut self, label: impl Into<String>) -> Self {
        self.label = Some(label.into());
        self
    }

    /// Set a suffix for the values (e.g., "%", "ms", "Hz")
    #[must_use]
    pub fn suffix(mut self, suffix: impl Into<String>) -> Self {
        self.suffix = Some(suffix.into());
        self
    }

    /// Set a step value for snapping
    #[must_use]
    pub const fn step(mut self, step: f32) -> Self {
        self.step = Some(step);
        self
    }

    /// Set minimum gap between min and max thumbs
    #[must_use]
    pub const fn min_gap(mut self, gap: f32) -> Self {
        self.min_gap = gap;
        self
    }

    /// Allow dragging the filled region to move both thumbs together
    #[must_use]
    pub const fn allow_range_drag(mut self, allow: bool) -> Self {
        self.allow_range_drag = allow;
        self
    }

    /// Show the range slider
    pub fn show(
        self,
        ui: &mut Ui,
        min_value: &mut f32,
        max_value: &mut f32,
    ) -> RangeSliderResponse {
        let theme = ui.ctx().armas_theme();
        let mut changed = false;

        let slider_id = self
            .id
            .unwrap_or_else(|| ui.make_persistent_id("range_slider"));
        let drag_state_id = slider_id.with("drag_state");

        // Load state from memory if ID is set (for demos where values reset each frame)
        if let Some(id) = self.id {
            let min_state_id = id.with("min_value");
            let max_state_id = id.with("max_value");
            *min_value = ui
                .ctx()
                .data_mut(|d| d.get_temp(min_state_id).unwrap_or(*min_value));
            *max_value = ui
                .ctx()
                .data_mut(|d| d.get_temp(max_state_id).unwrap_or(*max_value));
        }

        // Clamp and ensure min <= max
        self.clamp_values(min_value, max_value);

        ui.vertical(|ui| {
            ui.spacing_mut().item_spacing.y = 4.0;

            // Label and values
            self.draw_label(ui, *min_value, *max_value);

            // Allocate slider area
            let (rect, response) =
                ui.allocate_exact_size(vec2(self.width, self.height), Sense::click_and_drag());

            // Track and thumb sizes (matching shadcn: h-1.5 track, size-4 thumb)
            let track_height = 6.0;
            let thumb_radius = 8.0;
            let track_rect =
                Rect::from_center_size(rect.center(), vec2(rect.width(), track_height));

            // Calculate thumb positions
            let min_x = self.value_to_x(*min_value, &track_rect);
            let max_x = self.value_to_x(*max_value, &track_rect);

            let geometry = SliderGeometry {
                track_rect: &track_rect,
                thumb_radius,
                min_x,
                max_x,
            };

            // Handle interactions
            let drag_state = self.handle_interaction(
                ui,
                &response,
                drag_state_id,
                &geometry,
                min_value,
                max_value,
                &mut changed,
            );

            // Determine which thumb is hovered (for per-thumb hover effect)
            let hovered_thumb = if response.hovered() {
                response.hover_pos().and_then(|pos| {
                    let dist_to_min = (pos.x - geometry.min_x).abs();
                    let dist_to_max = (pos.x - geometry.max_x).abs();
                    if dist_to_min <= geometry.thumb_radius {
                        Some(DragTarget::Min)
                    } else if dist_to_max <= geometry.thumb_radius {
                        Some(DragTarget::Max)
                    } else {
                        None
                    }
                })
            } else {
                None
            };

            // Draw the slider
            self.draw(
                ui,
                &response,
                &geometry,
                track_height,
                &drag_state,
                hovered_thumb,
                &theme,
            );
        });

        // Save state to memory if ID is set
        if let Some(id) = self.id {
            let min_state_id = id.with("min_value");
            let max_state_id = id.with("max_value");
            ui.ctx().data_mut(|d| {
                d.insert_temp(min_state_id, *min_value);
                d.insert_temp(max_state_id, *max_value);
            });
        }

        let response = ui.interact(ui.min_rect(), slider_id.with("response"), Sense::hover());

        RangeSliderResponse {
            response,
            min_value: *min_value,
            max_value: *max_value,
            changed,
        }
    }

    fn clamp_values(&self, min_value: &mut f32, max_value: &mut f32) {
        *min_value = min_value.clamp(self.range_min, self.range_max);
        *max_value = max_value.clamp(self.range_min, self.range_max);
        if *min_value > *max_value {
            std::mem::swap(min_value, max_value);
        }
    }

    fn draw_label(&self, ui: &mut Ui, min_value: f32, max_value: f32) {
        if self.label.is_none() && !self.show_value {
            return;
        }

        ui.horizontal(|ui| {
            ui.spacing_mut().item_spacing.x = 8.0;

            if let Some(label) = &self.label {
                ui.label(label);
            }

            if self.show_value {
                ui.allocate_space(ui.available_size());
                ui.label(format!(
                    "{} - {}",
                    self.format_value(min_value),
                    self.format_value(max_value)
                ));
            }
        });
    }

    fn format_value(&self, value: f32) -> String {
        self.suffix.as_ref().map_or_else(
            || format!("{value:.1}"),
            |suffix| format!("{value:.1}{suffix}"),
        )
    }

    fn apply_step(&self, value: f32) -> f32 {
        self.step
            .map_or(value, |step| (value / step).round() * step)
    }

    fn value_to_x(&self, value: f32, track_rect: &Rect) -> f32 {
        let t = (value - self.range_min) / (self.range_max - self.range_min);
        track_rect.left() + t * track_rect.width()
    }

    fn x_to_value(&self, x: f32, track_rect: &Rect) -> f32 {
        let t = ((x - track_rect.left()) / track_rect.width()).clamp(0.0, 1.0);
        self.range_min + t * (self.range_max - self.range_min)
    }

    fn determine_target(
        &self,
        pos_x: f32,
        min_x: f32,
        max_x: f32,
        handle_radius: f32,
    ) -> DragTarget {
        let dist_to_min = (pos_x - min_x).abs();
        let dist_to_max = (pos_x - max_x).abs();
        let in_range = pos_x > min_x + handle_radius && pos_x < max_x - handle_radius;

        if self.allow_range_drag
            && in_range
            && dist_to_min > handle_radius
            && dist_to_max > handle_radius
        {
            DragTarget::Both
        } else if dist_to_min <= dist_to_max {
            DragTarget::Min
        } else {
            DragTarget::Max
        }
    }

    fn handle_interaction(
        &self,
        ui: &mut Ui,
        response: &Response,
        drag_state_id: egui::Id,
        geometry: &SliderGeometry,
        min_value: &mut f32,
        max_value: &mut f32,
        changed: &mut bool,
    ) -> RangeSliderDragState {
        let mut drag_state: RangeSliderDragState = ui
            .ctx()
            .data_mut(|d| d.get_temp(drag_state_id).unwrap_or_default());

        // Handle drag start
        if response.drag_started() {
            if let Some(pos) = response.interact_pointer_pos() {
                drag_state.target = self.determine_target(
                    pos.x,
                    geometry.min_x,
                    geometry.max_x,
                    geometry.thumb_radius,
                );
                drag_state.drag_start_min = *min_value;
                drag_state.drag_start_max = *max_value;
                drag_state.drag_start_x = pos.x;
            }
        }

        // Handle dragging
        if response.dragged() {
            if let Some(pos) = response.interact_pointer_pos() {
                // Fallback if target wasn't set
                if drag_state.target == DragTarget::None {
                    drag_state.target = self.determine_target(
                        pos.x,
                        geometry.min_x,
                        geometry.max_x,
                        geometry.thumb_radius,
                    );
                    drag_state.drag_start_min = *min_value;
                    drag_state.drag_start_max = *max_value;
                    drag_state.drag_start_x = pos.x;
                }

                self.update_values_from_drag(
                    pos.x,
                    geometry.track_rect,
                    &drag_state,
                    min_value,
                    max_value,
                    changed,
                );
            }
        }

        // Handle drag end
        if response.drag_stopped() {
            drag_state.target = DragTarget::None;
        }

        // Save state
        ui.ctx()
            .data_mut(|d| d.insert_temp(drag_state_id, drag_state.clone()));

        drag_state
    }

    fn update_values_from_drag(
        &self,
        pos_x: f32,
        track_rect: &Rect,
        drag_state: &RangeSliderDragState,
        min_value: &mut f32,
        max_value: &mut f32,
        changed: &mut bool,
    ) {
        let raw_value = self.x_to_value(pos_x, track_rect);

        match drag_state.target {
            DragTarget::Min => {
                let new_value = self
                    .apply_step(raw_value)
                    .clamp(self.range_min, *max_value - self.min_gap);

                if (new_value - *min_value).abs() > 0.001 {
                    *min_value = new_value;
                    *changed = true;
                }
            }
            DragTarget::Max => {
                let new_value = self
                    .apply_step(raw_value)
                    .clamp(*min_value + self.min_gap, self.range_max);

                if (new_value - *max_value).abs() > 0.001 {
                    *max_value = new_value;
                    *changed = true;
                }
            }
            DragTarget::Both => {
                let delta_x = pos_x - drag_state.drag_start_x;
                let delta_value = delta_x / track_rect.width() * (self.range_max - self.range_min);

                let range_size = drag_state.drag_start_max - drag_state.drag_start_min;
                let mut new_min = drag_state.drag_start_min + delta_value;
                #[allow(clippy::useless_let_if_seq)]
                let mut new_max = drag_state.drag_start_max + delta_value;

                // Clamp to bounds while preserving range size
                if new_min < self.range_min {
                    new_min = self.range_min;
                    new_max = self.range_min + range_size;
                }
                if new_max > self.range_max {
                    new_max = self.range_max;
                    new_min = self.range_max - range_size;
                }

                new_min = self.apply_step(new_min);
                new_max = self.apply_step(new_max);

                if (new_min - *min_value).abs() > 0.001 || (new_max - *max_value).abs() > 0.001 {
                    *min_value = new_min;
                    *max_value = new_max;
                    *changed = true;
                }
            }
            DragTarget::None => {}
        }
    }

    fn draw(
        &self,
        ui: &Ui,
        response: &Response,
        geometry: &SliderGeometry,
        track_height: f32,
        drag_state: &RangeSliderDragState,
        hovered_thumb: Option<DragTarget>,
        theme: &crate::Theme,
    ) {
        let painter = ui.painter();

        // Background track
        painter.rect_filled(*geometry.track_rect, track_height / 2.0, theme.muted());

        // Filled region between thumbs
        let fill_rect = Rect::from_min_max(
            pos2(geometry.min_x, geometry.track_rect.top()),
            pos2(geometry.max_x, geometry.track_rect.bottom()),
        );
        painter.rect_filled(fill_rect, track_height / 2.0, theme.primary());

        // Draw thumbs
        for (x, is_min) in [(geometry.min_x, true), (geometry.max_x, false)] {
            let center = pos2(x, geometry.track_rect.center().y);
            let this_target = if is_min {
                DragTarget::Min
            } else {
                DragTarget::Max
            };

            // Determine if this thumb is active (being dragged)
            let is_active = response.dragged()
                && (drag_state.target == this_target || drag_state.target == DragTarget::Both);

            // Determine if this specific thumb is hovered
            let is_hovered = hovered_thumb == Some(this_target);

            // Hover ring effect (like shadcn ring-4 with ring-ring/50)
            if is_active || is_hovered {
                let ring_color = theme.ring().gamma_multiply(0.5);
                painter.circle_filled(center, geometry.thumb_radius + 4.0, ring_color);
            }

            // Shadow
            painter.circle_filled(
                center + vec2(0.0, 1.0),
                geometry.thumb_radius,
                Color32::from_black_alpha(40),
            );

            // Handle fill
            let handle_color = if is_active {
                theme.primary()
            } else {
                theme.foreground()
            };

            painter.circle_filled(center, geometry.thumb_radius, handle_color);
            painter.circle_stroke(
                center,
                geometry.thumb_radius,
                Stroke::new(1.0, theme.primary()),
            );
        }
    }
}

/// Response from a range slider
pub struct RangeSliderResponse {
    /// The UI response
    pub response: Response,
    /// Current minimum value
    pub min_value: f32,
    /// Current maximum value
    pub max_value: f32,
    /// Whether either value changed this frame
    pub changed: bool,
}