concinnity-dev 0.19.119

//! EditorHook: the Assets browse panel and header combo, plus the Templates
//! panel's actions (including applying a template and its detail view).

use concinnity_core::ecs::World;

use super::{EditorHook, FormOverridesData, PanelData, TemplateDetailData, declared_id};
use crate::editor::asset_handle::AssetHandle;
use crate::editor::hud::HudAction;
use crate::editor::overrides;
use crate::editor::panels::form_panel::{self, FormView};
use crate::editor::panels::registry::PanelKey;
use crate::editor::panels::template_panel::{TemplateAction, TemplateView};

impl EditorHook {
    // Apply every entry of engine-owned template `i`, skipping any whose name
    // already exists (so re-applying is idempotent). Marks dirty if anything was
    // added.
    pub(super) fn apply_template(&mut self, i: usize) {
        let Some(t) = concinnity_cook::authoring::template::TEMPLATES.get(i) else {
            return;
        };
        // The template's typed specs become world-line entries via the app bridge;
        // no JSON string is parsed here.
        let entries = crate::authoring::world_template_entries(t);
        let mut added = 0;
        for entry in entries {
            if declared_id(&entry).is_some_and(|n| self.name_taken(n)) {
                continue;
            }
            self.entries.push(entry);
            added += 1;
        }
        if added > 0 {
            self.mark_changed();
            tracing::info!("editor: applied template '{}' ({added} asset(s))", t.name);
        }
    }

    // The per-tick Assets-panel data: the flattened tree, the type picker's
    // options while it is open, and the form heading -- all derived from the
    // cooked model plus the live search field, then borrowed for both
    // hit-testing and layout.
    pub(super) fn panel_data(&self, world: &World) -> PanelData {
        let mut form_title = match (self.form.target.is_edit(), &self.form.selected_type) {
            (true, Some(t)) => format!("Edit {t}"),
            (false, Some(t)) => format!("New {t}"),
            _ => "New asset".to_string(),
        };
        if self.form.touched {
            form_title.push_str(" *");
        }
        let (form_extras, form_blocked) = self.form_extras_data(world);
        let names = |set: &std::collections::BTreeSet<AssetHandle>| {
            set.iter().filter_map(|h| self.handle_name(h)).collect()
        };
        PanelData {
            rows: self.tree_rows(world),
            hidden: names(&self.hidden_assets),
            locked: names(&self.locked_assets),
            row_menu: self
                .assets
                .row_menu
                .as_ref()
                .and_then(|h| self.handle_name(h)),
            picker_options: self.picker_options(world),
            form_title,
            form_overrides: self.form_overrides_data(),
            form_extras,
            form_blocked,
        }
    }

    // The open form's override state (marks, summary count, any open menu's
    // option labels), owned for the tick. `None` outside a template-derived
    // form.
    fn form_overrides_data(&self) -> Option<FormOverridesData> {
        let marks = self.form_override_marks()?;
        let count = marks
            .iter()
            .filter(|m| **m != overrides::FieldOrigin::Inherited)
            .count();
        Some(FormOverridesData {
            field_menu: self.form.override_menu.map(|i| {
                let labels = self
                    .override_menu_options(i)
                    .into_iter()
                    .map(|(_, l)| l)
                    .collect();
                (i, labels)
            }),
            entity_menu: self.form.entity_menu_open.then(|| {
                self.entity_menu_options()
                    .into_iter()
                    .map(|(_, l)| l)
                    .collect()
            }),
            marks,
            count,
        })
    }

    pub(super) fn make_form_view<'a>(&'a self, d: &'a PanelData, mouse: [f32; 2]) -> FormView<'a> {
        FormView {
            title: &d.form_title,
            editing: self.form.target.is_edit(),
            form_fields: &self.form.fields,
            form_scroll: self.form.scroll,
            form_focus: self.form.focus,
            field_dropdown: self.form.field_dropdown,
            field_dropdown_scroll: self.form.field_dropdown_scroll,
            form_error: self.form.error.as_deref(),
            extras: &d.form_extras,
            blocked: d.form_blocked.as_deref(),
            overrides: d
                .form_overrides
                .as_ref()
                .map(|ovr| form_panel::OverridesView {
                    marks: &ovr.marks,
                    count: ovr.count,
                    field_menu: ovr
                        .field_menu
                        .as_ref()
                        .map(|(i, opts)| (*i, opts.as_slice())),
                    entity_menu: ovr.entity_menu.as_deref(),
                }),
            mouse,
        }
    }

    // Action handling

    // Route a resolved top-bar click: SAVE persists to disk (the live preview is
    // already current), the View button toggles the View panel.
    pub(super) fn apply_top(&mut self, action: HudAction, world: &mut World) {
        match action {
            HudAction::Save => self.save(),
            HudAction::Undo => self.undo(world),
            HudAction::Redo => self.redo(world),
            HudAction::ToggleView => self.open[PanelKey::View] = !self.open[PanelKey::View],
            HudAction::ToggleDisplay => self.toggle_display_menu(),
            HudAction::PlayPause => self.sim_toggle_play(),
            HudAction::Step => self.sim.step(),
            HudAction::Stop => self.sim_stop(),
            // A bar click that hit no chip: swallowed (the caller already
            // dismisses any open overlays).
            HudAction::Consume => {}
        }
    }

    // Open (or re-target) the Template detail panel on template `i` (a preview of
    // the assets it would add, with an Apply button), bringing it to the front of
    // the focus stack. The Templates list stays open so another can be picked.
    pub(super) fn open_template_detail(&mut self, i: usize) {
        if i >= concinnity_cook::authoring::template::TEMPLATES.len() {
            return;
        }
        self.templates.detail = Some(i);
        self.templates.detail_scroll = 0;
        self.focus_panel(PanelKey::TemplateDetail);
    }

    // Close the Template detail panel (its state is transient; the Templates list
    // stays as it was).
    pub(super) fn close_template_detail(&mut self) {
        self.templates.detail = None;
        self.templates.detail_scroll = 0;
    }

    // Route a resolved Template-detail click: Apply layers the template's assets
    // (idempotently) then closes the panel; the "X" just closes it.
    pub(super) fn apply_template_detail(&mut self, action: TemplateAction) {
        match action {
            TemplateAction::Apply => {
                if let Some(i) = self.templates.detail {
                    self.apply_template(i);
                }
                self.close_template_detail();
            }
            TemplateAction::Close => self.close_template_detail(),
            TemplateAction::Consume => {}
        }
    }

    // The per-frame Template detail view data (title, description, grouped rows),
    // borrowed for both hit-testing and layout.
    pub(super) fn template_detail_data(&self, i: usize) -> TemplateDetailData {
        let (title, description) = concinnity_cook::authoring::template::TEMPLATES
            .get(i)
            .map(|t| (format!("Template {}", t.title), t.description.to_string()))
            .unwrap_or_default();
        TemplateDetailData {
            title,
            description,
            rows: self.template_rows(i),
        }
    }

    pub(super) fn make_template_view<'a>(
        &self,
        d: &'a TemplateDetailData,
        mouse: [f32; 2],
    ) -> TemplateView<'a> {
        TemplateView {
            title: &d.title,
            description: &d.description,
            rows: &d.rows,
            scroll: self.templates.detail_scroll,
            mouse,
        }
    }
}