//! Layers panel, artboards.
//!
//! The Layers panel works on rows: layers, sublayers, groups and objects. Clicking a row makes it
//! the highlighted row (`layer.setCurrent`; Shift and Ctrl change several, `layer.highlight`) and
//! its layer the current one, where new art goes. Panel commands without `ids` act on the
//! highlighted rows, else on the current layer. More panel-menu operations live in
//! [`super::layerpanel`].

use std::collections::HashSet;
use std::sync::Arc;

use serde_json::{Value, json};
use vectorcraft_doc::{Artboard, Document, LAYER_COLORS, LayerColor, Node, NodeId, NodeKind, Scaling};
use vectorcraft_geom::{Affine, Rect};

use super::*;
use crate::EngineError;

/// Most rows one panel command takes (ids are untrusted input).
pub(crate) const MAX_ROWS: usize = 100_000;

pub fn specs() -> Vec<CommandSpec> {
    vec![
        cmd!(
            "layer.new",
            "New Layer…",
            ["Window", "Layers"],
            Some("Cmd+L"),
            "{name?, top?: bool, color?, template?, locked?, visible?, printable?, preview?, dimImages?} a layer directly above the current layer, at its level (a sublayer beside a current sublayer); `top`: above all layers (Ctrl-click the button). Options as layer.setProps → {id}",
            has_doc,
            new_layer
        ),
        cmd!(
            "layer.newSublayer",
            "New Sublayer…",
            ["Window", "Layers"],
            None,
            "{parent?: layer id (default: the highlighted row's layer, else the current layer), name?, …options as layer.new} a sublayer on top of the parent's contents → {id}",
            has_doc,
            new_sublayer
        ),
        cmd!(
            "layer.delete",
            "Delete Selection",
            ["Window", "Layers"],
            None,
            "{ids?|id?} delete rows: layers, sublayers, groups or objects with what they hold (default: the highlighted rows, else the current layer). The last layer stays → {deleted}",
            has_doc,
            delete_rows
        ),
        cmd!(
            "layer.duplicate",
            "Duplicate Selection",
            ["Window", "Layers"],
            None,
            "{ids?|id?} copy rows (default: the highlighted rows, else the current layer), each just above its original; a layer's copy is named `<name> copy`. The copies are highlighted → {ids}",
            has_doc,
            duplicate_rows
        ),
        cmd!(
            "layer.setCurrent",
            "Set Current Layer",
            [],
            None,
            "{id} click a row: it alone is highlighted, and the layer it is (or the layer it is in) becomes the current layer, where new art goes. Not an undo step → {id, layer}",
            has_doc,
            set_current
        ),
        cmd!(
            "layer.highlight",
            "Highlight Rows",
            [],
            None,
            "{ids, mode?: \"set\"|\"add\"|\"toggle\"} highlight Layers panel rows (Shift-click: a range, Ctrl-click: toggle one); the last one's layer becomes current. Not an undo step → {rows}",
            has_doc,
            highlight
        ),
        cmd!(
            "layer.setProps",
            "Layer Options…",
            ["Window", "Layers"],
            None,
            "{ids?|id? (default: the highlighted rows, else the current layer), name? (with prefs.identifyObjectsBy xmlId: a valid XML ID, stored as the object name), visible?, locked?, template?, printable?, preview?, dimImages?: 0..100|false, color?: index 0..26|\"#rrggbb\"|preset name} Layer Options; rows that are not layers take name, visible and locked. Template on also locks the layer and dims its images to 50% (unless given); off unlocks it and stops dimming. One undo step",
            has_doc,
            set_props
        ),
        cmd!(
            "layer.collectInNew",
            "Collect in New Layer",
            ["Window", "Layers"],
            None,
            "{ids?} move rows (default: the highlighted rows, else the selected objects) into a new layer where the topmost of them was (a sublayer when they are in a layer), deselecting every selected object left hidden or locked (the key object too) → {id}",
            has_doc,
            collect
        ),
        cmd!(
            "layer.selectAll",
            "Select Art",
            [],
            None,
            "{id, add?: bool} the Layers panel's selection column: select the visible, unlocked art of a layer (its sublayers' too), or the object itself; `add` (Shift-click) adds it to the selection, or removes it when it is all selected already → {selected: [..]}",
            has_doc,
            select_art
        ),
        cmd!(
            "layer.move",
            "Move Rows",
            [],
            None,
            "{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer or group (on top of its contents). Layers go only in layers or at the top level, objects in layers and groups; an object placed beside a top-level layer goes inside it. A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies. Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids}",
            has_doc,
            move_rows
        ),
        cmd!(
            "node.move",
            "Reorder",
            [],
            None,
            "{id, parent?: id (null = top level), index} put a row at `index` (0 = bottom) of `parent` (layers only at the top level or in layers), deselecting every selected object left hidden or locked (the key object too)",
            has_doc,
            move_node
        ),
        cmd!(
            "artboard.new",
            "New Artboard",
            ["Window", "Artboards"],
            None,
            "{x?, y?, width?, height?, name?} (default: right of the last)",
            has_doc,
            artboard_new
        ),
        cmd!(
            "artboard.delete",
            "Delete Artboard",
            ["Window", "Artboards"],
            None,
            "{index | indices: [index…]} delete artboards (with their guides) in one step; one is always left",
            has_doc,
            artboard_delete
        ),
        cmd!(
            "artboard.setProps",
            "Artboard Options…",
            ["Window", "Artboards"],
            None,
            "{index, name?, x?, y?, width?, height?, moveArt?: bool (default false; a position-only change moves the contained art with its artboard), scaleArt?: bool (Scale Artwork with Artboard: resized, the artboard takes the art fully inside it (locked and hidden art only with lockedAndHidden?: bool, default prefs moveLockedWithArtboard) and its guides from its old rectangle onto the new one, each side by its own ratio; strokes/corners/patterns as object.scale), strokes?: bool, corners?: bool, patterns?: bool (the three as object.scale, for art that moves or scales with the artboard), lockedAndHidden?: bool (locked and hidden art moves along; default: the preference; recorded in the journal so a replay matches)} → null, or with scaleArt {scaled: the art scaled}",
            has_doc,
            artboard_set
        ),
        cmd!(
            "artboard.fitToArt",
            "Fit to Artwork Bounds",
            ["Object", "Artboards"],
            None,
            "{index?} the artboard fits the art that shows (with its strokes and effects; hidden objects and layers, guides and template layers don't count)",
            has_doc,
            artboard_fit_art
        ),
        cmd!("artboard.fitToSelection", "Fit to Selected Art", ["Object", "Artboards"], None, "{index?}", has_selection, artboard_fit_sel),
        cmd!(
            "layer.clippingMask.toggle",
            "Make/Release Clipping Mask",
            ["Window", "Layers"],
            None,
            "{id?: layer or group (default: the one highlighted layer or group row, else the one selected group, else the current layer)} make: its top object (a path, compound path or text, which loses its paint) clips the rest and moves to the bottom (new art added on top is clipped); release: it stops clipping, the clipping path stays unpainted → {clip}",
            has_doc,
            clip_toggle
        ),
        cmd!(
            "layer.target",
            "Target",
            [],
            None,
            "{id, add?: bool (Shift-click: the item joins the selection, or leaves it when all selected; nothing is targeted)} target a layer, group or object as clicking its target circle in the Layers panel does: a layer gets its visible, unlocked art (its sublayers' too) selected and becomes the current layer, and appearance.*, effect.*, transparency.* and the opacity-mask commands without `ids` then act on the layer itself; anything else is selected. Any other selection change ends the targeting (`document.inspect` → target) → {id, selected: [..]}",
            has_doc,
            target
        ),
        cmd!(
            "layer.pasteRemembersLayers",
            "Paste Remembers Layers",
            ["Window", "Layers"],
            None,
            "{on?} (default: toggle) the document option: on, the Paste commands put objects back into the layers they were copied from (by name; a missing one is made on top), off into the current layer; one undo step when it changes (document.inspect → pasteRemembersLayers) → {on}",
            has_doc,
            paste_remembers_layers
        ),
    ]
}

