//! Semantic control shared by the GUI, headless client and web adapter.
use super::{Message, OpenCADStudio};
use crate::command::{InputKind, StepInput};
use iced::Task;
use serde_json::{json, Value};
use std::{collections::VecDeque, sync::OnceLock};
#[cfg(not(target_arch = "wasm32"))]
mod transport;
#[cfg(not(target_arch = "wasm32"))]
pub(super) use transport::subscribe;

pub(super) fn session_id() -> &'static str {
    static ID: OnceLock<String> = OnceLock::new();
    ID.get_or_init(|| {
        #[cfg(not(target_arch = "wasm32"))]
        {
            let mut bytes = [0u8; 16];
            getrandom::fill(&mut bytes).expect("OS random source");
            bytes.iter().map(|v| format!("{v:02x}")).collect()
        }
        #[cfg(target_arch = "wasm32")]
        {
            format!("web-{}", js_sys::Date::now())
        }
    })
}

#[derive(Debug, Clone)]
pub struct Envelope {
    pub request: Value,
    pub reply: Reply,
}
#[derive(Debug, Clone)]
pub enum Reply {
    Native(std::sync::mpsc::Sender<Value>),
    Web(String),
}
impl Reply {
    pub(super) fn send(self, value: Value) {
        match self {
            Self::Native(sender) => {
                let _ = sender.send(value);
            }
            Self::Web(id) => web_store(id, value),
        }
    }
}

#[cfg(not(target_arch = "wasm32"))]
fn web_store(_: String, _: Value) {}

#[cfg(target_arch = "wasm32")]
static WEB_QUEUE: std::sync::Mutex<VecDeque<(String, Value)>> =
    std::sync::Mutex::new(VecDeque::new());
#[cfg(target_arch = "wasm32")]
static WEB_RESULTS: std::sync::Mutex<VecDeque<(String, Value)>> =
    std::sync::Mutex::new(VecDeque::new());
#[cfg(target_arch = "wasm32")]
static WEB_TICKET: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);

#[cfg(target_arch = "wasm32")]
fn web_store(id: String, value: Value) {
    let mut queue = WEB_RESULTS.lock().unwrap();
    queue.push_back((id, value));
    while queue.len() > 64 {
        queue.pop_front();
    }
}

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen::prelude::wasm_bindgen]
pub fn ocs_control_submit(request: String) -> String {
    let serial = WEB_TICKET.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    let id = format!("web-{}-{serial}", js_sys::Date::now());
    let value = serde_json::from_str(&request)
        .unwrap_or_else(|error| json!({"op":"invalid","parse_error":error.to_string()}));
    let mut queue = WEB_QUEUE.lock().unwrap();
    if queue.len() >= 64 {
        drop(queue);
        web_store(id.clone(), failure("busy", "Web control queue full"));
    } else {
        queue.push_back((id.clone(), value));
    }
    id
}

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen::prelude::wasm_bindgen]
pub fn ocs_control_take(id: &str) -> Option<String> {
    let mut queue = WEB_RESULTS.lock().unwrap();
    let position = queue.iter().position(|(candidate, _)| candidate == id)?;
    Some(queue.remove(position).unwrap().1.to_string())
}

#[cfg(target_arch = "wasm32")]
pub(super) fn web_request() -> Option<Envelope> {
    let (id, request) = WEB_QUEUE.lock().unwrap().pop_front()?;
    Some(Envelope {
        request,
        reply: Reply::Web(id),
    })
}
#[derive(Default)]
pub(super) struct State {
    pending: Option<Operation>,
    completed: VecDeque<(String, Value, Value)>,
    owner: Option<(u64, String)>,
    pub enabled: bool,
    /// Set by the first control request of the session (or by a web host's
    /// boot-time opt-in): while control is enabled, startup prompts that
    /// would block automation — the donation prompt — are suppressed (#1349).
    pub automation_seen: bool,
    serial: u64,
    events: VecDeque<Value>,
    /// Monotonic counter bumped on every real selection change, so clients
    /// can detect highlight changes without polling the full selection.
    selection_revision: u64,
    pub(super) routing: bool,
    /// Session-scoped named handle sets for selection_set_save/load.
    selection_sets: std::collections::BTreeMap<String, Vec<codec::Handle>>,
    /// Live `user_select` request — the client asked the person at the screen
    /// to pick entities; Some until that person answers with Enter/Escape.
    pub(super) user_select: Option<UserSelectSession>,
    /// Live `getpoint` request — the client asked for one picked point; Some
    /// until the person clicks (answer) or presses Escape (cancel).
    pub(super) get_point: Option<UserPointSession>,
    /// `capture` request parked until the window has drawn another frame:
    /// screenshotting in the same batch as the state change used to return the
    /// previous frame (C11). Cleared by `on_control_capture_frame`.
    pub(super) capture_frame_pending: bool,
    /// Whether the parked capture actually waited for a redraw (vs. the
    /// anti-hang timer). Reported in the capture result as `waited_for_frame`.
    pub(super) capture_after_redraw: bool,
    /// Web: when a parked capture gives up. Only a presented frame can be
    /// read back on wasm, and a hidden or idle tab may never present one, so
    /// the timer tick fails the capture past this instant instead of letting
    /// it hold the control slot forever.
    #[cfg(target_arch = "wasm32")]
    pub(super) capture_deadline: Option<iced::time::Instant>,
}

/// The pending half of an interactive `user_select` operation (`interactive`
/// module owns the flow): which request it answers, which document's
/// selection to read, and the filter the answer must satisfy.
pub(super) struct UserSelectSession {
    pub(super) request_id: String,
    pub(super) document_id: u64,
    pub(super) type_filter: Option<String>,
    pub(super) layer_filter: Option<String>,
    pub(super) detail: String,
    /// The pinned command-line line shown while the person picks — the
    /// prompt plus the request identity, so the screen keeps saying who is
    /// waiting for what until they answer.
    pub(super) label: String,
}

/// The pending half of a `getpoint` operation: which request it answers and
/// which document's viewport the pick must land in.
pub(super) struct UserPointSession {
    pub(super) request_id: String,
    pub(super) document_id: u64,
    /// Same pinned line as `UserSelectSession::label`.
    pub(super) label: String,
}
impl State {
    pub(super) fn new() -> Self {
        Self {
            enabled: true,
            ..Self::default()
        }
    }
}
struct Operation {
    id: String,
    request: Value,
    pending: usize,
    error_revision: u64,
    document_id: Option<u64>,
    origin_document: u64,
    geometry_revision: u64,
    result: Value,
    /// Set when an interactive request (`getpoint`/`user_select`) was answered
    /// with a cancellation, so the final status reports "cancelled".
    cancelled: bool,
}
fn failure(code: &str, error: impl ToString) -> Value {
    json!({"ok":false,"status":"failed","code":code,"error":error.to_string()})
}
/// `{"op":"open","name":"plan.dwg","data_base64":"…"}`: the web build has no
/// filesystem path to open, so the caller sends the file itself. `name` is
/// reduced to its file name; it labels the tab and the recent-files entry.
fn open_bytes_request(req: &Value) -> Result<(String, Vec<u8>), Value> {
    use base64::Engine as _;
    let name = string(req, "name")?;
    let name = name.rsplit(['/', '\\']).next().unwrap_or(name);
    if name.is_empty() {
        return Err(failure("invalid_request", "Missing name"));
    }
    let bytes = base64::engine::general_purpose::STANDARD
        .decode(req["data_base64"].as_str().unwrap_or_default())
        .map_err(|e| failure("invalid_request", format!("data_base64: {e}")))?;
    if bytes.is_empty() {
        return Err(failure("invalid_request", "data_base64 is empty"));
    }
    Ok((name.to_string(), bytes))
}
fn string<'a>(req: &'a Value, key: &str) -> Result<&'a str, Value> {
    req[key]
        .as_str()
        .filter(|v| !v.is_empty())
        .ok_or_else(|| failure("invalid_request", format!("Missing {key}")))
}
fn handle(req: &Value) -> Result<codec::Handle, Value> {
    u64::from_str_radix(string(req, "handle")?.trim_start_matches("0x"), 16)
        .map(codec::Handle::new)
        .map_err(|_| failure("invalid_handle", "Expected hexadecimal handle"))
}
#[cfg(not(target_arch = "wasm32"))]
fn plugin_ids() -> Vec<String> {
    crate::plugin::external::with_manager(|m| m.ids())
}
#[cfg(target_arch = "wasm32")]
fn plugin_ids() -> Vec<String> {
    Vec::new()
}

fn point(req: &Value) -> Result<glam::DVec3, Value> {
    let values = req["point"]
        .as_array()
        .filter(|v| v.len() == 3)
        .ok_or_else(|| failure("invalid_point", "Expected three finite coordinates"))?;
    let mut p = [0.; 3];
    for (i, v) in values.iter().enumerate() {
        p[i] = v
            .as_f64()
            .filter(|v| v.is_finite())
            .ok_or_else(|| failure("invalid_point", "Expected finite coordinates"))?;
    }
    Ok(glam::DVec3::from_array(p))
}

fn command_examples(name: &str) -> &'static [&'static str] {
    match name {
        "LINE" => &["LINE 0,0 10,10"],
        "CIRCLE" => &["CIRCLE 5,5 3"],
        "PLINE" => &["PLINE 0,0 10,0 10,10 C"],
        "ZOOM" => &["ZOOM EXTENTS"],
        "MOVE" => &["MOVE 0,0 100,0"],
        "ROTATE" => &["ROTATE 0,0 90"],
        "UCS" => &["UCS Z 90"],
        "PDMODE" => &["PDMODE 3"],
        "LTSCALE" => &["LTSCALE 2.5"],
        _ => &[],
    }
}

fn command_category(name: &str) -> &'static str {
    if [
        "LINE", "CIRCLE", "PLINE", "ARC", "ELLIPSE", "POINT", "SPLINE", "RECT", "RECTANG",
        "POLYGON", "HATCH", "RAY", "XLINE", "3DPOLY", "MLINE", "TEXT", "MTEXT", "TABLE",
    ]
    .contains(&name)
    {
        "create"
    } else if [
        "MOVE",
        "COPY",
        "ROTATE",
        "SCALE",
        "MIRROR",
        "ERASE",
        "TRIM",
        "EXTEND",
        "OFFSET",
        "FILLET",
        "CHAMFER",
        "BREAK",
        "JOIN",
        "EXPLODE",
        "STRETCH",
        "ARRAY",
        "PEDIT",
        "SPLINEDIT",
        "REVERSE",
        "ALIGN",
    ]
    .contains(&name)
    {
        "modify"
    } else if ["DIST", "ID", "AREA", "MEASURE", "MEASUREGEOM"].contains(&name) {
        "inspect"
    } else if ["ZOOM", "PAN", "UCS", "PLAN", "VPORTS", "3DORBIT"].contains(&name) {
        "view"
    } else if name.starts_with("DIM") || ["LEADER", "MLEADER", "TOLERANCE"].contains(&name) {
        "annotate"
    } else if [
        "GEOMCONSTRAINT",
        "GCCOINCIDENT",
        "GCCOLLINEAR",
        "GCPERPENDICULAR",
        "QCONSTRAINT",
        "PCONSTRAINT",
        "GCHORIZONTAL",
        "VCONSTRAINT",
        "ECONSTRAINT",
        "GCEQUAL",
        "TCONSTRAINT",
        "GCCONCENTRIC",
        "NRCONSTRAINT",
        "LCONSTRAINT",
        "DELCONSTRAINT",
    ]
    .contains(&name)
    {
        "parametric"
    } else if [
        "BOX",
        "CYLINDER",
        "CONE",
        "SPHERE",
        "TORUS",
        "WEDGE",
        "EXTRUDE",
        "REVOLVE",
        "SWEEP",
        "LOFT",
        "UNION",
        "SUBTRACT",
        "INTERSECT",
        "PRESSPULL",
    ]
    .contains(&name)
    {
        "model"
    } else {
        "other"
    }
}

fn command_selection_policy(name: &str) -> &'static str {
    if [
        "ARRAY",
        "ARRAYPATH",
        "ARRAYPOLAR",
        "ARRAYRECT",
        "BLOCK",
        "COPY",
        "COPYCLIP",
        "CUTCLIP",
        "ERASE",
        "EXPLODE",
        "GROUP",
        "LAYFRZ",
        "LAYLCK",
        "LAYMCUR",
        "LAYOFF",
        "LAYULK",
        "MIRROR",
        "MOVE",
        "ROTATE",
        "SCALE",
        "STRETCH",
    ]
    .contains(&name)
    {
        "current_selection_or_prompt"
    } else {
        "command_defined"
    }
}

