//! 独立 2D 相机与可逆投影。视口尺寸属于布局；平移、缩放属于视图，不改变世界对象的逻辑位置。
//! project 为每次出现附加组合变换、裁剪和嵌套面板映射；绘制与命中共用这些结果。fit 根据有限内容边界调整指定相机。
//!
//! Reversible projections keep camera movement independent of layout.
pub mod spatial;
use crate::geometry::{Point, Rect};
use endor_core::{ObjectPayload, ObjectRef, ObjectStore, VmError};

/// Marker payload gives cameras a native nominal identity while their fields
/// remain ordinary traced, bindable VM attributes.
#[derive(Debug)]
/// 托管 2D 相机的名义标记，实际位置/缩放是被追踪的普通属性。
pub struct Camera2D;
impl ObjectPayload for Camera2D {
    /// 提供受检查的 Any 下转型入口，让宿主按具体 payload 类型读取数据。
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
    /// 返回运行时诊断/类型检查使用的稳定 payload 名称。
    fn kind_name(&self) -> &'static str {
        "camera-2d"
    }
    /// 声明此 payload 是否允许使用托管属性存储，具体字段仍由类型与调用检查约束。
    fn allows_attributes(&self) -> bool {
        true
    }
    /// 枚举本对象真正拥有的托管强引用，供 Aster 引用追踪和循环回收使用。
    fn trace(&self, _: &mut dyn FnMut(ObjectRef)) {}
}

#[derive(Debug, Clone, PartialEq)]
/// 从 VM 提取的独立相机数值描述，渲染与布局投影不直接读取托管堆。
pub struct CameraView {
    pub identity: String,
    pub x: f32,
    pub y: f32,
    pub zoom: f32,
}

/// 读取并校验托管 Camera2D 的位置和缩放，生成原生投影描述。
pub fn camera(store: &ObjectStore, object: ObjectRef) -> Result<CameraView, VmError> {
    store.payload::<Camera2D>(object, "Camera2D")?;
    let x = crate::scroll::coordinate(&store.get_attr(object, "x")?)?;
    let y = crate::scroll::coordinate(&store.get_attr(object, "y")?)?;
    let zoom = crate::scroll::coordinate(&store.get_attr(object, "zoom")?)?;
    if !(0.01..=100.0).contains(&zoom) {
        return Err(VmError::InvalidArgument(
            "Camera2D.zoom expects 0.01 through 100",
        ));
    }
    Ok(CameraView {
        identity: object.to_string(),
        x,
        y,
        zoom,
    })
}

/// Fit finite scene bounds using this occurrence's allocation. Sharing a camera
/// is explicit, so fitting one view then intentionally affects all its users.
/// 根据这个 CanvasViewport 出现的有限内容范围调整其相机；显式共享相机会同步影响其他视口。
pub fn fit(
    cx: &mut endor_core::NativeContext<'_>,
    mount: &crate::mount::Mount,
) -> Result<(), VmError> {
    if !mount.geometry.canvas_viewport || mount.layout.is_some() {
        return Err(VmError::InvalidArgument(
            "fitView requires a committed CanvasViewport Mount",
        ));
    }
    let (_, data) = crate::block::resolve(cx.store(), mount.block)?;
    let data = crate::block::visual_data(cx.store(), data)?;
    let camera = data
        .camera
        .ok_or(VmError::InvalidArgument("missing viewport camera"))?;
    let root = mount
        .first_child
        .map(|weak| cx.upgrade(weak))
        .transpose()?
        .flatten()
        .ok_or(VmError::InvalidArgument("missing scene occurrence"))?;
    let scene = cx
        .store()
        .payload::<crate::mount::Mount>(root, "Mount")?
        .clone();
    let mut next = scene.first_child;
    let mut bounds: Option<[f32; 4]> = None;
    let mut count = 0;
    while let Some(weak) = next {
        count += 1;
        if count > 10_000 {
            return Err(VmError::ExecutionLimit("fitView scene bounds"));
        }
        let object = cx
            .upgrade(weak)?
            .ok_or(VmError::InvalidArgument("expired scene child"))?;
        let child = cx.store().payload::<crate::mount::Mount>(object, "Mount")?;
        let rect = [
            child.geometry.x - scene.geometry.x,
            child.geometry.y - scene.geometry.y,
            child.geometry.x - scene.geometry.x + child.geometry.width,
            child.geometry.y - scene.geometry.y + child.geometry.height,
        ];
        bounds = Some(bounds.map_or(rect, |b| {
            [
                b[0].min(rect[0]),
                b[1].min(rect[1]),
                b[2].max(rect[2]),
                b[3].max(rect[3]),
            ]
        }));
        next = child.next_sibling;
    }
    let node = crate::block::snapshot(cx.store(), mount.block)?;
    let inset = crate::layout::insets(&node);
    let width = (mount.geometry.width - inset.horizontal()).max(0.0);
    let height = (mount.geometry.height - inset.vertical()).max(0.0);
    let (x, y, zoom) = if let Some(bounds) = bounds {
        let zoom = (width / (bounds[2] - bounds[0] + 48.0))
            .min(height / (bounds[3] - bounds[1] + 48.0))
            .clamp(0.01, 100.0);
        (
            (bounds[0] + bounds[2]) / 2.0 - width / (2.0 * zoom),
            (bounds[1] + bounds[3]) / 2.0 - height / (2.0 * zoom),
            zoom,
        )
    } else {
        (0.0, 0.0, 1.0)
    };
    for (name, value) in [("x", x), ("y", y), ("zoom", zoom)] {
        cx.set_attr(
            camera,
            name,
            crate::native_visual::value(value.clamp(-1_000_000.0, 1_000_000.0)),
        )?;
    }
    Ok(())
}