/// The rows a panel command acts on: `ids` or `id`, else the highlighted rows, else the current
/// layer (capped at [`MAX_ROWS`]).
pub(crate) fn rows_param(s: &Session, p: &Value, command: &str) -> Result<Vec<NodeId>> {
    // Presence is explicit intent: validate every target before fallback, truncation or edits.
    let mut ids = if p.get("ids").is_some() {
        checked_ids_param(s, p, "ids", command)?
    } else if let Some(id) = p.get("id") {
        vec![checked_id(s, id, command)?]
    } else {
        let st = s.doc()?;
        let rows = st.highlighted_rows();
        if rows.is_empty() { st.current_layer().into_iter().collect() } else { rows }
    };
    ids.truncate(MAX_ROWS);
    Ok(ids)
}

/// `ids` that exist, without repeats or rows inside another listed row, in paint order (bottom
/// first).
pub(crate) fn row_roots(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
    let set: HashSet<NodeId> = ids.iter().copied().filter(|i| d.node(*i).is_some()).collect();
    let keep: Vec<NodeId> = set
        .iter()
        .copied()
        .filter(|id| d.ancestry(*id).is_some_and(|a| a.split_last().is_none_or(|(_, above)| !above.iter().any(|x| set.contains(x)))))
        .collect();
    d.paint_order(keep)
}

