xpath.rs

//
use platynui_core::ui::PatternName;
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};

use platynui_core::provider::ProviderError;
use platynui_core::ui::attribute_names;
use platynui_core::ui::identifiers::RuntimeId;
use platynui_core::ui::{Namespace as UiNamespace, UiAttribute, UiNode, UiValue};
use platynui_xpath::compiler;
use platynui_xpath::engine::evaluator;
use platynui_xpath::engine::runtime::{DynamicContextBuilder, StaticContextBuilder};
use platynui_xpath::model::{NodeKind, QName};
use platynui_xpath::xdm::XdmAtomicValue;
use platynui_xpath::{self, XdmNode};
use std::sync::LazyLock;
use thiserror::Error;

const CONTROL_NS_URI: &str = "urn:platynui:control";
const ITEM_NS_URI: &str = "urn:platynui:item";
const APP_NS_URI: &str = "urn:platynui:app";
const NATIVE_NS_URI: &str = "urn:platynui:native";

type NodeIterator = Box<dyn Iterator<Item = Arc<dyn UiNode>> + Send>;
type AttributeIterator = Box<dyn Iterator<Item = Arc<dyn UiAttribute>> + Send>;
type NodeIteratorCell = Arc<Mutex<Option<NodeIterator>>>;
type AttributeIteratorCell = Arc<Mutex<Option<AttributeIterator>>>;
type NodeCacheCell = Arc<Mutex<Vec<RuntimeXdmNode>>>;
type ParentCacheCell = Arc<Mutex<Option<Option<RuntimeXdmNode>>>>;
type SharedFlag = Arc<AtomicBool>;

/// Cross-evaluation XDM tree cache.
///
/// `Clone + Send + Sync` so a single runtime-owned cache can be shared across
/// threads while still preserving explicit invalidation semantics.
#[derive(Clone)]
pub struct XdmCache {
    inner: Arc<Mutex<Option<(RuntimeId, RuntimeXdmNode)>>>,
}

impl XdmCache {
    pub fn new() -> Self {
        Self { inner: Arc::new(Mutex::new(None)) }
    }

    pub fn clear(&self) {
        self.inner.lock().expect("xdm cache mutex poisoned").take();
    }
}

impl Default for XdmCache {
    fn default() -> Self {
        Self::new()
    }
}

impl std::fmt::Debug for XdmCache {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let has_entry = self.inner.lock().expect("xdm cache mutex poisoned").is_some();
        f.debug_struct("XdmCache").field("cached", &has_entry).finish()
    }
}

pub trait NodeResolver: Send + Sync {
    fn resolve(&self, runtime_id: &RuntimeId) -> Result<Option<Arc<dyn UiNode>>, ProviderError>;
}

#[derive(Clone)]
#[must_use]
pub struct EvaluateOptions {
    desktop: Arc<dyn UiNode>,
    invalidate_before_eval: bool,
    resolver: Option<Arc<dyn NodeResolver>>,
    cache: Option<XdmCache>,
    cancel_flag: Option<Arc<AtomicBool>>,
}

impl EvaluateOptions {
    pub fn new(desktop: Arc<dyn UiNode>) -> Self {
        Self { desktop, invalidate_before_eval: false, resolver: None, cache: None, cancel_flag: None }
    }

    pub fn desktop(&self) -> Arc<dyn UiNode> {
        Arc::clone(&self.desktop)
    }

    pub fn with_invalidation(mut self, invalidate: bool) -> Self {
        self.invalidate_before_eval = invalidate;
        self
    }

    pub fn invalidate_before_eval(&self) -> bool {
        self.invalidate_before_eval
    }

    pub fn with_node_resolver(mut self, resolver: Arc<dyn NodeResolver>) -> Self {
        self.resolver = Some(resolver);
        self
    }

    pub fn node_resolver(&self) -> Option<Arc<dyn NodeResolver>> {
        self.resolver.as_ref().map(Arc::clone)
    }

    pub fn with_cache(mut self, cache: XdmCache) -> Self {
        self.cache = Some(cache);
        self
    }

    pub fn without_cache(mut self) -> Self {
        self.cache = None;
        self
    }

    pub fn cache(&self) -> Option<&XdmCache> {
        self.cache.as_ref()
    }

    pub fn with_cancel_flag(mut self, flag: Arc<AtomicBool>) -> Self {
        self.cancel_flag = Some(flag);
        self
    }

    pub fn cancel_flag(&self) -> Option<&Arc<AtomicBool>> {
        self.cancel_flag.as_ref()
    }
}

#[derive(Debug, Error)]
pub enum EvaluateError {
    #[error("XPath evaluation failed {0}")]
    XPath(#[from] platynui_xpath::engine::runtime::Error),
    #[error("context node not part of current evaluation (runtime id: {0})")]
    ContextNodeUnknown(String),
    #[error("provider error during context resolution: {0}")]
    Provider(#[from] ProviderError),
}

#[derive(Clone)]
pub struct EvaluatedAttribute {
    pub owner: Arc<dyn UiNode>,
    pub namespace: UiNamespace,
    pub name: String,
    pub value: UiValue,
}

impl std::fmt::Debug for EvaluatedAttribute {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EvaluatedAttribute")
            .field("namespace", &self.namespace)
            .field("name", &self.name)
            .field("value", &self.value)
            .finish()
    }
}

#[derive(Clone)]
pub enum EvaluationItem {
    Node(Arc<dyn UiNode>),
    Attribute(EvaluatedAttribute),
    Value(UiValue),
}

impl std::fmt::Debug for EvaluationItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            EvaluationItem::Node(node) => f.debug_tuple("Node").field(&node.runtime_id().as_str()).finish(),
            EvaluationItem::Attribute(attr) => f.debug_tuple("Attribute").field(attr).finish(),
            EvaluationItem::Value(value) => f.debug_tuple("Value").field(value).finish(),
        }
    }
}

pub fn evaluate(
    node: Option<Arc<dyn UiNode>>,
    xpath: &str,
    options: EvaluateOptions,
) -> Result<Vec<EvaluationItem>, EvaluateError> {
    tracing::debug!(xpath, cached = options.cache().is_some(), "xpath evaluate");
    let iter = evaluate_iter(node, xpath, options)?;
    iter.collect()
}

/// Returns whether an XPath expression's top-level node selection is relative to the context node —
/// a relative path (`.//x`, `child::x`) or the context item (`.`). Absolute paths (`/x`, `//x`),
/// filtered/parenthesized absolute paths (`(//x)[1]`) and expressions that do not select nodes from
/// the context (`count(...)`, comparisons, ...) are independent; compound forms (if/for/let,
/// sequences) are relative iff a produced branch is. Parses only; no context node or backend is
/// required.
pub fn is_context_dependent(xpath: &str) -> Result<bool, EvaluateError> {
    Ok(platynui_xpath::parser::parse(xpath)?.is_context_dependent())
}

pub struct EvaluationStream {
    inner: Box<dyn Iterator<Item = Result<EvaluationItem, EvaluateError>>>,
}

impl Iterator for EvaluationStream {
    type Item = Result<EvaluationItem, EvaluateError>;
    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next()
    }
}

impl EvaluationStream {
    pub fn new(node: Option<Arc<dyn UiNode>>, xpath: String, options: EvaluateOptions) -> Result<Self, EvaluateError> {
        let context = resolve_context(node.as_ref(), &options)?;

        if options.invalidate_before_eval() {
            context.invalidate();
        }

        let xdm_root = get_or_create_xdm_root(&context, options.invalidate_before_eval(), options.cache());

        let static_ctx = build_static_context();
        let compiled = compiler::compile_with_context(&xpath, static_ctx)?;
        let mut dyn_builder = DynamicContextBuilder::new();
        dyn_builder = dyn_builder.with_context_item(xdm_root);
        if let Some(flag) = options.cancel_flag() {
            dyn_builder = dyn_builder.with_cancel_flag(Arc::clone(flag));
        }
        let dyn_ctx = dyn_builder.build();

        let stream = evaluator::evaluate_stream(&compiled, &dyn_ctx)?;
        let it = eval_stream_to_iter(stream);
        Ok(Self { inner: Box::new(it) })
    }
}

