//! 通过真正的源/原生 hitTest 协议确定指针目标。
//! 按逆绘制顺序筛选候选，并在同一只读 VM 调用与预算中比较按下、释放目标；透明或未命中的子项可以继续回退。
//!
//! Resolve pointer targets in paint order through source/native hitTest methods.
//! Both press and release selectors share one read-only VM call and budget.
use crate::{mount::Mount, ui_bridge::attach_desktop_type};
use endor_core::{
    CodeLayout, ContextNativeFunction, EndorCode, EndorCodeObject, Instruction, NativeCallable,
    NativeContext, NativeResult, ObjectRef, Opcode, Value, Vm, VmError, WeakObjectRef,
};

#[derive(Debug)]
/// 验证 hitTest 返回的是 Bool，避免把任意真值隐式当成命中。
struct Boolean;
impl NativeCallable for Boolean {
    /// 接收 hitTest 返回的唯一值，交给 invoke 严格检查 Bool。
    fn arity(&self) -> Option<endor_core::CallArity> {
        Some(endor_core::CallArity::exact(1))
    }

    /// 只接受真正的 Bool 并原样返回；数字或对象不能以宿主真值规则替代源协议契约。
    fn invoke(&self, _: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
        // 协议要求明确 Bool；拒绝数字、对象等“真值”，使用户实现错误立即暴露。
        let [Value::Bool(value)] = args else {
            return Err(VmError::InvalidArgument("hitTest must return Bool"));
        };
        Ok(NativeResult::Return(Value::Bool(*value)))
    }
}
#[derive(Debug)]
/// 比较按下与释放的选择结果，只有同一目标才能继续点击分发。
struct SameTarget;
impl NativeCallable for SameTarget {
    /// 接收按下与释放两次命中选择的结果。
    fn arity(&self) -> Option<endor_core::CallArity> {
        Some(endor_core::CallArity::exact(2))
    }