/// Whether `parent` (None: the top level) can hold `n`: layers go at the top level or in layers,
/// anything else in layers and groups.
pub(crate) fn accepts(d: &Document, parent: Option<NodeId>, n: &Node) -> bool {
    match parent {
        None => n.is_layer(),
        Some(p) => match d.node(p).map(|x| &x.kind) {
            Some(NodeKind::Layer { .. }) => true,
            Some(NodeKind::Group { .. }) => !n.is_layer(),
            _ => false,
        },
    }
}

/// Whether `id` or a container around it is locked.
pub(crate) fn locked_within(d: &Document, id: NodeId) -> bool {
    d.ancestry(id).unwrap_or_default().iter().any(|a| d.node(*a).is_some_and(|n| n.locked))
}

/// The number and the names of a document's layers and sublayers, from which [`NewLayers::make`]
/// names and colors a new layer. [`NewLayers::of`] reads them in one walk of the document, and
/// [`NewLayers::add`] counts each new layer as it goes in.
pub(crate) struct NewLayers {
    count: usize,
    taken: HashSet<String>,
}

impl NewLayers {
    pub(crate) fn of(d: &Document) -> Self {
        let mut layers = Self { count: 0, taken: HashSet::new() };
        d.walk(|n| layers.note(n));
        layers
    }

    /// A new layer named `name` (default: the next `Layer N`, as [`Document::next_layer_name`]
    /// gives it) in the next layer color.
    pub(crate) fn make(&self, d: &mut Document, name: Option<&str>) -> Node {
        let name = name
            .map(str::to_string)
            .unwrap_or_else(|| (self.count + 1..).map(|i| format!("Layer {i}")).find(|name| !self.taken.contains(name)).unwrap_or_default());
        let id = d.alloc_id();
        Node::layer(id, &name, LayerColor::Preset((self.count % LAYER_COLORS.len()) as u8))
    }

    /// Count `n`, a layer going into the document, and the layers inside it.
    pub(crate) fn add(&mut self, n: &Node) {
        n.walk(&mut |c| self.note(c));
    }

    fn note(&mut self, n: &Node) {
        if n.is_layer() {
            self.count += 1;
            self.taken.extend(n.name.clone());
        }
    }
}

/// A new layer named `name` (default: the next `Layer N`) in the next layer colour.
pub(crate) fn make_layer(d: &mut Document, name: Option<&str>) -> Node {
    NewLayers::of(d).make(d, name)
}

/// A layer colour: a preset index (0–26), `#rrggbb` or a preset's name (any case).
fn layer_color_param(v: &Value) -> std::result::Result<LayerColor, String> {
    match v {
        Value::Number(n) => match n.as_u64() {
            Some(i) if (i as usize) < LAYER_COLORS.len() => Ok(LayerColor::Preset(i as u8)),
            _ => Err(format!("a colour index is 0 to {}, not {n}", LAYER_COLORS.len() - 1)),
        },
        Value::String(s) => {
            if let Some(i) = LAYER_COLORS.iter().position(|(name, _)| name.eq_ignore_ascii_case(s.trim())) {
                return Ok(LayerColor::Preset(i as u8));
            }
            let c = vectorcraft_color::Color::from_hex(s).ok_or_else(|| format!("`{s}` is not a colour (#rrggbb or a preset name)"))?;
            let [r, g, b, _] = c.to_rgba8(1.0);
            Ok(LayerColor::Custom([r, g, b]))
        }
        _ => Err(format!("a colour is an index, #rrggbb or a preset name, not {v}")),
    }
}

/// Layer Options in `p` applied to layer or row `n` (validated first by [`check_options`]).
/// `xml_id`: Preferences › Units › Identify Objects By › XML ID — `name` is an XML id and is
/// stored as the object name ([`vectorcraft_doc::xml_id`]).
fn apply_options(n: &mut Node, p: &Value, xml_id: bool) {
    if let Some(v) = str_param(p, "name") {
        if v.trim().is_empty() {
            // A layer keeps a name; an object goes back to its generated `<Kind>` one.
            if !n.is_layer() {
                n.name = None;
            }
        } else {
            let name = if xml_id { vectorcraft_doc::xml_id::to_object_name(v) } else { v.to_string() };
            n.name = Some(name.chars().take(512).collect());
        }
    }
    if let Some(v) = p.get("visible").and_then(Value::as_bool) {
        n.visible = v;
    }
    let locked = p.get("locked").and_then(Value::as_bool);
    if let Some(v) = locked {
        n.locked = v;
    }
    let mut lock = None;
    if let NodeKind::Layer { template, printable, color, preview, dim_images, .. } = &mut n.kind {
        let dim_given = p.get("dimImages").is_some();
        if let Some(v) = p.get("template").and_then(Value::as_bool)
            && v != *template
        {
            *template = v;
            // A template is locked and its images dimmed; it stops being either with it.
            lock = Some(v);
            if !dim_given {
                *dim_images = v.then_some(50);
            }
        }
        if let Some(v) = p.get("printable").and_then(Value::as_bool) {
            *printable = v;
        }
        if let Some(v) = p.get("preview").and_then(Value::as_bool) {
            *preview = v;
        }
        match p.get("dimImages") {
            Some(Value::Bool(false) | Value::Null) => *dim_images = None,
            Some(Value::Bool(true)) => *dim_images = Some(50),
            Some(v) => {
                if let Some(x) = v.as_f64().filter(|x| x.is_finite()) {
                    *dim_images = Some(x.clamp(0.0, 100.0).round() as u8);
                }
            }
            None => {}
        }
        if let Some(c) = p.get("color").and_then(|v| layer_color_param(v).ok()) {
            *color = c;
        }
    }
    if let (Some(v), None) = (lock, locked) {
        n.locked = v;
    }
}