pub(super) fn active_command_metadata(command: &dyn crate::command::CadCommand) -> Value {
    let options = command.options();
    let mut accepts = Vec::new();
    if command.is_selection_gathering() {
        accepts.push("selection");
    }
    if command.needs_structure_point_pick() {
        accepts.push("structure");
    }
    if command.needs_entity_pick() {
        accepts.push("entity");
    }
    if accepts.is_empty() && !command.needs_tangent_pick() {
        let kind = match command.input_kind() {
            InputKind::Point => "point",
            InputKind::SingleToken => "token",
            InputKind::FreeText => "text",
        };
        // A point step that also takes keyword letters (MOVE/COPY's base
        // point with [Displacement]) reports SingleToken so the letters reach
        // the command line, but it still takes a point.
        if command.point_step_accepts_keywords() && kind != "point" {
            accepts.push("point");
        }
        accepts.push(kind);
    }
    if options.iter().any(|option| !option.keyword.is_empty()) && !accepts.contains(&"token") {
        accepts.push("token");
    }
    accepts.push("enter");

    let input_example = if accepts.contains(&"point") {
        json!({"op":"input","kind":"point","point":[0,0,0],"space":"wcs"})
    } else if accepts.contains(&"entity") {
        json!({"op":"input","kind":"entity","handle":"HANDLE","point":[0,0,0]})
    } else if accepts.contains(&"structure") {
        json!({"op":"input","kind":"structure","handle":"HANDLE","point":[0,0,0]})
    } else if accepts.contains(&"selection") {
        json!({"op":"input","kind":"selection"})
    } else if accepts.contains(&"text") {
        json!({"op":"input","kind":"text","text":"value"})
    } else if accepts.contains(&"token") {
        let token = options
            .iter()
            .find(|option| !option.keyword.is_empty())
            .map_or("VALUE", |option| option.keyword.as_str());
        json!({"op":"input","kind":"token","text":token})
    } else {
        json!({"op":"input","kind":"enter"})
    };

    json!({
        "name":command.name(),
        "prompt":command.prompt(),
        "accepts":accepts,
        "input_example":input_example,
        "options":options.iter().map(|option| json!({
            "label":option.label,
            "keyword":option.keyword,
            "kind":if option.keyword.is_empty(){"enter"}else{"token"}
        })).collect::<Vec<_>>(),
        "entity_pick":command.needs_entity_pick(),
        "structure_pick":command.needs_structure_point_pick(),
        "selection":command.is_selection_gathering(),
        "tangent_pick":command.needs_tangent_pick(),
        "free_text":command.is_free_text_step()
    })
}

impl OpenCADStudio {
    pub(super) fn control_busy(&self) -> bool {
        self.control.pending.is_some()
    }

    /// Mirror a real selection change into the automation event stream. The
    /// plugin host already publishes the V4 selection event; automation clients
    /// need the same signal instead of polling `state`.
    #[cfg(not(target_arch = "wasm32"))]
    pub(super) fn control_record_selection_event(&mut self, handles: &[codec::Handle]) {
        let (document_id, revision) = {
            let tab = &self.tabs[self.active_tab];
            (tab.id, tab.edit_revision)
        };
        let selection: Vec<String> = handles
            .iter()
            .map(|handle| format!("{:X}", handle.value()))
            .collect();
        self.control.selection_revision = self.control.selection_revision.wrapping_add(1);
        let selection_revision = self.control.selection_revision;
        self.control.serial += 1;
        self.control.events.push_back(json!({
            "sequence": self.control.serial,
            "kind": "selection",
            "document_id": document_id,
            "revision": revision,
            "selection_revision": selection_revision,
            "selection": selection,
        }));
        while self.control.events.len() > 128 {
            self.control.events.pop_front();
        }
    }

    pub(super) fn control_state(&self) -> Value {
        let tab = &self.tabs[self.active_tab];
        let command = tab.active_cmd.as_deref().map(active_command_metadata);
        let missing_fonts = crate::io::font_repo::missing_shx_fonts(&tab.scene.document);
        json!({"ok":true,"protocol":1,"session_id":session_id(),"version":env!("OCS_APP_VERSION"),
            "mode":if self.main_window.is_some(){"gui"}else{"headless"},"enabled":self.control.enabled,
            "read_only":self.read_only,"missing_fonts":missing_fonts,
            "document_id":tab.id,"revision":tab.edit_revision,"geometry_revision":tab.scene.geometry_epoch,"camera_revision":tab.scene.camera_generation,
            "hand_seed":format!("{:X}",tab.scene.document.header.handle_seed.max(tab.scene.document.next_handle())),
            "plugins":plugin_ids(),
            "documents":self.tabs.iter().map(|t|json!({"id":t.id,"title":t.tab_title,"path":t.current_path,"dirty":t.dirty,"revision":t.edit_revision,"start":t.is_start})).collect::<Vec<_>>(),
            "selection":tab.scene.selected_handles_in_order().iter().map(|h|format!("{:X}",h.value())).collect::<Vec<_>>(),
            "selection_revision":self.control.selection_revision,
            "command":command,"modal":self.active_modal.as_ref().map(|m|format!("{m:?}")),
            "layout":tab.scene.current_layout,
            "ucs":tab.active_ucs.as_ref().map(|u|json!({"name":u.name,"origin":[u.origin.x,u.origin.y,u.origin.z],"x_axis":[u.x_axis.x,u.x_axis.y,u.x_axis.z],"y_axis":[u.y_axis.x,u.y_axis.y,u.y_axis.z],"elevation":u.elevation})),
            "cursor":{"world":tab.last_cursor_world.to_array(),"screen":[tab.last_cursor_screen.x,tab.last_cursor_screen.y]},
            "viewport_size":({let s=tab.scene.selection.borrow();[s.view.vp_size.0,s.view.vp_size.1]}),
            "camera":({let c=tab.scene.camera.borrow();json!({"target":c.target.to_array(),"rotation":[c.rotation.x,c.rotation.y,c.rotation.z,c.rotation.w],"distance":c.distance,"fov_y":c.fov_y,"projection":format!("{:?}",c.projection),"yaw":c.yaw,"pitch":c.pitch})}),
            "mtext_editor":self.mtext_editor.as_ref().map(|e|json!({"text":e.content.text(),"height":e.height,"style":e.style})),
            "text_editor":self.text_inline.is_some(),"event_cursor":self.control.serial,
            "operation":self.control.pending.as_ref().map(|p| &p.id),
            "capabilities":["commands","command_manifest","step_input","batch","compact_results","entity_pick","structure_pick","selection","user_select","properties","records","record_schemas","record_filters","atomic_record_updates","layers","history","documents","events","capture","viewport_capture","measure","spatial_query","audit","verified_save","explicit_save_version"]
        })
    }