pub fn evaluate_iter(
    node: Option<Arc<dyn UiNode>>,
    xpath: &str,
    options: EvaluateOptions,
) -> Result<impl Iterator<Item = Result<EvaluationItem, EvaluateError>>, EvaluateError> {
    tracing::debug!(xpath, cached = options.cache().is_some(), "xpath evaluate_iter");
    let context = resolve_context(node.as_ref(), &options)?;

    if options.invalidate_before_eval() {
        context.invalidate();
    }

    let xdm_root = get_or_create_xdm_root(&context, options.invalidate_before_eval(), options.cache());

    let static_ctx = build_static_context();
    let compiled = compiler::compile_with_context(xpath, static_ctx)?;
    let mut dyn_builder = DynamicContextBuilder::new();
    dyn_builder = dyn_builder.with_context_item(xdm_root);
    if let Some(flag) = options.cancel_flag() {
        dyn_builder = dyn_builder.with_cancel_flag(Arc::clone(flag));
    }
    let dyn_ctx = dyn_builder.build();

    let stream = evaluator::evaluate_stream(&compiled, &dyn_ctx)?;
    Ok(eval_stream_to_iter(stream))
}

/// Resolve the effective context node for evaluation based on input node and options.
fn resolve_context(
    node: Option<&Arc<dyn UiNode>>,
    options: &EvaluateOptions,
) -> Result<Arc<dyn UiNode>, EvaluateError> {
    let root = options.desktop();
    let context = if let Some(node_ref) = node {
        if let Some(resolver) = options.node_resolver() {
            let runtime_id = node_ref.runtime_id().clone();
            match resolver.resolve(&runtime_id)? {
                Some(resolved) => resolved,
                None => return Err(EvaluateError::ContextNodeUnknown(runtime_id.to_string())),
            }
        } else {
            Arc::clone(node_ref)
        }
    } else {
        root.clone()
    };
    Ok(context)
}

fn get_or_create_xdm_root(context: &Arc<dyn UiNode>, force_rebuild: bool, cache: Option<&XdmCache>) -> RuntimeXdmNode {
    let Some(cache) = cache else {
        return RuntimeXdmNode::from_node(Arc::clone(context));
    };

    let mut slot = cache.inner.lock().expect("xdm cache mutex poisoned");

    if !force_rebuild {
        let context_id = context.runtime_id();
        if let Some((cached_id, cached_node)) = slot.as_ref()
            && *cached_id == *context_id
            && cached_node.is_valid()
        {
            let node = cached_node.clone();
            node.prepare_for_evaluation();
            return node;
        }
    }

    let context_id = context.runtime_id().clone();
    let node = RuntimeXdmNode::from_node(Arc::clone(context));
    *slot = Some((context_id, node.clone()));
    node
}

/// Build the static context with PlatynUI namespaces configured.
fn build_static_context() -> &'static platynui_xpath::engine::runtime::StaticContext {
    static STATIC_CTX: LazyLock<platynui_xpath::engine::runtime::StaticContext> = LazyLock::new(|| {
        StaticContextBuilder::new()
            .with_default_element_namespace(CONTROL_NS_URI)
            .with_namespace("control", CONTROL_NS_URI)
            .with_namespace("item", ITEM_NS_URI)
            .with_namespace("app", APP_NS_URI)
            .with_namespace("native", NATIVE_NS_URI)
            .build()
    });
    &STATIC_CTX
}

/// Map a stream of XDM items to `EvaluationItem`s, propagating evaluation errors.
fn eval_stream_to_iter<I>(iter: I) -> impl Iterator<Item = Result<EvaluationItem, EvaluateError>>
where
    I: IntoIterator<
        Item = Result<platynui_xpath::xdm::XdmItem<RuntimeXdmNode>, platynui_xpath::engine::runtime::Error>,
    >,
{
    use platynui_xpath::xdm::XdmItem;
    iter.into_iter().map(|res| match res {
        Err(e) => Err(EvaluateError::XPath(e)),
        Ok(item) => match item {
            XdmItem::Node(node) => match node {
                RuntimeXdmNode::Document(doc) => Ok(EvaluationItem::Node(doc.root.clone())),
                RuntimeXdmNode::Element(elem) => Ok(EvaluationItem::Node(elem.node.clone())),
                RuntimeXdmNode::Attribute(attr) => Ok(EvaluationItem::Attribute(attr.to_evaluated())),
            },
            XdmItem::Atomic(atom) => Ok(EvaluationItem::Value(atomic_to_ui_value(&atom))),
        },
    })
}

#[derive(Clone)]
enum RuntimeXdmNode {
    Document(DocumentData),
    Element(ElementData),
    Attribute(AttributeData),
}

impl RuntimeXdmNode {
    fn document(root: Arc<dyn UiNode>) -> Self {
        let runtime_id = root.runtime_id().clone();
        RuntimeXdmNode::Document(DocumentData::new(root, runtime_id))
    }

    fn element(node: Arc<dyn UiNode>) -> Self {
        let runtime_id = node.runtime_id().clone();
        tracing::trace!(
            runtime_id = %runtime_id,
            "RuntimeXdmNode::element: resolving namespace/role",
        );
        let namespace = node.namespace();
        let role = node.role().to_string();
        let order_key = node.doc_order_key();
        tracing::trace!(
            runtime_id = %runtime_id,
            role = %role,
            "RuntimeXdmNode::element: resolved",
        );
        RuntimeXdmNode::Element(ElementData::new(node, runtime_id, namespace, role, order_key))
    }

    fn from_node(node: Arc<dyn UiNode>) -> Self {
        if node.parent().is_none() { RuntimeXdmNode::document(node) } else { RuntimeXdmNode::element(node) }
    }

    fn is_valid(&self) -> bool {
        match self {
            RuntimeXdmNode::Document(doc) => doc.root.is_valid(),
            RuntimeXdmNode::Element(elem) => elem.node.is_valid(),
            RuntimeXdmNode::Attribute(attr) => attr.owner.is_valid(),
        }
    }

    fn prepare_for_evaluation(&self) {
        match self {
            RuntimeXdmNode::Document(doc) => {
                doc.attrs_cache.lock().expect("document attrs cache mutex poisoned").clear();
                doc.attrs_finished.store(false, Ordering::Release);
                *doc.attrs_inner.lock().expect("document attrs iterator mutex poisoned") = None;
                doc.children_validated.store(false, Ordering::Release);
                let children = doc.children_cache.lock().expect("document children cache mutex poisoned").clone();
                for child in &children {
                    child.prepare_for_evaluation();
                }
            }
            RuntimeXdmNode::Element(elem) => {
                elem.attrs_cache.lock().expect("element attrs cache mutex poisoned").clear();
                elem.attrs_finished.store(false, Ordering::Release);
                *elem.attrs_inner.lock().expect("element attrs iterator mutex poisoned") = None;
                elem.children_validated.store(false, Ordering::Release);
                let children = elem.children_cache.lock().expect("element children cache mutex poisoned").clone();
                for child in &children {
                    child.prepare_for_evaluation();
                }
            }
            RuntimeXdmNode::Attribute(_) => {}
        }
    }
}

impl PartialEq for RuntimeXdmNode {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (RuntimeXdmNode::Document(a), RuntimeXdmNode::Document(b)) => a.runtime_id == b.runtime_id,
            (RuntimeXdmNode::Element(a), RuntimeXdmNode::Element(b)) => {
                a.runtime_id == b.runtime_id && a.order_key == b.order_key
            }
            (RuntimeXdmNode::Attribute(a), RuntimeXdmNode::Attribute(b)) => {
                a.owner_runtime_id == b.owner_runtime_id && a.namespace == b.namespace && a.name == b.name
            }
            _ => false,
        }
    }
}