/// Bad values in Layer Options params, as an error for `cmd`.
/// `xml_id`: Preferences › Units › Identify Objects By › XML ID — a non-empty `name` must be a
/// valid XML id.
fn check_options(cmd: &str, p: &Value, xml_id: bool) -> Result<()> {
    if let Some(v) = p.get("color") {
        layer_color_param(v).map_err(|e| bad(cmd, e))?;
    }
    for k in ["visible", "locked", "template", "printable", "preview"] {
        if p.get(k).is_some_and(|v| !v.is_boolean()) {
            return Err(bad(cmd, format!("`{k}` is true or false")));
        }
    }
    if let Some(v) = p.get("dimImages")
        && !(v.is_boolean() || v.is_null() || v.as_f64().is_some_and(f64::is_finite))
    {
        return Err(bad(cmd, "`dimImages` is a percentage or false"));
    }
    if xml_id
        && let Some(name) = str_param(p, "name").filter(|n| !n.trim().is_empty())
        && !vectorcraft_doc::xml_id::is_valid(name)
    {
        return Err(bad(cmd, "Identify Objects By is XML ID: the name must be a valid XML ID (start with a letter, underscore or colon; no spaces)"));
    }
    Ok(())
}

/// Layers panel → Paste Remembers Layers.
fn paste_remembers_layers(s: &mut Session, p: &Value) -> Result<Value> {
    let cur = s.doc()?.doc.paste_remembers_layers;
    let on = bool_or(p, "on", !cur);
    if on != cur {
        s.edit("Paste Remembers Layers", |d, _| {
            d.paste_remembers_layers = on;
            Ok(())
        })?;
    }
    Ok(json!({ "on": on }))
}

/// The Layers panel's target circle.
fn target(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "layer.target";
    let id = id_param(p, "id").ok_or_else(|| bad(C, "missing id"))?;
    let st = s.doc()?;
    let n = st.doc.node(id).ok_or(EngineError::NoNode(id))?;
    if !st.doc.is_editable(id) {
        return Err(bad(C, "the object is hidden or locked"));
    }
    let layer = n.is_layer();
    let rows = st.layer_rows.clone();
    if p.get("add").and_then(Value::as_bool).unwrap_or(false) {
        s.select(|d, sel| sel.toggle_target(d, id))?;
    } else {
        s.select(|d, sel| sel.set_target(d, id))?;
    }
    let st = s.doc_mut()?;
    // Targeting doesn't change which rows are highlighted.
    st.layer_rows = rows;
    if layer {
        st.active_layer = Some(id);
    }
    Ok(json!({ "id": id.0, "selected": st.selection.objects.iter().map(|i| i.0).collect::<Vec<_>>() }))
}

/// The Layers panel's clipping mask button: the top object of a layer (or group) clips the rest,
/// or the clipping mask is released.
fn clip_toggle(s: &mut Session, p: &Value) -> Result<Value> {
    let st = s.doc()?;
    let container = |id: &NodeId| st.doc.node(*id).is_some_and(|n| matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }));
    let row = match st.highlighted_rows().as_slice() {
        [id] if container(id) => Some(*id),
        _ => None,
    };
    let group = match st.selection.objects.as_slice() {
        [id] if matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::Group { .. })) => Some(*id),
        _ => None,
    };
    let id = id_param(p, "id").or(row).or(group).or(st.current_layer()).ok_or_else(|| bad("layer.clippingMask.toggle", "no layer"))?;
    let clip = s.edit("Make/Release Clipping Mask", |d, _| {
        let n = d.node(id).ok_or(EngineError::NoNode(id))?;
        if !matches!(n.kind, NodeKind::Layer { .. } | NodeKind::Group { .. }) {
            return Err(bad("layer.clippingMask.toggle", "not a layer or group"));
        }
        if n.clips() {
            super::object::release_clip(d, id);
            return Ok(false);
        }
        let top =
            n.children().and_then(|c| c.last()).map(|c| c.id).ok_or_else(|| EngineError::Other("the layer has no objects to clip by".into()))?;
        super::object::make_clipping_path(d, top)?;
        d.move_node(top, Some(id), 0)?;
        if let Some(n) = d.node_mut(id) {
            n.set_clips(true);
        }
        Ok(true)
    })?;
    Ok(json!({ "clip": clip }))
}