    pub(super) fn control_request(&mut self, req: Value) -> (Value, Task<Message>) {
        // First control contact marks the session automated (#1349): a
        // DonationPrompt that is still queued (not yet shown) is dropped so
        // automation never waits behind it, and `queue_startup_prompts`
        // stops queueing one. A prompt already on screen stays — a human
        // may be reading it; clients close it with `close_modal`.
        if !self.control.automation_seen && self.control.enabled {
            self.control.automation_seen = true;
            if self.active_modal != Some(super::ModalKind::DonationPrompt) {
                self.pending_startup_modals
                    .retain(|kind| kind != &super::ModalKind::DonationPrompt);
            }
        }
        let op = req["op"].as_str().unwrap_or("");
        let query = matches!(
            op,
            "state"
                | "hello"
                | "operation"
                | "events"
                | "commands"
                | "properties"
                | "measure"
                | "snap"
                | "grips"
                | "query"
                | "records"
                | "record_schema"
                | "capabilities"
                | "tools"
                | "entities"
                | "layers"
                | "header"
                | "history"
                | "xdata_get"
                | "get_selection"
                | "audit"
                | "text_search"
                | "text_audit"
        );
        if !query && !self.control.enabled {
            return (
                failure("disabled", "Automation is stopped. Enable it in OCS."),
                Task::none(),
            );
        }
        if req["protocol"].as_u64().is_some_and(|v| v != 1) {
            return (
                failure("protocol_mismatch", "Protocol 1 required"),
                Task::none(),
            );
        }
        if req["session_id"]
            .as_str()
            .is_some_and(|v| v != session_id())
        {
            return (
                failure(
                    "session_changed",
                    "Reconnect; do not replay mutations in a new session",
                ),
                Task::none(),
            );
        }
        if op == "hello" || op == "state" {
            return (self.control_state(), Task::none());
        }
        if op == "operation" {
            let id = req["request_id"].as_str().unwrap_or("");
            let response = if let Some(p) = self.control.pending.as_ref().filter(|p| p.id == id) {
                json!({"ok":true,"status":"running","request_id":p.id})
            } else {
                self.control
                    .completed
                    .iter()
                    .find(|(i, _, _)| i == id)
                    .map(|(_, _, r)| r.clone())
                    .unwrap_or_else(|| {
                        failure(
                            "unknown_operation",
                            "Operation absent or expired; do not automatically replay",
                        )
                    })
            };
            return (response, Task::none());
        }
        if op == "events" {
            let cursor = req["after"].as_u64().unwrap_or(0);
            return (
                json!({"ok":true,"cursor":self.control.serial,"resync":self.control.events.front().is_some_and(|e|cursor+1<e["sequence"].as_u64().unwrap_or(0)),"events":self.control.events.iter().filter(|e|e["sequence"].as_u64().unwrap_or(0)>cursor).collect::<Vec<_>>()}),
                Task::none(),
            );
        }
        #[cfg(not(target_arch = "wasm32"))]
        if op == "tools" {
            return (
                json!({
                    "ok": true,
                    "status": "completed",
                    "tools": crate::mcp::tool_definitions(),
                    "instructions": crate::mcp::INSTRUCTIONS
                }),
                Task::none(),
            );
        }
        if op == "commands" {
            let mut names = crate::command::all_registered_command_names();
            let mut names: Vec<String> = names.drain(..).map(str::to_owned).collect();
            names.extend(self.command_line.dynamic_commands.iter().cloned());
            names.sort_unstable();
            names.dedup();
            if let Some(requested) = req["name"].as_str() {
                let Some(name) = names
                    .iter()
                    .find(|name| name.eq_ignore_ascii_case(requested))
                else {
                    return (
                        failure(
                            "unknown_command",
                            format!(
                                "Unknown command {requested}; call commands without name to list commands"
                            ),
                        ),
                        Task::none(),
                    );
                };
                return (
                    json!({
                        "ok":true,
                        "command":{
                            "name":name,
                            "category":command_category(name),
                            "preconditions":{
                                "document":true,
                                "selection":command_selection_policy(name)
                            },
                            "batch":{
                                "op":"run",
                                "syntax":"Command name followed by prompt answers separated by spaces. Points use x,y or x,y,z; options use their token.",
                                "examples":command_examples(name)
                            },
                            "interactive":{
                                "op":"start",
                                "request":{"op":"start","cmd":name},
                                "next":"Follow state.command.accepts, options and input_example after every step."
                            },
                            "completion":"completed is final; waiting_input requires another input step; failed includes the reason."
                        }
                    }),
                    Task::none(),
                );
            }
            if let Some(search) = req["search"].as_str().filter(|search| !search.is_empty()) {
                let search = search.to_ascii_uppercase();
                names.retain(|name| name.contains(&search));
            }
            let count = names.len();
            let offset = req["offset"].as_u64().unwrap_or(0) as usize;
            let limit = req["limit"].as_u64().unwrap_or(200).min(1000) as usize;
            let commands: Vec<String> = names.into_iter().skip(offset).take(limit).collect();
            return (
                json!({
                    "ok":true,"count":count,"returned":commands.len(),
                    "next_offset":(offset + commands.len() < count).then_some(offset + commands.len()),
                    "commands":commands,"actions":actions::NAMES,
                    "detail_parameters":{"name":"LINE"},"search_parameter":{"search":"LINE"},
                    "guidance":"Request one command by name for batch examples and interactive input guidance."
                }),
                Task::none(),
            );
        }
        let id = if query {
            String::new()
        } else {
            let id = match string(&req, "request_id") {
                Ok(v) if v.len() <= 128 => v.to_owned(),
                _ => {
                    return (
                        failure(
                            "request_id_required",
                            "Supply a unique request_id (maximum 128 bytes)",
                        ),
                        Task::none(),
                    );
                }
            };
            if let Some((_, old, result)) = self.control.completed.iter().find(|(i, _, _)| i == &id)
            {
                return (
                    if old == &req {
                        result.clone()
                    } else {
                        failure(
                            "request_id_reused",
                            format!(
                                "Request payload changed for request_id '{id}'; generate a new unique request_id or resend the original payload",
                            ),
                        )
                    },
                    Task::none(),
                );
            }
            if let Some(p) = &self.control.pending {
                // `cancel` is a reference to the pending request, not a
                // replay of its payload. It must reach the interactive cancel
                // branch below even when it uses the same request_id.
                if p.id == id && op != "cancel" {
                    return (
                        if p.request == req {
                            json!({"ok":true,"status":"running","request_id":id})
                        } else {
                            failure(
                                "request_id_reused",
                                format!(
                                    "Request payload changed for request_id '{id}'; generate a new unique request_id or resend the original payload",
                                ),
                            )
                        },
                        Task::none(),
                    );
                }
                // An interactive request (`user_select`/`getpoint`) outlives
                // normal request handling — it only ends when the person
                // answers. Let a client retract it with `cancel` instead of
                // waiting for their Escape.
                let pending_op = p.request["op"].as_str().unwrap_or("").to_owned();
                let pending_id = p.id.clone();
                if op == "cancel" && matches!(pending_op.as_str(), "user_select" | "getpoint") {
                    if pending_op == "getpoint" {
                        self.resolve_get_point(None);
                    } else {
                        self.resolve_user_select(false);
                    }
                    let response = self
                        .control
                        .completed
                        .iter()
                        .find(|(i, _, _)| *i == pending_id)
                        .map(|(_, _, r)| r.clone());
                    return (
                        response
                            .unwrap_or_else(|| failure("busy", "Wait for the running operation")),
                        Task::none(),
                    );
                }
                return (
                    failure("busy", "Wait for the running operation"),
                    Task::none(),
                );
            }
            id
        };
        if let Some(id) = req["document_id"].as_u64() {
            if !self.tabs.iter().any(|t| t.id == id) {
                return (
                    failure("document_closed", "Document no longer exists"),
                    Task::none(),
                );
            }
            if self.tabs[self.active_tab].id != id
                && !matches!(
                    op,
                    "activate" | "switch_document" | "close" | "entities_copy_to"
                )
            {
                return (
                    failure(
                        "document_not_active",
                        "Activate the requested document first",
                    ),
                    Task::none(),
                );
            }
        // Interactive requests operate on the active tab by definition, so
        // a client may omit document_id (the GUI-hosted REST channel does).
        } else if !query && !matches!(op, "new" | "open" | "stop" | "user_select" | "getpoint") {
            return (
                failure("document_required", "Read state and supply document_id"),
                Task::none(),
            );
        }
        let tab = &self.tabs[self.active_tab];
        if req["revision"]
            .as_u64()
            .is_some_and(|v| v != tab.edit_revision)
            || req["geometry_revision"]
                .as_u64()
                .is_some_and(|v| v != tab.scene.geometry_epoch)
            || req["camera_revision"]
                .as_u64()
                .is_some_and(|v| v != tab.scene.camera_generation)
        {
            return (
                json!({"ok":false,"status":"failed","code":"stale_state","error":"Refresh state before editing","state":self.control_state()}),
                Task::none(),
            );
        }
        if query {
            let response = match op {
                "properties" => self.control_properties(),
                "measure" => self.control_measure(&req),
                // The object snap a cursor over `point` (world) would get;
                // `from` is the base for perpendicular and tangent.
                "snap" => 'snap: {
                    let p = &req["point"];
                    let (Some(x), Some(y)) = (p[0].as_f64(), p[1].as_f64()) else {
                        break 'snap failure("invalid_point", "point must be [x, y] or [x, y, z]");
                    };
                    let world = glam::DVec3::new(x, y, p[2].as_f64().unwrap_or(0.0));
                    let from = req["from"].as_array().map(|f| {
                        glam::DVec3::new(
                            f.first().and_then(|v| v.as_f64()).unwrap_or(0.0),
                            f.get(1).and_then(|v| v.as_f64()).unwrap_or(0.0),
                            f.get(2).and_then(|v| v.as_f64()).unwrap_or(0.0),
                        )
                    });
                    let i = self.active_tab;
                    match self.snap_query(i, world, from) {
                        Some(hit) => {
                            json!({"ok":true,"snap":format!("{:?}", hit.snap_type),"world":[hit.world.x,hit.world.y,hit.world.z]})
                        }
                        None => json!({"ok":true,"snap":null}),
                    }
                }
                "grips" => self.control_grips(),
                "xdata_get" => self.xdata_read(&req),
                "get_selection" => self.control_get_selection(),
                "text_search" => self.control_text_search(&req).unwrap_or_else(|e| e),
                "text_audit" => self.control_text_audit(&req).unwrap_or_else(|e| e),
                "history" => {
                    json!({"ok":true,"entries":self.command_line.history.iter().map(|e|json!({"kind":format!("{:?}",e.kind),"text":e.text})).collect::<Vec<_>>()})
                }
                _ => self.automation_op_inner(&req.to_string()),
            };
            return (response, Task::none());
        }
        let client = req["client_id"].as_str().unwrap_or("default").to_owned();
        if tab.active_cmd.is_some()
            && (self.control.owner.as_ref() != Some(&(tab.id, client.clone()))
                || matches!(
                    op,
                    "run" | "start" | "new" | "open" | "activate" | "switch_document"
                ))
            && op != "cancel"
        {
            return (
                failure("command_busy", "An interactive command is already active"),
                Task::none(),
            );
        }
        if matches!(op, "run" | "start" | "input") && tab.is_start {
            return (
                failure("no_document", "Create or open a drawing first"),
                Task::none(),
            );
        }
        if let Some(expected) = req["selection"].as_array() {
            let actual: Vec<Value> = tab
                .scene
                .selected_handles_in_order()
                .iter()
                .map(|h| json!(format!("{:X}", h.value())))
                .collect();
            if &actual != expected {
                return (
                    failure(
                        "selection_changed",
                        "Read state and confirm the current selection",
                    ),
                    Task::none(),
                );
            }
        }
        let doc = if matches!(op, "new" | "open" | "activate" | "switch_document") {
            None
        } else {
            Some(tab.id)
        };
        self.control.pending = Some(Operation {
            id: id.clone(),
            request: req.clone(),
            pending: 1,
            error_revision: self.command_line.error_revision,
            document_id: doc,
            origin_document: tab.id,
            geometry_revision: tab.scene.geometry_epoch,
            result: json!({}),
            cancelled: false,
        });
        self.control.routing = true;
        let action = self.control_action(&req);
        self.control.routing = false;
        let task = match action {
            Ok(t) => t,
            Err(error) => {
                self.control.pending.take();
                return (error, Task::none());
            }
        };
        if self.tabs[self.active_tab].active_cmd.is_some() {
            self.control.owner = Some((self.tabs[self.active_tab].id, client));
        }
        if matches!(op, "new" | "activate" | "switch_document")
            && self
                .control
                .pending
                .as_ref()
                .is_some_and(|pending| pending.origin_document != self.tabs[self.active_tab].id)
        {
            if let Some(pending) = self.control.pending.as_mut() {
                pending.document_id = Some(self.tabs[self.active_tab].id);
            }
        }
        self.finish_all_pending_history();
        let task = self.control_track(task);
        if let Some(p) = self.control.pending.as_mut() {
            // Interactive requests hold their slot open on purpose: the
            // counter stays at one so settle keeps returning `running` until
            // the person at the screen answers and the resolver zeroes it.
            // `capture` is parked the same way until the next drawn frame.
            if !matches!(
                p.request["op"].as_str(),
                Some("user_select" | "getpoint" | "capture")
            ) {
                p.pending -= 1;
            }
        }
        self.control_settle();
        let response = self
            .control
            .completed
            .iter()
            .find(|(i, _, _)| i == &id)
            .map(|(_, _, r)| r.clone())
            .unwrap_or_else(|| json!({"ok":true,"status":"accepted","request_id":id}));
        (response, task)
    }

    fn control_action(&mut self, req: &Value) -> Result<Task<Message>, Value> {
        let i = self.active_tab;
        Ok(match req["op"].as_str().unwrap_or("") {
            "new" => {
                if let Some(template) = req["template"].as_str() {
                    match self.apply_template(template) {
                        Ok(purged) => {
                            self.set_control_result(json!({
                                "template": template,
                                "purged": purged,
                                "total": self.tabs[i].scene.document.entities().count(),
                            }));
                            Task::none()
                        }
                        Err(error) => return Err(error),
                    }
                } else {
                    self.update(Message::TabNew)
                }
            }
            "open" if req.get("data_base64").is_some() => {
                let (name, bytes) = open_bytes_request(req)?;
                #[cfg(target_arch = "wasm32")]
                {
                    if self.opening.is_some() {
                        return Err(failure("busy", "Another drawing is still opening"));
                    }
                    self.open_web_bytes(name, bytes)
                }
                #[cfg(not(target_arch = "wasm32"))]
                {
                    let _ = (name, bytes);
                    return Err(failure(
                        "invalid_request",
                        "data_base64 is for the web build; supply path",
                    ));
                }
            }
            "open" => self.update(Message::OpenExternal(std::path::PathBuf::from(string(
                req, "path",
            )?))),
            "activate" | "switch_document" => {
                let i = self
                    .tabs
                    .iter()
                    .position(|t| Some(t.id) == req["document_id"].as_u64())
                    .ok_or_else(|| failure("document_closed", "Document absent"))?;
                self.update(Message::TabSwitch(i))
            }
            "run" => self.run_command_line(string(req, "cmd")?),
            "start" => self.dispatch_command(string(req, "cmd")?),
            "input" => {
                if self.tabs[i].active_cmd.is_none() {
                    return Err(failure("no_command", "No command waiting for input"));
                }
                match string(req, "kind")? {
                    "text" => self
                        .feed_command(StepInput::Text(req["text"].as_str().unwrap_or("").into())),
                    "token" => self.feed_active_cmd(string(req, "text")?),
                    "point" => {
                        let mut p = point(req)?;
                        match req["space"].as_str().unwrap_or("wcs") {
                            "wcs" => {}
                            "ucs" => {
                                if let Some(u) = &self.tabs[i].active_ucs {
                                    p = super::helpers::ucs_to_wcs(p, u);
                                }
                            }
                            "relative" => {
                                let base = self.last_point.ok_or_else(|| {
                                    failure(
                                        "no_base_point",
                                        "Relative input needs a previous point",
                                    )
                                })?;
                                if let Some(u) = &self.tabs[i].active_ucs {
                                    p = super::helpers::ucs_rotate_vec(p, u);
                                }
                                p += base;
                            }
                            _ => return Err(failure("invalid_space", "Use wcs, ucs or relative")),
                        };
                        self.feed_command(StepInput::Point(p))
                    }
                    "entity" | "structure" => {
                        let h = handle(req)?;
                        if self.tabs[i].scene.document.get_entity(h).is_none() {
                            return Err(failure("entity_absent", "Unknown entity"));
                        }
                        let p = point(req)?;
                        self.feed_command(if req["kind"] == "structure" {
                            StepInput::StructurePick(h, p)
                        } else {
                            StepInput::EntityPick(h, p)
                        })
                    }
                    "selection" => {
                        let hs = self.tabs[i].scene.selected_handles_in_order();
                        self.feed_command(StepInput::SelectionComplete(hs))
                    }
                    "enter" => self.feed_command(StepInput::Enter),
                    _ => return Err(failure("invalid_input", "Unknown input kind")),
                }
            }
            "cancel" => self.update(Message::CommandEscape),
            "undo" => self.update(Message::Undo),
            "redo" => self.update(Message::Redo),
            "select" => {
                if let Some(hs) = req["handles"].as_array() {
                    for v in hs {
                        let h = u64::from_str_radix(
                            v.as_str().unwrap_or("").trim_start_matches("0x"),
                            16,
                        )
                        .map(codec::Handle::new)
                        .map_err(|_| failure("invalid_handle", "Expected hexadecimal handle"))?;
                        if self.tabs[i].scene.document.get_entity(h).is_none() {
                            return Err(failure(
                                "entity_absent",
                                format!("Entity {} does not exist", v),
                            ));
                        }
                    }
                }
                let result = self.automation_op_inner(&req.to_string());
                if result["ok"] != true {
                    return Err(result);
                }
                self.refresh_properties();
                Task::none()
            }
            "property" => self.control_set_property(req)?,
            "grip_drag" => self.control_grip_drag(req)?,
            "click" => self.control_click(req)?,
            "set_properties" => self.control_set_record_properties(req)?,
            "action" => self.control_ui_action(req)?,
            #[cfg(not(target_arch = "wasm32"))]
            "embed_image" => self.control_embed_image(req)?,
            #[cfg(not(target_arch = "wasm32"))]
            "wblock" => self.control_wblock(req)?,
            #[cfg(not(target_arch = "wasm32"))]
            "plot" => self.control_plot(req)?,
            "entities_create" => self.control_entities_create(req)?,
            "entities_delete" => self.control_entities_delete(req)?,
            "entities_transform" => self.control_entities_transform(req)?,
            "entities_copy_to" => self.control_entities_copy_to(req)?,
            "text_replace" => self.control_text_replace(req)?,
            "xdata_set" => self.control_xdata_set(req)?,
            "block_define" => self.control_block_define(req)?,
            "block_delete" => self.control_block_delete(req)?,
            "group_create" => self.control_group_create(req)?,
            "selection_set_save" => self.control_selection_set_save(req)?,
            "selection_set_load" => self.control_selection_set_load(req)?,
            "user_select" => self.control_user_select(req)?,
            "getpoint" => self.control_getpoint(req)?,
            "close" => self.control_close(req)?,
            "sysvar" => self.control_sysvar(req)?,
            "layout_create" => self.control_layout_create(req)?,
            "page_setup_set" => self.control_page_setup_set(req)?,
            "file_identity" => self.control_file_identity(req)?,
            #[cfg(not(target_arch = "wasm32"))]
            "view_focus" => self.control_view_focus(req)?,
            #[cfg(not(target_arch = "wasm32"))]
            "save" => {
                let path = req["path"]
                    .as_str()
                    .map(std::path::PathBuf::from)
                    .or_else(|| self.tabs[i].current_path.clone())
                    .ok_or_else(|| failure("path_required", "Supply a save path"))?;
                let default_is_dxf = crate::io::source_is_dxf(
                    self.tabs[i].current_path.as_deref(),
                    &self.tabs[i].scene.document,
                );
                let (version, is_dxf) = super::automation::requested_save_target(
                    req,
                    self.tabs[i].scene.document.version,
                    default_is_dxf,
                    Some(&path),
                )
                .map_err(|error| failure("invalid_target", error))?;
                let dropped =
                    crate::io::dropped_on_save_count(&self.tabs[i].scene.document, version, is_dxf);
                if dropped > 0 && req["allow_lossy"].as_bool() != Some(true) {
                    return Err(failure(
                        "lossy_conversion_not_acknowledged",
                        format!(
                            "Conversion would drop {dropped} unsupported record(s); set allow_lossy=true to acknowledge"
                        ),
                    ));
                }
                self.set_control_result(json!({
                    "saved":path,"target_format":if is_dxf { "dxf" } else { "dwg" },
                    "target_version":format!("{version:?}"),"dropped_on_save":dropped,
                }));
                if self.main_window.is_none() {
                    self.save_tab_synchronously_protected_as(i, path, version, true)
                        .map_err(|e| failure("save_failed", e))?;
                    Task::none()
                } else {
                    self.prepare_native_save(i);
                    self.queue_native_save(
                        i,
                        path,
                        version,
                        super::SavePurpose::SaveAs,
                        super::SaveContinuation::None,
                        true,
                        true,
                    )
                }
            }
            // Web: no filesystem path; the drawing comes back in the reply.
            #[cfg(target_arch = "wasm32")]
            "save" => {
                use base64::Engine as _;
                let default_is_dxf = crate::io::source_is_dxf(None, &self.tabs[i].scene.document);
                let (version, is_dxf) = super::automation::requested_save_target(
                    req,
                    self.tabs[i].scene.document.version,
                    default_is_dxf,
                    None,
                )
                .map_err(|error| failure("invalid_target", error))?;
                let dropped =
                    crate::io::dropped_on_save_count(&self.tabs[i].scene.document, version, is_dxf);
                if dropped > 0 && req["allow_lossy"].as_bool() != Some(true) {
                    return Err(failure(
                        "lossy_conversion_not_acknowledged",
                        format!(
                            "Conversion would drop {dropped} unsupported record(s); set allow_lossy=true to acknowledge"
                        ),
                    ));
                }
                let ext = if is_dxf { "dxf" } else { "dwg" };
                self.sync_view_state_for_save(i);
                super::update::util::sync_annotation_scale_header(&mut self.tabs[i].scene);
                self.stamp_header_sysvars(i);
                self.sync_solid_models_for_save(i);
                self.tabs[i].scene.sync_native_parametric_graph();
                let bytes = crate::io::save_to_bytes(&self.tabs[i].scene.document, ext, version)
                    .map_err(|error| failure("save_failed", error))?;
                self.tabs[i].dirty = false;
                let name = req["name"].as_str().filter(|name| !name.is_empty());
                let name = name.map_or_else(|| format!("drawing.{ext}"), str::to_string);
                self.set_control_result(json!({
                    "name": name,
                    "target_format": ext,
                    "target_version": format!("{version:?}"),
                    "dropped_on_save": dropped,
                    "bytes": bytes.len(),
                    "data_base64": base64::engine::general_purpose::STANDARD.encode(&bytes),
                }));
                Task::none()
            }
            #[cfg(not(target_arch = "wasm32"))]
            "save_verified" => {
                let result = self.save_verified_request(req)?;
                self.set_control_result(result);
                Task::none()
            }
            "capture" => {
                self.main_window
                    .ok_or_else(|| failure("gui_required", "Capture requires a GUI window"))?;
                string(req, "path")?;
                let was_minimized = crate::sys::restore_window_if_minimized();
                if was_minimized {
                    std::thread::sleep(std::time::Duration::from_millis(60));
                }

                // Optional framing / selection adjustments prior to snapshot:
                if let Some(handles) = req.get("highlight_handles").and_then(Value::as_array) {
                    let hex_handles: Vec<codec::Handle> = handles
                        .iter()
                        .filter_map(|v| v.as_str())
                        .filter_map(|v| u64::from_str_radix(v.trim_start_matches("0x"), 16).ok())
                        .map(codec::Handle::new)
                        .collect();
                    if !hex_handles.is_empty() {
                        let scene = &mut self.tabs[self.active_tab].scene;
                        scene.deselect_all();
                        for h in hex_handles {
                            scene.select_entity(h, false);
                        }
                    }
                }
                if let Some(focus) = req.get("focus_handles").and_then(Value::as_array) {
                    let hex_handles: Vec<codec::Handle> = focus
                        .iter()
                        .filter_map(|v| v.as_str())
                        .filter_map(|v| u64::from_str_radix(v.trim_start_matches("0x"), 16).ok())
                        .map(codec::Handle::new)
                        .collect();
                    if !hex_handles.is_empty() {
                        self.tabs[self.active_tab]
                            .scene
                            .zoom_to_entities(&hex_handles);
                    }
                } else if let Some(bounds) = req.get("bounds").and_then(Value::as_array) {
                    if bounds.len() >= 4 {
                        if let (Some(x0), Some(y0), Some(x1), Some(y1)) = (
                            bounds[0].as_f64(),
                            bounds[1].as_f64(),
                            bounds[2].as_f64(),
                            bounds[3].as_f64(),
                        ) {
                            let p1 = glam::Vec3::new(x0 as f32, y0 as f32, 0.0);
                            let p2 = glam::Vec3::new(x1 as f32, y1 as f32, 0.0);
                            self.tabs[self.active_tab].scene.zoom_to_window(p1, p2);
                        }
                    }
                } else if let Some(view) = req.get("view").and_then(Value::as_str) {
                    if view == "extents" {
                        self.tabs[self.active_tab].scene.fit_all();
                    } else if view == "selection" {
                        let selected = self.tabs[self.active_tab].scene.selected_handles_in_order();
                        if !selected.is_empty() {
                            self.tabs[self.active_tab].scene.zoom_to_entities(&selected);
                        }
                    }
                }

                // C11: do not capture in the same batch. Park until the next
                // rendered frame (or the timer fallback) so geometry changes are
                // visible rather than returning a stale frame.
                self.control.capture_frame_pending = true;
                #[cfg(target_arch = "wasm32")]
                {
                    self.control.capture_deadline =
                        Some(iced::time::Instant::now() + std::time::Duration::from_secs(5));
                }
                Task::none()
            }
            "stop" => {
                self.control.enabled = false;
                Task::none()
            }
            _ => return Err(failure("unknown_operation", "Unknown operation")),
        })
    }

    pub(super) fn set_control_result(&mut self, value: Value) {
        if let Some(operation) = self.control.pending.as_mut() {
            operation.result = value;
        }
    }

    pub(super) fn control_track(&mut self, task: Task<Message>) -> Task<Message> {
        let track_zero_unit = self.control.pending.as_ref().is_some_and(|p| {
            p.request["op"] == "run"
                && p.request["cmd"]
                    .as_str()
                    .is_some_and(|cmd| {
                        matches!(
                            cmd.trim().to_ascii_uppercase().as_str(),
                            "SAVE" | "QSAVE"
                        )
                    })
        });
        // Most zero-unit tasks are `Task::none()` and have already completed
        // synchronously. SAVE/QSAVE are the deliberate exception: the command
        // dispatcher returns a zero-unit Task::done(Message::SaveFile), and
        // the operation must wait for that message before reporting its state.
        if task.units() == 0 && !track_zero_unit {
            return task;
        }
        let Some(p) = self.control.pending.as_mut() else {
            return task;
        };
        p.pending += 1;
        let id = p.id.clone();
        let end = id.clone();
        task.map(move |m| Message::ControlStep(id.clone(), Box::new(m)))
            .chain(Task::done(Message::ControlTaskDone(end)))
    }
    pub(super) fn control_step(&mut self, id: String, msg: Message) -> Task<Message> {
        if !self.control.pending.as_ref().is_some_and(|p| p.id == id) {
            return Task::none();
        }
        let previous = self.active_tab;
        let target = self.control.pending.as_ref().and_then(|p| p.document_id);
        if let Some(doc) = target {
            let Some(i) = self.tabs.iter().position(|t| t.id == doc) else {
                self.command_line
                    .push_error(crate::t!("Automation target document closed").as_ref());
                return Task::none();
            };
            self.active_tab = i;
        }
        self.control.routing = true;
        let task = self.update(msg);
        self.control.routing = false;
        if let Some(pending) = self.control.pending.as_mut() {
            if pending.document_id.is_none()
                && matches!(
                    pending.request["op"].as_str(),
                    Some("new" | "open" | "activate" | "switch_document")
                )
                && pending.origin_document != self.tabs[self.active_tab].id
            {
                pending.document_id = Some(self.tabs[self.active_tab].id);
            }
        }
        if target.is_some() && previous < self.tabs.len() {
            self.active_tab = previous;
        }
        self.control_track(task)
    }
    pub(super) fn control_task_done(&mut self, id: &str) {
        if let Some(p) = self.control.pending.as_mut().filter(|p| p.id == id) {
            p.pending = p.pending.saturating_sub(1);
        }
        self.control_settle();
    }
    pub(super) fn control_observe_user_message(&mut self, message: &Message) {
        if self.control.routing || self.control.owner.is_none() {
            return;
        }
        if matches!(
            message,
            Message::CommandSubmit
                | Message::CommandFinalize
                | Message::CommandOptionPick(_)
                | Message::CommandEscape
                | Message::ViewportLeftPress
                | Message::ViewportLeftRelease
                | Message::PanePress(_)
                | Message::PaneRelease(_)
                | Message::ShortcutPressed(_)
                | Message::MTextOk
                | Message::MTextCancel
                | Message::TextInlineOk
        ) {
            self.control.owner = None;
        }
    }
    pub(super) fn control_settle(&mut self) {
        if self.control.pending.as_ref().is_none_or(|p| p.pending != 0) || self.opening.is_some() {
            return;
        }
        #[cfg(not(target_arch = "wasm32"))]
        if !self.active_save_jobs.is_empty() || self.pending_native_thumbnail_save.is_some() {
            return;
        }
        let p = self.control.pending.take().unwrap();
        let previous = self.active_tab;
        if let Some(index) = p
            .document_id
            .and_then(|id| self.tabs.iter().position(|tab| tab.id == id))
        {
            self.active_tab = index;
        }
        let failed = self.command_line.error_revision != p.error_revision;
        let waiting = self.tabs[self.active_tab].active_cmd.is_some()
            || self.active_modal.is_some()
            || self.mtext_editor.is_some()
            || self.text_inline.is_some();
        if !waiting {
            self.control.owner = None;
        }
        let status = if failed {
            "failed"
        } else if p.cancelled || p.request["op"] == "cancel" {
            "cancelled"
        } else if waiting {
            "waiting_input"
        } else {
            "completed"
        };
        let changes = self.tabs[self.active_tab].scene.replay_since(p.geometry_revision)
            .map(|values| values.into_iter().take(1000).map(|(handle,kind)|json!({"handle":format!("{:X}",handle.value()),"kind":format!("{kind:?}")})).collect::<Vec<_>>());
        let response = json!({"ok":!failed,"status":status,"request_id":p.id,"error":if failed{self.command_line.last_error.clone()}else{None},"result":p.result,"changes":changes,"state":self.control_state()});
        self.control.serial += 1;
        self.control.events.push_back(json!({"sequence":self.control.serial,"request_id":p.id,"status":status,"document_id":self.tabs[self.active_tab].id,"revision":self.tabs[self.active_tab].edit_revision}));
        while self.control.events.len() > 128 {
            self.control.events.pop_front();
        }
        self.control
            .completed
            .push_back((p.id, p.request, response));
        while self.control.completed.len() > 128 {
            self.control.completed.pop_front();
        }
        if previous < self.tabs.len() {
            self.active_tab = previous;
        }
    }
    pub(super) fn control_measure(&self, req: &Value) -> Value {
        let tab = &self.tabs[self.active_tab];
        let requested: Vec<codec::Handle> = req["handles"]
            .as_array()
            .map(|a| {
                a.iter()
                    .filter_map(|v| v.as_str())
                    .filter_map(|v| u64::from_str_radix(v.trim_start_matches("0x"), 16).ok())
                    .map(codec::Handle::new)
                    .collect()
            })
            .unwrap_or_else(|| tab.scene.selected_handles_in_order());
        let mut out = Vec::new();
        for handle in requested {
            let Some(entity) = tab.scene.document.get_entity(handle) else {
                continue;
            };
            let (min, max) =
                crate::scene::convert::tess::entity_bounds_in(&tab.scene.document, entity);
            let metrics = tab
                .scene
                .meshes
                .get(&handle)
                .or_else(|| tab.scene.block_meshes.get(&handle))
                .cloned()
                .or_else(|| {
                    let h = &tab.scene.document.header;
                    crate::entities::solid3d::tessellate_volume(
                        entity,
                        [1.; 4],
                        h.facet_resolution,
                        crate::entities::solid3d::display_deflection(h, h.facet_resolution),
                        crate::entities::solid3d::clamp_header_isolines(h.isolines),
                    )
                });
            let curve = crate::entities::curve::entity_curve(entity).map(|planar| {
                let length = planar.curve.length();
                json!({
                    "bounded":length.is_finite(),
                    "closed":planar.curve.is_closed(),
                    "length":length.is_finite().then_some(length),
                    "area":planar.curve.is_closed().then(|| planar.curve.enclosed_area().abs())
                })
            });
            out.push(json!({"handle":format!("{:X}",handle.value()),"type":crate::entities::names::ui_name(entity),"bounds":{"min":min,"max":max},"curve":curve,"mesh":metrics.map(|m|json!({"vertices":m.metrics.vertices,"triangles":m.metrics.triangles,"surface_area":m.metrics.surface_area,"volume":m.metrics.volume,"centroid":m.metrics.centroid,"moment_of_inertia":m.metrics.moment_of_inertia,"principal_directions":m.metrics.principal_directions,"principal_moments":m.metrics.principal_moments,"product_of_inertia":m.metrics.product_of_inertia,"radii_of_gyration":m.metrics.radii_of_gyration}))}));
        }
        json!({"ok":true,"document_id":tab.id,"geometry_revision":tab.scene.geometry_epoch,"measurements":out})
    }

    pub(super) fn control_screenshot(
        &mut self,
        path: String,
        screenshot: Option<iced::window::Screenshot>,
    ) {
        let waited_for_frame = self.control.capture_after_redraw;
        let result = (|| -> Result<Value, String> {
            let s = screenshot
                .ok_or("The window is minimized or has no size; restore it and capture again")?;
            let requested_scope = self
                .control
                .pending
                .as_ref()
                .and_then(|pending| pending.request["scope"].as_str())
                .unwrap_or("viewport");
            let max_dimension = self
                .control
                .pending
                .as_ref()
                .and_then(|pending| pending.request["max_dimension"].as_u64())
                .unwrap_or(1600)
                .clamp(256, 4096) as u32;
            let annotate = self
                .control
                .pending
                .as_ref()
                .and_then(|pending| pending.request["annotate"].as_bool())
                .unwrap_or(false);

            let mut image =
                image::RgbaImage::from_raw(s.size.width, s.size.height, s.rgba.to_vec())
                    .ok_or("Renderer returned malformed image data")?;
            let mut actual_scope = "window";

            let (vp_w, vp_h) = self.tabs[self.active_tab]
                .scene
                .selection
                .borrow()
                .view
                .vp_size;
            let mut vp_logical_width = if vp_w > 0.0 {
                vp_w
            } else {
                image.width() as f32 / s.scale_factor
            };
            let mut vp_logical_height = if vp_h > 0.0 {
                vp_h
            } else {
                image.height() as f32 / s.scale_factor
            };

            if requested_scope == "viewport" {
                if let Some(bounds) = crate::ui::wrap_bar::dropdown_bounds(
                    crate::app::view::VIEWPORT_CAPTURE_BOUNDS_ID,
                ) {
                    let scale = s.scale_factor;
                    let left = (bounds.x * scale).floor().clamp(0.0, image.width() as f32) as u32;
                    let top = (bounds.y * scale).floor().clamp(0.0, image.height() as f32) as u32;
                    let right = ((bounds.x + bounds.width) * scale)
                        .ceil()
                        .clamp(0.0, image.width() as f32) as u32;
                    let bottom = ((bounds.y + bounds.height) * scale)
                        .ceil()
                        .clamp(0.0, image.height() as f32) as u32;
                    if right > left && bottom > top {
                        image = image::imageops::crop_imm(
                            &image,
                            left,
                            top,
                            right - left,
                            bottom - top,
                        )
                        .to_image();
                        actual_scope = "viewport";
                        vp_logical_width = bounds.width;
                        vp_logical_height = bounds.height;
                    }
                }
            }
            let longest = image.width().max(image.height());
            if longest > max_dimension {
                let scale = max_dimension as f64 / longest as f64;
                let width = ((image.width() as f64 * scale).round() as u32).max(1);
                let height = ((image.height() as f64 * scale).round() as u32).max(1);
                image = image::imageops::resize(
                    &image,
                    width,
                    height,
                    image::imageops::FilterType::Triangle,
                );
            }

            // Spatial grounding: camera, world bounds, and visible entity centroids
            let grounding = vision::compute_grounding(
                self,
                vp_logical_width,
                vp_logical_height,
                image.width(),
                image.height(),
            );

            // Optional Set-of-Marks visual overlay badges
            if annotate {
                for ent_val in &grounding.visible_entities {
                    if let (Some(tag), Some(px_arr), Some(selected)) = (
                        ent_val["tag"].as_u64(),
                        ent_val["screen_pixel"].as_array(),
                        ent_val["selected"].as_bool(),
                    ) {
                        if px_arr.len() == 2 {
                            if let (Some(x), Some(y)) = (px_arr[0].as_i64(), px_arr[1].as_i64()) {
                                vision::draw_som_badge(
                                    &mut image,
                                    x as i32,
                                    y as i32,
                                    tag as usize,
                                    selected,
                                );
                            }
                        }
                    }
                }
            }

            #[cfg(not(target_arch = "wasm32"))]
            image
                .save_with_format(&path, image::ImageFormat::Png)
                .map_err(|e| e.to_string())?;
            // No filesystem behind a web "path": encode the PNG in memory and
            // hand it to the browser as a download named after the request's
            // file name — the delivery every other web output uses.
            #[cfg(target_arch = "wasm32")]
            {
                let mut png = Vec::new();
                image
                    .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
                    .map_err(|e| e.to_string())?;
                let download = path
                    .rsplit(['/', '\\'])
                    .next()
                    .filter(|name| !name.is_empty())
                    .unwrap_or("capture.png")
                    .to_string();
                crate::sys::download_bytes(&download, &png);
            }

            let doc_unit = crate::app::properties::insunits_name(
                self.tabs[self.active_tab]
                    .scene
                    .document
                    .header
                    .insertion_units,
            );

            let spatial_obj = json!({
                "crs": "CAD_WCS",
                "unit": doc_unit,
                "pixel_resolution": [image.width(), image.height()],
                "world_bounds": grounding.viewport_world_bounds,
                "pixel_to_world_matrix": grounding.pixel_to_world_matrix,
                "world_to_pixel_matrix": grounding.world_to_pixel_matrix,
                "camera": grounding.camera,
                "target_plane": grounding.target_plane,
                "annotations": grounding.visible_entities.clone(),
            });

            Ok(json!({
                "path": path,
                "scope": actual_scope,
                "width": image.width(),
                "height": image.height(),
                "scale_factor": s.scale_factor,
                "waited_for_frame": waited_for_frame,
                "document_id": self.tabs[self.active_tab].id,
                "revision": self.tabs[self.active_tab].edit_revision,
                "camera_revision": self.tabs[self.active_tab].scene.camera_generation,
                "_spatial": spatial_obj,
                "pixel_to_world_matrix": grounding.pixel_to_world_matrix,
                "world_to_pixel_matrix": grounding.world_to_pixel_matrix,
                "viewport_world_bounds": grounding.viewport_world_bounds,
                "camera": grounding.camera,
                "annotated": annotate,
                "annotations": grounding.visible_entities.clone(),
                "visible_entities": grounding.visible_entities,
            }))
        })();
        match result {
            Ok(v) => {
                if let Some(p) = self.control.pending.as_mut() {
                    p.result = v;
                }
            }
            Err(e) => self.command_line.push_error(&e),
        }
        // `capture` is parked until this result (or error) arrives, rather
        // than being settled by the task counter used for ordinary actions.
        if let Some(p) = self
            .control
            .pending
            .as_mut()
            .filter(|p| p.request["op"] == "capture")
        {
            p.pending = 0;
        }
        self.control.capture_after_redraw = false;
        self.control_settle();
    }

    /// A frame finished rendering (or the anti-hang timer expired): start the
    /// screenshot only after the capture request has been parked.
    pub(super) fn on_control_capture_frame(&mut self, redrew: bool) -> Task<Message> {
        if !self.control.capture_frame_pending {
            return Task::none();
        }
        let Some(path) = self
            .control
            .pending
            .as_ref()
            .filter(|p| p.request["op"] == "capture")
            .and_then(|p| p.request["path"].as_str())
            .map(str::to_owned)
        else {
            self.control.capture_frame_pending = false;
            return Task::none();
        };
        // Web: iced's window screenshot needs a synchronous GPU map wasm
        // cannot provide; the canvas readback (the save-thumbnail technique)
        // only sees the drawing right after a presented frame, before the
        // browser clears the WebGL buffer — so wait for a real frame.
        #[cfg(target_arch = "wasm32")]
        {
            let expired = self
                .control
                .capture_deadline
                .is_some_and(|deadline| iced::time::Instant::now() >= deadline);
            if !redrew && !expired && crate::sys::page_visible() {
                return Task::none();
            }
            self.control.capture_frame_pending = false;
            self.control.capture_deadline = None;
            self.control.capture_after_redraw = redrew;
            // No frame to read (hidden tab or nothing redrawing): report the
            // capture as failed rather than hand back a blank canvas.
            let screenshot = if redrew {
                crate::sys::capture_canvas()
            } else {
                None
            };
            Task::done(Message::ControlScreenshot(path, screenshot))
        }
        #[cfg(not(target_arch = "wasm32"))]
        {
            self.control.capture_frame_pending = false;
            self.control.capture_after_redraw = redrew;
            let Some(window) = self.main_window else {
                return Task::done(Message::ControlScreenshot(path, None));
            };
            // A minimized window has a 0x0 surface and the renderer panics
            // reading it back, so report instead of capturing.
            iced::window::size(window).then(move |size| {
                let path = path.clone();
                if size.width <= 0.0 || size.height <= 0.0 {
                    Task::done(Message::ControlScreenshot(path, None))
                } else {
                    iced::window::screenshot(window).map(move |screenshot| {
                        Message::ControlScreenshot(path.clone(), Some(screenshot))
                    })
                }
            })
        }
    }
}
mod actions;
pub(crate) mod vision;
pub(crate) use actions::property_json;
mod entities;
#[cfg(not(target_arch = "wasm32"))]
pub(crate) mod http_bridge;
mod interactive;
mod sheets;
pub(crate) use sheets::new_guid_v4;
pub(crate) mod spellcheck;
pub(crate) mod text_ops;