impl Eq for RuntimeXdmNode {}

impl std::fmt::Debug for RuntimeXdmNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            RuntimeXdmNode::Document(doc) => f.debug_struct("Document").field("runtime_id", &doc.runtime_id).finish(),
            RuntimeXdmNode::Element(elem) => f
                .debug_struct("Element")
                .field("runtime_id", &elem.runtime_id)
                .field("order_key", &elem.order_key)
                .field("role", &elem.role)
                .finish(),
            RuntimeXdmNode::Attribute(attr) => {
                f.debug_struct("Attribute").field("owner", &attr.owner_runtime_id).field("name", &attr.name).finish()
            }
        }
    }
}

impl XdmNode for RuntimeXdmNode {
    type Children<'a>
        = NodeChildrenIter<'a>
    where
        Self: 'a;
    type Attributes<'a>
        = NodeAttributeIter<'a>
    where
        Self: 'a;
    type Namespaces<'a>
        = std::iter::Empty<RuntimeXdmNode>
    where
        Self: 'a;

    fn kind(&self) -> NodeKind {
        match self {
            RuntimeXdmNode::Document(_) => NodeKind::Document,
            RuntimeXdmNode::Element(_) => NodeKind::Element,
            RuntimeXdmNode::Attribute(_) => NodeKind::Attribute,
        }
    }

    fn name(&self) -> Option<QName> {
        match self {
            RuntimeXdmNode::Document(_) => None,
            RuntimeXdmNode::Element(elem) => Some(elem.qname.clone()),
            RuntimeXdmNode::Attribute(attr) => Some(attr.qname.clone()),
        }
    }

    fn typed_value(&self) -> Vec<XdmAtomicValue> {
        match self {
            RuntimeXdmNode::Document(_) | RuntimeXdmNode::Element(_) => Vec::new(),
            RuntimeXdmNode::Attribute(attr) => attr.typed().clone(),
        }
    }

    fn base_uri(&self) -> Option<String> {
        None
    }

    fn parent(&self) -> Option<Self> {
        match self {
            RuntimeXdmNode::Document(_) => None,
            RuntimeXdmNode::Element(elem) => {
                if let Some(cached) = elem.parent_cache.lock().expect("parent cache mutex poisoned").as_ref() {
                    return cached.clone();
                }
                let computed: Option<RuntimeXdmNode> = match elem.node.parent() {
                    Some(parent) => match parent.upgrade() {
                        Some(p) => Some(RuntimeXdmNode::from_node(p)),
                        None => Some(RuntimeXdmNode::document(elem.node.clone())),
                    },
                    None => Some(RuntimeXdmNode::document(elem.node.clone())),
                };
                *elem.parent_cache.lock().expect("parent cache mutex poisoned") = Some(computed.clone());
                computed
            }
            RuntimeXdmNode::Attribute(attr) => Some(RuntimeXdmNode::from_node(attr.owner.clone())),
        }
    }

    fn children(&self) -> Self::Children<'_> {
        match self {
            RuntimeXdmNode::Document(doc) => {
                if !doc.children_validated.load(Ordering::Acquire) {
                    let has_invalid = doc
                        .children_cache
                        .lock()
                        .expect("document children cache mutex poisoned")
                        .iter()
                        .any(|c| !c.is_valid());
                    if has_invalid {
                        doc.children_cache.lock().expect("document children cache mutex poisoned").clear();
                        doc.children_finished.store(false, Ordering::Release);
                        *doc.children_inner.lock().expect("document children iterator mutex poisoned") =
                            Some(doc.root.children());
                    }
                    doc.children_validated.store(true, Ordering::Release);
                }
                let needs_init = {
                    doc.children_inner.lock().expect("document children iterator mutex poisoned").is_none()
                        && !doc.children_finished.load(Ordering::Acquire)
                };
                if needs_init {
                    *doc.children_inner.lock().expect("document children iterator mutex poisoned") =
                        Some(doc.root.children());
                }
                NodeChildrenIter::from_shared(
                    Arc::clone(&doc.children_inner),
                    Arc::clone(&doc.children_cache),
                    Arc::clone(&doc.children_finished),
                )
                .with_parent_node(self.clone())
            }
            RuntimeXdmNode::Element(elem) => {
                if !elem.children_validated.load(Ordering::Acquire) {
                    let has_invalid = elem
                        .children_cache
                        .lock()
                        .expect("element children cache mutex poisoned")
                        .iter()
                        .any(|c| !c.is_valid());
                    if has_invalid {
                        elem.children_cache.lock().expect("element children cache mutex poisoned").clear();
                        elem.children_finished.store(false, Ordering::Release);
                        *elem.children_inner.lock().expect("element children iterator mutex poisoned") =
                            Some(elem.node.children());
                    }
                    elem.children_validated.store(true, Ordering::Release);
                }
                let needs_init = {
                    elem.children_inner.lock().expect("element children iterator mutex poisoned").is_none()
                        && !elem.children_finished.load(Ordering::Acquire)
                };
                if needs_init {
                    *elem.children_inner.lock().expect("element children iterator mutex poisoned") =
                        Some(elem.node.children());
                }
                NodeChildrenIter::from_shared(
                    Arc::clone(&elem.children_inner),
                    Arc::clone(&elem.children_cache),
                    Arc::clone(&elem.children_finished),
                )
                .with_parent_node(self.clone())
            }
            RuntimeXdmNode::Attribute(_) => NodeChildrenIter::empty(),
        }
    }

    fn attributes(&self) -> Self::Attributes<'_> {
        match self {
            RuntimeXdmNode::Document(doc) => {
                let needs_init = {
                    doc.attrs_inner.lock().expect("document attrs iterator mutex poisoned").is_none()
                        && !doc.attrs_finished.load(Ordering::Acquire)
                };
                if needs_init {
                    *doc.attrs_inner.lock().expect("document attrs iterator mutex poisoned") =
                        Some(doc.root.attributes());
                }
                NodeAttributeIter::from_shared(
                    doc.root.clone(),
                    Arc::clone(&doc.attrs_inner),
                    Arc::clone(&doc.attrs_cache),
                    Arc::clone(&doc.attrs_finished),
                )
            }
            RuntimeXdmNode::Element(elem) => {
                let needs_init = {
                    elem.attrs_inner.lock().expect("element attrs iterator mutex poisoned").is_none()
                        && !elem.attrs_finished.load(Ordering::Acquire)
                };
                if needs_init {
                    *elem.attrs_inner.lock().expect("element attrs iterator mutex poisoned") =
                        Some(elem.node.attributes());
                }
                NodeAttributeIter::from_shared(
                    elem.node.clone(),
                    Arc::clone(&elem.attrs_inner),
                    Arc::clone(&elem.attrs_cache),
                    Arc::clone(&elem.attrs_finished),
                )
            }
            RuntimeXdmNode::Attribute(_) => NodeAttributeIter::empty(),
        }
    }

    fn namespaces(&self) -> Self::Namespaces<'_> {
        std::iter::empty()
    }

    fn doc_order_key(&self) -> Option<u64> {
        match self {
            RuntimeXdmNode::Element(elem) => elem.order_key,
            RuntimeXdmNode::Document(_) | RuntimeXdmNode::Attribute(_) => None,
        }
    }

    /// O(1) attribute lookup via the provider's `UiNode::attribute()` method,
    /// bypassing the full attribute iterator. This avoids materialising
    /// expensive native properties (≈1 050 COM calls per element on Windows)
    /// when the requested attribute lives in a cheaper namespace.
    fn attribute_by_name(&self, name: &QName) -> Option<Self> {
        let node: &Arc<dyn UiNode> = match self {
            RuntimeXdmNode::Document(doc) => &doc.root,
            RuntimeXdmNode::Element(elem) => &elem.node,
            RuntimeXdmNode::Attribute(_) => return None,
        };

        // Map XPath namespace URI to provider UiNamespace.
        let ui_ns = match &name.ns_uri {
            None => UiNamespace::Control,
            Some(uri) => match uri.as_str() {
                CONTROL_NS_URI => UiNamespace::Control,
                ITEM_NS_URI => UiNamespace::Item,
                APP_NS_URI => UiNamespace::App,
                NATIVE_NS_URI => UiNamespace::Native,
                _ => return None,
            },
        };

        // Fast path: direct provider lookup (handles Role, Name, Id, Bounds, …)
        if let Some(attr) = node.attribute(ui_ns, &name.local) {
            return Some(RuntimeXdmNode::Attribute(AttributeData::new_from_source(
                node.clone(),
                attr.namespace(),
                attr.name().to_string(),
                attr,
            )));
        }

        // Handle virtual component attributes (e.g. Bounds.X, ActivationPoint.Y)
        // that only exist inside the `NodeAttributeIter` expansion.
        if ui_ns == UiNamespace::Control {
            if let Some(suffix) = name.local.strip_prefix("Bounds.") {
                let comp = match suffix {
                    "X" => Some(RectComp::X),
                    "Y" => Some(RectComp::Y),
                    "Width" => Some(RectComp::Width),
                    "Height" => Some(RectComp::Height),
                    _ => None,
                };
                if let Some(comp) = comp
                    && let Some(base) = node.attribute(ui_ns, attribute_names::element::BOUNDS)
                {
                    return Some(RuntimeXdmNode::Attribute(AttributeData::new_rect_component(
                        node.clone(),
                        ui_ns,
                        base,
                        attribute_names::element::BOUNDS,
                        comp,
                    )));
                }
            }
            if let Some(suffix) = name.local.strip_prefix("ActivationPoint.") {
                let comp = match suffix {
                    "X" => Some(PointComp::X),
                    "Y" => Some(PointComp::Y),
                    _ => None,
                };
                if let Some(comp) = comp
                    && let Some(base) = node.attribute(ui_ns, attribute_names::activation_target::ACTIVATION_POINT)
                {
                    return Some(RuntimeXdmNode::Attribute(AttributeData::new_point_component(
                        node.clone(),
                        ui_ns,
                        base,
                        attribute_names::activation_target::ACTIVATION_POINT,
                        comp,
                    )));
                }
            }
        }

        None
    }
}

