concinnity-dev 0.19.119

//! The editor's Template detail panel: a floating preview of one engine-owned
//! world template, spawned by clicking a row in the Templates list (`templates.rs`).
//! It mirrors the edit-form panel's shape -- a draggable title bar ("Template
//! <name>") with an "X" close button, a header row carrying the template's
//! description on the left and an "Apply" button pinned to the top-right, then a
//! scrollable list of the template's assets underneath. Applying layers the
//! template's assets into the world (the hook owns that, idempotently).
//!
//! The asset list is the shared grouped list (`asset_list.rs`): assets grouped
//! under a type sub-header, names indented and alphabetized -- identical to the
//! Assets browse panel's list. Like the rest of the editor HUD the panel is plain
//! `Sprite` / `TextLabel` components at reserved ids driven each frame by the hook;
//! it is read-only (no per-row interaction), so it needs no typed fields.

use concinnity_core::components::TextAlign;
use concinnity_core::ecs::World;

use super::asset_list::{self, ListRow, MAX_ROWS, ROW_H};
use super::registry::PanelKey;
use crate::editor::hud_ids::{hud_ids, panel_base};
use crate::editor::theme;
use crate::editor::widget::{self, place_rounded, point_in};

// Geometry, in window pixels. Every rect derives from the panel origin `o` (the
// title bar's top-left), so dragging the title bar moves the whole panel.
// The default (and minimum) width; the user can widen the panel past this.
pub(crate) const TPL_W: f32 = 420.0;
// The injected row pool: the default shows up to `MAX_ROWS`, resizing taller
// reveals more up to this.
const POOL_MAX: usize = 28;

// Background + chrome, the row backgrounds, then the scrollbar above them.
hud_ids! {
    base: panel_base(PanelKey::TemplateDetail);
    sprites: [
        pub(crate) PANEL_BG,
        pub(crate) CLOSE_BG,
        pub(crate) APPLY_BG,
        pub(crate) row_bg[POOL_MAX],
        pub(crate) LIST_TRACK,
        pub(crate) LIST_THUMB,
    ];
    labels: [
        pub(crate) TITLE_LABEL,
        pub(crate) CLOSE_LABEL,
        pub(crate) APPLY_LABEL,
        pub(crate) DESC_LABEL,
        pub(crate) row_label[POOL_MAX],
    ];
}

const PAD: f32 = 10.0;
const GAP: f32 = 8.0;
// The header row: the description and the Apply button.
const HEADER_H: f32 = 34.0;
const BTN_W: f32 = 84.0;
// The description draws a touch smaller than the body text so a full one-line
// summary clears the Apply button.
const DESC_SCALE: f32 = 0.8;

const BTN_TINT: [f32; 4] = [0.22, 0.40, 0.56, 1.0];
const BTN_TINT_HOVER: [f32; 4] = [0.28, 0.48, 0.66, 1.0];
const DESC_COLOR: [f32; 3] = [0.72, 0.76, 0.84];
const LABEL_WHITE: [f32; 3] = [1.0, 1.0, 1.0];

// A resolved Template-panel click.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum TemplateAction {
    // The Apply button: layer the template's assets into the world.
    Apply,
    // The title-bar "X": close the panel.
    Close,
    // A click inside the panel that hits no control (swallowed).
    Consume,
}

// The per-frame data the hook hands to `place` / `hit_test`.
pub(crate) struct TemplateView<'a> {
    // The title-bar heading, already prefixed ("Template Minimal 3D World").
    pub title: &'a str,
    // The template's one-line description.
    pub description: &'a str,
    // The template's assets as the shared grouped rows (read-only here).
    pub rows: &'a [ListRow],
    // First visible row of the scroll window.
    pub scroll: usize,
    pub mouse: [f32; 2],
}

// The default (minimum) on-screen list rows: the row count capped at the window.
fn visible_rows(n_rows: usize) -> usize {
    n_rows.clamp(1, MAX_ROWS)
}

// The chrome height around the row band (title bar + header row + pads).
const CHROME_H: f32 = widget::TITLE_H + PAD + HEADER_H + PAD + PAD;

fn panel_height(rows: usize) -> f32 {
    CHROME_H + rows as f32 * ROW_H
}

// The number of row slots that fit panel height `h`, capped at the pool.
pub(crate) fn rows_for_height(h: f32) -> usize {
    (((h - CHROME_H) / ROW_H).floor() as usize).clamp(1, POOL_MAX)
}