#[cfg(test)]
mod p1_tests;
pub(super) fn action_names() -> &'static [&'static str] {
    actions::NAMES
}

#[cfg(test)]
mod tests {
    use super::*;
    fn request(app: &mut OpenCADStudio, mut req: Value) -> Value {
        let state = app.control_state();
        req["protocol"] = json!(1);
        req["document_id"] = state["document_id"].clone();
        req["revision"] = state["revision"].clone();
        req["client_id"] = json!("test");
        if req.get("request_id").is_none() {
            req["request_id"] = json!(format!("req-{}", app.control.serial));
        }
        let (r, t) = app.control_request(req.clone());
        app.drive_headless_task(t).unwrap();
        if matches!(r["status"].as_str(), Some("accepted" | "running")) {
            app.control_request(json!({"op":"operation","request_id":req["request_id"]}))
                .0
        } else {
            r
        }
    }
    #[test]
    fn qsave_completion_reports_clean_document_state() {
        let mut app = OpenCADStudio::new_for_test();
        assert_eq!(request(&mut app, json!({"op":"new"}))["ok"], true);
        assert_eq!(
            request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,0"}))["status"],
            "completed"
        );
        let path = std::env::temp_dir().join(format!(
            "ocs_qsave_state_{}_{}.dwg",
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos(),
        ));
        let _ = std::fs::remove_file(&path);
        let saved = request(
            &mut app,
            json!({"op":"save","path":path,"overwrite":true}),
        );
        assert_eq!(saved["ok"], true, "{saved}");
        assert_eq!(
            request(&mut app, json!({"op":"run","cmd":"LINE 0,5 10,5"}))["status"],
            "completed"
        );
        let qsave = request(&mut app, json!({"op":"run","cmd":"QSAVE"}));
        assert_eq!(qsave["status"], "completed", "{qsave}");
        let document_id = qsave["state"]["document_id"].as_u64().unwrap();
        let dirty = qsave["state"]["documents"]
            .as_array()
            .unwrap()
            .iter()
            .find(|document| document["id"].as_u64() == Some(document_id))
            .and_then(|document| document["dirty"].as_bool());
        assert_eq!(dirty, Some(false), "{qsave}");
        let _ = std::fs::remove_file(path);
    }