#[derive(Clone)]
struct DocumentData {
    root: Arc<dyn UiNode>,
    runtime_id: RuntimeId,
    children_inner: NodeIteratorCell,
    children_cache: NodeCacheCell,
    children_finished: SharedFlag,
    children_validated: SharedFlag,
    attrs_inner: AttributeIteratorCell,
    attrs_cache: NodeCacheCell,
    attrs_finished: SharedFlag,
}

impl DocumentData {
    fn new(root: Arc<dyn UiNode>, runtime_id: RuntimeId) -> Self {
        Self {
            root,
            runtime_id,
            children_inner: Arc::new(Mutex::new(None)),
            children_cache: Arc::new(Mutex::new(Vec::new())),
            children_finished: Arc::new(AtomicBool::new(false)),
            children_validated: Arc::new(AtomicBool::new(false)),
            attrs_inner: Arc::new(Mutex::new(None)),
            attrs_cache: Arc::new(Mutex::new(Vec::new())),
            attrs_finished: Arc::new(AtomicBool::new(false)),
        }
    }
}

#[derive(Clone)]
struct ElementData {
    node: Arc<dyn UiNode>,
    runtime_id: RuntimeId,
    role: String,
    qname: QName,
    order_key: Option<u64>,
    children_inner: NodeIteratorCell,
    children_cache: NodeCacheCell,
    children_finished: SharedFlag,
    children_validated: SharedFlag,
    attrs_inner: AttributeIteratorCell,
    attrs_cache: NodeCacheCell,
    attrs_finished: SharedFlag,
    parent_cache: ParentCacheCell,
}

impl ElementData {
    fn new(
        node: Arc<dyn UiNode>,
        runtime_id: RuntimeId,
        namespace: UiNamespace,
        role: String,
        order_key: Option<u64>,
    ) -> Self {
        let qname = element_qname(namespace, &role);
        Self {
            node,
            runtime_id,
            role,
            qname,
            order_key,
            children_inner: Arc::new(Mutex::new(None)),
            children_cache: Arc::new(Mutex::new(Vec::new())),
            children_finished: Arc::new(AtomicBool::new(false)),
            children_validated: Arc::new(AtomicBool::new(false)),
            attrs_inner: Arc::new(Mutex::new(None)),
            attrs_cache: Arc::new(Mutex::new(Vec::new())),
            attrs_finished: Arc::new(AtomicBool::new(false)),
            parent_cache: Arc::new(Mutex::new(None)),
        }
    }
}

#[derive(Clone)]
struct AttributeData {
    owner: Arc<dyn UiNode>,
    owner_runtime_id: RuntimeId,
    namespace: UiNamespace,
    name: String,
    qname: QName,
    // Lazy value provider (either direct source or derived component)
    value_kind: ValueKind,
    value_cell: std::sync::OnceLock<UiValue>,
    typed_cell: std::sync::OnceLock<Vec<XdmAtomicValue>>,
}

// no StaticUiAttribute needed; attributes are sourced from provider or derived lazily

#[derive(Clone)]
enum ValueKind {
    Source(Arc<dyn UiAttribute>),
    RectComp { base: Arc<dyn UiAttribute>, comp: RectComp },
    PointComp { base: Arc<dyn UiAttribute>, comp: PointComp },
}

#[derive(Clone)]
enum RectComp {
    X,
    Y,
    Width,
    Height,
}
#[derive(Clone)]
enum PointComp {
    X,
    Y,
}

impl AttributeData {
    fn new_from_source(
        owner: Arc<dyn UiNode>,
        namespace: UiNamespace,
        name: String,
        source: Arc<dyn UiAttribute>,
    ) -> Self {
        let owner_runtime_id = owner.runtime_id().clone();
        let qname = attribute_qname(namespace, &name);
        Self {
            owner,
            owner_runtime_id,
            namespace,
            name,
            qname,
            value_kind: ValueKind::Source(source),
            value_cell: std::sync::OnceLock::new(),
            typed_cell: std::sync::OnceLock::new(),
        }
    }
    fn new_rect_component(
        owner: Arc<dyn UiNode>,
        namespace: UiNamespace,
        base: Arc<dyn UiAttribute>,
        base_name: &str,
        comp: RectComp,
    ) -> Self {
        let name = component_attribute_name(
            base_name,
            match comp {
                RectComp::X => "X",
                RectComp::Y => "Y",
                RectComp::Width => "Width",
                RectComp::Height => "Height",
            },
        );
        let owner_runtime_id = owner.runtime_id().clone();
        let qname = attribute_qname(namespace, &name);
        Self {
            owner,
            owner_runtime_id,
            namespace,
            name,
            qname,
            value_kind: ValueKind::RectComp { base, comp },
            value_cell: std::sync::OnceLock::new(),
            typed_cell: std::sync::OnceLock::new(),
        }
    }
    fn new_point_component(
        owner: Arc<dyn UiNode>,
        namespace: UiNamespace,
        base: Arc<dyn UiAttribute>,
        base_name: &str,
        comp: PointComp,
    ) -> Self {
        let name = component_attribute_name(
            base_name,
            match comp {
                PointComp::X => "X",
                PointComp::Y => "Y",
            },
        );
        let owner_runtime_id = owner.runtime_id().clone();
        let qname = attribute_qname(namespace, &name);
        Self {
            owner,
            owner_runtime_id,
            namespace,
            name,
            qname,
            value_kind: ValueKind::PointComp { base, comp },
            value_cell: std::sync::OnceLock::new(),
            typed_cell: std::sync::OnceLock::new(),
        }
    }
    fn value(&self) -> UiValue {
        self.value_cell
            .get_or_init(|| match &self.value_kind {
                ValueKind::Source(src) => src.value(),
                ValueKind::RectComp { base, comp } => match base.value() {
                    UiValue::Rect(r) => match comp {
                        RectComp::X => UiValue::from(r.x()),
                        RectComp::Y => UiValue::from(r.y()),
                        RectComp::Width => UiValue::from(r.width()),
                        RectComp::Height => UiValue::from(r.height()),
                    },
                    _ => UiValue::Null,
                },
                ValueKind::PointComp { base, comp } => match base.value() {
                    UiValue::Point(p) => match comp {
                        PointComp::X => UiValue::from(p.x()),
                        PointComp::Y => UiValue::from(p.y()),
                    },
                    _ => UiValue::Null,
                },
            })
            .clone()
    }
    fn typed(&self) -> &Vec<XdmAtomicValue> {
        self.typed_cell.get_or_init(|| ui_value_to_atomic_values(&self.value()))
    }
    fn to_evaluated(&self) -> EvaluatedAttribute {
        EvaluatedAttribute {
            owner: self.owner.clone(),
            namespace: self.namespace,
            name: self.name.clone(),
            value: self.value(),
        }
    }
}