// The tallest the panel resizes to for a template of `n_rows`: its rows shown in
// full, capped at the injected pool. Width is unbounded (capped by the screen).
pub(crate) fn max_size(n_rows: usize) -> [f32; 2] {
    [f32::INFINITY, panel_height(n_rows.clamp(1, POOL_MAX))]
}

// Where the panel sits until the user drags it: centered, just below the top bar.
pub(crate) fn default_origin(vw: f32) -> [f32; 2] {
    [(vw - TPL_W) * 0.5, crate::editor::hud::body_top() + 30.0]
}

// The panel footprint for a template of `n_rows` grouped rows (the list area
// tracks the row count, capped at the window). Origin-independent; the hook's
// drag clamp uses this.
pub(crate) fn size(n_rows: usize) -> [f32; 2] {
    [TPL_W, panel_height(visible_rows(n_rows))]
}

// The "X" close button, flush in the title bar's top-right corner. The hook
// checks this before the title-bar drag, so clicking the X closes the panel.
pub(crate) fn close_rect(o: [f32; 2], w: f32) -> [f32; 4] {
    widget::close_rect(widget::title_rect(o, w))
}

// The header row under the title bar: description on the left, Apply on the right.
pub(crate) fn apply_rect(o: [f32; 2], w: f32) -> [f32; 4] {
    [
        o[0] + w - PAD - BTN_W,
        widget::header_y(o, PAD),
        BTN_W,
        HEADER_H,
    ]
}
// The description area, filling the header row left of the Apply button.
fn desc_rect(o: [f32; 2], w: f32) -> [f32; 4] {
    [
        o[0] + PAD,
        widget::header_y(o, PAD),
        w - 2.0 * PAD - (BTN_W + GAP),
        HEADER_H,
    ]
}

// Where the scrollable asset list begins (below the header row).
fn body_top(o: [f32; 2]) -> f32 {
    widget::header_y(o, PAD) + HEADER_H + PAD
}

// Full-width rect of visible list row `r` at the effective width `w`.
fn list_row_rect(o: [f32; 2], w: f32, r: usize) -> [f32; 4] {
    [o[0], body_top(o) + r as f32 * ROW_H, w, ROW_H]
}

// Whether the cursor is over the panel (for wheel-scrolling the asset list).
pub(crate) fn cursor_over(mx: f32, my: f32, o: [f32; 2], s: [f32; 2]) -> bool {
    point_in(mx, my, widget::outer_rect(o, s))
}

// Resolve a click against the open panel at origin `o`, size `s`. `None` means
// the click missed the panel. Title-bar presses never reach this: the hook
// intercepts them first to start a drag (and to catch the "X").
pub(crate) fn hit_test(mx: f32, my: f32, o: [f32; 2], s: [f32; 2]) -> Option<TemplateAction> {
    let w = s[0];
    if !point_in(mx, my, widget::outer_rect(o, s)) {
        return None;
    }
    if point_in(mx, my, close_rect(o, w)) {
        return Some(TemplateAction::Close);
    }
    if point_in(mx, my, apply_rect(o, w)) {
        return Some(TemplateAction::Apply);
    }
    // The asset list is read-only; every other click inside the panel is
    // swallowed so it cannot fall through to the world.
    Some(TemplateAction::Consume)
}