#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
/// 可组合的均匀缩放与平移；正向绘制和逆向命中必须使用同一结果。
pub struct Transform {
    pub zoom: f32,
    pub x: f32,
    pub y: f32,
}
impl Default for Transform {
    /// 建立类型约定的初始值，供尚未发布或尚未交互的状态使用。
    fn default() -> Self {
        Self {
            zoom: 1.0,
            x: 0.0,
            y: 0.0,
        }
    }
}
impl Transform {
    /// 将逻辑点按当前缩放和平移变换到外层视图。
    pub fn point(self, point: Point) -> Point {
        Point::new(point.x * self.zoom + self.x, point.y * self.zoom + self.y)
    }
    /// 将视图点反算回逻辑坐标，供命中和手势锚点计算使用。
    pub fn inverse(self, point: Point) -> Point {
        Point::new(
            (point.x - self.x) / self.zoom,
            (point.y - self.y) / self.zoom,
        )
    }
    /// 使用同一缩放和平移转换矩形的位置与尺寸。
    pub fn rect(self, rect: Rect) -> Rect {
        let point = self.point(Point::new(rect.x, rect.y));
        Rect::new(
            point.x,
            point.y,
            rect.width * self.zoom,
            rect.height * self.zoom,
        )
    }
    /// 将当前变换再放入外层变换，保持绘制与逆向命中的组合顺序一致。
    pub fn then(self, outer: Self) -> Self {
        Self {
            zoom: self.zoom * outer.zoom,
            x: self.x * outer.zoom + outer.x,
            y: self.y * outer.zoom + outer.y,
        }
    }
    /// 检查数值、几何和资源条件是否满足本类型约束，供上层拒绝非法输入。
    pub fn valid(self) -> bool {
        self.zoom.is_finite()
            && self.zoom > 0.0
            && self.zoom <= 1_000_000.0
            && self.x.is_finite()
            && self.y.is_finite()
            && self.x.abs() <= 1_000_000_000_000.0
            && self.y.abs() <= 1_000_000_000_000.0
    }
}

/// 计算视口与祖先裁剪的共同可见矩形。
fn intersect(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
    let x = a[0].max(b[0]);
    let y = a[1].max(b[1]);
    [
        x,
        y,
        ((a[0] + a[2]).min(b[0] + b[2]) - x).max(0.0),
        ((a[1] + a[3]).min(b[1] + b[3]) - y).max(0.0),
    ]
}

