resuma 1.3.1

//! The View tree — Resuma's resumable equivalent of a virtual DOM.
//!
//! A `View` is just data. It is built by components, walked by the SSR
//! renderer to emit HTML, and never re-executed on the client. Reactivity is
//! recovered by the runtime through `Dynamic` nodes that carry a signal id
//! plus a small JS expression describing how to project the signal value.

use serde::{Deserialize, Serialize};
use serde_json::Value;

use super::handler::HandlerRef;
use super::signal::SignalId;

/// Top-level view returned from a component.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum View {
    Text(String),
    /// Reactive text/HTML node bound to a signal.
    Dynamic(Dynamic),
    Element(Element),
    Fragment(Fragment),
    Component(ComponentMarker),
    /// A self-contained interactive island. Renders its own SSR HTML and
    /// declares the chunk that will be lazy-loaded on first interaction.
    Island(Island),
    /// Resumable component boundary — lazy handler chunk + viewport prefetch.
    Boundary(Boundary),
    /// Content projection slot — resolved from parent slotted children.
    Slot(SlotView),
    /// A rendered chunk of raw HTML — used for trusted output and for nested
    /// pre-rendered components that have already been flattened.
    Raw(String),
    /// Reactive conditional — toggles branches on the client via `<resuma-show>`.
    Show(ShowView),
    /// Reactive keyed list — client diffing via `<resuma-for>`.
    For(ForView),
    /// Reactive multi-branch match — client toggles via `<resuma-match>`.
    Match(MatchView),
    Empty,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Element {
    pub tag: String,
    pub attrs: Vec<Attr>,
    pub children: Vec<Child>,
    /// Optional explicit DOM id. Mostly used by tests/devtools.
    pub dom_id: Option<String>,
}

impl Element {
    /// Last write wins for a given name (e.g. force `type="button"` on a submit).
    /// `style` is concatenated so Popup `anchor-name` does not drop host styles.
    pub(crate) fn merge_attrs(&mut self, extra: impl IntoIterator<Item = Attr>) {
        for a in extra {
            if a.name == "style" {
                if let (Some(existing), AttrValue::Static(extra_style)) =
                    (self.attrs.iter_mut().find(|x| x.name == "style"), &a.value)
                {
                    if let AttrValue::Static(cur) = &mut existing.value {
                        append_css(cur, extra_style);
                        continue;
                    }
                }
            }
            if let Some(existing) = self.attrs.iter_mut().find(|x| x.name == a.name) {
                *existing = a;
            } else {
                self.attrs.push(a);
            }
        }
    }
}

