pane_ui 0.1.0

//! UI item definitions.
//!
//! Each struct here is a fully-described, renderable widget. Items are created by
//! the builder from RON definitions and stored in [`Root`](crate::logic::Root) roots.
//! They carry no render state — all mutable frame state lives in the parallel
//! `ItemState` vec in `logic.rs`.
//!
//! ## Container children
//!
//! All container children store `Vec<UiItem>` directly. There are no separate
//! `ScrollItem` or `BarItem` enums. `UiItem::Spacer` is only meaningful inside a `Bar`.

#![allow(dead_code)]
use crate::loader::{
    DropdownAction, PressAction, RadioAction, SliderAction, TextBoxAction, ToggleAction,
};
use crate::styles::StyleId;

// ── Button ────────────────────────────────────────────────────────────────────

/// A clickable button. All interactive elements — menu items, icon buttons, close
/// buttons — are represented as `Button`. Position and size are always explicit;
/// no automatic layout is applied at this level.
pub struct Button {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    /// Text rendered centred inside the button. Empty string for icon-only buttons.
    pub text: String,
    pub style: StyleId,
    /// Tooltip shown on hover. `None` for no tooltip.
    pub tooltip: Option<String>,
    /// What happens when the button is clicked.
    pub action: PressAction,
    /// When `true`, the button is drawn with its `disabled` style and ignores input.
    pub disabled: bool,
    /// If `true`, this button receives focus by default when the root is entered via gamepad.
    pub nav_default: bool,
}

// ── ScrollList ────────────────────────────────────────────────────────────────

/// A scrolling list of items, clipped to its bounds.
///
/// Items are laid out top-to-bottom (or left-to-right when `horizontal`) with `gap` spacing.
/// The list clips its children and handles scroll input (mouse wheel, touch drag) internally.
pub struct ScrollList {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    /// Inner padding applied before the first and after the last item.
    pub pad_left: f32,
    pub pad_right: f32,
    pub pad_top: f32,
    pub pad_bottom: f32,
    /// Gap between items.
    pub gap: f32,
    /// Optional background shape drawn behind the list contents.
    pub style: Option<StyleId>,
    /// If `true`, items are laid out left-to-right; height is imposed, width comes from each item.
    /// If `false` (default), items are laid out top-to-bottom; width is imposed, height from each item.
    pub horizontal: bool,
    /// If `true`, spans the full screen along the scroll axis and centers on that axis.
    pub full_span: bool,
    /// Children. In vertical mode: width imposed, height from item. In horizontal mode: height imposed, width from item.
    pub items: Vec<UiItem>,
}

// ── Bar ───────────────────────────────────────────────────────────────────────

/// Which edge of the screen a [`Bar`] is anchored to, or `Free` for manual positioning.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BarEdge {
    Top,
    Bottom,
    Left,
    Right,
    /// No edge anchor — position is set via `x`, `y`, `width`, `height` on [`Bar`].
    Free,
}

/// An edge-anchored panel that draws a background and defines layout geometry.
/// Children are first-class root items positioned by the builder at load time;
/// the Bar itself owns only the geometry needed to draw its background.
pub struct Bar {
    pub id: String,
    pub edge: BarEdge,
    /// Cross-axis size (height for top/bottom bars, width for left/right bars).
    pub thickness: f32,
    /// Padding between the bar edge and its first/last item.
    pub pad: f32,
    /// Gap between consecutive items.
    pub gap: f32,
    /// Optional background shape drawn behind bar contents.
    pub style: Option<StyleId>,
    /// Extra inset from the top of the screen (e.g. for a system status bar).
    pub top_inset: f32,
    /// Extra inset from the bottom of the screen (e.g. for a home indicator).
    pub bottom_inset: f32,
    /// Children laid out along the bar axis. Positions are computed at tick time.
    pub items: Vec<UiItem>,
    /// When true, items use their RON x/y as screen-space coordinates (same as manual `ScrollPane`).
    pub manual: bool,
    /// X position for `BarEdge::Free` bars (screen-space, origin at center).
    pub x: f32,
    /// Y position for `BarEdge::Free` bars.
    pub y: f32,
    /// Explicit width for `BarEdge::Free` bars (0.0 = use thickness).
    pub width: f32,
    /// Explicit height for `BarEdge::Free` bars (0.0 = use thickness).
    pub height: f32,
}