// Position + show the panel's elements for this frame at origin `o`, effective
// size `s`.
pub(crate) fn place(world: &mut World, view: &TemplateView, o: [f32; 2], s: [f32; 2]) {
    // Blank everything, then re-show what this frame needs.
    ids().hide(world);

    let w = s[0];
    let window = rows_for_height(s[1]);
    widget::place_panel(world, PANEL_BG, widget::outer_rect(o, s));
    widget::place_heading(world, TITLE_LABEL, widget::title_rect(o, w), view.title);
    let close_hover = point_in(view.mouse[0], view.mouse[1], close_rect(o, w));
    widget::place_close(
        world,
        CLOSE_BG,
        CLOSE_LABEL,
        widget::title_rect(o, w),
        close_hover,
    );

    // The header row: the description (left) and the pinned Apply button (right).
    let desc = desc_rect(o, w);
    if let Some(l) = widget::label_mut(world, DESC_LABEL) {
        l.x = desc[0];
        l.y = desc[1] + HEADER_H * 0.5 - 10.0 * DESC_SCALE;
        l.align = TextAlign::Left;
        l.color = DESC_COLOR;
        l.scale = DESC_SCALE;
        l.visible = true;
        // Bounded in place rather than through `place_message`: this label
        // draws at its own scale, which the line budget there does not know.
        l.wrap_width = desc[2].max(0.0);
        l.max_lines = 1;
        l.content = view.description.to_string();
    }
    let apply_btn = apply_rect(o, w);
    let hover = point_in(view.mouse[0], view.mouse[1], apply_btn);
    place_rounded(
        world,
        APPLY_BG,
        apply_btn,
        if hover { BTN_TINT_HOVER } else { BTN_TINT },
        theme::CONTROL_RADIUS,
        true,
    );
    if let Some(l) = widget::label_mut(world, APPLY_LABEL) {
        l.x = apply_btn[0] + apply_btn[2] * 0.5;
        l.y = apply_btn[1] + apply_btn[3] * 0.5 - theme::TEXT_HALF;
        l.align = TextAlign::Center;
        l.color = LABEL_WHITE;
        l.visible = true;
        l.content = "Apply".to_string();
    }

    // The template's assets: the shared grouped list, a scrolling window over the
    // row pool, plus a scrollbar when it overflows.
    let total = view.rows.len();
    let scroll = view.scroll.min(total.saturating_sub(1));
    for r in 0..window {
        let idx = scroll + r;
        if idx >= total {
            break;
        }
        asset_list::place_row(
            world,
            row_bg(r),
            row_label(r),
            &view.rows[idx],
            list_row_rect(o, w, r),
            asset_list::ROW_TINT,
        );
    }
    asset_list::layout_scrollbar(
        world,
        (LIST_TRACK, LIST_THUMB),
        total,
        scroll,
        window,
        o[0] + w,
        body_top(o),
    );
}

#[cfg(test)]
mod tests {
    use super::*;
    use concinnity_core::components::{Sprite, TextLabel};
    use concinnity_core::ecs::asset_id::AssetId;

    fn test_origin() -> [f32; 2] {
        default_origin(1280.0)
    }

    fn rows() -> Vec<ListRow> {
        vec![
            ListRow {
                is_header: true,
                text: "Camera3D".into(),
                entry: None,
            },
            ListRow {
                is_header: false,
                text: "world_camera".into(),
                entry: Some(0),
            },
            ListRow {
                is_header: true,
                text: "Room".into(),
                entry: None,
            },
            ListRow {
                is_header: false,
                text: "world_room".into(),
                entry: Some(1),
            },
        ]
    }

