fret-ui 0.1.0

use fret_core::{AppWindowId, NodeId, Rect};

use super::with_window_state;
use super::{ElementContext, ElementRuntime, GlobalElementId};
use crate::UiHost;

pub fn with_element_cx<H: UiHost, R>(
    app: &mut H,
    window: AppWindowId,
    bounds: Rect,
    root_name: &str,
    f: impl FnOnce(&mut ElementContext<'_, H>) -> R,
) -> R {
    app.with_global_mut_untracked(ElementRuntime::new, |runtime, app| {
        let mut cx = ElementContext::new_for_root_name(app, runtime, window, bounds, root_name);
        f(&mut cx)
    })
}

pub fn root_bounds_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> Option<Rect> {
    app.with_global_mut_untracked(ElementRuntime::new, |runtime, _app| {
        let state = runtime.for_window_mut(window);
        let root = state.node_entry(element).map(|e| e.root)?;
        state.root_bounds(root)
    })
}

/// Returns the most recent retained `NodeId` mapping for `element`.
///
/// This is intentionally a last-known query surface for post-frame / component-policy code.
/// Mechanism paths that already have access to `UiTree` or the declarative window frame should
/// resolve a live attached node instead of treating this mapping as authoritative truth.
pub fn node_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> Option<NodeId> {
    with_window_state(app, window, |st| st.node_entry(element).map(|e| e.node))
}

/// Returns the current-frame node mapping for `element`, if available.
///
/// The authoritative liveness signal is the retained `node_entry` record being touched in the
/// current frame (`last_seen_frame == app.frame_id()`). The declarative window-frame cache keeps
/// stale records until subtree GC, so it must not be treated as a standalone liveness oracle.
///
/// Prefer this for render-time/component-policy code that needs a node that is still live for the
/// current frame rather than a purely cross-frame cached mapping.
pub fn live_node_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> Option<NodeId> {
    let frame_id = app.frame_id();
    with_window_state(app, window, |st| {
        st.node_entry(element)
            .and_then(|entry| (entry.last_seen_frame == frame_id).then_some(entry.node))
    })
}

/// Returns the most recent `NodeId` mapping for `element` without preparing element runtime for the
/// current frame.
///
/// This is intended for callers that run *during* tree construction (e.g. overlay policy hooks)
/// where calling `prepare_window_for_frame` can reset `*_next` state.
///
/// Prefer `node_for_element` for normal post-frame queries.
pub fn peek_node_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> Option<NodeId> {
    app.with_global_mut_untracked(ElementRuntime::new, |runtime, _app| {
        let state = runtime.for_window(window)?;
        state.node_entry(element).map(|e| e.node)
    })
}

/// Returns whether `element` is known to be mounted in the **current frame**.
///
/// `node_for_element` may return a stale mapping by design (cross-frame queries). For policies
/// that need a liveness gate (e.g. cached overlay request synthesis), prefer this check.
pub fn element_is_live_in_current_frame<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> bool {
    let frame_id = app.frame_id();
    with_window_state(app, window, |st| {
        st.node_entry(element)
            .map(|e| e.last_seen_frame == frame_id)
            .unwrap_or(false)
    })
}

/// Returns whether `element` participated in the current frame's declarative authoring pass.
///
/// Unlike [`element_is_live_in_current_frame`], this also returns `true` for scope-only identities
/// created via `scope` / `keyed` that may not map to a mounted `NodeId` themselves.
///
/// This is the correct liveness predicate for policy caches keyed by declarative authoring
/// identities (for example, overlay request owners).
pub fn element_identity_is_live_in_current_frame<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> bool {
    with_window_state(app, window, |st| {
        st.element_identity_is_live_in_current_frame(element)
    })
}

/// Returns the most recent **committed** bounds for a declarative element, if available.
///
/// This is a cross-frame geometry query intended for component-layer policies (e.g. anchored
/// overlays) that need a stable anchor rect. The value is committed at frame boundaries to avoid
/// feedback loops during layout (see `ElementRuntime` geometry buffering notes).
pub fn bounds_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> Option<Rect> {
    with_window_state(app, window, |st| st.last_bounds(element))
}

/// Returns the most recent recorded bounds for `element`, including the current frame's
/// in-progress layout deltas.
///
/// Prefer [`bounds_for_element`] for policy code that must avoid layout feedback loops (e.g.
/// anchored overlays). This helper is intended for mechanism code that runs *during* layout and
/// needs immediate access to the bounds just recorded for the current frame.
pub fn current_bounds_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> Option<Rect> {
    with_window_state(app, window, |st| st.current_bounds(element))
}

/// Returns the most recent committed **visual** bounds (post-`render_transform` AABB) for a
/// declarative element, if available.
///
/// This is a cross-frame geometry query intended for component-layer anchored overlay policies
/// that must track render transforms (ADR 0082) while keeping layout authoritative.
pub fn visual_bounds_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> Option<Rect> {
    with_window_state(app, window, |st| {
        st.last_visual_bounds(element)
            .or_else(|| st.last_bounds(element))
    })
}

/// Returns the most recent recorded **visual** bounds for `element`, including the current
/// frame's in-progress layout deltas.
pub fn current_visual_bounds_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
) -> Option<Rect> {
    with_window_state(app, window, |st| {
        st.current_visual_bounds(element)
            .or_else(|| st.current_bounds(element))
    })
}

pub(crate) fn record_bounds_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
    bounds: Rect,
) {
    with_window_state(app, window, |st| st.record_bounds(element, bounds));
}

pub(crate) fn record_visual_bounds_for_element<H: UiHost>(
    app: &mut H,
    window: AppWindowId,
    element: GlobalElementId,
    bounds: Rect,
) {
    with_window_state(app, window, |st| st.record_visual_bounds(element, bounds));
}