fn append_css(cur: &mut String, extra: &str) {
    let extra = extra.trim();
    if extra.is_empty() {
        return;
    }
    if cur.trim().is_empty() {
        *cur = extra.to_string();
        return;
    }
    if !cur.trim_end().ends_with(';') {
        cur.push(';');
    }
    if !cur.ends_with(' ') {
        cur.push(' ');
    }
    cur.push_str(extra);
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Fragment {
    pub children: Vec<Child>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComponentMarker {
    pub name: String,
    pub view: Box<View>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SlotView {
    pub name: Option<String>,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
pub enum IslandLoad {
    #[default]
    Eager,
    Visible,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Island {
    /// Stable, build-time id of the island chunk on disk (e.g. `counter`).
    pub chunk_id: String,
    /// Per-instance id (each `<Counter />` on the page gets its own).
    pub instance_id: String,
    /// Signal ids belonging to this island. Used by the runtime to wire
    /// reactivity locally.
    pub signal_ids: Vec<SignalId>,
    /// Pre-rendered SSR HTML of the island content.
    pub view: Box<View>,
    /// Props serialized as JSON, passed to the island's resume() entry.
    pub props: Value,
    /// When to load island JS (`eager` default, `visible` uses IntersectionObserver).
    #[serde(default)]
    pub load: IslandLoad,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Boundary {
    pub chunk_id: String,
    pub view: Box<View>,
}

/// Reactive `<Show when={signal}>` — both branches are SSR'd; the runtime
/// toggles visibility based on the bound bool signal.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ShowView {
    pub signal: SignalId,
    /// When true, the `when` branch is shown when the signal is *false*.
    pub inverted: bool,
    /// SSR snapshot of whether the "if" branch is visible.
    pub initial: bool,
    pub children: Vec<Child>,
    pub fallback: Option<Box<View>>,
}

/// Reactive keyed `<For each={signal}>`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ForView {
    pub signal: SignalId,
    pub key_field: Option<String>,
    pub items: Vec<ForItemView>,
    /// Windowed list (`<For virtual>`). SSR emits a prefix of `items`; the
    /// client window lives in `/_resuma/ui.js`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub virtual_list: Option<VirtualListOpts>,
}

/// Options for a virtualized `<For>`.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct VirtualListOpts {
    pub item_height: u32,
    pub overscan: u32,
    /// Full collection length (SSR `items` may be a windowed prefix).
    pub total: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ForItemView {
    pub key: String,
    pub children: Vec<Child>,
}

/// Reactive `<Match value={signal}>`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MatchView {
    pub signal: SignalId,
    /// SSR snapshot of the active branch key.
    pub initial: String,
    pub cases: Vec<MatchCase>,
    pub default: Option<Vec<Child>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MatchCase {
    pub when: String,
    pub children: Vec<Child>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Child {
    View(View),
    /// Raw text — convenience to avoid wrapping every literal in `View::Text`.
    Text(String),
}

impl From<View> for Child {
    fn from(v: View) -> Self {
        Child::View(v)
    }
}
impl From<&str> for Child {
    fn from(s: &str) -> Self {
        Child::Text(s.to_string())
    }
}
impl From<String> for Child {
    fn from(s: String) -> Self {
        Child::Text(s)
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Attr {
    pub name: String,
    pub value: AttrValue,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum AttrValue {
    /// Plain string attribute.
    Static(String),
    /// Reactive attribute bound to a signal.
    Dynamic {
        signal: SignalId,
        format: Option<String>,
    },
    /// Event handler (`onClick`, `onInput`, …). Resolved at SSR time to a
    /// `HandlerRef` pointing at a JS chunk.
    Handler(HandlerRef),
    /// Boolean attribute that is omitted when false.
    Bool(bool),
    /// Declarative `preventDefault` for event handlers (async-safe).
    PreventDefault(String),
    /// Declarative `stopPropagation` for event handlers (async-safe).
    StopPropagation(String),
}

/// Reactive text/HTML node bound to a signal.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Dynamic {
    pub signal: SignalId,
    /// Optional format string. `{}` is replaced with the signal's value.
    pub format: Option<String>,
    /// JSON-serialized snapshot of the signal value at SSR time.
    pub snapshot: Value,
}

impl View {
    pub fn text(s: impl Into<String>) -> Self {
        View::Text(s.into())
    }
    /// Emit raw HTML without escaping.
    ///
    /// **Security:** never pass user-controlled strings here — use `view!` text
    /// interpolation instead, which escapes HTML entities automatically.
    pub fn raw(html: impl Into<String>) -> Self {
        View::Raw(html.into())
    }
    pub fn empty() -> Self {
        View::Empty
    }

    pub fn element(tag: impl Into<String>) -> ElementBuilder {
        ElementBuilder {
            element: Element {
                tag: tag.into(),
                ..Default::default()
            },
        }
    }

    pub fn fragment(children: Vec<Child>) -> Self {
        View::Fragment(Fragment { children })
    }

    pub fn slot(name: Option<String>) -> Self {
        View::Slot(SlotView { name })
    }

    /// Wrap a component view in a resumable boundary (lazy handler chunk).
    pub fn boundary(chunk_id: impl Into<String>, view: View) -> Self {
        View::Boundary(Boundary {
            chunk_id: chunk_id.into(),
            view: Box::new(view),
        })
    }
}

/// Ergonomic builder used by the `view!` macro expansion.
pub struct ElementBuilder {
    element: Element,
}

impl ElementBuilder {
    pub fn attr(mut self, name: impl Into<String>, value: AttrValue) -> Self {
        self.element.attrs.push(Attr {
            name: name.into(),
            value,
        });
        self
    }

    pub fn child(mut self, child: impl Into<Child>) -> Self {
        self.element.children.push(child.into());
        self
    }

    pub fn children(mut self, children: impl IntoIterator<Item = Child>) -> Self {
        self.element.children.extend(children);
        self
    }

    pub fn dom_id(mut self, id: impl Into<String>) -> Self {
        self.element.dom_id = Some(id.into());
        self
    }

    pub fn build(self) -> View {
        View::Element(self.element)
    }
}