// ── Popout ────────────────────────────────────────────────────────────────────

/// A panel that spring-animates between a closed and open position.
///
/// The panel is toggled by a child [`Button`] whose id matches `toggle_id`. When
/// closed, the panel is at `(closed_x, closed_y)`; when open, at `(open_x, open_y)`.
/// All children are positioned relative to the panel's current animated origin.
///
/// Popouts do not clip their children — add a [`ScrollList`] child if clipping is needed.
pub struct Popout {
    pub id: String,
    /// Position when closed (centred coordinate space).
    pub closed_x: f32,
    pub closed_y: f32,
    /// Position when open (centred coordinate space).
    pub open_x: f32,
    pub open_y: f32,
    pub width: f32,
    pub height: f32,
    /// Id of the child button that toggles this popout open and closed.
    pub toggle_id: String,
    /// Optional background shape drawn behind the panel.
    pub style: Option<StyleId>,
    /// Which screen edge the popout slides in from (used to set animation direction).
    pub edge: Option<crate::items::PopoutEdge>,
    /// If `true`, a drop shadow is rendered behind the panel.
    pub shadow: bool,
    /// If `true`, children are laid out left-to-right (like a horizontal bar) with `gap` spacing.
    /// If `false` (default), children are positioned absolutely relative to the panel origin.
    pub horizontal: bool,
    /// Gap between children when `horizontal` is true.
    pub gap: f32,
    /// If `true`, stretches to fill the full screen along the cross axis of the panel's `edge`.
    /// Top/Bottom/None edge: spans full width. Left/Right edge: spans full height.
    pub full_span: bool,
    /// If `true`, pressing the controller home/guide button toggles this popout open/closed.
    pub home_toggles: bool,
    pub items: Vec<UiItem>,
}

/// The screen edge a [`Popout`] slides in from.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PopoutEdge {
    Left,
    Right,
    Top,
    Bottom,
}

// ── Toggle ────────────────────────────────────────────────────────────────────

/// A button that holds an on/off state.
///
/// Drawn with `style_off` when unchecked and `style_on` when checked. The action
/// fires with the new `bool` value on every state flip.
pub struct Toggle {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub text: String,
    pub tooltip: Option<String>,
    /// Initial checked value used when the toggle is first constructed.
    /// The live state lives on `ButtonState::checked`.
    pub default_checked: bool,
    pub disabled: bool,
    /// Shape used when the toggle is off (unchecked).
    pub style_off: StyleId,
    /// Shape used when the toggle is on (checked).
    pub style_on: StyleId,
    pub action: ToggleAction,
}

// ── FreeLabel ─────────────────────────────────────────────────────────────────

/// A free-standing text label positioned in the root's coordinate space.
///
/// Not interactive. Left-aligned at `(x, y)`.
pub struct FreeLabel {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub text: String,
    /// Font size in logical pixels.
    pub size: f32,
    pub color: crate::draw::Color,
    /// When used inside a Bar, how much main-axis space this label occupies.
    /// Has no effect outside of bars.
    pub width: f32,
}

// ── Divider ───────────────────────────────────────────────────────────────────

/// A solid filled rectangle used as a visual separator or decorative rule.
///
/// Visual properties (color, opacity, shader) come from the style's `idle` state.
/// Not interactive.
pub struct Divider {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub style: StyleId,
    /// If `true`, spans the full screen width each frame (x and width are overridden).
    pub full_span: bool,
}

// ── Image ─────────────────────────────────────────────────────────────────────