/// 遍历出现树，组合相机与父视图变换，建立裁剪和世界 UI 映射，最后重建屏幕命中索引。
pub fn project(
    root: &crate::ui_bridge::UiNode,
    frame: &mut crate::document::Frame,
) -> anyhow::Result<()> {
    use crate::ui_bridge::UiKind;
    use std::collections::HashMap;
    use std::sync::Arc;
    let mut nodes = HashMap::new();
    let mut work = vec![root];
    while let Some(node) = work.pop() {
        nodes.insert(node.block_id.as_str(), node);
        work.extend(node.children().iter().map(|node| node.as_ref()));
    }
    type Scope = (
        Transform,
        Option<[f32; 4]>,
        Option<Arc<crate::scene3d::panel::Mapping>>,
    );
    let mut contexts = HashMap::<u64, Scope>::new();
    let next: HashMap<_, _> = frame
        .mounts
        .iter()
        .map(|mount| (mount.id, mount.next_sibling))
        .collect();
    let mut panels =
        HashMap::<u64, (Arc<crate::scene3d::panel::Mapping>, crate::layout::Size)>::new();
    for mount in &mut frame.mounts {
        let node = nodes[mount.block_id.as_str()];
        let (view, clip, panel) = if let Some((panel, size)) = panels.get(&mount.id) {
            (
                Transform::default(),
                Some([0., 0., size.width, size.height]),
                Some(panel.clone()),
            )
        } else {
            mount
                .parent
                .and_then(|parent| contexts.get(&parent).cloned())
                .unwrap_or_default()
        };
        anyhow::ensure!(
            view.valid(),
            "nested viewport transform exceeds numeric budget"
        );
        mount.view = (view != Transform::default()).then_some(view);
        mount.panel = panel.clone();
        mount.clip = clip;
        mount.viewport_clip = None;
        let mut child_view = view;
        let mut child_clip = clip;
        let inset = crate::layout::insets(node);
        let viewport = if let UiKind::CanvasViewport { camera, .. } = &node.kind {
            let x = mount.x + inset.left;
            let y = mount.y + inset.top;
            child_view = Transform {
                zoom: camera.zoom,
                x: x * (1.0 - camera.zoom) - camera.x * camera.zoom,
                y: y * (1.0 - camera.zoom) - camera.y * camera.zoom,
            }
            .then(view);
            Some(Rect::new(
                x,
                y,
                (mount.width - inset.horizontal()).max(0.0),
                (mount.height - inset.vertical()).max(0.0),
            ))
        } else if matches!(node.kind, UiKind::Viewport3D { .. }) {
            Some(Rect::new(
                mount.x + inset.left,
                mount.y + inset.top,
                (mount.width - inset.horizontal()).max(0.),
                (mount.height - inset.vertical()).max(0.),
            ))
        } else if node.clip_children {
            let border = node.border;
            Some(Rect::new(
                mount.x + border.left.min(mount.width),
                mount.y + border.top.min(mount.height),
                (mount.width - border.horizontal()).max(0.0),
                (mount.height - border.vertical()).max(0.0),
            ))
        } else if matches!(node.kind, UiKind::Scroll { .. }) {
            Some(Rect::new(mount.x, mount.y, mount.width, mount.height))
        } else {
            None
        };
        if let Some(rect) = viewport {
            let rect = view.rect(rect);
            let rect = [rect.x, rect.y, rect.width, rect.height];
            child_clip = Some(clip.map_or(rect, |clip| intersect(clip, rect)));
            if mount.canvas_viewport || mount.scene3d_viewport {
                mount.viewport_clip = child_clip;
            }
        }
        if let UiKind::Viewport3D {
            view: scene,
            panels: sizes,
            ..
        } = &node.kind
        {
            let mut depth = 0;
            let mut ancestor = panel.clone();
            while let Some(mapping) = ancestor {
                depth += 1;
                ancestor = mapping.parent.clone();
            }
            anyhow::ensure!(depth < 8, "3D UI viewport nesting exceeds 8 surfaces");
            let mut child = mount.first_child;
            for (key, size) in node.slots.iter().zip(sizes) {
                let id = child.ok_or_else(|| anyhow::anyhow!("missing 3D UI root occurrence"))?;
                let mapping = Arc::new(crate::scene3d::panel::Mapping {
                    owner: mount.id,
                    key: *key,
                    view: scene.clone(),
                    rect: [
                        mount.x + inset.left,
                        mount.y + inset.top,
                        (mount.width - inset.horizontal()).max(0.),
                        (mount.height - inset.vertical()).max(0.),
                    ],
                    outer: view,
                    clip: mount.viewport_clip,
                    parent: panel.clone(),
                });
                panels.insert(id, (mapping, *size));
                child = next[&id];
            }
        }
        contexts.insert(mount.id, (child_view, child_clip, panel));
    }
    let mounts: HashMap<_, _> = frame.mounts.iter().map(|mount| (mount.id, mount)).collect();
    frame.command_views.clear();
    frame.command_clips.clear();
    anyhow::ensure!(
        frame.command_mounts.len() == frame.commands.len(),
        "missing command occurrence table"
    );
    for owner in &frame.command_mounts {
        let mount = mounts
            .get(owner)
            .ok_or_else(|| anyhow::anyhow!("paint owner is unavailable"))?;
        frame.command_views.push(mount.view);
        frame.command_clips.push(mount.clip);
    }
    frame.hit_index = std::sync::Arc::new(spatial::Index::build(&frame.mounts));
    Ok(())
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn nested_views_compose_and_invert_without_changing_layout_coordinates() {
        // Camera coordinates may be +/-1e6 at zoom 100. Their projected
        // translation must not inherit the smaller world-coordinate limit.
        assert!(
            Transform {
                zoom: 100.,
                x: -100_000_000.,
                y: 100_000_000.
            }
            .valid()
        );
        let inner = Transform {
            zoom: 2.0,
            x: 12.0,
            y: -40.0,
        };
        let outer = Transform {
            zoom: 0.5,
            x: 80.0,
            y: 20.0,
        };
        let point = Point::new(-5.0, 100.0);
        let composed = inner.then(outer);
        assert_eq!(composed.point(point), outer.point(inner.point(point)));
        assert_eq!(composed.inverse(composed.point(point)), point);
        assert_eq!(
            composed.rect(Rect::new(-5.0, 100.0, 20.0, 30.0)),
            Rect::new(81.0, 100.0, 20.0, 30.0)
        );
    }
}