    #[test]
    fn qsave_save_failure_settles_instead_of_hanging() {
        let mut app = OpenCADStudio::new_for_test();
        assert_eq!(request(&mut app, json!({"op":"new"}))["ok"], true);
        assert_eq!(
            request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,0"}))["status"],
            "completed"
        );
        let dir = std::env::temp_dir().join(format!(
            "ocs_qsave_fail_{}_{}",
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos(),
        ));
        std::fs::create_dir_all(&dir).unwrap();
        let path = dir.join("blocked.dwg");
        let saved = request(
            &mut app,
            json!({"op":"save","path":path,"overwrite":true}),
        );
        assert_eq!(saved["ok"], true, "{saved}");
        // A directory at the target path makes the next write fail
        // deterministically; the operation must settle as failed instead of
        // waiting forever on its task counter.
        std::fs::remove_file(&path).unwrap();
        std::fs::create_dir(&path).unwrap();
        assert_eq!(
            request(&mut app, json!({"op":"run","cmd":"LINE 0,5 10,5"}))["status"],
            "completed"
        );
        let qsave = request(&mut app, json!({"op":"run","cmd":"QSAVE"}));
        assert_eq!(qsave["status"], "failed", "{qsave}");
        assert!(
            qsave["error"].as_str().is_some_and(|error| !error.is_empty()),
            "{qsave}"
        );
        let _ = std::fs::remove_dir_all(&dir);
    }

    #[test]
    fn capture_parks_for_the_next_frame_then_finishes_with_its_result() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        assert_eq!(request(&mut app, json!({"op":"new"}))["ok"], true);
        let path = std::env::temp_dir().join(format!("ocs-capture-frame-{}.png", session_id()));
        let state = app.control_state();
        let parked = app
            .control_request(json!({
                "protocol":1,
                "op":"capture",
                "request_id":"cap-frame",
                "document_id": state["document_id"],
                "revision": state["revision"],
                "path": path.to_string_lossy(),
            }))
            .0;
        assert_eq!(parked["status"], "accepted", "{parked}");
        assert!(app.control.capture_frame_pending, "capture should wait for a frame");
        let running = app
            .control_request(json!({"op":"operation","request_id":"cap-frame"}))
            .0;
        assert_eq!(running["status"], "running", "{running}");