/// A non-interactive image or GIF at an explicit position.
///
/// The texture is loaded at build time. For animated GIFs the texture registry
/// advances frames automatically each render tick.
pub struct Image {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub texture: crate::textures::TextureId,
    pub shader: crate::draw::ShaderId,
}

// ── ProgressBar ───────────────────────────────────────────────────────────────

/// A read-only progress bar driven entirely by the application.
///
/// `value` is in `0.0..=1.0`. The track style covers the full bar width;
/// the fill style covers the filled portion. Update via
/// [`PaneOverlay::set_progress`](crate::api::PaneOverlay::set_progress).
pub struct ProgressBar {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    /// Current fill fraction in `0.0..=1.0`.
    pub value: f32,
    /// Shape for the unfilled background track.
    pub style_track: StyleId,
    /// Shape for the filled foreground portion.
    pub style_fill: StyleId,
}

// ── Actor ─────────────────────────────────────────────────────────────────────

/// A decorative, non-interactive element that animates in response to mouse events.
///
/// Actors have an origin position they rest at when idle, and a list of
/// `(trigger, action)` behaviour pairs that fire based on cursor interaction.
/// Multiple behaviours can be defined — the highest-priority active one wins.
///
/// ## Visuals
///
/// Visual priority (highest to lowest):
/// 1. A [`SwapGif`](Action::SwapGif) override from an active trigger behaviour
/// 2. The actor's base `gif`, which loops automatically at all times
/// 3. The actor's `style`, drawn as a static component
///
/// ## Z-order
///
/// - `z_front: false` — drawn in document order, interleaved with other items
/// - `z_front: true` — drawn after all other items, always on top
///
/// Actors never receive focus, block input, or emit actions.
pub struct Actor {
    pub id: String,
    /// Resting X position in centred coordinate space. The actor lerps back here when idle.
    pub origin_x: f32,
    /// Resting Y position in centred coordinate space.
    pub origin_y: f32,
    pub width: f32,
    pub height: f32,
    /// Fallback visual shape, used when no gif is set and no `SwapGif` override is active.
    pub style: Option<StyleId>,
    /// Base gif texture. Loops automatically. Shown when no `SwapGif` override is active.
    pub gif: Option<crate::textures::TextureId>,
    /// Shader used to render the base gif.
    pub gif_shader: crate::draw::ShaderId,
    /// If `true`, drawn after all other items (on top of everything).
    pub z_front: bool,
    /// If `true`, the actor lerps back to its origin when the active trigger ends.
    pub return_on_end: bool,
    pub behaviours: Vec<Behaviour>,
    /// Size of the internal cursor trail buffer. Set automatically by the builder
    /// from the largest `trail` value across all `FollowCursor` behaviours.
    pub trail_capacity: f32,
}

/// A single (trigger, action) pair on an [`Actor`].
pub struct Behaviour {
    pub trigger: Trigger,
    pub action: Action,
}

/// The condition that activates an actor [`Action`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Trigger {
    /// Always active. Used for persistent baseline behaviours (e.g. always follow cursor).
    Always,
    /// Active while the cursor is inside the actor's hitbox.
    OnHoverSelf,
    /// Active while the primary mouse button is held down over the actor's hitbox.
    OnPressSelf,
    /// Fires once on left-button release over the actor's hitbox. Latches until superseded.
    OnClickSelf,
    /// Fires once on any left-button release anywhere on screen. Latches until superseded.
    OnClickAnywhere,
}

/// What an actor does when its trigger is active.
#[derive(Debug, Clone)]
pub enum Action {
    /// Chase the cursor, optionally lagging behind by `trail` seconds.
    ///
    /// `speed` controls the lerp rate (higher = snappier). `trail: 0.0` means
    /// the actor aims directly at the current cursor position.
    FollowCursor { speed: f32, trail: f32 },

    /// Lerp toward a fixed point at `speed` units per second.
    ///
    /// `x` and `y` are in the centred coordinate space, added to the actor's origin.
    /// If `return_on_end` is set on the actor, it lerps back to origin when the trigger ends.
    MoveTo { x: f32, y: f32, speed: f32 },