/// A new layer with the options in `p`, at `parent`/`index`; it becomes current and highlighted.
fn add_layer(s: &mut Session, p: &Value, cmd: &str, label: &str, place: impl FnOnce(&Document) -> Result<(Option<NodeId>, usize)>) -> Result<Value> {
    let xml_id = s.prefs.identify_objects_by == "xmlId";
    check_options(cmd, p, xml_id)?;
    let name = str_param(p, "name").filter(|n| !n.trim().is_empty()).map(str::to_string);
    let id = s.edit(label, |d, _| {
        let (parent, index) = place(d)?;
        let mut n = make_layer(d, name.as_deref());
        apply_options(&mut n, p, xml_id);
        Ok(d.insert(parent, index, n)?)
    })?;
    let st = s.doc_mut()?;
    st.active_layer = Some(id);
    st.layer_rows = vec![id];
    Ok(json!({ "id": id.0 }))
}

fn new_layer(s: &mut Session, p: &Value) -> Result<Value> {
    let st = s.doc()?;
    // Above the current layer, at its level; on top of everything with `top`.
    let cur = st.current_layer().filter(|_| !bool_or(p, "top", false));
    add_layer(s, p, "layer.new", "New Layer", |d| match cur.and_then(|c| d.position(c)) {
        Some((parent, i, _)) => Ok((parent, i + 1)),
        None => Ok((None, usize::MAX)),
    })
}

fn new_sublayer(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "layer.newSublayer";
    let st = s.doc()?;
    let row = st.highlighted_rows().last().and_then(|r| st.doc.layer_containing(*r));
    let parent = id_param(p, "parent").or(row).or(st.current_layer()).ok_or_else(|| bad(C, "no parent layer"))?;
    if !st.doc.node(parent).is_some_and(Node::is_layer) {
        return Err(bad(C, "the parent must be a layer or sublayer"));
    }
    add_layer(s, p, C, "New Sublayer", |_| Ok((Some(parent), usize::MAX)))
}

fn delete_rows(s: &mut Session, p: &Value) -> Result<Value> {
    let ids = rows_param(s, p, "layer.delete")?;
    let st = s.doc()?;
    let ids = row_roots(&st.doc, &ids);
    if ids.is_empty() {
        return Err(bad("layer.delete", "no such rows"));
    }
    let listed: HashSet<NodeId> = ids.iter().copied().collect();
    if st.doc.layers.iter().all(|l| listed.contains(&l.id)) {
        return Err(EngineError::Other("a document needs at least one layer".into()));
    }
    s.edit("Delete Selection", |d, sel| {
        d.remove_many(&ids)?;
        // The guides on the deleted layers go with them.
        d.drop_guides_of_deleted_layers(sel);
        sel.prune(d);
        Ok(())
    })?;
    let st = s.doc_mut()?;
    st.layer_rows.clear();
    if st.current_layer().is_none() {
        st.active_layer = st.doc.default_layer();
    }
    Ok(json!({ "deleted": ids.len() }))
}

fn duplicate_rows(s: &mut Session, p: &Value) -> Result<Value> {
    let ids = rows_param(s, p, "layer.duplicate")?;
    let ids = row_roots(&s.doc()?.doc, &ids);
    if ids.is_empty() {
        return Err(bad("layer.duplicate", "no such rows"));
    }
    let copies = s.edit("Duplicate Selection", |d, _| {
        super::edit::copy_above(d, &ids, |d, n, c| {
            if n.is_layer() {
                c.name = Some(format!("{} copy", n.display_name()));
                d.copy_layer_guides(n, c);
            }
        })
    })?;
    s.doc_mut()?.layer_rows = copies.clone();
    Ok(json!({ "ids": copies.iter().map(|i| i.0).collect::<Vec<_>>() }))
}

fn set_current(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "layer.setCurrent";
    let id = id_param(p, "id").ok_or_else(|| bad(C, "missing id"))?;
    let st = s.doc_mut()?;
    let layer = st.doc.layer_containing(id).ok_or(EngineError::NoNode(id))?;
    st.active_layer = Some(layer);
    st.layer_rows = vec![id];
    st.revision += 1;
    Ok(json!({ "id": id.0, "layer": layer.0 }))
}