    fn view(rows: &[ListRow]) -> TemplateView<'_> {
        TemplateView {
            title: "Template Minimal 3D World",
            description: "A lit room with a camera and sky.",
            rows,
            scroll: 0,
            mouse: [0.0, 0.0],
        }
    }

    fn injected_world() -> World {
        ids().test_world()
    }

    fn sprite(world: &World, id: AssetId) -> Sprite {
        world
            .get_by_id::<Sprite>(id)
            .cloned()
            .expect("sprite present")
    }
    fn label(world: &World, id: AssetId) -> TextLabel {
        world
            .get_by_id::<TextLabel>(id)
            .cloned()
            .expect("label present")
    }

    // The header pins the description left of the Apply button, both under the
    // title bar; the X sits in the title bar's right corner.
    #[test]
    fn header_pins_description_and_apply_under_the_title_bar() {
        let o = test_origin();
        let title = widget::title_rect(o, TPL_W);
        assert_eq!(title, [o[0], o[1], TPL_W, widget::TITLE_H]);
        let close = close_rect(o, TPL_W);
        assert_eq!(close[1], o[1], "the X sits in the title bar");
        assert_eq!(
            close[0] + close[2],
            o[0] + TPL_W,
            "flush to the panel right"
        );
        let desc = desc_rect(o, TPL_W);
        let apply_btn = apply_rect(o, TPL_W);
        assert_eq!(desc[1], o[1] + widget::TITLE_H + PAD, "under the title bar");
        assert_eq!(
            desc[1], apply_btn[1],
            "description shares Apply's header row"
        );
        assert!(
            desc[0] + desc[2] <= apply_btn[0],
            "description ends left of Apply"
        );
        assert_eq!(
            apply_btn[0] + apply_btn[2],
            o[0] + TPL_W - PAD,
            "Apply flush to the panel's right pad"
        );
        // The whole panel follows its origin.
        let moved = widget::outer_rect([40.0, 60.0], size(0));
        assert_eq!((moved[0], moved[1]), (40.0, 60.0));
        assert_eq!(
            size(0),
            [moved[2], moved[3]],
            "drag-clamp footprint matches"
        );
    }

    // The panel height tracks the row count up to the window cap.
    #[test]
    fn panel_height_tracks_rows_and_caps_at_the_window() {
        let short = size(3);
        let tall = size(MAX_ROWS + 10);
        assert!(short[1] < tall[1]);
        assert_eq!(
            tall[1],
            size(MAX_ROWS)[1],
            "a list past the window scrolls instead of growing"
        );
    }

    #[test]
    fn apply_and_close_hit_test() {
        let s = size(rows().len());
        let o = test_origin();
        let a = apply_rect(o, TPL_W);
        let x = close_rect(o, TPL_W);
        assert_eq!(
            hit_test(a[0] + 5.0, a[1] + 5.0, o, s),
            Some(TemplateAction::Apply)
        );
        assert_eq!(
            hit_test(x[0] + 5.0, x[1] + 5.0, o, s),
            Some(TemplateAction::Close)
        );
        // A title-bar click off the X is consumed (the hook grabs drags first).
        let t = widget::title_rect(o, TPL_W);
        assert_eq!(
            hit_test(t[0] + 5.0, t[1] + 5.0, o, s),
            Some(TemplateAction::Consume)
        );
        // A body click is consumed; a miss falls through.
        let row = list_row_rect(o, TPL_W, 1);
        assert_eq!(
            hit_test(row[0] + 5.0, row[1] + 5.0, o, s),
            Some(TemplateAction::Consume)
        );
        assert_eq!(hit_test(5.0, 5.0, o, s), None);
    }

    // Placing lays out the title, description, Apply caption, and the grouped
    // asset rows (headers + indented names).
    #[test]
    fn place_renders_title_description_and_rows() {
        let rs = rows();
        let mut world = injected_world();
        let o = test_origin();
        place(&mut world, &view(&rs), o, size(rs.len()));
        assert_eq!(
            label(&world, TITLE_LABEL).content,
            "Template Minimal 3D World"
        );
        let desc = label(&world, DESC_LABEL);
        assert!(desc.visible && desc.content == "A lit room with a camera and sky.");
        assert!(desc.scale < 1.0, "description draws a touch smaller");
        assert_eq!(label(&world, APPLY_LABEL).content, "Apply");
        // Row 0 is the "Camera3D" header; row 1 is the indented "world_camera".
        assert_eq!(label(&world, row_label(0)).content, "Camera3D");
        let name = label(&world, row_label(1));
        assert_eq!(name.content, "world_camera");
        assert!(
            name.x > label(&world, row_label(0)).x,
            "the name is indented under its type header"
        );
        assert!(sprite(&world, PANEL_BG).visible);
    }

    // A short list draws no scrollbar; a long one does.
    #[test]
    fn scrollbar_only_when_the_list_overflows() {
        let short = rows();
        let mut world = injected_world();
        place(&mut world, &view(&short), test_origin(), size(short.len()));
        assert!(!sprite(&world, LIST_THUMB).visible, "short list, no bar");

        let long: Vec<ListRow> = (0..MAX_ROWS + 6)
            .map(|i| ListRow {
                is_header: false,
                text: format!("asset_{i}"),
                entry: Some(i),
            })
            .collect();
        place(&mut world, &view(&long), test_origin(), size(long.len()));
        assert!(sprite(&world, LIST_THUMB).visible, "overflow shows the bar");
    }

    // A template with more rows than the default window can be resized taller to
    // reveal them (up to the pool); a small template's height is locked.
    #[test]
    fn taller_size_reveals_more_rows_up_to_the_pool() {
        let n = MAX_ROWS + 8;
        assert_eq!(
            rows_for_height(size(n)[1]),
            MAX_ROWS,
            "default shows the window"
        );
        assert_eq!(
            rows_for_height(max_size(n)[1]),
            n,
            "max reveals all the rows"
        );
        assert_eq!(rows_for_height(10_000.0), POOL_MAX, "capped at the pool");
        // A short template cannot grow taller (no more rows to show).
        assert_eq!(max_size(3)[1], size(3)[1]);
    }
}