    /// 仅当两结果为同一 Mount 对象才返回目标，否则返回 Nil；共享 Block 的不同出现位置也不能合成点击。
    fn invoke(&self, _: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
        // 比较的是实际出现 Mount 的身份；即使共享同一个 Block，不同出现之间拖动也不构成点击。
        let value = match args {
            [Value::Object(first), Value::Object(second)] if first == second => {
                Value::Object(*first)
            }
            _ => Value::Nil,
        };
        Ok(NativeResult::Return(value))
    }
}
/// 构造只读命中选择驱动所需的托管代码与函数对象。
fn code(
    cx: &mut NativeContext<'_>,
    instructions: Vec<Instruction>,
    constants: Vec<Value>,
    layout: CodeLayout,
) -> Result<ObjectRef, VmError> {
    // 校验并编码指令，同时设置诊断位置；独立空 globals 避免驱动依赖业务全局命名空间。
    let code = EndorCode::from_instructions(&instructions, constants, layout)?.with_location(
        "<pointer hitTest>",
        "<tessera>",
        1,
    );
    let code = cx.allocate(EndorCodeObject::new(code))?;
    let globals = cx.new_dict()?;
    cx.new_function("pointer hitTest", code, globals)
}
/// 按逆绘制顺序构造候选 hitTest 调用，先进行几何与局部坐标筛选。
fn selector(
    cx: &mut NativeContext<'_>,
    candidates: &[WeakObjectRef],
    point: [f32; 2],
    desktop: ObjectRef,
) -> Result<ObjectRef, VmError> {
    let validate = cx.allocate(ContextNativeFunction::new(
        "validate hitTest",
        Boolean,
        vec![],
    ))?;
    let mut instructions = Vec::new();
    let mut constants = vec![Value::Object(validate)];
    // 候选按绘制顺序提供，逆序使最上层先参与测试；弱引用失效视为过期输入错误。
    for weak in candidates.iter().rev() {
        let mount = cx
            .upgrade(*weak)?
            .ok_or(VmError::InvalidArgument("pointer Mount expired"))?;
        let target = cx.store().payload::<Mount>(mount, "Mount")?.clone();
        // 先排除已卸载、非交互和几何不命中的出现，避免为明显无效候选构造源调用。
        if !target.mounted
            || !target.geometry.interactive
            || !target
                .geometry
                .contains(crate::geometry::Point::new(point[0], point[1]))
        {
            continue;
        }
        let geometry = &target.geometry;
        let point = crate::geometry::Point::new(point[0], point[1]);
        // 把投影坐标反算到节点逻辑空间；不可逆/无效投影没有可用于 hitTest 的局部坐标。
        let Some(point) = geometry.logical_point(point) else {
            continue;
        };
        // 源 Point 以节点左上为原点；这里再次验证范围，避免变换后的点落到节点盒子之外。
        let x = point.x - geometry.x;
        let y = point.y - geometry.y;
        if x < 0.0 || y < 0.0 || x > geometry.width || y > geometry.height {
            continue;
        }
        // 依据真实 Block 的名义类型解析 hitTest，不用原生矩形命中替代源协议。
        let definition = cx
            .store()
            .type_of(target.block)?
            .ok_or(VmError::InvalidArgument("untyped hit target"))?;
        let function = cx
            .store()
            .lookup_method(definition, "hitTest")?
            .ok_or(VmError::InvalidArgument("missing hitTest method"))?;
        let local = cx.new_object()?;
        attach_desktop_type(cx, local, "Point", desktop)?;
        cx.set_attr(local, "x", Value::Number((x as f64).into()))?;
        cx.set_attr(local, "y", Value::Number((y as f64).into()))?;
        // 每个候选占四个常量：协议函数、Block、Mount、局部 Point；索引供下面字节码复用。
        let start = constants.len() as u32;
        constants.extend([
            Value::Object(function),
            Value::Object(target.block),
            Value::Object(mount),
            Value::Object(local),
        ]);
        // false 分支只跳过“加载本 Mount 并返回”两条指令。按编码宽度计算，
        // 常量索引大到需要扩展操作数时仍能跳到下一候选。
        let skip = (Instruction::encode_all(&[
            Instruction::new(Opcode::LoadConst, start + 2),
            Instruction::simple(Opcode::ReturnValue),
        ])?
        .len()
            / 2) as u32;
        // 先调用 hitTest(block, mount, local)，再把结果传给 validate。
        // true 立即返回本 Mount；false 继续下一个候选，实现透明区域向下穿透。
        instructions.extend([
            Instruction::new(Opcode::LoadConst, 0),
            Instruction::simple(Opcode::PushNull),
            Instruction::new(Opcode::LoadConst, start),
            Instruction::simple(Opcode::PushNull),
            Instruction::new(Opcode::LoadConst, start + 1),
            Instruction::new(Opcode::LoadConst, start + 2),
            Instruction::new(Opcode::LoadConst, start + 3),
            Instruction::new(Opcode::Call, 3),
            Instruction::new(Opcode::Call, 1),
            Instruction::new(Opcode::PopJumpIfFalse, skip),
            Instruction::new(Opcode::LoadConst, start + 2),
            Instruction::simple(Opcode::ReturnValue),
        ]);
    }
    // 所有候选均未命中时显式返回 Nil；不会把最后一个 false 当作选择结果。
    let end = constants.len() as u32;
    constants.push(Value::Nil);
    instructions.extend([
        Instruction::new(Opcode::LoadConst, end),
        Instruction::simple(Opcode::ReturnValue),
    ]);
    code(cx, instructions, constants, CodeLayout::default())
}
#[derive(Debug)]
/// 在一个只读调用中准备两次指针选择所需的候选与局部坐标。
struct Prepare {
    candidates: Vec<WeakObjectRef>,
    press: [f32; 2],
    release: [f32; 2],
    desktop: ObjectRef,
}
impl NativeCallable for Prepare {
    /// 候选、按下点和释放点已保存于适配器，无需外部实参。
    fn arity(&self) -> Option<endor_core::CallArity> {
        Some(endor_core::CallArity::exact(0))
    }