fn highlight(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "layer.highlight";
    let mut ids = ids_param(p, "ids").ok_or_else(|| bad(C, "missing ids"))?;
    ids.truncate(MAX_ROWS);
    let mode = str_param(p, "mode").unwrap_or("set");
    let st = s.doc_mut()?;
    ids.retain(|id| st.doc.node(*id).is_some());
    let mut rows = st.highlighted_rows();
    match mode {
        "set" => rows.clear(),
        "add" | "toggle" => {}
        other => return Err(bad(C, format!("mode is set, add or toggle, not `{other}`"))),
    }
    let mut last = None;
    for id in ids {
        if mode == "toggle" && rows.contains(&id) {
            rows.retain(|r| *r != id);
        } else if !rows.contains(&id) {
            rows.push(id);
            last = Some(id);
        }
    }
    if let Some(layer) = last.or(rows.last().copied()).and_then(|id| st.doc.layer_containing(id)) {
        st.active_layer = Some(layer);
    }
    st.layer_rows = rows;
    st.revision += 1;
    Ok(json!({ "rows": st.layer_rows.iter().map(|i| i.0).collect::<Vec<_>>() }))
}

fn set_props(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "layer.setProps";
    let xml_id = s.prefs.identify_objects_by == "xmlId";
    check_options(C, p, xml_id)?;
    let ids = rows_param(s, p, C)?;
    if ids.is_empty() {
        return Err(bad(C, "no rows"));
    }
    s.edit("Layer Options", |d, sel| {
        for id in &ids {
            apply_options(d.node_mut(*id).ok_or(EngineError::NoNode(*id))?, p, xml_id);
        }
        sel.deselect_uneditable(d);
        Ok(())
    })?;
    ok()
}

fn collect(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "layer.collectInNew";
    let ids = if p.get("ids").is_some() {
        checked_ids_param(s, p, "ids", C)?
    } else {
        let rows = s.doc()?.highlighted_rows();
        if rows.is_empty() { super::edit::selected_roots(s)? } else { rows }
    };
    let ids = row_roots(&s.doc()?.doc, &ids);
    let Some(top) = ids.last().copied() else { return Err(bad(C, "select rows or objects to collect")) };
    let lid = s.edit("Collect in New Layer", |d, sel| {
        // Where the topmost of them is: beside it in its layer, or on top of the layer holding
        // its group.
        let beside = d.position(top).is_some_and(|(par, _, _)| par.is_none_or(|p| d.node(p).is_some_and(Node::is_layer)));
        let holder = d.layer_containing(top);
        let mut layer = make_layer(d, None);
        let lid = layer.id;
        if beside {
            d.wrap(&ids, |rows| {
                if let Some(ch) = layer.children_mut() {
                    *ch = rows;
                }
                layer
            })?;
        } else {
            let rows = d.remove_many(&ids)?;
            if let Some(ch) = layer.children_mut() {
                *ch = rows;
            }
            d.insert(holder, usize::MAX, layer)?;
        }
        sel.prune(d);
        sel.deselect_uneditable(d);
        Ok(lid)
    })?;
    let st = s.doc_mut()?;
    st.active_layer = Some(lid);
    st.layer_rows = vec![lid];
    Ok(json!({ "id": lid.0 }))
}