    /// Temporarily display a different gif while the trigger is active.
    ///
    /// Reverts to the actor's base gif (or style) automatically when the trigger ends.
    /// The replacement gif loops continuously while active.
    SwapGif {
        texture: crate::textures::TextureId,
        shader: crate::draw::ShaderId,
    },
}

/// A transient notification that fades out after `duration` seconds.
///
/// Added to the active root via `push_toast`. Ticked like any other item;
/// expired toasts are removed back-to-front after each tick pass.
pub struct Toast {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub message: String,
    pub duration: f32,
    /// Shape used to draw the toast background and text.
    pub shape: Option<StyleId>,
}

// ── Tab ───────────────────────────────────────────────────────────────────────

/// One page inside a [`Tab`] container.
pub struct TabPage {
    /// Label shown on the selector button for this page (informational; not rendered by Tab itself).
    pub label: String,
    /// Children laid out vertically in the scrollable content area.
    pub items: Vec<UiItem>,
}

/// A content-switcher container. Renders the active page's children in a scrollable,
/// clipped area. Page switching is driven externally by buttons with `SwitchTabPage` actions.
pub struct Tab {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub pad_left: f32,
    pub pad_right: f32,
    pub pad_top: f32,
    pub pad_bottom: f32,
    pub gap: f32,
    pub style: Option<StyleId>,
    pub pages: Vec<TabPage>,
    pub full_span: bool,
}

// ── UiItem ────────────────────────────────────────────────────────────────────

/// Any item that can appear in a UI root or container.
///
/// `Spacer` is only meaningful inside a `Bar` — it expands to fill remaining main-axis space.
pub enum UiItem {
    Slider(Slider),
    Button(Button),
    ScrollList(ScrollList),
    Bar(Bar),
    Popout(Popout),
    Toggle(Toggle),
    TextBox(TextBox),
    Label(FreeLabel),
    Divider(Divider),
    Image(Image),
    ProgressBar(ProgressBar),
    ScrollPane(ScrollPane),
    Dropdown(Dropdown),
    RadioGroup(RadioGroup),
    Actor(Actor),
    Toast(Toast),
    Tab(Tab),
    /// Fills remaining space along a Bar's main axis. No-op outside of Bar.
    Spacer,
}

impl UiItem {
    /// The id string of this item, or `""` for items that have none (Spacer, Divider, Label).
    pub fn id(&self) -> &str {
        match self {
            Self::Slider(x) => &x.id,
            Self::Button(x) => &x.id,
            Self::ScrollList(x) => &x.id,
            Self::Bar(x) => &x.id,
            Self::Popout(x) => &x.id,
            Self::Toggle(x) => &x.id,
            Self::TextBox(x) => &x.id,
            Self::ProgressBar(x) => &x.id,
            Self::ScrollPane(x) => &x.id,
            Self::Dropdown(x) => &x.id,
            Self::RadioGroup(x) => &x.id,
            Self::Actor(x) => &x.id,
            Self::Toast(x) => &x.id,
            Self::Tab(x) => &x.id,
            Self::Label(_) | Self::Divider(_) | Self::Image(_) | Self::Spacer => "",
        }
    }
}

// ── Slider ────────────────────────────────────────────────────────────────────

/// A horizontal drag slider with separate track and thumb styles.
///
/// The thumb is square (`height × height`) and slides along the track.
/// Value fires on every drag movement via the slider's action.
pub struct Slider {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub min: f32,
    pub max: f32,
    /// Initial slider value used when the slider is first constructed.
    /// The live state lives on `SliderState::value`.
    pub default_value: f32,
    /// Optional snap increment. `None` = continuous.
    pub step: Option<f32>,
    pub tooltip: Option<String>,
    /// Shape for the full-width background track.
    pub style_track: StyleId,
    /// Shape for the draggable thumb.
    pub style_thumb: StyleId,
    pub action: SliderAction,
}