    /// 为按下/释放各建立只读选择器，把两次结果放入同一 VM 调用序列，再交 SameTarget 比较实际出现身份。
    fn invoke(&self, cx: &mut NativeContext<'_>, _: &[Value]) -> Result<NativeResult, VmError> {
        // 按下和释放分别构造选择器，但都在本次只读执行内调用，使用同一预算域。
        let down = selector(cx, &self.candidates, self.press, self.desktop)?;
        let up = selector(cx, &self.candidates, self.release, self.desktop)?;
        let compare = cx.allocate(ContextNativeFunction::new(
            "same pointer target",
            SameTarget,
            vec![],
        ))?;
        // 两次选择结果先存入局部槽，再作为两个实参交给 SameTarget；局部槽也保留中间结果生命周期。
        let instructions = vec![
            Instruction::new(Opcode::LoadConst, 0),
            Instruction::simple(Opcode::PushNull),
            Instruction::new(Opcode::Call, 0),
            Instruction::new(Opcode::StoreFast, 0),
            Instruction::new(Opcode::LoadConst, 1),
            Instruction::simple(Opcode::PushNull),
            Instruction::new(Opcode::Call, 0),
            Instruction::new(Opcode::StoreFast, 1),
            Instruction::new(Opcode::LoadConst, 2),
            Instruction::simple(Opcode::PushNull),
            Instruction::new(Opcode::LoadFast, 0),
            Instruction::new(Opcode::LoadFast, 1),
            Instruction::new(Opcode::Call, 2),
            Instruction::simple(Opcode::ReturnValue),
        ];
        let driver = code(
            cx,
            instructions,
            vec![
                Value::Object(down),
                Value::Object(up),
                Value::Object(compare),
            ],
            CodeLayout {
                locals: vec!["press".into(), "release".into()],
                ..CodeLayout::default()
            },
        )?;
        // 把执行权交回 VM 运行驱动，不在宿主里递归开启另一次 VM 调用。
        Ok(NativeResult::Invoke {
            function: driver,
            arguments: vec![],
        })
    }
}
/// Returned Mount owns one root. No-hit and mismatched targets return None.
/// 在一次有界只读调用中分别选择按下与释放目标；仅二者为同一 Mount 时返回其拥有根。
pub fn resolve(
    vm: &mut Vm,
    desktop: ObjectRef,
    candidates: Vec<WeakObjectRef>,
    press: [f32; 2],
    release: [f32; 2],
) -> anyhow::Result<Option<ObjectRef>> {
    // 显式 captures 保活 desktop；候选列表仍是弱引用，不因等待选择而保活全部旧 Mount。
    let prepare = vm.allocate(ContextNativeFunction::new(
        "prepare pointer hitTest",
        Prepare {
            candidates,
            press,
            release,
            desktop,
        },
        vec![desktop],
    ))?;
    let result = vm.call_read_only_with_limits(
        prepare,
        &[],
        endor_core::ExecutionLimits {
            max_frames: 128,
            max_instructions: 1_000_000,
        },
    );
    // 先保存调用结果再释放入口根，因此 VM 返回错误时也能完成入口清理。
    vm.release(prepare)?;
    let (value, _) = result.map_err(|error| crate::endor_host::runtime_error(vm, error))?;
    match value {
        // 成功返回的 Mount 仍拥有一次根引用，交由调用方使用并释放；None 不转移任何对象根。
        Value::Object(mount) => Ok(Some(mount)),
        Value::Nil => Ok(None),
        value => {
            vm.release_value(value)?;
            anyhow::bail!("invalid hitTest target")
        }
    }
}