        let _frame_task = app.on_control_capture_frame(true);
        assert!(!app.control.capture_frame_pending);
        let screenshot = iced::window::Screenshot::new(
            vec![0u8; 4 * 4 * 4],
            iced::Size::new(4, 4),
            1.0,
        );
        app.control_screenshot(path.to_string_lossy().into_owned(), Some(screenshot));
        let done = app
            .control_request(json!({"op":"operation","request_id":"cap-frame"}))
            .0;
        assert_eq!(done["status"], "completed", "{done}");
        assert_eq!(done["result"]["waited_for_frame"], true, "{done}");
        assert_eq!(done["result"]["width"], 4, "{done}");
        assert!(path.exists(), "capture should be written");
        let _ = std::fs::remove_file(&path);
    }

    #[test]
    fn control_stepwise_drawing_undo_and_properties() {
        let mut app = OpenCADStudio::new_for_test();
        assert_eq!(
            request(&mut app, json!({"op":"new"}))["status"],
            "completed"
        );
        let started = request(&mut app, json!({"op":"start","cmd":"LINE"}));
        assert_eq!(started["status"], "waiting_input");
        assert!(started["state"]["command"]["accepts"]
            .as_array()
            .unwrap()
            .contains(&json!("point")));
        assert_eq!(
            started["state"]["command"]["input_example"]["kind"],
            "point"
        );
        assert_eq!(
            request(
                &mut app,
                json!({"op":"input","kind":"point","point":[0.,0.,0.]})
            )["ok"],
            true
        );
        assert_eq!(
            request(
                &mut app,
                json!({"op":"input","kind":"point","point":[10.,0.,0.]})
            )["ok"],
            true
        );
        assert_eq!(
            request(&mut app, json!({"op":"input","kind":"enter"}))["status"],
            "completed"
        );
        assert_eq!(app.automation_op(r#"{"op":"entities"}"#)["total"], 1);
        request(&mut app, json!({"op":"select","type":"LINE"}));
        assert!(!app.control_properties()["sections"]
            .as_array()
            .unwrap()
            .is_empty());
        let changed = request(&mut app, json!({"op":"property","field":"color","value":1}));
        assert_eq!(changed["ok"], true, "{changed}");
        assert_eq!(
            app.tabs[app.active_tab]
                .scene
                .document
                .entities()
                .next()
                .unwrap()
                .common()
                .color
                .index(),
            Some(1)
        );
        assert_eq!(request(&mut app, json!({"op":"undo"}))["ok"], true);
        assert_eq!(app.automation_op(r#"{"op":"entities"}"#)["total"], 1);
        request(&mut app, json!({"op":"undo"}));
        assert_eq!(app.automation_op(r#"{"op":"entities"}"#)["total"], 0);
    }
    #[test]
    fn selection_changes_are_published_to_the_event_stream() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,0"}));
        let handle = request(&mut app, json!({"op":"query","type":"Line"}))["entities"][0]["handle"]
            .as_str()
            .unwrap()
            .to_string();
        let before = app.control_state()["selection_revision"].as_u64().unwrap();
        let selected = app.automation_op(&format!(
            r#"{{"op":"select","handles":["{handle}"]}}"#
        ));
        assert_eq!(selected["ok"], true, "{selected}");
        let state = app.control_state();
        assert_eq!(
            state["selection_revision"].as_u64().unwrap(),
            before + 1,
            "selection revision should increment once: {state}"
        );
        assert!(
            state["selection"].as_array().unwrap().contains(&json!(handle)),
            "{state}"
        );
        let events = app.control_request(json!({"op":"events"})).0;
        let last = events["events"].as_array().unwrap().last().unwrap();
        assert_eq!(last["kind"], "selection", "{events}");
        assert_eq!(last["document_id"], state["document_id"], "{events}");
        assert!(
            last["selection"].as_array().unwrap().contains(&json!(handle)),
            "{events}"
        );
    }

    #[test]
    fn command_discovery_explains_batch_and_interactive_use() {
        let mut app = OpenCADStudio::new_for_test();
        let detail = app
            .control_request(json!({"op":"commands","name":"pline"}))
            .0;
        assert_eq!(detail["command"]["name"], "PLINE");
        assert_eq!(
            detail["command"]["batch"]["examples"][0],
            "PLINE 0,0 10,0 10,10 C"
        );
        assert_eq!(detail["command"]["interactive"]["op"], "start");
        assert_eq!(detail["command"]["category"], "create");
        assert_eq!(detail["command"]["preconditions"]["document"], true);
        assert_eq!(
            app.control_request(json!({"op":"commands","name":"NOT_A_COMMAND"}))
                .0["code"],
            "unknown_command"
        );
    }
    #[test]
    fn control_queries_exact_curve_relationships_and_metrics() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE -5,0 5,0"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,-5 0,5"}));
        request(&mut app, json!({"op":"run","cmd":"CIRCLE 20,0 2"}));

        let lines = app.control_request(json!({"op":"query","type":"Line"})).0;
        let first = lines["entities"][0]["handle"].as_str().unwrap();
        let second = lines["entities"][1]["handle"].as_str().unwrap();
        let intersections = app
            .control_request(json!({"op":"query","intersections":[first,second]}))
            .0;
        assert_eq!(intersections["count"], 1, "{intersections}");
        assert_eq!(
            intersections["intersections"][0]["point"],
            json!([0.0, 0.0])
        );

        let nearest = app
            .control_request(json!({"op":"query","near":[20.0,0.0],"limit":1}))
            .0;
        assert_eq!(nearest["entities"][0]["type"], "Circle");
        assert_eq!(nearest["entities"][0]["distance"], 2.0);
        let circle = nearest["entities"][0]["handle"]
            .as_str()
            .unwrap()
            .to_owned();

        let contains = app
            .control_request(json!({"op":"query","contains_point":[20.0,0.0]}))
            .0;
        assert_eq!(contains["count"], 1, "{contains}");
        assert_eq!(contains["entities"][0]["handle"], circle);

        let projected = app
            .control_request(
                json!({"op":"query","handle":circle,"detail":"full","fields":["type"]}),
            )
            .0;
        assert_eq!(projected["entities"][0].as_object().unwrap().len(), 2);

        let measured = app
            .control_request(json!({"op":"measure","handles":[circle]}))
            .0;
        let curve = &measured["measurements"][0]["curve"];
        assert!((curve["length"].as_f64().unwrap() - std::f64::consts::TAU * 2.0).abs() < 1e-9);
        assert!((curve["area"].as_f64().unwrap() - std::f64::consts::PI * 4.0).abs() < 1e-9);
    }

    #[test]
    fn control_shell_roundtrips_with_kernel_mass_properties() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"start","cmd":"BOX"}));
        request(
            &mut app,
            json!({"op":"input","kind":"point","point":[0.0,0.0,0.0]}),
        );
        request(
            &mut app,
            json!({"op":"input","kind":"point","point":[6.0,5.0,0.0]}),
        );
        assert_eq!(
            request(&mut app, json!({"op":"input","kind":"token","text":"4"}))["status"],
            "completed"
        );
        let handle = app.tabs[app.active_tab]
            .scene
            .document
            .entities()
            .find_map(|entity| {
                matches!(entity, codec::EntityType::Solid3D(_)).then(|| entity.common().handle)
            })
            .unwrap();
        let handle_text = format!("{:X}", handle.value());

        request(&mut app, json!({"op":"select","handles":[handle_text]}));
        request(&mut app, json!({"op":"start","cmd":"SHELL"}));
        request(
            &mut app,
            json!({"op":"input","kind":"entity","handle":handle_text,"point":[3.0,2.5,4.0]}),
        );
        request(&mut app, json!({"op":"input","kind":"enter"}));
        assert_eq!(
            request(&mut app, json!({"op":"input","kind":"token","text":"0.5"}))["status"],
            "completed"
        );

        let measured = app.control_measure(&json!({"handles":[handle_text]}));
        let mesh = &measured["measurements"][0]["mesh"];
        assert!((mesh["volume"].as_f64().unwrap() - 50.0).abs() < 1e-9);
        assert_eq!(mesh["principal_moments"].as_array().unwrap().len(), 3);
        assert!(matches!(
            app.tabs[app.active_tab]
                .scene
                .document
                .solid_history_operation(handle),
            Some(codec::objects::SolidHistoryOperation::Brep(_))
        ));

        assert_eq!(request(&mut app, json!({"op":"undo"}))["ok"], true);
        let restored = app.control_measure(&json!({"handles":[handle_text]}));
        assert!(
            (restored["measurements"][0]["mesh"]["volume"]
                .as_f64()
                .unwrap()
                - 120.0)
                .abs()
                < 1e-9
        );
        assert_eq!(request(&mut app, json!({"op":"redo"}))["ok"], true);

        let path = std::env::temp_dir().join(format!("ocs-shell-{}.dwg", session_id()));
        assert_eq!(
            request(&mut app, json!({"op":"save","path":path}))["ok"],
            true
        );
        request(&mut app, json!({"op":"new"}));
        assert_eq!(
            request(&mut app, json!({"op":"open","path":path}))["status"],
            "completed"
        );
        let reopened = app.control_measure(&json!({"handles":[handle_text]}));
        assert!(
            (reopened["measurements"][0]["mesh"]["volume"]
                .as_f64()
                .unwrap()
                - 50.0)
                .abs()
                < 1e-9
        );
        let _ = std::fs::remove_file(path);
    }

    #[test]
    fn control_retry_is_idempotent_and_stale_state_rejected() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        let state = app.control_state();
        let req = json!({"op":"run","cmd":"LINE 0,0 10,0","request_id":"line","document_id":state["document_id"],"revision":state["revision"]});
        let (first, t) = app.control_request(req.clone());
        app.drive_headless_task(t).unwrap();
        let repeat = app.control_request(req.clone()).0;
        assert!(repeat["ok"] == true, "{first} {repeat}");
        assert_eq!(app.automation_op(r#"{"op":"entities"}"#)["total"], 1);
        let mut stale = req;
        stale["request_id"] = json!("stale");
        assert_eq!(app.control_request(stale).0["code"], "stale_state");
    }
    #[test]
    fn external_change_modal_actions_are_automatable() {
        let mut app = OpenCADStudio::new_for_test();
        let names = crate::app::automation_action_names();
        for name in [
            "external_change_reload",
            "external_change_overwrite",
            "external_change_save_as",
            "external_change_cancel",
        ] {
            assert!(names.contains(&name), "{name} should be listed");
        }
        // No conflict pending: the action is a harmless no-op, not an error.
        let reply = request(
            &mut app,
            json!({
                "op":"action",
                "request_id":"external-action-noop",
                "name":"external_change_reload"
            }),
        );
        assert_eq!(reply["status"], "completed", "{reply}");
    }

    #[test]
    fn pending_request_id_reuse_rejects_changed_payload() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        assert_eq!(request(&mut app, json!({"op":"new"}))["status"], "completed");

        let pending = request(
            &mut app,
            json!({
                "op":"user_select",
                "request_id":"pending-reuse",
                "prompt":"pick the first object"
            }),
        );
        assert_eq!(pending["status"], "running", "{pending}");

        let changed = request(
            &mut app,
            json!({
                "op":"user_select",
                "request_id":"pending-reuse",
                "prompt":"pick a different object"
            }),
        );
        assert_eq!(changed["code"], "request_id_reused", "{changed}");
        assert!(
            changed["error"]
                .as_str()
                .unwrap()
                .contains("pending-reuse"),
            "{changed}"
        );

        let cancelled = request(
            &mut app,
            json!({"op":"cancel","request_id":"cancel-pending-reuse"}),
        );
        assert_eq!(cancelled["status"], "cancelled", "{cancelled}");
    }

    #[test]
    fn control_errors_and_missing_entities_do_not_report_success() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        let result = request(&mut app, json!({"op":"run","cmd":"NONEXISTENT_COMMAND"}));
        assert_eq!(result["status"], "failed", "{result}");
        assert_eq!(
            request(&mut app, json!({"op":"select","handles":["FFFFFFFF"]}))["code"],
            "entity_absent"
        );
        assert_eq!(
            app.automation_op(r#"{"op":"run","cmd":"NONEXISTENT_COMMAND"}"#)["ok"],
            false
        );
    }
    #[test]
    fn direct_user_input_takes_command_ownership() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"start","cmd":"LINE"}));
        let _ = app.update(Message::ViewportLeftPress);
        let result = request(
            &mut app,
            json!({"op":"input","kind":"point","point":[10.,0.,0.]}),
        );
        assert_eq!(result["code"], "command_busy");
    }
    #[test]
    fn control_preserves_other_documents_and_waits_for_async_open() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"CIRCLE 0,0 3"}));
        let id = app.control_state()["document_id"].as_u64().unwrap();
        let path = std::env::temp_dir().join(format!("ocs-control-{}.dxf", session_id()));
        assert_eq!(
            request(&mut app, json!({"op":"save","path":path}))["ok"],
            true
        );
        request(&mut app, json!({"op":"new"}));
        let opened = request(&mut app, json!({"op":"open","path":path}));
        assert_eq!(opened["status"], "completed", "{opened}");
        assert!(app.tabs.iter().any(|t| t.id == id));
        assert_eq!(
            app.tabs[app.active_tab].scene.document.entities().count(),
            1
        );
        let _ = std::fs::remove_file(path);
    }

    #[test]
    fn open_from_bytes_validates_the_request() {
        let ok = open_bytes_request(&json!({"name":"C:\\plans\\plan.dwg","data_base64":"AAEC"}));
        assert_eq!(ok, Ok(("plan.dwg".to_string(), vec![0, 1, 2])));
        for (req, error) in [
            (json!({"data_base64":"AAEC"}), "Missing name"),
            (json!({"name":"dir/","data_base64":"AAEC"}), "Missing name"),
            (
                json!({"name":"a.dwg","data_base64":""}),
                "data_base64 is empty",
            ),
        ] {
            assert_eq!(
                open_bytes_request(&req).unwrap_err()["error"],
                error,
                "{req}"
            );
        }
        let bad = open_bytes_request(&json!({"name":"a.dwg","data_base64":"not base64!"}));
        assert_eq!(bad.unwrap_err()["code"], "invalid_request");
    }
    #[test]
    fn open_from_bytes_is_refused_natively_without_touching_documents() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        let tabs = app.tabs.len();
        let reply = request(
            &mut app,
            json!({"op":"open","name":"a.dxf","data_base64":"AAEC"}),
        );
        assert_eq!(reply["code"], "invalid_request", "{reply}");
        assert_eq!(app.tabs.len(), tabs);
        assert!(app.opening.is_none());
    }

    #[test]
    fn point_steps_that_take_keywords_accept_points() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"CIRCLE 0,0 3"}));
        request(&mut app, json!({"op":"select","type":"CIRCLE"}));
        let started = request(&mut app, json!({"op":"start","cmd":"MOVE"}));
        assert_eq!(started["status"], "waiting_input", "{started}");
        let command = &started["state"]["command"];
        let accepts = command["accepts"].as_array().unwrap();
        assert!(accepts.contains(&json!("point")), "{command}");
        assert!(accepts.contains(&json!("token")), "{command}");
        assert_eq!(command["input_example"]["kind"], "point");
        let base = request(
            &mut app,
            json!({"op":"input","kind":"point","point":[0.,0.,0.]}),
        );
        assert_eq!(base["status"], "waiting_input", "{base}");
        let moved = request(
            &mut app,
            json!({"op":"input","kind":"point","point":[0.,-10.,0.]}),
        );
        assert_eq!(moved["status"], "completed", "{moved}");
        let circle = app.tabs[app.active_tab]
            .scene
            .document
            .entities()
            .find_map(|e| match e {
                codec::EntityType::Circle(c) => Some(c.center.y),
                _ => None,
            });
        assert_eq!(circle, Some(-10.0));
    }

    #[test]
    fn embed_image_op_places_an_ole2frame_and_undoes_it() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        let img = image::RgbaImage::from_pixel(40, 30, image::Rgba([9, 9, 9, 255]));
        let path = std::env::temp_dir().join(format!("ocs-embed-{}.png", session_id()));
        img.save(&path).unwrap();

        let response = request(
            &mut app,
            json!({"op":"embed_image","path":path.to_string_lossy(),"at":[0,0,0],"width":20}),
        );
        assert_eq!(response["status"], "completed", "{response}");
        let handle = response["result"]["handle"].as_str().unwrap().to_string();
        assert_eq!(response["result"]["kind"], "Ole2Frame");
        let ole_count = |app: &OpenCADStudio| {
            app.tabs[app.active_tab]
                .scene
                .document
                .entities()
                .filter(|e| matches!(e, codec::EntityType::Ole2Frame(_)))
                .count()
        };
        assert_eq!(ole_count(&app), 1);

        // The entity must be queryable like any other and undoable as one step.
        let queried = app.automation_op(
            json!({"op":"entities","type":"OLE2FRAME"})
                .to_string()
                .as_str(),
        );
        assert_eq!(queried["total"], 1, "{queried}");
        request(&mut app, json!({"op":"undo"}));
        assert_eq!(ole_count(&app), 0);
        let _ = std::fs::remove_file(path);
        let _ = handle;
    }

    #[test]
    fn embed_image_calibrates_from_source_and_target_points() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        let img = image::RgbaImage::from_pixel(100, 100, image::Rgba([12, 12, 12, 255]));
        let path = std::env::temp_dir().join(format!("ocs-embed-calib-{}.png", session_id()));
        img.save(&path).unwrap();

        // 2 points on image: bottom-left (0, 100) and bottom-right (100, 100)
        // Target CAD points: (10.0, 20.0) and (210.0, 20.0) -> scale = 200/100 = 2.0
        let response = request(
            &mut app,
            json!({
                "op": "embed_image",
                "path": path.to_string_lossy(),
                "linked": true,
                "source_points": [[0, 100], [100, 100]],
                "target_points": [[10.0, 20.0], [210.0, 20.0]]
            }),
        );
        assert_eq!(response["status"], "completed", "{response}");
        assert_eq!(response["result"]["kind"], "RasterImage");
        assert_eq!(response["result"]["width"], 200.0);
        assert_eq!(response["result"]["height"], 200.0);
        let at = response["result"]["at"].as_array().unwrap();
        assert_eq!(at[0], 10.0);
        assert_eq!(at[1], 20.0);
        let _ = std::fs::remove_file(path);
    }

    fn user_select_pick(app: &mut OpenCADStudio, kind: &str) -> String {
        let handle = app.automation_op(
            format!(r#"{{"op":"query","type":"{kind}","detail":"summary"}}"#).as_str(),
        )["entities"][0]["handle"]
            .as_str()
            .unwrap()
            .to_owned();
        let value = u64::from_str_radix(&handle, 16).unwrap();
        app.tabs[app.active_tab]
            .scene
            .select_entity(codec::Handle::new(value), false);
        handle
    }

    fn user_select_result(app: &mut OpenCADStudio, request_id: &str) -> Value {
        app.control_request(json!({"op":"operation","request_id":request_id}))
            .0
    }

    #[test]
    fn user_select_stays_running_until_the_user_confirms_then_returns_entities() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        assert_eq!(
            request(&mut app, json!({"op":"new"}))["status"],
            "completed"
        );
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,10"}));
        let asked = request(
            &mut app,
            json!({"op":"user_select","request_id":"us-1","type":"LINE"}),
        );
        assert_eq!(asked["status"], "running", "{asked}");
        // A second request waits like any other mutation while one is open.
        let busy = request(&mut app, json!({"op":"user_select","request_id":"us-2"}));
        assert_eq!(busy["code"], "busy", "{busy}");
        // The person picks the line in the viewport and presses Enter.
        let handle = user_select_pick(&mut app, "LINE");
        let _ = app.update(Message::CommandFinalize);
        let done = user_select_result(&mut app, "us-1");
        assert_eq!(done["status"], "completed", "{done}");
        assert_eq!(done["result"]["cancelled"], false);
        assert_eq!(done["result"]["count"], 1);
        assert_eq!(done["result"]["handles"][0], json!(handle));
        assert_eq!(done["result"]["entities"][0]["type"], "Line");
        // detail defaults to full, so the whole entity object rides along.
        assert!(
            done["result"]["entities"][0]["properties"].is_object(),
            "{done}"
        );
    }

    #[test]
    fn user_select_filter_deselects_entities_outside_the_request() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,10"}));
        request(&mut app, json!({"op":"run","cmd":"CIRCLE 0,0 5"}));
        request(
            &mut app,
            json!({"op":"user_select","request_id":"us-f","type":"CIRCLE"}),
        );
        user_select_pick(&mut app, "LINE");
        user_select_pick(&mut app, "CIRCLE");
        let _ = app.update(Message::CommandFinalize);
        let done = user_select_result(&mut app, "us-f");
        assert_eq!(done["status"], "completed", "{done}");
        assert_eq!(done["result"]["count"], 1);
        assert_eq!(done["result"]["ignored"], 1);
        assert_eq!(done["result"]["entities"][0]["type"], "Circle");
        // The filtered-out pick is deselected in the drawing too.
        assert_eq!(
            app.tabs[app.active_tab]
                .scene
                .selected_handles_in_order()
                .len(),
            1
        );
    }

    #[test]
    fn user_select_escape_cancels_and_an_empty_enter_confirms_zero() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,10"}));
        request(&mut app, json!({"op":"user_select","request_id":"us-x"}));
        let _ = app.update(Message::CommandEscape);
        let cancelled = user_select_result(&mut app, "us-x");
        assert_eq!(cancelled["status"], "cancelled", "{cancelled}");
        assert_eq!(cancelled["result"]["cancelled"], true);
        assert_eq!(cancelled["result"]["count"], 0);
        // An immediate Enter with nothing picked answers the
        // request with an empty set rather than hanging forever.
        request(&mut app, json!({"op":"user_select","request_id":"us-e"}));
        let _ = app.update(Message::CommandFinalize);
        let empty = user_select_result(&mut app, "us-e");
        assert_eq!(empty["result"]["cancelled"], false, "{empty}");
        assert_eq!(empty["result"]["count"], 0);
        // A client can also retract its own request programmatically.
        request(&mut app, json!({"op":"user_select","request_id":"us-c"}));
        let retracted = request(&mut app, json!({"op":"cancel","request_id":"us-c-x"}));
        assert_eq!(retracted["status"], "cancelled", "{retracted}");
        assert_eq!(retracted["result"]["cancelled"], true, "{retracted}");
    }

    #[test]
    fn user_select_request_is_printed_and_stays_visible_until_answered() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,10"}));
        request(
            &mut app,
            json!({"op":"user_select","request_id":"us-ui","type":"LINE","prompt":"Chọn block"}),
        );
        // The message list names the request — who asked and what for.
        let last = app.command_line.history.last().unwrap();
        assert!(
            last.text.contains("us-ui") && last.text.contains("Chọn block"),
            "{last:?}"
        );
        // The end-of-update driver pins that line so it cannot fade away
        // while the pick is still open.
        let label = app.pending_pick_label().expect("pending label");
        app.command_line.set_step_prompt(Some(label));
        assert!(
            app.command_line.history.last().unwrap().pinned,
            "{:?}",
            app.command_line.history.last().unwrap()
        );
        // The person answers: the line un-pins and the resolution is printed
        // with the same identity.
        user_select_pick(&mut app, "LINE");
        let _ = app.update(Message::CommandFinalize);
        assert!(app.pending_pick_label().is_none());
        let tail: Vec<String> = app
            .command_line
            .history
            .iter()
            .rev()
            .take(3)
            .map(|e| e.text.clone())
            .collect();
        assert!(
            tail.iter()
                .any(|t| t.contains("us-ui") && t.contains("1 object(s)")),
            "{tail:?}"
        );
    }

    #[test]
    fn user_select_requires_a_gui_window() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        let reply = request(&mut app, json!({"op":"user_select","request_id":"us-h"}));
        assert_eq!(reply["code"], "gui_required", "{reply}");
    }

    #[test]
    fn getpoint_resolves_with_the_clicked_point_and_esc_cancels() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        request(&mut app, json!({"op":"new"}));
        let asked = request(
            &mut app,
            json!({"op":"getpoint","request_id":"gp-1","prompt":"Chọn vị trí QR"}),
        );
        assert_eq!(asked["status"], "running", "{asked}");
        // While the pick is pending, everything else waits.
        let busy = request(&mut app, json!({"op":"getpoint","request_id":"gp-2"}));
        assert_eq!(busy["code"], "busy", "{busy}");
        // The person clicks: the snapped world point under the cursor is the
        // answer, and the click leaves the selection untouched.
        app.tabs[app.active_tab].last_cursor_world = glam::DVec3::new(125.5, 64.25, 0.0);
        let _ = app.update(Message::ViewportLeftPress);
        let done = user_select_result(&mut app, "gp-1");
        assert_eq!(done["status"], "completed", "{done}");
        assert_eq!(done["result"]["point"], json!([125.5, 64.25, 0.0]));
        // Escape with no request pending is still just Escape.
        let _ = app.update(Message::CommandEscape);
        // A second pick parks again and cancels on Escape.
        request(&mut app, json!({"op":"getpoint","request_id":"gp-3"}));
        let _ = app.update(Message::CommandEscape);
        let cancelled = user_select_result(&mut app, "gp-3");
        assert_eq!(cancelled["status"], "cancelled", "{cancelled}");
        assert_eq!(cancelled["result"]["cancelled"], true);
    }

    #[test]
    fn getpoint_snap_marker_and_snapped_answer_while_pending() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 100,0"}));
        let i = app.active_tab;
        {
            let tab = &mut app.tabs[i];
            tab.scene.selection.borrow_mut().view.vp_size = (1920.0, 1080.0);
            tab.scene.sync_tiles_from_panes(1920.0, 1080.0);
            tab.scene.fit_all(); // bring the line into the pane so snaps can hit
        }
        // Park a client pick: with no command running, a cursor move must
        // still run the object-snap engine so the marker shows and the
        // click hands the snapped point back.
        let asked = request(
            &mut app,
            json!({"op":"getpoint","request_id":"gp-snap","prompt":"Chọn góc"}),
        );
        assert_eq!(asked["status"], "running", "{asked}");

        // Screen position of the line's endpoint through the live camera.
        let endpoint = glam::DVec3::new(100.0, 0.0, 0.0);
        let (sx, sy) = {
            let cam = app.tabs[i].scene.camera.borrow();
            let bounds = iced::Rectangle {
                x: 0.0,
                y: 0.0,
                width: 1920.0,
                height: 1080.0,
            };
            let view = cam.view_proj_rte(bounds);
            let eye = cam.eye();
            let ndc = view.project_point3((endpoint - eye).as_vec3());
            (
                (ndc.x + 1.0) * 0.5 * bounds.width,
                (1.0 - ndc.y) * 0.5 * bounds.height,
            )
        };
        let _ = app.update(Message::ViewportMove(iced::Point::new(
            sx as f32, sy as f32,
        )));

        assert!(
            app.tabs[i].snap_result.is_some(),
            "no object-snap marker while a getpoint is pending"
        );
        let snapped = app.tabs[i].last_cursor_world;
        assert!(
            (snapped - endpoint).length() < 1e-6,
            "cursor point not snapped to the endpoint: {snapped:?}"
        );

        // The click answers the pick with the snapped endpoint.
        let _ = app.update(Message::ViewportLeftPress);
        let done = user_select_result(&mut app, "gp-snap");
        assert_eq!(done["status"], "completed", "{done}");
        assert_eq!(done["result"]["point"], json!([100.0, 0.0, 0.0]));
    }

    #[test]
    fn user_select_snap_marker_shows_while_pending() {
        let mut app = OpenCADStudio::new_for_test();
        app.main_window = Some(iced::window::Id::unique());
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 100,0"}));
        let i = app.active_tab;
        {
            let tab = &mut app.tabs[i];
            tab.scene.selection.borrow_mut().view.vp_size = (1920.0, 1080.0);
            tab.scene.sync_tiles_from_panes(1920.0, 1080.0);
            tab.scene.fit_all();
        }
        let asked = request(
            &mut app,
            json!({"op":"user_select","request_id":"us-snap","prompt":"Chọn trường","clear":true}),
        );
        assert_eq!(asked["status"], "running", "{asked}");

        let endpoint = glam::DVec3::new(100.0, 0.0, 0.0);
        let (sx, sy) = {
            let cam = app.tabs[i].scene.camera.borrow();
            let bounds = iced::Rectangle {
                x: 0.0,
                y: 0.0,
                width: 1920.0,
                height: 1080.0,
            };
            let view = cam.view_proj_rte(bounds);
            let eye = cam.eye();
            let ndc = view.project_point3((endpoint - eye).as_vec3());
            (
                (ndc.x + 1.0) * 0.5 * bounds.width,
                (1.0 - ndc.y) * 0.5 * bounds.height,
            )
        };
        let _ = app.update(Message::ViewportMove(iced::Point::new(
            sx as f32, sy as f32,
        )));
        assert!(
            app.tabs[i].snap_result.is_some(),
            "no object-snap marker while a user_select is pending"
        );

        // The pick itself stays entity-based: selecting the line + Enter still
        // answers the request — the marker must not break selection.
        let handle = app.automation_op(r#"{"op":"query","type":"LINE","detail":"summary"}"#)
            ["entities"][0]["handle"]
            .as_str()
            .unwrap()
            .to_owned();
        let value = u64::from_str_radix(&handle, 16).unwrap();
        app.tabs[i]
            .scene
            .select_entity(codec::Handle::new(value), false);
        let _ = app.update(Message::CommandFinalize);
        let done = user_select_result(&mut app, "us-snap");
        assert_eq!(done["status"], "completed", "{done}");
        assert_eq!(done["result"]["count"], 1);
    }

    #[test]
    fn get_selection_reports_insert_block_and_position() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,10"}));
        let line = app.automation_op(r#"{"op":"query","type":"LINE","detail":"summary"}"#)
            ["entities"][0]["handle"]
            .as_str()
            .unwrap()
            .to_owned();
        // A title-block-style definition with one placed reference.
        request(
            &mut app,
            json!({"op":"block_define","name":"A3","base":[0,0],"handles":[line]}),
        );
        let insert = app.automation_op(r#"{"op":"query","type":"Insert","detail":"summary"}"#)
            ["entities"][0]["handle"]
            .as_str()
            .unwrap()
            .to_owned();
        app.automation_op(&format!(r#"{{"op":"select","handles":["{insert}"]}}"#));
        let read = request(&mut app, json!({"op":"get_selection"}));
        assert_eq!(read["status"], "completed", "{read}");
        assert_eq!(read["result"]["count"], 1);
        let entity = &read["result"]["entities"][0];
        assert_eq!(entity["type"], "Block Reference");
        assert_eq!(entity["block"], "A3");
        assert!(entity["position"].is_array(), "{entity}");
        // Non-inserts answer null for the block field.
        app.tabs[app.active_tab].scene.deselect_all();
        let circle = request(
            &mut app,
            json!({"op":"entities_create","entities":[{"type":"Circle","center":[0,0],"radius":2}]}),
        );
        let circle_handle = circle["result"]["handles"][0].as_str().unwrap().to_owned();
        app.automation_op(&format!(
            r#"{{"op":"select","handles":["{circle_handle}"]}}"#
        ));
        let read = request(&mut app, json!({"op":"get_selection"}));
        assert_eq!(read["result"]["count"], 1);
        assert_eq!(read["result"]["entities"][0]["block"], Value::Null);
    }

    #[test]
    fn plot_op_applies_per_layer_lineweights() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        {
            let scene = &mut app.tabs[app.active_tab].scene;
            // Two layers set to different pen weights; entities fully ByLayer.
            for (name, weight) in [
                ("THIN", codec::types::LineWeight::Value(13)),
                ("THICK", codec::types::LineWeight::Value(50)),
            ] {
                let mut layer = codec::tables::Layer::new(name);
                layer.line_weight = weight;
                let _ = scene.document.layers.add(layer);
            }
            for (name, origin) in [("THIN", 0.0), ("THICK", 3000.0)] {
                let mut line = codec::entities::Line::new();
                line.common.layer = name.to_string();
                line.start = codec::types::Vector3::new(origin, origin, 0.0);
                line.end = codec::types::Vector3::new(origin + 3000.0, origin + 2000.0, 0.0);
                scene.add_entity(codec::EntityType::Line(line));
            }
        }

        let pdf = std::env::temp_dir().join(format!("ocs-plot-lw-{}.pdf", std::process::id()));
        let response = request(
            &mut app,
            json!({"op":"plot","path":pdf.to_string_lossy(),"plot_style":"monochrome.ctb"}),
        );
        assert_eq!(response["status"], "completed", "{response}");

        // The plotted PDF carries two distinct pen widths — the per-layer
        // 0.13 mm / 0.50 mm hierarchy survives the plot style (thin clamps to
        // the 1 px floor, so the ratio is the clamped-pixel ratio 1.889).
        let text =
            crate::io::pdf_export::pdf_stream_text(&std::fs::read(&pdf).expect("pdf written"));
        let tokens: Vec<&str> = text.split_whitespace().collect();
        let mut widths: Vec<f32> = tokens
            .windows(2)
            .filter_map(|pair| {
                if pair[1] == "w" {
                    pair[0].parse::<f32>().ok()
                } else {
                    None
                }
            })
            .collect();
        widths.sort_by(|a, b| a.partial_cmp(b).unwrap());
        widths.dedup_by(|a, b| (*a - *b).abs() < 0.01);
        widths.retain(|width| *width > 0.2);
        assert_eq!(
            widths.len(),
            2,
            "two layer weights in the plotted PDF: {widths:?}"
        );
        assert!(
            (widths[1] / widths[0] - 1.889).abs() < 0.15,
            "0.50 mm vs 0.13 mm hierarchy: {widths:?}"
        );
        let _ = std::fs::remove_file(&pdf);
    }

    #[test]
    fn plot_op_applies_ctb_colors_through_layer_aci() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        {
            let scene = &mut app.tabs[app.active_tab].scene;
            // Frame layer carries the classic cyan ACI 4; its entity is ByLayer.
            let mut frame = codec::tables::Layer::new("FRAME-CYAN");
            frame.color = codec::types::Color::Index(4);
            let _ = scene.document.layers.add(frame);
            let mut frame_line = codec::entities::Line::new();
            frame_line.common.layer = "FRAME-CYAN".to_string();
            frame_line.start = codec::types::Vector3::new(0.0, 0.0, 0.0);
            frame_line.end = codec::types::Vector3::new(3000.0, 0.0, 0.0);
            scene.add_entity(codec::EntityType::Line(frame_line));

            // An explicit red ACI 1 and a true-color green: index must map
            // through the CTB, the true color must stay RGB (aci 0).
            let mut red = codec::entities::Line::new();
            red.common.color = codec::types::Color::Index(1);
            red.start = codec::types::Vector3::new(0.0, 1000.0, 0.0);
            red.end = codec::types::Vector3::new(3000.0, 1000.0, 0.0);
            scene.add_entity(codec::EntityType::Line(red));

            let mut true_color = codec::entities::Line::new();
            true_color.common.color = codec::types::Color::from_true_color_value(0x0000FF00);
            true_color.start = codec::types::Vector3::new(0.0, 2000.0, 0.0);
            true_color.end = codec::types::Vector3::new(3000.0, 2000.0, 0.0);
            scene.add_entity(codec::EntityType::Line(true_color));
        }

        let pdf = std::env::temp_dir().join(format!("ocs-plot-aci-{}.pdf", std::process::id()));
        let response = request(
            &mut app,
            json!({"op":"plot","path":pdf.to_string_lossy(),"plot_style":"monochrome.ctb"}),
        );
        assert_eq!(response["status"], "completed", "{response}");

        let text =
            crate::io::pdf_export::pdf_stream_text(&std::fs::read(&pdf).expect("pdf written"));
        // Monochrome maps every index colour (ByLayer cyan frame, explicit
        // red) to black; the true-color line keeps its RGB by definition.
        assert!(
            !text.contains("0 1 1 rg") && !text.contains("0 1 1 RG"),
            "cyan frame must be CTB-mapped to monochrome"
        );
        assert!(
            !text.contains("1 0 0 rg") && !text.contains("1 0 0 RG"),
            "explicit red must be CTB-mapped to monochrome"
        );
        assert!(
            text.contains("0 1 0 rg") || text.contains("0 1 0 RG"),
            "true-color line keeps its RGB (aci 0 is not CTB-mapped)"
        );
        assert!(
            text.contains("0 0 0 rg") || text.contains("0 0 0 RG"),
            "monochrome strokes must plot black"
        );

        // Without a plot style the same drawing keeps its colours: the cyan
        // frame plots as the dark-blue print remap, the red line stays red.
        let plain =
            std::env::temp_dir().join(format!("ocs-plot-aci-plain-{}.pdf", std::process::id()));
        let response = request(
            &mut app,
            json!({"op":"plot","path":plain.to_string_lossy()}),
        );
        assert_eq!(response["status"], "completed", "{response}");
        let text =
            crate::io::pdf_export::pdf_stream_text(&std::fs::read(&plain).expect("pdf written"));
        let color_ops: Vec<[f32; 3]> = {
            let tokens: Vec<&str> = text.split_whitespace().collect();
            tokens
                .windows(4)
                .filter_map(|quad| {
                    if quad[3] != "rg" && quad[3] != "RG" {
                        return None;
                    }
                    Some([
                        quad[0].parse::<f32>().ok()?,
                        quad[1].parse::<f32>().ok()?,
                        quad[2].parse::<f32>().ok()?,
                    ])
                })
                .collect()
        };
        let near = |color: &[f32; 3], target: [f32; 3]| {
            color
                .iter()
                .zip(target)
                .all(|(channel, expected)| (channel - expected).abs() < 0.02)
        };
        assert!(
            color_ops.iter().any(|c| near(c, [0.0, 0.15, 0.5])),
            "unstyled cyan frame plots as the dark-blue print remap: {color_ops:?}"
        );
        assert!(
            color_ops.iter().any(|c| near(c, [1.0, 0.0, 0.0])),
            "unstyled red line keeps its colour: {color_ops:?}"
        );
        assert!(
            color_ops.iter().any(|c| near(c, [0.0, 1.0, 0.0])),
            "unstyled true-color line keeps its colour: {color_ops:?}"
        );
        let _ = std::fs::remove_file(&pdf);
        let _ = std::fs::remove_file(&plain);
    }

    /// An unknown `entities_transform` action must come back as a clean
    /// validation error. Pre-fix it reached
    /// `unreachable!("validated by transform()")` (entities.rs:476) and
    /// killed the whole process — over REST, MCP and `--serve` alike —
    /// because validation lived inside the `transform` closure, which the
    /// dispatch match only invokes from some of its arms.
    #[test]
    fn entities_transform_rejects_unknown_actions_without_panicking() {
        let mut app = OpenCADStudio::new_for_test();
        request(&mut app, json!({"op":"new"}));
        request(&mut app, json!({"op":"run","cmd":"LINE 0,0 10,0"}));
        let lines = app.control_request(json!({"op":"query","type":"Line"})).0;
        let handle = lines["entities"][0]["handle"].as_str().unwrap().to_string();

        // Not one of the six whitelisted actions.
        let rejected = request(
            &mut app,
            json!({
                "op":"entities_transform",
                "handles":[handle],
                "action":"explode"
            }),
        );
        assert_eq!(rejected["code"], "invalid_action", "{rejected}");

        // Whitespace-only is unknown too — not a panic.
        let blank = request(
            &mut app,
            json!({
                "op":"entities_transform",
                "handles":[handle],
                "action":"   "
            }),
        );
        assert_eq!(blank["code"], "invalid_action", "{blank}");

        // A valid action is matched case- and whitespace-insensitively.
        let moved = request(
            &mut app,
            json!({
                "op":"entities_transform",
                "handles":[handle],
                "action":" move ",
                "vector":[5,0,0]
            }),
        );
        assert_eq!(moved["ok"], true, "{moved}");
    }
}