/// The selection column: select a row's art.
fn select_art(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "layer.selectAll";
    let id = id_param(p, "id").ok_or_else(|| bad(C, "missing id"))?;
    let add = bool_or(p, "add", false);
    let st = s.doc()?;
    let n = st.doc.node(id).ok_or(EngineError::NoNode(id))?;
    let ids: Vec<NodeId> = if !st.doc.is_editable(id) {
        vec![]
    } else if n.is_layer() {
        n.layer_art(true)
    } else {
        vec![id]
    };
    let all_selected = !ids.is_empty() && ids.iter().all(|i| st.selection.contains(*i));
    let rows = st.layer_rows.clone();
    s.select(|_, sel| {
        if !add {
            sel.set(ids.iter().copied());
        } else if all_selected {
            for i in &ids {
                sel.remove(*i);
            }
        } else {
            for i in &ids {
                sel.add(*i);
            }
        }
    })?;
    let st = s.doc_mut()?;
    // The selection column leaves the highlighted rows as they are.
    st.layer_rows = rows;
    Ok(json!({ "selected": st.selection.objects.iter().map(|i| i.0).collect::<Vec<_>>() }))
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum Place {
    Above,
    Below,
    Inside,
}

/// Drag rows in the Layers panel.
fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "layer.move";
    let mut ids = ids_param(p, "ids").or_else(|| id_param(p, "id").map(|i| vec![i])).ok_or_else(|| bad(C, "missing ids"))?;
    ids.truncate(MAX_ROWS);
    let target = id_param(p, "target").ok_or_else(|| bad(C, "missing target"))?;
    let place = match str_param(p, "place").unwrap_or("inside") {
        "above" => Place::Above,
        "below" => Place::Below,
        "inside" | "into" => Place::Inside,
        other => return Err(bad(C, format!("place is above, below or inside, not `{other}`"))),
    };
    let copy = bool_or(p, "copy", false);
    let st = s.doc()?;
    let d = &st.doc;
    d.node(target).ok_or(EngineError::NoNode(target))?;
    let ids = row_roots(d, &ids);
    if ids.is_empty() {
        return Err(bad(C, "no such rows"));
    }
    // Never into itself or a row inside it.
    let around = d.ancestry(target).unwrap_or_default();
    if ids.iter().any(|i| around.contains(i)) {
        return Err(bad(C, "a row can't go into itself"));
    }
    let nodes: Vec<&Node> = ids.iter().filter_map(|i| d.node(*i)).collect();
    let (parent, anchor) = match place {
        Place::Inside => (Some(target), None),
        _ => match d.parent_of(target) {
            // Objects can't be at the top level: beside a top-level layer means in it.
            None if nodes.iter().any(|n| !n.is_layer()) => (Some(target), None),
            parent => (parent, Some(target)),
        },
    };
    if let Some(n) = nodes.iter().find(|n| !accepts(d, parent, n)) {
        let into = parent.and_then(|p| d.node(p)).map_or("the top level", |p| if p.is_layer() { "a layer" } else { p.kind_label() });
        return Err(bad(C, format!("{} can't go into {into}", n.display_name())));
    }
    if parent.is_some_and(|p| locked_within(d, p)) {
        return Err(EngineError::Other("the layer or group is locked".into()));
    }
    let label = if copy { "Duplicate Rows" } else { "Move Rows" };
    let moved = s.edit(label, |d, sel| {
        let nodes = if copy {
            let mut nodes = vec![];
            for id in &ids {
                let n = d.node(*id).cloned().ok_or(EngineError::NoNode(*id))?;
                let c = d.reid(&n);
                if n.is_layer() {
                    d.copy_layer_guides(&n, &c);
                }
                nodes.push(Arc::new(c));
            }
            nodes
        } else {
            d.remove_many(&ids)?
        };
        let count = d.children(parent).map_or(0, Vec::len);
        let mut index = match anchor {
            None => count,
            Some(a) => {
                let (_, i, _) = d.position(a).ok_or(EngineError::NoNode(a))?;
                if place == Place::Above { i + 1 } else { i }
            }
        };
        // The clipping path stays at the bottom of a clip group or a clipping layer.
        if count > 0 && parent.and_then(|p| d.node(p)).is_some_and(Node::clips) {
            index = index.max(1);
        }
        let out: Vec<NodeId> = nodes.iter().map(|n| n.id).collect();
        let ch = d.children_mut(parent)?;
        let index = index.min(ch.len());
        ch.splice(index..index, nodes);
        sel.prune(d);
        sel.deselect_uneditable(d);
        Ok(out)
    })?;
    let st = s.doc_mut()?;
    st.layer_rows = moved.clone();
    Ok(json!({ "ids": moved.iter().map(|i| i.0).collect::<Vec<_>>() }))
}

fn move_node(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "node.move";
    let id = id_param(p, "id").ok_or_else(|| bad(C, "missing id"))?;
    let parent = id_param(p, "parent");
    let index = p.get("index").and_then(Value::as_u64).unwrap_or(u64::MAX).min(usize::MAX as u64) as usize;
    let d = &s.doc()?.doc;
    let n = d.node(id).ok_or(EngineError::NoNode(id))?;
    if !accepts(d, parent, n) {
        return Err(bad(C, "layers go only at the top level or in layers, objects in layers and groups"));
    }
    s.edit("Reorder", |d, sel| {
        d.move_node(id, parent, index)?;
        sel.deselect_uneditable(d);
        Ok(())
    })?;
    ok()
}

fn rect_from(p: &Value, default: Rect) -> Rect {
    let x = f64_or(p, "x", default.x0);
    let y = f64_or(p, "y", default.y0);
    let w = f64_or(p, "width", default.width()).max(1.0);
    let h = f64_or(p, "height", default.height()).max(1.0);
    Rect::new(x, y, x + w, y + h)
}

fn artboard_new(s: &mut Session, p: &Value) -> Result<Value> {
    let d0 = &s.doc()?.doc;
    let last = d0.artboards.last().map(|a| a.rect).unwrap_or(Rect::new(0.0, 0.0, 612.0, 792.0));
    let def = Rect::new(last.x1 + 20.0, last.y0, last.x1 + 20.0 + last.width(), last.y1);
    let r = rect_from(p, def);
    let idx = s.edit("New Artboard", |d, _| {
        let id = d.next_artboard_id();
        let name = str_param(p, "name").map(str::to_string).unwrap_or_else(|| format!("Artboard {}", d.artboards.len() + 1));
        d.artboards.push(Artboard { id, name, rect: r, show_center_mark: false, show_cross_hairs: false });
        Ok(d.artboards.len() - 1)
    })?;
    Ok(json!({ "index": idx }))
}