fn ui_value_to_atomic_values(value: &UiValue) -> Vec<XdmAtomicValue> {
    match value {
        UiValue::Null => Vec::new(),
        UiValue::Bool(b) => vec![XdmAtomicValue::Boolean(*b)],
        UiValue::Integer(i) => vec![XdmAtomicValue::Integer(*i)],
        UiValue::Number(n) => vec![XdmAtomicValue::Double(*n)],
        UiValue::String(s) => vec![XdmAtomicValue::String(s.clone())],
        UiValue::Array(items) => {
            serde_json::to_string(items).ok().map(|json| vec![XdmAtomicValue::String(json)]).unwrap_or_default()
        }
        UiValue::Object(map) => {
            serde_json::to_string(map).ok().map(|json| vec![XdmAtomicValue::String(json)]).unwrap_or_default()
        }
        UiValue::Point(point) => {
            serde_json::to_string(point).ok().map(|json| vec![XdmAtomicValue::String(json)]).unwrap_or_default()
        }
        UiValue::Size(size) => {
            serde_json::to_string(size).ok().map(|json| vec![XdmAtomicValue::String(json)]).unwrap_or_default()
        }
        UiValue::Rect(rect) => {
            serde_json::to_string(rect).ok().map(|json| vec![XdmAtomicValue::String(json)]).unwrap_or_default()
        }
    }
}

fn component_attribute_name(base: &str, suffix: &str) -> String {
    format!("{}.{}", base, suffix)
}

fn element_qname(ns: UiNamespace, role: &str) -> QName {
    QName {
        prefix: namespace_prefix(ns).map(|p| p.to_string()),
        local: role.to_string(),
        ns_uri: Some(namespace_uri(ns).to_string()),
    }
}

fn attribute_qname(ns: UiNamespace, name: &str) -> QName {
    QName {
        prefix: attribute_prefix(ns).map(|p| p.to_string()),
        local: name.to_string(),
        ns_uri: attribute_namespace(ns).map(|uri| uri.to_string()),
    }
}

fn namespace_prefix(ns: UiNamespace) -> Option<&'static str> {
    match ns {
        UiNamespace::Control => None,
        UiNamespace::Item => Some("item"),
        UiNamespace::App => Some("app"),
        UiNamespace::Native => Some("native"),
    }
}

fn namespace_uri(ns: UiNamespace) -> &'static str {
    match ns {
        UiNamespace::Control => CONTROL_NS_URI,
        UiNamespace::Item => ITEM_NS_URI,
        UiNamespace::App => APP_NS_URI,
        UiNamespace::Native => NATIVE_NS_URI,
    }
}

fn attribute_prefix(ns: UiNamespace) -> Option<&'static str> {
    match ns {
        UiNamespace::Control => None,
        UiNamespace::Item => Some("item"),
        UiNamespace::App => Some("app"),
        UiNamespace::Native => Some("native"),
    }
}

fn attribute_namespace(ns: UiNamespace) -> Option<&'static str> {
    match ns {
        UiNamespace::Control => None,
        UiNamespace::Item => Some(ITEM_NS_URI),
        UiNamespace::App => Some(APP_NS_URI),
        UiNamespace::Native => Some(NATIVE_NS_URI),
    }
}

fn atomic_to_ui_value(value: &XdmAtomicValue) -> UiValue {
    use XdmAtomicValue::*;
    match value {
        Boolean(b) => UiValue::Bool(*b),
        String(s) | UntypedAtomic(s) | AnyUri(s) | NormalizedString(s) | Token(s) | Language(s) | Name(s)
        | NCName(s) | NMTOKEN(s) | Id(s) | IdRef(s) | Entity(s) | Notation(s) => UiValue::String(s.clone()),
        Integer(i) | Long(i) | NonPositiveInteger(i) | NegativeInteger(i) => UiValue::Integer(*i),
        Decimal(d) => {
            use rust_decimal::prelude::ToPrimitive;
            UiValue::Number(d.to_f64().unwrap_or(f64::NAN))
        }
        Double(d) => UiValue::Number(*d),
        Float(f) => UiValue::Number(*f as f64),
        UnsignedLong(u) => UiValue::Integer(*u as i64),
        NonNegativeInteger(u) => UiValue::Integer(*u as i64),
        PositiveInteger(u) => UiValue::Integer(*u as i64),
        UnsignedInt(u) => UiValue::Integer(*u as i64),
        UnsignedShort(u) => UiValue::Integer(*u as i64),
        UnsignedByte(u) => UiValue::Integer(*u as i64),
        Int(i) => UiValue::Integer(*i as i64),
        Short(i) => UiValue::Integer(*i as i64),
        Byte(i) => UiValue::Integer(*i as i64),
        QName { ns_uri, prefix, local } => {
            let mut map = std::collections::BTreeMap::new();
            if let Some(ns) = ns_uri {
                map.insert("ns_uri".to_string(), UiValue::String(ns.clone()));
            }
            if let Some(pref) = prefix {
                map.insert("prefix".to_string(), UiValue::String(pref.clone()));
            }
            map.insert("local".to_string(), UiValue::String(local.clone()));
            UiValue::Object(map)
        }
        DateTime(dt) => UiValue::String(dt.to_rfc3339()),
        Date { date, tz } => UiValue::String(match tz {
            Some(offset) => format!("{}{}", date, offset),
            None => date.to_string(),
        }),
        Time { time, tz } => UiValue::String(match tz {
            Some(offset) => format!("{}{}", time, offset),
            None => time.to_string(),
        }),
        YearMonthDuration(months) => UiValue::String(format!("P{}M", months)),
        DayTimeDuration(secs) => UiValue::String(format!("PT{}S", secs)),
        Base64Binary(data) | HexBinary(data) => UiValue::String(data.clone()),
        GYear { year, tz } => UiValue::String(format!("{}{}", year, tz.map_or("".to_string(), |o| o.to_string()))),
        GYearMonth { year, month, tz } => {
            UiValue::String(format!("{}-{:02}{}", year, month, tz.map_or("".to_string(), |o| o.to_string())))
        }
        GMonth { month, tz } => {
            UiValue::String(format!("{:02}{}", month, tz.map_or("".to_string(), |o| o.to_string())))
        }
        GMonthDay { month, day, tz } => {
            UiValue::String(format!("{:02}-{:02}{}", month, day, tz.map_or("".to_string(), |o| o.to_string())))
        }
        GDay { day, tz } => UiValue::String(format!("{:02}{}", day, tz.map_or("".to_string(), |o| o.to_string()))),
    }
}