// ── TextBox ───────────────────────────────────────────────────────────────────

/// A text input field. Supports both single-line and multi-line modes.
///
/// `on_change` fires on every keystroke with the full current string.
/// `on_submit` fires when the user presses Enter (or Ctrl+Enter in multiline mode).
/// The field uses `style_idle` when unfocused and `style_focus` when focused.
pub struct TextBox {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    /// Initial text content used when the textbox is first constructed.
    /// The live state lives on `TextBoxState::text`.
    pub default_text: String,
    /// Ghost text shown when the field is empty and unfocused.
    pub placeholder: String,
    /// Maximum character count. `None` = unlimited.
    pub max_len: Option<usize>,
    pub tooltip: Option<String>,
    pub style_idle: StyleId,
    pub style_focus: StyleId,
    pub on_change: TextBoxAction,
    pub on_submit: TextBoxAction,
    /// When `true`, the displayed text is replaced with bullet characters (•).
    pub password: bool,
    /// When `true`, Enter inserts a newline instead of submitting; Ctrl+Enter submits.
    pub multiline: bool,
    /// Override the font size used for text rendering and caret measurement.
    /// `None` = derive from widget height automatically.
    pub font_size: Option<f32>,
}

// ── ScrollPane ────────────────────────────────────────────────────────────────

/// A scrollable container that can hold any mix of [`UiItem`]s.
///
/// Children are laid out vertically (or horizontally when `horizontal`). The visible
/// area is clipped to the pane's bounds. Scroll input (wheel, touch drag) is
/// handled internally.
pub struct ScrollPane {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub pad_left: f32,
    pub pad_right: f32,
    pub pad_top: f32,
    pub pad_bottom: f32,
    /// Gap between children.
    pub gap: f32,
    /// Optional background shape.
    pub style: Option<StyleId>,
    /// If `true`, children are laid out left-to-right; height is imposed, width from each child.
    /// If `false` (default), children are laid out top-to-bottom; width is imposed, height from each child.
    pub horizontal: bool,
    /// If `true`, spans the full screen along the scroll axis and centers on that axis.
    pub full_span: bool,
    /// If `true`, skip auto-layout. Items are positioned relative to the pane's origin
    /// using their RON x/y values; only scroll offset is applied each frame.
    pub manual: bool,
    pub items: Vec<UiItem>,
}

// ── Dropdown ──────────────────────────────────────────────────────────────────

/// A dropdown header that owns its option buttons directly.
/// When open, option buttons are ticked with offset below the header.
/// Selection is handled internally — no backchannel needed.
pub struct Dropdown {
    pub id: String,
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    /// Initial selected option index. The live state lives on `DropdownState::selected`.
    pub default_selected: usize,
    /// Labels for each option — kept so the header can display the selected text.
    pub options: Vec<String>,
    /// Shape for the collapsed header button.
    pub style: StyleId,
    /// Optional background box drawn behind the open option list.
    pub style_list: Option<StyleId>,
    pub action: DropdownAction,
    /// Option buttons owned by this dropdown, ticked internally when open.
    pub items: Vec<Button>,
}

// ── RadioGroup ────────────────────────────────────────────────────────────────

/// A group of mutually exclusive option buttons, owned and ticked internally.
/// Each frame the container programs each button's style based on selection.
pub struct RadioGroup {
    pub id: String,
    /// Initial selected option index. The live state lives on `RadioGroupState::selected`.
    pub default_selected: usize,
    /// Labels — kept so dispatch can report the selected label in `UiMsg::Radio`.
    pub options: Vec<String>,
    /// Shape for unselected option buttons.
    pub style_idle: StyleId,
    /// Shape for the selected option button.
    pub style_selected: StyleId,
    pub action: RadioAction,
    /// Option buttons owned by this group, ticked internally each frame.
    pub items: Vec<Button>,
    /// X position of the group.
    pub x: f32,
    /// Y position of the group.
    pub y: f32,
}