fn artboard_delete(s: &mut Session, p: &Value) -> Result<Value> {
    let indices = super::panelcmds::artboard_indices(&s.doc()?.doc, p, "artboard.delete")?;
    s.edit("Delete Artboard", |d, sel| {
        if indices.len() >= d.artboards.len() {
            return Err(EngineError::Other("a document needs at least one artboard".into()));
        }
        // The last first, so the others keep their places; their guides go with them.
        for &i in indices.iter().rev() {
            let id = d.artboards.remove(i).id;
            d.retain_guides(sel, |_, g| g.artboard != Some(id));
        }
        Ok(())
    })?;
    ok()
}

fn artboard_set(s: &mut Session, p: &Value) -> Result<Value> {
    let i = p.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;
    let was = s.doc()?.doc.artboards.get(i).map(|a| a.rect).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
    let now = rect_from(p, was);
    let resized = (now.width() - was.width()).abs() > 1e-6 || (now.height() - was.height()).abs() > 1e-6;
    // Scale Artwork with Artboard: resized, it takes the art fully inside it (as Move Artwork with
    // Artboard gathers it) and its guides from the old rectangle onto the new one.
    let scale_art = bool_or(p, "scaleArt", false);
    let fit = if scale_art && resized { rect_map(was, now) } else { None };
    // Position fields honor Move Artwork independently of Scale Artwork. A resize still
    // leaves the art alone unless scaling was requested. Fit-to-art callers keep the default.
    let delta = now.origin() - was.origin();
    let moving = !resized && bool_or(p, "moveArt", false) && delta != vectorcraft_geom::Vec2::ZERO;
    let transform = fit.or_else(|| moving.then(|| Affine::translate(delta)));
    let art = if transform.is_some() {
        // Locked and hidden art too? Noted in the journal, so a replay transforms the same objects
        // whatever the preference is then.
        let all = bool_or(p, "lockedAndHidden", s.prefs.move_locked_with_artboard);
        s.note_journal("lockedAndHidden", json!(all));
        s.doc()?.doc.art_on_artboard(was, all)
    } else {
        vec![]
    };
    let mut sc = match fit {
        Some(xf) if Scaling::factor(xf).is_some() => super::object::scaling(s, p),
        _ => Scaling::default(),
    };
    sc.patterns = super::object::transform_patterns(s, p, &art)?;
    s.edit("Artboard Options", |d, _| {
        let a = d.artboards.get_mut(i).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
        a.rect = now;
        if let Some(n) = str_param(p, "name") {
            a.name = n.to_string();
        }
        let id = a.id;
        if let Some(xf) = transform {
            d.map_artboard_guides(id, xf);
            for id in &art {
                if let Some(n) = d.node_mut(*id) {
                    n.transform(xf, sc);
                }
            }
        } else if !resized {
            // Moved (not resized), it takes its guides along.
            d.move_artboard_guides(id, delta);
        }
        Ok(())
    })?;
    if !scale_art {
        return ok();
    }
    Ok(json!({ "scaled": if fit.is_some() { art.iter().map(|i| i.0).collect::<Vec<_>>() } else { vec![] } }))
}

/// The map taking artboard rectangle `from` onto `to`, each side scaled by its own ratio. None
/// when `from` has no area or the map isn't finite (a size out of range).
fn rect_map(from: Rect, to: Rect) -> Option<Affine> {
    if from.width() <= 1e-9 || from.height() <= 1e-9 {
        return None;
    }
    let (sx, sy) = (to.width() / from.width(), to.height() / from.height());
    let xf = Affine::translate(to.origin().to_vec2()) * Affine::scale_non_uniform(sx, sy) * Affine::translate(-from.origin().to_vec2());
    xf.is_finite().then_some(xf)
}

/// The artboard fits the art that exports draw: hidden objects and layers, guides and template
/// layers don't count.
fn artboard_fit_art(s: &mut Session, p: &Value) -> Result<Value> {
    let i = p.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;
    let b = vectorcraft_render::encode::art_bounds(&s.doc()?.doc).ok_or_else(|| EngineError::Other("no artwork".into()))?;
    s.execute("artboard.setProps", &json!({"index": i, "x": b.x0, "y": b.y0, "width": b.width(), "height": b.height()}))
}

fn artboard_fit_sel(s: &mut Session, p: &Value) -> Result<Value> {
    let i = p.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;
    let st = s.doc()?;
    let b = st.doc.bounds_of(&st.selection.objects, true).ok_or_else(|| EngineError::Other("no selection bounds".into()))?;
    s.execute("artboard.setProps", &json!({"index": i, "x": b.x0, "y": b.y0, "width": b.width(), "height": b.height()}))
}