struct NodeChildrenIter<'a> {
    inner: NodeIteratorCell,
    cache: NodeCacheCell,
    finished: SharedFlag,
    pos: usize,
    _marker: std::marker::PhantomData<&'a ()>,
    parent_node: Option<RuntimeXdmNode>,
}
impl<'a> NodeChildrenIter<'a> {
    fn from_shared(inner: NodeIteratorCell, cache: NodeCacheCell, finished: SharedFlag) -> Self {
        Self { inner, cache, finished, pos: 0, _marker: std::marker::PhantomData, parent_node: None }
    }
    fn with_parent_node(mut self, parent: RuntimeXdmNode) -> Self {
        self.parent_node = Some(parent);
        self
    }
    fn empty() -> Self {
        Self {
            inner: Arc::new(Mutex::new(None)),
            cache: Arc::new(Mutex::new(Vec::new())),
            finished: Arc::new(AtomicBool::new(true)),
            pos: 0,
            _marker: std::marker::PhantomData,
            parent_node: None,
        }
    }
}
impl<'a> Iterator for NodeChildrenIter<'a> {
    type Item = RuntimeXdmNode;
    fn next(&mut self) -> Option<Self::Item> {
        {
            let cache = self.cache.lock().expect("children cache mutex poisoned");
            if self.pos < cache.len() {
                let item = cache[self.pos].clone();
                drop(cache);
                self.pos += 1;
                return Some(item);
            }
        }
        if self.finished.load(Ordering::Acquire) {
            return None;
        }
        let mut inner_borrow = self.inner.lock().expect("children iterator mutex poisoned");
        match inner_borrow.as_mut() {
            Some(iter) => {
                if let Some(owner) = iter.next() {
                    let mut node = RuntimeXdmNode::from_node(owner);
                    // Pre-link child's parent_cache to the parent node (Document or Element).
                    // This ensures that cursor helpers like next_sibling_in_doc()
                    // get the SAME parent wrapper (with shared children_cache), avoiding
                    // O(N²) COM TreeWalker re-enumeration per sibling lookup.
                    if let RuntimeXdmNode::Element(elem) = &mut node
                        && let Some(parent) = self.parent_node.as_ref()
                    {
                        *elem.parent_cache.lock().expect("parent cache mutex poisoned") = Some(Some(parent.clone()));
                    }
                    self.cache.lock().expect("children cache mutex poisoned").push(node.clone());
                    self.pos += 1;
                    Some(node)
                } else {
                    self.finished.store(true, Ordering::Release);
                    None
                }
            }
            None => {
                self.finished.store(true, Ordering::Release);
                None
            }
        }
    }
}

struct NodeAttributeIter<'a> {
    owner: Arc<dyn UiNode>,
    inner: AttributeIteratorCell,
    cache: NodeCacheCell,
    finished: SharedFlag,
    pos: usize,
    _marker: std::marker::PhantomData<&'a ()>,
}
impl<'a> NodeAttributeIter<'a> {
    fn from_shared(
        owner: Arc<dyn UiNode>,
        inner: AttributeIteratorCell,
        cache: NodeCacheCell,
        finished: SharedFlag,
    ) -> Self {
        Self { owner, inner, cache, finished, pos: 0, _marker: std::marker::PhantomData }
    }
    fn empty() -> Self {
        Self {
            owner: Arc::new(DummyNode),
            inner: Arc::new(Mutex::new(None)),
            cache: Arc::new(Mutex::new(Vec::new())),
            finished: Arc::new(AtomicBool::new(true)),
            pos: 0,
            _marker: std::marker::PhantomData,
        }
    }
}
impl<'a> Iterator for NodeAttributeIter<'a> {
    type Item = RuntimeXdmNode;
    fn next(&mut self) -> Option<Self::Item> {
        {
            let cache = self.cache.lock().expect("attribute cache mutex poisoned");
            if self.pos < cache.len() {
                let item = cache[self.pos].clone();
                drop(cache);
                self.pos += 1;
                return Some(item);
            }
        }
        if self.finished.load(Ordering::Acquire) {
            return None;
        }
        let mut inner_borrow = self.inner.lock().expect("attribute iterator mutex poisoned");
        let iter = inner_borrow.as_mut()?;
        if let Some(attr) = iter.next() {
            let ns = attr.namespace();
            let base_name = attr.name().to_string();
            let src = attr.clone();
            {
                let mut cache = self.cache.lock().expect("attribute cache mutex poisoned");
                cache.push(RuntimeXdmNode::Attribute(AttributeData::new_from_source(
                    self.owner.clone(),
                    ns,
                    base_name.clone(),
                    src.clone(),
                )));
                if base_name == attribute_names::element::BOUNDS {
                    cache.push(RuntimeXdmNode::Attribute(AttributeData::new_rect_component(
                        self.owner.clone(),
                        ns,
                        src.clone(),
                        attribute_names::element::BOUNDS,
                        RectComp::X,
                    )));
                    cache.push(RuntimeXdmNode::Attribute(AttributeData::new_rect_component(
                        self.owner.clone(),
                        ns,
                        src.clone(),
                        attribute_names::element::BOUNDS,
                        RectComp::Y,
                    )));
                    cache.push(RuntimeXdmNode::Attribute(AttributeData::new_rect_component(
                        self.owner.clone(),
                        ns,
                        src.clone(),
                        attribute_names::element::BOUNDS,
                        RectComp::Width,
                    )));
                    cache.push(RuntimeXdmNode::Attribute(AttributeData::new_rect_component(
                        self.owner.clone(),
                        ns,
                        src,
                        attribute_names::element::BOUNDS,
                        RectComp::Height,
                    )));
                } else if base_name == attribute_names::activation_target::ACTIVATION_POINT {
                    let src_point = attr.clone();
                    cache.push(RuntimeXdmNode::Attribute(AttributeData::new_point_component(
                        self.owner.clone(),
                        ns,
                        src_point.clone(),
                        attribute_names::activation_target::ACTIVATION_POINT,
                        PointComp::X,
                    )));
                    cache.push(RuntimeXdmNode::Attribute(AttributeData::new_point_component(
                        self.owner.clone(),
                        ns,
                        src_point,
                        attribute_names::activation_target::ACTIVATION_POINT,
                        PointComp::Y,
                    )));
                }
            }
            // Return the just-pushed item at current position (should exist)
            let idx = self.pos;
            {
                let cache = self.cache.lock().expect("attribute cache mutex poisoned");
                if idx < cache.len() {
                    let it = cache[idx].clone();
                    self.pos += 1;
                    return Some(it);
                }
            }
            // Fallback: inconsistent state — mark finished
            self.finished.store(true, Ordering::Release);
            None
        } else {
            self.finished.store(true, Ordering::Release);
            None
        }
    }
}

struct DummyNode;
impl UiNode for DummyNode {
    fn namespace(&self) -> UiNamespace {
        UiNamespace::Control
    }
    fn role(&self) -> &str {
        ""
    }
    fn name(&self) -> String {
        String::new()
    }
    fn runtime_id(&self) -> &RuntimeId {
        static RID: std::sync::OnceLock<RuntimeId> = std::sync::OnceLock::new();
        RID.get_or_init(|| RuntimeId::from("dummy"))
    }
    fn parent(&self) -> Option<std::sync::Weak<dyn UiNode>> {
        None
    }
    fn children(&self) -> Box<dyn Iterator<Item = Arc<dyn UiNode>> + Send + 'static> {
        Box::new(std::iter::empty())
    }
    fn attributes(&self) -> Box<dyn Iterator<Item = Arc<dyn UiAttribute>> + Send + 'static> {
        Box::new(std::iter::empty())
    }
    fn supported_patterns(&self) -> Vec<PatternName> {
        Vec::new()
    }
    fn invalidate(&self) {}
}

#[cfg(test)]
mod tests {
    use super::*;
    use platynui_core::provider::ProviderError;
    use platynui_core::types::Rect;
    use platynui_core::ui::{PatternName, RuntimeId, UiAttribute, UiNode, attribute_names, supported_patterns_value};
    use rstest::rstest;
    use std::sync::{Arc, Mutex, Weak};

    #[rstest]
    #[case("//x", false)]
    #[case("/Window", false)]
    #[case("(//x)[1]", false)]
    #[case("//x[.='y']", false)]
    #[case(".//x", true)]
    #[case(".", true)]
    fn is_context_dependent_classifies(#[case] expr: &str, #[case] expected: bool) {
        assert_eq!(is_context_dependent(expr).expect("should parse"), expected, "for {expr}");
    }

    #[test]
    fn is_context_dependent_rejects_malformed_xpath() {
        assert!(matches!(is_context_dependent("//x[broken"), Err(EvaluateError::XPath(_))));
    }

    struct StaticAttribute {
        namespace: UiNamespace,
        name: String,
        value: UiValue,
    }

    impl StaticAttribute {
        fn new(namespace: UiNamespace, name: &str, value: UiValue) -> Self {
            Self { namespace, name: name.to_string(), value }
        }
    }

    impl UiAttribute for StaticAttribute {
        fn namespace(&self) -> UiNamespace {
            self.namespace
        }

        fn name(&self) -> &str {
            &self.name
        }

        fn value(&self) -> UiValue {
            self.value.clone()
        }
    }

    struct StaticNode {
        namespace: UiNamespace,
        role: &'static str,
        name: String,
        runtime_id: RuntimeId,
        attributes: Vec<Arc<dyn UiAttribute>>,
        patterns: Vec<PatternName>,
        children: Mutex<Vec<Arc<dyn UiNode>>>,
        parent: Mutex<Option<Weak<dyn UiNode>>>,
    }

    impl StaticNode {
        fn new(
            namespace: UiNamespace,
            runtime_id: &str,
            role: &'static str,
            name: &str,
            bounds: Rect,
            patterns: Vec<&str>,
        ) -> Arc<Self> {
            let runtime_id = RuntimeId::from(runtime_id);
            let patterns_vec: Vec<PatternName> = patterns.into_iter().map(PatternName::from).collect();
            let supported = supported_patterns_value(&patterns_vec);

            let mut attributes: Vec<Arc<dyn UiAttribute>> = vec![
                Arc::new(StaticAttribute::new(namespace, attribute_names::element::BOUNDS, UiValue::Rect(bounds)))
                    as Arc<dyn UiAttribute>,
                Arc::new(StaticAttribute::new(namespace, attribute_names::common::ROLE, UiValue::from(role)))
                    as Arc<dyn UiAttribute>,
                Arc::new(StaticAttribute::new(namespace, attribute_names::common::NAME, UiValue::from(name)))
                    as Arc<dyn UiAttribute>,
                Arc::new(StaticAttribute::new(namespace, attribute_names::element::IS_VISIBLE, UiValue::from(true)))
                    as Arc<dyn UiAttribute>,
                Arc::new(StaticAttribute::new(namespace, attribute_names::element::IS_ENABLED, UiValue::from(true)))
                    as Arc<dyn UiAttribute>,
                Arc::new(StaticAttribute::new(
                    namespace,
                    attribute_names::common::RUNTIME_ID,
                    UiValue::from(runtime_id.as_str().to_owned()),
                )) as Arc<dyn UiAttribute>,
                Arc::new(StaticAttribute::new(namespace, attribute_names::common::TECHNOLOGY, UiValue::from("Mock")))
                    as Arc<dyn UiAttribute>,
                Arc::new(StaticAttribute::new(namespace, attribute_names::common::SUPPORTED_PATTERNS, supported))
                    as Arc<dyn UiAttribute>,
            ];

            if role == "Desktop" {
                attributes.push(Arc::new(StaticAttribute::new(
                    namespace,
                    attribute_names::desktop::DISPLAY_COUNT,
                    UiValue::from(1_i64),
                )) as Arc<dyn UiAttribute>);
                attributes.push(Arc::new(StaticAttribute::new(
                    namespace,
                    attribute_names::desktop::OS_NAME,
                    UiValue::from("Test OS"),
                )) as Arc<dyn UiAttribute>);
                attributes.push(Arc::new(StaticAttribute::new(
                    namespace,
                    attribute_names::desktop::OS_VERSION,
                    UiValue::from("1.0"),
                )) as Arc<dyn UiAttribute>);
                let mut monitor = std::collections::BTreeMap::new();
                monitor.insert("Name".to_string(), UiValue::from("Display 1"));
                monitor.insert("Bounds".to_string(), UiValue::Rect(bounds));
                attributes.push(Arc::new(StaticAttribute::new(
                    namespace,
                    attribute_names::desktop::MONITORS,
                    UiValue::Array(vec![UiValue::Object(monitor)]),
                )) as Arc<dyn UiAttribute>);
            }

            let node = Arc::new(Self {
                namespace,
                role,
                name: name.to_string(),
                runtime_id,
                attributes,
                patterns: patterns_vec,
                children: Mutex::new(Vec::new()),
                parent: Mutex::new(None),
            });

            if matches!(namespace, UiNamespace::Control | UiNamespace::Item) {
                platynui_core::ui::validate_control_or_item(node.as_ref())
                    .expect("StaticNode violates UiNode contract");
            }

            node
        }

        fn to_ref(this: &Arc<Self>) -> Arc<dyn UiNode> {
            Arc::clone(this) as Arc<dyn UiNode>
        }

        fn add_child(parent: &Arc<Self>, child: &Arc<Self>) {
            *child.parent.lock().unwrap() = Some(Arc::downgrade(&(Arc::clone(parent) as Arc<dyn UiNode>)));
            parent.children.lock().unwrap().push(Self::to_ref(child));
        }
    }

    impl UiNode for StaticNode {
        fn namespace(&self) -> UiNamespace {
            self.namespace
        }

        fn role(&self) -> &str {
            self.role
        }

        fn name(&self) -> String {
            self.name.clone()
        }

        fn runtime_id(&self) -> &RuntimeId {
            &self.runtime_id
        }

        fn parent(&self) -> Option<Weak<dyn UiNode>> {
            self.parent.lock().unwrap().clone()
        }

        fn children(&self) -> Box<dyn Iterator<Item = Arc<dyn UiNode>> + Send + 'static> {
            let snapshot = self.children.lock().unwrap().clone();
            Box::new(snapshot.into_iter())
        }

        fn attributes(&self) -> Box<dyn Iterator<Item = Arc<dyn UiAttribute>> + Send + 'static> {
            Box::new(self.attributes.clone().into_iter())
        }

        fn supported_patterns(&self) -> Vec<PatternName> {
            self.patterns.clone()
        }

        fn invalidate(&self) {}
    }

    fn sample_tree() -> Arc<dyn UiNode> {
        let window = StaticNode::new(
            UiNamespace::Control,
            "window-1",
            "Window",
            "Main",
            Rect::new(0.0, 0.0, 800.0, 600.0),
            vec![],
        );
        let desktop = StaticNode::new(
            UiNamespace::Control,
            "desktop",
            "Desktop",
            "Desktop",
            Rect::new(0.0, 0.0, 1920.0, 1080.0),
            vec![],
        );

        StaticNode::add_child(&desktop, &window);

        StaticNode::to_ref(&desktop)
    }

    #[rstest]
    fn evaluates_node_selection() {
        let tree = sample_tree();
        let items = evaluate(None, "//Window", EvaluateOptions::new(tree.clone())).unwrap();
        assert_eq!(items.len(), 1);
        match &items[0] {
            EvaluationItem::Node(node) => {
                assert_eq!(node.runtime_id().as_str(), "window-1");
            }
            other => panic!("unexpected evaluation result: {:?}", other),
        }
    }

    #[rstest]
    fn evaluates_count_function() {
        let tree = sample_tree();
        let items = evaluate(None, "count(//Window)", EvaluateOptions::new(tree.clone())).unwrap();
        assert_eq!(items.len(), 1);
        match &items[0] {
            EvaluationItem::Value(value) => assert_eq!(value, &UiValue::Integer(1)),
            other => panic!("unexpected evaluation result: {:?}", other),
        }
    }

    #[rstest]
    fn absolute_path_from_document_returns_children() {
        let tree = sample_tree();
        let items = evaluate(None, "/*", EvaluateOptions::new(tree.clone())).unwrap();
        assert_eq!(items.len(), 1);
        match &items[0] {
            EvaluationItem::Node(node) => {
                assert_eq!(node.runtime_id().as_str(), "window-1");
            }
            other => panic!("unexpected evaluation result: {:?}", other),
        }
    }

    #[rstest]
    fn desktop_bounds_alias_attributes_are_available() {
        let tree = sample_tree();
        let items = evaluate(None, "./@Bounds.X", EvaluateOptions::new(tree.clone())).unwrap();
        assert_eq!(items.len(), 1);
        match &items[0] {
            EvaluationItem::Attribute(attr) => {
                assert_eq!(attr.name, "Bounds.X");
                assert_eq!(attr.value, UiValue::Number(0.0));
            }
            other => panic!("unexpected attribute result: {:?}", other),
        }
    }

    #[rstest]
    fn bounds_width_data_returns_numbers() {
        let tree = sample_tree();
        let attrs = evaluate(None, "//@*:Bounds.Width", EvaluateOptions::new(tree.clone())).unwrap();
        assert!(!attrs.is_empty());
        for item in &attrs {
            match item {
                EvaluationItem::Attribute(attr) => {
                    assert!(matches!(attr.value, UiValue::Number(_)));
                }
                other => panic!("expected attribute node, got {:?}", other),
            }
        }
        let items = evaluate(None, "data(//@*:Bounds.Width)", EvaluateOptions::new(tree.clone())).unwrap();
        assert!(!items.is_empty());
        let mut widths = Vec::new();
        for item in items {
            match item {
                EvaluationItem::Value(UiValue::Number(n)) => widths.push(n),
                other => panic!("expected numeric UiValue, got {:?}", other),
            }
        }
        assert!(widths.contains(&1920.0));
        assert!(widths.contains(&800.0));
    }

    #[rstest]
    fn boolean_attributes_atomize_to_bools() {
        let tree = sample_tree();
        let items = evaluate(None, "data(//@*:IsVisible)", EvaluateOptions::new(tree.clone())).unwrap();
        assert!(!items.is_empty());
        for item in items {
            match item {
                EvaluationItem::Value(UiValue::Bool(value)) => assert!(value),
                other => panic!("expected boolean UiValue, got {:?}", other),
            }
        }
    }

    #[rstest]
    fn bounds_base_attribute_remains_json_string() {
        let tree = sample_tree();
        let items = evaluate(None, "data(./@Bounds)", EvaluateOptions::new(tree.clone())).unwrap();
        assert_eq!(items.len(), 1);
        match &items[0] {
            EvaluationItem::Value(UiValue::String(json)) => {
                assert!(json.contains("\"width\""));
                assert!(json.contains("\"height\""));
            }
            other => panic!("expected serialized bounds string, got {:?}", other),
        }
    }

    #[rstest]
    fn desktop_monitors_attribute_is_exposed() {
        let tree = sample_tree();
        let items = evaluate(None, "./@Monitors", EvaluateOptions::new(tree.clone())).unwrap();
        assert_eq!(items.len(), 1);
        match &items[0] {
            EvaluationItem::Attribute(attr) => {
                assert_eq!(attr.name, "Monitors");
                match &attr.value {
                    UiValue::Array(monitors) => {
                        assert_eq!(monitors.len(), 1);
                    }
                    other => panic!("unexpected attribute type: {:?}", other),
                }
            }
            other => panic!("unexpected monitors result: {:?}", other),
        }
    }

    struct ResolverOk {
        node: Arc<dyn UiNode>,
    }

    impl NodeResolver for ResolverOk {
        fn resolve(&self, _runtime_id: &RuntimeId) -> Result<Option<Arc<dyn UiNode>>, ProviderError> {
            Ok(Some(self.node.clone()))
        }
    }

    struct ResolverMissing;

    impl NodeResolver for ResolverMissing {
        fn resolve(&self, _runtime_id: &RuntimeId) -> Result<Option<Arc<dyn UiNode>>, ProviderError> {
            Ok(None)
        }
    }

    struct ResolverError;

    impl NodeResolver for ResolverError {
        fn resolve(&self, _runtime_id: &RuntimeId) -> Result<Option<Arc<dyn UiNode>>, ProviderError> {
            Err(ProviderError::TreeUnavailable { provider: "resolver", details: None })
        }
    }

    #[rstest]
    fn context_is_re_resolved_via_resolver() {
        let tree = sample_tree();
        let stale = StaticNode::new(
            UiNamespace::Control,
            "stale-window",
            "Window",
            "Old",
            Rect::new(0.0, 0.0, 100.0, 100.0),
            vec![],
        );
        let fresh = StaticNode::new(
            UiNamespace::Control,
            "stale-window",
            "Window",
            "New",
            Rect::new(0.0, 0.0, 100.0, 100.0),
            vec![],
        );
        let stale_node = StaticNode::to_ref(&stale);
        let fresh_node = StaticNode::to_ref(&fresh);
        let resolver = Arc::new(ResolverOk { node: fresh_node.clone() });

        let items =
            evaluate(Some(stale_node.clone()), ".", EvaluateOptions::new(tree.clone()).with_node_resolver(resolver))
                .unwrap();

        match &items[0] {
            EvaluationItem::Node(node) => {
                assert!(Arc::ptr_eq(node, &fresh_node));
            }
            other => panic!("unexpected result: {:?}", other),
        }
    }

    #[rstest]
    fn context_missing_yields_error() {
        let tree = sample_tree();
        let stale = StaticNode::new(
            UiNamespace::Control,
            "missing-window",
            "Window",
            "Old",
            Rect::new(0.0, 0.0, 100.0, 100.0),
            vec![],
        );
        let stale_node = StaticNode::to_ref(&stale);
        let runtime_id = stale_node.runtime_id().as_str().to_string();
        let resolver = Arc::new(ResolverMissing);

        let result =
            evaluate(Some(stale_node.clone()), ".", EvaluateOptions::new(tree.clone()).with_node_resolver(resolver));

        match result {
            Err(EvaluateError::ContextNodeUnknown(id)) => assert_eq!(id, runtime_id),
            other => panic!("unexpected result: {:?}", other),
        }
    }

    #[rstest]
    fn resolver_error_is_propagated() {
        let tree = sample_tree();
        let stale = StaticNode::new(
            UiNamespace::Control,
            "errored-window",
            "Window",
            "Old",
            Rect::new(0.0, 0.0, 100.0, 100.0),
            vec![],
        );
        let stale_node = StaticNode::to_ref(&stale);
        let resolver = Arc::new(ResolverError);

        let result =
            evaluate(Some(stale_node.clone()), ".", EvaluateOptions::new(tree.clone()).with_node_resolver(resolver));

        match result {
            Err(EvaluateError::Provider(err)) => match err {
                ProviderError::TreeUnavailable { .. } => {}
                other => panic!("unexpected provider error: {other}"),
            },
            other => panic!("unexpected result: {:?}", other),
        }
    }
}