fd_core/

parser.rs

//! Parser for the FD text format → SceneGraph.
//!
//! Built on `winnow` 0.7 for efficient, streaming parsing.
//! Handles: comments, style definitions, imports, node declarations
//! (group, rect, ellipse, path, text), inline properties, animations,
//! and top-level constraints.

use crate::id::NodeId;
use crate::model::*;
use winnow::ascii::space1;
use winnow::combinator::{alt, delimited, opt, preceded};
use winnow::error::ContextError;
use winnow::prelude::*;
use winnow::token::{take_till, take_while};

/// Parse an FD document string into a `SceneGraph`.
#[must_use = "parsing result should be used"]
pub fn parse_document(input: &str) -> Result<SceneGraph, String> {
    let mut graph = SceneGraph::new();
    let mut rest = input;

    // Collect any leading comments before the first declaration.
    let mut pending_comments = collect_leading_comments(&mut rest);

    while !rest.is_empty() {
        let line = line_number(input, rest);
        let end = {
            let max = rest.len().min(40);
            // Find a valid UTF-8 char boundary at or before `max`
            let mut e = max;
            while e > 0 && !rest.is_char_boundary(e) {
                e -= 1;
            }
            e
        };
        let ctx = &rest[..end];

        if rest.starts_with("import ") {
            let import = parse_import_line
                .parse_next(&mut rest)
                .map_err(|e| format!("line {line}: import error — expected `import \"path\" as name`, got `{ctx}…`: {e}"))?;
            graph.imports.push(import);
            pending_comments.clear();
        } else if rest.starts_with("style ") || rest.starts_with("theme ") {
            let (name, style) = parse_style_block
                .parse_next(&mut rest)
                .map_err(|e| format!("line {line}: theme/style error — expected `theme name {{ props }}`, got `{ctx}…`: {e}"))?;
            graph.define_style(name, style);
            pending_comments.clear();
        } else if rest.starts_with("spec ") || rest.starts_with("spec{") {
            // Top-level spec blocks are ignored (they only apply inside nodes)
            let _ = parse_spec_block.parse_next(&mut rest);
            pending_comments.clear();
        } else if rest.starts_with('@') {
            if is_generic_node_start(rest) {
                let mut node_data = parse_node.parse_next(&mut rest).map_err(|e| {
                    format!("line {line}: node error — expected `@id {{ ... }}`, got `{ctx}…`: {e}")
                })?;
                node_data.comments = std::mem::take(&mut pending_comments);
                let root = graph.root;
                insert_node_recursive(&mut graph, root, node_data);
            } else {
                let (node_id, constraint) = parse_constraint_line
                    .parse_next(&mut rest)
                    .map_err(|e| format!("line {line}: constraint error — expected `@id -> type: value`, got `{ctx}…`: {e}"))?;
                if let Some(node) = graph.get_by_id_mut(node_id) {
                    node.constraints.push(constraint);
                }
                pending_comments.clear();
            }
        } else if rest.starts_with("edge ") {
            let edge = parse_edge_block
                .parse_next(&mut rest)
                .map_err(|e| format!("line {line}: edge error — expected `edge @id {{ from: @a to: @b }}`, got `{ctx}…`: {e}"))?;
            graph.edges.push(edge);
            pending_comments.clear();
        } else if starts_with_node_keyword(rest) {
            let mut node_data = parse_node.parse_next(&mut rest).map_err(|e| {
                format!(
                    "line {line}: node error — expected `kind @id {{ ... }}`, got `{ctx}…`: {e}"
                )
            })?;
            node_data.comments = std::mem::take(&mut pending_comments);
            let root = graph.root;
            insert_node_recursive(&mut graph, root, node_data);
        } else {
            // Skip unknown line
            let _ = take_till::<_, _, ContextError>(0.., '\n').parse_next(&mut rest);
            if rest.starts_with('\n') {
                rest = &rest[1..];
            }
            pending_comments.clear();
        }

        // Collect comments between top-level declarations.
        // They will be attached to the *next* node parsed.
        let more = collect_leading_comments(&mut rest);
        pending_comments.extend(more);
    }

    Ok(graph)
}

/// Compute the 1-based line number of `remaining` within `full_input`.
fn line_number(full_input: &str, remaining: &str) -> usize {
    let consumed = full_input.len() - remaining.len();
    full_input[..consumed].matches('\n').count() + 1
}

fn starts_with_node_keyword(s: &str) -> bool {
    s.starts_with("group")
        || s.starts_with("frame")
        || s.starts_with("rect")
        || s.starts_with("ellipse")
        || s.starts_with("path")
        || s.starts_with("text")
}

/// Check if input starts with `@identifier` followed by whitespace then `{`.
/// Distinguishes generic nodes (`@id { }`) from constraint lines (`@id -> ...`).
fn is_generic_node_start(s: &str) -> bool {
    let rest = match s.strip_prefix('@') {
        Some(r) => r,
        None => return false,
    };
    let after_id = rest.trim_start_matches(|c: char| c.is_alphanumeric() || c == '_');
    // Must have consumed at least one identifier char
    if after_id.len() == rest.len() {
        return false;
    }
    after_id.trim_start().starts_with('{')
}

/// Internal representation during parsing before inserting into graph.
#[derive(Debug)]
struct ParsedNode {
    id: NodeId,
    kind: NodeKind,
    style: Style,
    use_styles: Vec<NodeId>,
    constraints: Vec<Constraint>,
    animations: Vec<AnimKeyframe>,
    annotations: Vec<Annotation>,
    /// Comments that appeared before this node's opening `{` in the source.
    comments: Vec<String>,
    children: Vec<ParsedNode>,
}

fn insert_node_recursive(
    graph: &mut SceneGraph,
    parent: petgraph::graph::NodeIndex,
    parsed: ParsedNode,
) {
    let mut node = SceneNode::new(parsed.id, parsed.kind);
    node.style = parsed.style;
    node.use_styles.extend(parsed.use_styles);
    node.constraints.extend(parsed.constraints);
    node.animations.extend(parsed.animations);
    node.annotations = parsed.annotations;
    node.comments = parsed.comments;

    let idx = graph.add_node(parent, node);

    for child in parsed.children {
        insert_node_recursive(graph, idx, child);
    }
}

// ─── Import parser ──────────────────────────────────────────────────────

/// Parse `import "path.fd" as namespace`.
fn parse_import_line(input: &mut &str) -> ModalResult<Import> {
    let _ = "import".parse_next(input)?;
    let _ = space1.parse_next(input)?;
    let path = parse_quoted_string
        .map(|s| s.to_string())
        .parse_next(input)?;
    let _ = space1.parse_next(input)?;
    let _ = "as".parse_next(input)?;
    let _ = space1.parse_next(input)?;
    let namespace = parse_identifier.map(|s| s.to_string()).parse_next(input)?;
    skip_opt_separator(input);
    Ok(Import { path, namespace })
}

// ─── Low-level parsers ──────────────────────────────────────────────────

/// Collect leading whitespace and `# comment` lines, returning the comments.
fn collect_leading_comments(input: &mut &str) -> Vec<String> {
    let mut comments = Vec::new();
    loop {
        // Skip pure whitespace (not newlines that separate nodes)
        let before = *input;
        *input = input.trim_start();
        if input.starts_with('#') {
            // Regular `# comment` — collect it
            let end = input.find('\n').unwrap_or(input.len());
            let text = input[1..end].trim().to_string();
            if !text.is_empty() {
                comments.push(text);
            }
            *input = &input[end.min(input.len())..];
            if input.starts_with('\n') {
                *input = &input[1..];
            }
            continue;
        }
        if *input == before {
            break;
        }
    }
    comments
}

/// Skip whitespace and comments without collecting them (used in style/anim blocks
/// where comments are rare and not worth attaching to a model element).
fn skip_ws_and_comments(input: &mut &str) {
    let _ = collect_leading_comments(input);
}

/// Consume optional whitespace (concrete error type avoids inference issues).
fn skip_space(input: &mut &str) {
    use winnow::ascii::space0;
    let _: Result<&str, winnow::error::ErrMode<ContextError>> = space0.parse_next(input);
}

fn parse_identifier<'a>(input: &mut &'a str) -> ModalResult<&'a str> {
    take_while(1.., |c: char| c.is_alphanumeric() || c == '_').parse_next(input)
}

fn parse_node_id(input: &mut &str) -> ModalResult<NodeId> {
    preceded('@', parse_identifier)
        .map(NodeId::intern)
        .parse_next(input)
}

fn parse_hex_color(input: &mut &str) -> ModalResult<Color> {
    let _ = '#'.parse_next(input)?;
    let hex_digits: &str = take_while(1..=8, |c: char| c.is_ascii_hexdigit()).parse_next(input)?;
    Color::from_hex(hex_digits)
        .ok_or_else(|| winnow::error::ErrMode::Backtrack(ContextError::new()))
}

fn parse_number(input: &mut &str) -> ModalResult<f32> {
    let start = *input;
    if input.starts_with('-') {
        *input = &input[1..];
    }
    let _ = take_while(1.., |c: char| c.is_ascii_digit()).parse_next(input)?;
    if input.starts_with('.') {
        *input = &input[1..];
        let _ =
            take_while::<_, _, ContextError>(0.., |c: char| c.is_ascii_digit()).parse_next(input);
    }
    let matched = &start[..start.len() - input.len()];
    matched
        .parse::<f32>()
        .map_err(|_| winnow::error::ErrMode::Backtrack(ContextError::new()))
}

fn parse_quoted_string<'a>(input: &mut &'a str) -> ModalResult<&'a str> {
    delimited('"', take_till(0.., '"'), '"').parse_next(input)
}

fn skip_opt_separator(input: &mut &str) {
    if input.starts_with(';') || input.starts_with('\n') {
        *input = &input[1..];
    }
}

/// Strip an optional trailing `px` unit suffix (e.g. `320px` → `320`).
fn skip_px_suffix(input: &mut &str) {
    if input.starts_with("px") {
        *input = &input[2..];
    }
}

// ─── Spec block parser ──────────────────────────────────────────────────

/// Parse a `spec { ... }` block or inline `spec "description"` into annotations.
fn parse_spec_block(input: &mut &str) -> ModalResult<Vec<Annotation>> {
    let _ = "spec".parse_next(input)?;
    skip_space(input);

    // Inline shorthand: `spec "description"`
    if input.starts_with('"') {
        let desc = parse_quoted_string
            .map(|s| s.to_string())
            .parse_next(input)?;
        skip_opt_separator(input);
        return Ok(vec![Annotation::Description(desc)]);
    }

    // Block form: `spec { ... }`
    let _ = '{'.parse_next(input)?;
    let mut annotations = Vec::new();
    skip_ws_and_comments(input);

    while !input.starts_with('}') {
        annotations.push(parse_spec_item.parse_next(input)?);
        skip_ws_and_comments(input);
    }

    let _ = '}'.parse_next(input)?;
    Ok(annotations)
}

/// Parse a single item inside a `spec { ... }` block.
///
/// Handles:
/// - `"description text"` → Description
/// - `accept: "criterion"` → Accept
/// - `status: value` → Status
/// - `priority: value` → Priority
/// - `tag: value` → Tag
fn parse_spec_item(input: &mut &str) -> ModalResult<Annotation> {
    // Freeform description: `"text"`
    if input.starts_with('"') {
        let desc = parse_quoted_string
            .map(|s| s.to_string())
            .parse_next(input)?;
        skip_opt_separator(input);
        return Ok(Annotation::Description(desc));
    }

    // Typed annotation: `keyword: value`
    let keyword = parse_identifier.parse_next(input)?;
    skip_space(input);
    let _ = ':'.parse_next(input)?;
    skip_space(input);

    let value = if input.starts_with('"') {
        parse_quoted_string
            .map(|s| s.to_string())
            .parse_next(input)?
    } else {
        let v: &str =
            take_till(0.., |c: char| c == '\n' || c == ';' || c == '}').parse_next(input)?;
        v.trim().to_string()
    };

    let ann = match keyword {
        "accept" => Annotation::Accept(value),
        "status" => Annotation::Status(value),
        "priority" => Annotation::Priority(value),
        "tag" => Annotation::Tag(value),
        _ => Annotation::Description(format!("{keyword}: {value}")),
    };

    skip_opt_separator(input);
    Ok(ann)
}

// ─── Style block parser ─────────────────────────────────────────────────

fn parse_style_block(input: &mut &str) -> ModalResult<(NodeId, Style)> {
    let _ = alt(("theme", "style")).parse_next(input)?;
    let _ = space1.parse_next(input)?;
    let name = parse_identifier.map(NodeId::intern).parse_next(input)?;
    skip_space(input);
    let _ = '{'.parse_next(input)?;

    let mut style = Style::default();
    skip_ws_and_comments(input);

    while !input.starts_with('}') {
        parse_style_property(input, &mut style)?;
        skip_ws_and_comments(input);
    }

    let _ = '}'.parse_next(input)?;
    Ok((name, style))
}

fn parse_style_property(input: &mut &str, style: &mut Style) -> ModalResult<()> {
    let prop_name = parse_identifier.parse_next(input)?;
    skip_space(input);
    let _ = ':'.parse_next(input)?;
    skip_space(input);

    match prop_name {
        "fill" | "background" | "color" => {
            style.fill = Some(parse_paint(input)?);
        }
        "font" => {
            parse_font_value(input, style)?;
        }
        "corner" | "rounded" | "radius" => {
            style.corner_radius = Some(parse_number.parse_next(input)?);
            skip_px_suffix(input);
        }
        "opacity" => {
            style.opacity = Some(parse_number.parse_next(input)?);
        }
        "align" | "text_align" => {
            parse_align_value(input, style)?;
        }
        _ => {
            let _ =
                take_till::<_, _, ContextError>(0.., |c: char| c == '\n' || c == ';' || c == '}')
                    .parse_next(input);
        }
    }

    skip_opt_separator(input);
    Ok(())
}

/// Map human-readable weight names to numeric values.
fn weight_name_to_number(name: &str) -> Option<u16> {
    match name {
        "thin" => Some(100),
        "extralight" | "extra_light" => Some(200),
        "light" => Some(300),
        "regular" | "normal" => Some(400),
        "medium" => Some(500),
        "semibold" | "semi_bold" => Some(600),
        "bold" => Some(700),
        "extrabold" | "extra_bold" => Some(800),
        "black" | "heavy" => Some(900),
        _ => None,
    }
}

fn parse_font_value(input: &mut &str, style: &mut Style) -> ModalResult<()> {
    let mut font = style.font.clone().unwrap_or_default();

    if input.starts_with('"') {
        let family = parse_quoted_string.parse_next(input)?;
        font.family = family.to_string();
        skip_space(input);
    }

    // Try named weight first (e.g. bold, semibold), then numeric
    let saved = *input;
    if let Ok(name) = parse_identifier.parse_next(input) {
        if let Some(w) = weight_name_to_number(name) {
            font.weight = w;
            skip_space(input);
            if let Ok(size) = parse_number.parse_next(input) {
                font.size = size;
                skip_px_suffix(input);
            }
        } else {
            *input = saved; // not a weight name, restore
        }
    }

    // Fallback: numeric weight + size
    if *input == saved
        && let Ok(n1) = parse_number.parse_next(input)
    {
        skip_space(input);
        if let Ok(n2) = parse_number.parse_next(input) {
            font.weight = n1 as u16;
            font.size = n2;
            skip_px_suffix(input);
        } else {
            font.size = n1;
            skip_px_suffix(input);
        }
    }

    style.font = Some(font);
    Ok(())
}

// ─── Node parser ─────────────────────────────────────────────────────────

fn parse_node(input: &mut &str) -> ModalResult<ParsedNode> {
    // Type keyword is optional — `@id { }` creates a Generic node
    let kind_str = if input.starts_with('@') {
        "generic"
    } else {
        alt((
            "group".value("group"),
            "frame".value("frame"),
            "rect".value("rect"),
            "ellipse".value("ellipse"),
            "path".value("path"),
            "text".value("text"),
        ))
        .parse_next(input)?
    };

    skip_space(input);

    let id = if input.starts_with('@') {
        parse_node_id.parse_next(input)?
    } else {
        NodeId::anonymous(kind_str)
    };

    skip_space(input);

    let inline_text = if kind_str == "text" && input.starts_with('"') {
        Some(
            parse_quoted_string
                .map(|s| s.to_string())
                .parse_next(input)?,
        )
    } else {
        None
    };

    skip_space(input);
    let _ = '{'.parse_next(input)?;

    let mut style = Style::default();
    let mut use_styles = Vec::new();
    let mut constraints = Vec::new();
    let mut animations = Vec::new();
    let mut annotations = Vec::new();
    let mut children = Vec::new();
    let mut width: Option<f32> = None;
    let mut height: Option<f32> = None;
    let mut layout = LayoutMode::Free;
    let mut clip = false;

    skip_ws_and_comments(input);

    while !input.starts_with('}') {
        if input.starts_with("spec ") || input.starts_with("spec{") {
            annotations.extend(parse_spec_block.parse_next(input)?);
        } else if starts_with_child_node(input) {
            let mut child = parse_node.parse_next(input)?;
            // Any comments collected before this child are attached to it
            // (they were consumed by the preceding skip_ws_and_comments/collect call)
            child.comments = Vec::new(); // placeholder; child attaches its own leading comments
            children.push(child);
        } else if input.starts_with("when") || input.starts_with("anim") {
            animations.push(parse_anim_block.parse_next(input)?);
        } else {
            parse_node_property(
                input,
                &mut style,
                &mut use_styles,
                &mut constraints,
                &mut width,
                &mut height,
                &mut layout,
                &mut clip,
            )?;
        }
        // Collect comments between items; they'll be attached to the *next* child node
        let _inner_comments = collect_leading_comments(input);
    }

    let _ = '}'.parse_next(input)?;

    let kind = match kind_str {
        "group" => NodeKind::Group { layout },
        "frame" => NodeKind::Frame {
            width: width.unwrap_or(200.0),
            height: height.unwrap_or(200.0),
            clip,
            layout,
        },
        "rect" => NodeKind::Rect {
            width: width.unwrap_or(100.0),
            height: height.unwrap_or(100.0),
        },
        "ellipse" => NodeKind::Ellipse {
            rx: width.unwrap_or(50.0),
            ry: height.unwrap_or(50.0),
        },
        "text" => NodeKind::Text {
            content: inline_text.unwrap_or_default(),
        },
        "path" => NodeKind::Path {
            commands: Vec::new(),
        },
        "generic" => NodeKind::Generic,
        _ => unreachable!(),
    };

    Ok(ParsedNode {
        id,
        kind,
        style,
        use_styles,
        constraints,
        animations,
        annotations,
        comments: Vec::new(),
        children,
    })
}

/// Check if the current position starts a child node keyword followed by
/// a space, @, {, or " (not a property name that happens to start with a keyword).
fn starts_with_child_node(input: &str) -> bool {
    // Generic nodes start with @id {
    if is_generic_node_start(input) {
        return true;
    }
    let keywords = &[
        ("group", 5),
        ("frame", 5),
        ("rect", 4),
        ("ellipse", 7),
        ("path", 4),
        ("text", 4),
    ];
    for &(keyword, len) in keywords {
        if input.starts_with(keyword) {
            if keyword == "text" && input.get(len..).is_some_and(|s| s.starts_with('_')) {
                continue; // e.g. "text_align" is a property, not a text node
            }
            if let Some(after) = input.get(len..)
                && after.starts_with(|c: char| {
                    c == ' ' || c == '\t' || c == '@' || c == '{' || c == '"'
                })
            {
                return true;
            }
        }
    }
    false
}

/// Map named colors to hex values.
fn named_color_to_hex(name: &str) -> Option<Color> {
    match name {
        "red" => Color::from_hex("#EF4444"),
        "orange" => Color::from_hex("#F97316"),
        "amber" | "yellow" => Color::from_hex("#F59E0B"),
        "lime" => Color::from_hex("#84CC16"),
        "green" => Color::from_hex("#22C55E"),
        "teal" => Color::from_hex("#14B8A6"),
        "cyan" => Color::from_hex("#06B6D4"),
        "blue" => Color::from_hex("#3B82F6"),
        "indigo" => Color::from_hex("#6366F1"),
        "purple" | "violet" => Color::from_hex("#8B5CF6"),
        "pink" => Color::from_hex("#EC4899"),
        "rose" => Color::from_hex("#F43F5E"),
        "white" => Color::from_hex("#FFFFFF"),
        "black" => Color::from_hex("#000000"),
        "gray" | "grey" => Color::from_hex("#6B7280"),
        "slate" => Color::from_hex("#64748B"),
        _ => None,
    }
}

/// Parse a `Paint` value: `#HEX`, named color, `linear(...)`, or `radial(...)`.
fn parse_paint(input: &mut &str) -> ModalResult<Paint> {
    if input.starts_with("linear(") {
        let _ = "linear(".parse_next(input)?;
        let angle = parse_number.parse_next(input)?;
        let _ = "deg".parse_next(input)?;
        let stops = parse_gradient_stops(input)?;
        let _ = ')'.parse_next(input)?;
        Ok(Paint::LinearGradient { angle, stops })
    } else if input.starts_with("radial(") {
        let _ = "radial(".parse_next(input)?;
        let stops = parse_gradient_stops(input)?;
        let _ = ')'.parse_next(input)?;
        Ok(Paint::RadialGradient { stops })
    } else if input.starts_with('#') {
        parse_hex_color.map(Paint::Solid).parse_next(input)
    } else {
        // Try named color (e.g. purple, red, blue)
        let saved = *input;
        if let Ok(name) = parse_identifier.parse_next(input) {
            if let Some(color) = named_color_to_hex(name) {
                return Ok(Paint::Solid(color));
            }
            *input = saved;
        }
        parse_hex_color.map(Paint::Solid).parse_next(input)
    }
}

/// Parse gradient stops: optional leading comma, then `#HEX offset` pairs separated by commas.
///
/// Handles both `linear(90deg, #HEX N, #HEX N)` (comma before first stop)
/// and `radial(#HEX N, #HEX N)` (no comma before first stop).
fn parse_gradient_stops(input: &mut &str) -> ModalResult<Vec<GradientStop>> {
    let mut stops = Vec::new();
    loop {
        skip_space(input);
        // Consume comma separator (required between stops, optional before first)
        if input.starts_with(',') {
            let _ = ','.parse_next(input)?;
            skip_space(input);
        }
        // Stop if we hit the closing paren or end of input
        if input.is_empty() || input.starts_with(')') {
            break;
        }
        // Try to parse a color; if it fails, we're done
        let Ok(color) = parse_hex_color.parse_next(input) else {
            break;
        };
        skip_space(input);
        let offset = parse_number.parse_next(input)?;
        stops.push(GradientStop { color, offset });
    }
    Ok(stops)
}

#[allow(clippy::too_many_arguments)]
fn parse_node_property(
    input: &mut &str,
    style: &mut Style,
    use_styles: &mut Vec<NodeId>,
    constraints: &mut Vec<Constraint>,
    width: &mut Option<f32>,
    height: &mut Option<f32>,
    layout: &mut LayoutMode,
    clip: &mut bool,
) -> ModalResult<()> {
    let prop_name = parse_identifier.parse_next(input)?;
    skip_space(input);
    let _ = ':'.parse_next(input)?;
    skip_space(input);

    match prop_name {
        "x" => {
            let x_val = parse_number.parse_next(input)?;
            // Replace existing Position constraint if present, else push new
            if let Some(Constraint::Position { x, .. }) = constraints
                .iter_mut()
                .find(|c| matches!(c, Constraint::Position { .. }))
            {
                *x = x_val;
            } else {
                constraints.push(Constraint::Position { x: x_val, y: 0.0 });
            }
        }
        "y" => {
            let y_val = parse_number.parse_next(input)?;
            if let Some(Constraint::Position { y, .. }) = constraints
                .iter_mut()
                .find(|c| matches!(c, Constraint::Position { .. }))
            {
                *y = y_val;
            } else {
                constraints.push(Constraint::Position { x: 0.0, y: y_val });
            }
        }
        "w" | "width" => {
            *width = Some(parse_number.parse_next(input)?);
            skip_px_suffix(input);
            skip_space(input);
            if input.starts_with("h:") || input.starts_with("h :") {
                let _ = "h".parse_next(input)?;
                skip_space(input);
                let _ = ':'.parse_next(input)?;
                skip_space(input);
                *height = Some(parse_number.parse_next(input)?);
                skip_px_suffix(input);
            }
        }
        "h" | "height" => {
            *height = Some(parse_number.parse_next(input)?);
            skip_px_suffix(input);
        }
        "fill" | "background" | "color" => {
            style.fill = Some(parse_paint(input)?);
        }
        "bg" => {
            style.fill = Some(Paint::Solid(parse_hex_color.parse_next(input)?));
            loop {
                skip_space(input);
                if input.starts_with("corner=") {
                    let _ = "corner=".parse_next(input)?;
                    style.corner_radius = Some(parse_number.parse_next(input)?);
                } else if input.starts_with("shadow=(") {
                    let _ = "shadow=(".parse_next(input)?;
                    let ox = parse_number.parse_next(input)?;
                    let _ = ','.parse_next(input)?;
                    let oy = parse_number.parse_next(input)?;
                    let _ = ','.parse_next(input)?;
                    let blur = parse_number.parse_next(input)?;
                    let _ = ','.parse_next(input)?;
                    let color = parse_hex_color.parse_next(input)?;
                    let _ = ')'.parse_next(input)?;
                    style.shadow = Some(Shadow {
                        offset_x: ox,
                        offset_y: oy,
                        blur,
                        color,
                    });
                } else {
                    break;
                }
            }
        }
        "stroke" => {
            let color = parse_hex_color.parse_next(input)?;
            let _ = space1.parse_next(input)?;
            let w = parse_number.parse_next(input)?;
            style.stroke = Some(Stroke {
                paint: Paint::Solid(color),
                width: w,
                ..Stroke::default()
            });
        }
        "corner" | "rounded" | "radius" => {
            style.corner_radius = Some(parse_number.parse_next(input)?);
            skip_px_suffix(input);
        }
        "opacity" => {
            style.opacity = Some(parse_number.parse_next(input)?);
        }
        "align" | "text_align" => {
            parse_align_value(input, style)?;
        }
        "shadow" => {
            // shadow: (ox,oy,blur,#COLOR)  — colon already consumed by property parser
            skip_space(input);
            if input.starts_with('(') {
                let _ = '('.parse_next(input)?;
                let ox = parse_number.parse_next(input)?;
                let _ = ','.parse_next(input)?;
                let oy = parse_number.parse_next(input)?;
                let _ = ','.parse_next(input)?;
                let blur = parse_number.parse_next(input)?;
                let _ = ','.parse_next(input)?;
                let color = parse_hex_color.parse_next(input)?;
                let _ = ')'.parse_next(input)?;
                style.shadow = Some(Shadow {
                    offset_x: ox,
                    offset_y: oy,
                    blur,
                    color,
                });
            }
        }
        "label" => {
            // Deprecated: label is now a text child node.
            // Skip the value to maintain backwards compatibility with old .fd files.
            if input.starts_with('"') {
                let _ = parse_quoted_string.parse_next(input)?;
            } else {
                let _ = take_till::<_, _, ContextError>(0.., |c: char| {
                    c == '\n' || c == ';' || c == '}'
                })
                .parse_next(input);
            }
        }
        "use" => {
            use_styles.push(parse_identifier.map(NodeId::intern).parse_next(input)?);
        }
        "font" => {
            parse_font_value(input, style)?;
        }
        "layout" => {
            let mode_str = parse_identifier.parse_next(input)?;
            skip_space(input);
            let mut gap = 0.0f32;
            let mut pad = 0.0f32;
            loop {
                skip_space(input);
                if input.starts_with("gap=") {
                    let _ = "gap=".parse_next(input)?;
                    gap = parse_number.parse_next(input)?;
                } else if input.starts_with("pad=") {
                    let _ = "pad=".parse_next(input)?;
                    pad = parse_number.parse_next(input)?;
                } else if input.starts_with("cols=") {
                    let _ = "cols=".parse_next(input)?;
                    let _ = parse_number.parse_next(input)?;
                } else {
                    break;
                }
            }
            *layout = match mode_str {
                "column" => LayoutMode::Column { gap, pad },
                "row" => LayoutMode::Row { gap, pad },
                "grid" => LayoutMode::Grid { cols: 2, gap, pad },
                _ => LayoutMode::Free,
            };
        }
        "clip" => {
            let val = parse_identifier.parse_next(input)?;
            *clip = val == "true";
        }
        _ => {
            let _ =
                take_till::<_, _, ContextError>(0.., |c: char| c == '\n' || c == ';' || c == '}')
                    .parse_next(input);
        }
    }

    skip_opt_separator(input);
    Ok(())
}

// ─── Alignment value parser ──────────────────────────────────────────────

fn parse_align_value(input: &mut &str, style: &mut Style) -> ModalResult<()> {
    use crate::model::{TextAlign, TextVAlign};

    let first = parse_identifier.parse_next(input)?;
    style.text_align = Some(match first {
        "left" => TextAlign::Left,
        "right" => TextAlign::Right,
        _ => TextAlign::Center, // "center" or unknown
    });

    // Check for optional vertical alignment
    skip_space(input);
    let at_end = input.is_empty()
        || input.starts_with('\n')
        || input.starts_with(';')
        || input.starts_with('}');
    if !at_end && let Ok(second) = parse_identifier.parse_next(input) {
        style.text_valign = Some(match second {
            "top" => TextVAlign::Top,
            "bottom" => TextVAlign::Bottom,
            _ => TextVAlign::Middle,
        });
    }

    Ok(())
}

// ─── Animation block parser ─────────────────────────────────────────────

fn parse_anim_block(input: &mut &str) -> ModalResult<AnimKeyframe> {
    let _ = alt(("when", "anim")).parse_next(input)?;
    let _ = space1.parse_next(input)?;
    let _ = ':'.parse_next(input)?;
    let trigger_str = parse_identifier.parse_next(input)?;
    let trigger = match trigger_str {
        "hover" => AnimTrigger::Hover,
        "press" => AnimTrigger::Press,
        "enter" => AnimTrigger::Enter,
        other => AnimTrigger::Custom(other.to_string()),
    };

    skip_space(input);
    let _ = '{'.parse_next(input)?;

    let mut props = AnimProperties::default();
    let mut duration_ms = 300u32;
    let mut easing = Easing::EaseInOut;

    skip_ws_and_comments(input);

    while !input.starts_with('}') {
        let prop = parse_identifier.parse_next(input)?;
        skip_space(input);
        let _ = ':'.parse_next(input)?;
        skip_space(input);

        match prop {
            "fill" => {
                props.fill = Some(Paint::Solid(parse_hex_color.parse_next(input)?));
            }
            "opacity" => {
                props.opacity = Some(parse_number.parse_next(input)?);
            }
            "scale" => {
                props.scale = Some(parse_number.parse_next(input)?);
            }
            "rotate" => {
                props.rotate = Some(parse_number.parse_next(input)?);
            }
            "ease" => {
                let ease_name = parse_identifier.parse_next(input)?;
                easing = match ease_name {
                    "linear" => Easing::Linear,
                    "ease_in" | "easeIn" => Easing::EaseIn,
                    "ease_out" | "easeOut" => Easing::EaseOut,
                    "ease_in_out" | "easeInOut" => Easing::EaseInOut,
                    "spring" => Easing::Spring,
                    _ => Easing::EaseInOut,
                };
                skip_space(input);
                if let Ok(n) = parse_number.parse_next(input) {
                    duration_ms = n as u32;
                    if input.starts_with("ms") {
                        *input = &input[2..];
                    }
                }
            }
            _ => {
                let _ = take_till::<_, _, ContextError>(0.., |c: char| {
                    c == '\n' || c == ';' || c == '}'
                })
                .parse_next(input);
            }
        }

        skip_opt_separator(input);
        skip_ws_and_comments(input);
    }

    let _ = '}'.parse_next(input)?;

    Ok(AnimKeyframe {
        trigger,
        duration_ms,
        easing,
        properties: props,
    })
}

// ─── Edge block parser ─────────────────────────────────────────────────

fn parse_edge_block(input: &mut &str) -> ModalResult<Edge> {
    let _ = "edge".parse_next(input)?;
    let _ = space1.parse_next(input)?;

    let id = if input.starts_with('@') {
        parse_node_id.parse_next(input)?
    } else {
        NodeId::anonymous("edge")
    };

    skip_space(input);
    let _ = '{'.parse_next(input)?;

    let mut from = None;
    let mut to = None;
    let mut label = None;
    let mut style = Style::default();
    let mut use_styles = Vec::new();
    let mut arrow = ArrowKind::None;
    let mut curve = CurveKind::Straight;
    let mut annotations = Vec::new();
    let mut animations = Vec::new();
    let mut flow = None;
    let mut label_offset = None;

    skip_ws_and_comments(input);

    while !input.starts_with('}') {
        if input.starts_with("spec ") || input.starts_with("spec{") {
            annotations.extend(parse_spec_block.parse_next(input)?);
        } else if input.starts_with("when") || input.starts_with("anim") {
            animations.push(parse_anim_block.parse_next(input)?);
        } else {
            let prop = parse_identifier.parse_next(input)?;
            skip_space(input);
            let _ = ':'.parse_next(input)?;
            skip_space(input);

            match prop {
                "from" => {
                    from = Some(parse_node_id.parse_next(input)?);
                }
                "to" => {
                    to = Some(parse_node_id.parse_next(input)?);
                }
                "label" => {
                    label = Some(
                        parse_quoted_string
                            .map(|s| s.to_string())
                            .parse_next(input)?,
                    );
                }
                "stroke" => {
                    let color = parse_hex_color.parse_next(input)?;
                    skip_space(input);
                    let w = parse_number.parse_next(input).unwrap_or(1.0);
                    style.stroke = Some(Stroke {
                        paint: Paint::Solid(color),
                        width: w,
                        ..Stroke::default()
                    });
                }
                "arrow" => {
                    let kind = parse_identifier.parse_next(input)?;
                    arrow = match kind {
                        "none" => ArrowKind::None,
                        "start" => ArrowKind::Start,
                        "end" => ArrowKind::End,
                        "both" => ArrowKind::Both,
                        _ => ArrowKind::None,
                    };
                }
                "curve" => {
                    let kind = parse_identifier.parse_next(input)?;
                    curve = match kind {
                        "straight" => CurveKind::Straight,
                        "smooth" => CurveKind::Smooth,
                        "step" => CurveKind::Step,
                        _ => CurveKind::Straight,
                    };
                }
                "use" => {
                    use_styles.push(parse_identifier.map(NodeId::intern).parse_next(input)?);
                }
                "opacity" => {
                    style.opacity = Some(parse_number.parse_next(input)?);
                }
                "flow" => {
                    let kind_str = parse_identifier.parse_next(input)?;
                    let kind = match kind_str {
                        "pulse" => FlowKind::Pulse,
                        "dash" => FlowKind::Dash,
                        _ => FlowKind::Pulse,
                    };
                    skip_space(input);
                    let dur = parse_number.parse_next(input).unwrap_or(800.0) as u32;
                    if input.starts_with("ms") {
                        *input = &input[2..];
                    }
                    flow = Some(FlowAnim {
                        kind,
                        duration_ms: dur,
                    });
                }
                "label_offset" => {
                    let ox = parse_number.parse_next(input)?;
                    skip_space(input);
                    let oy = parse_number.parse_next(input)?;
                    label_offset = Some((ox, oy));
                }
                _ => {
                    let _ = take_till::<_, _, ContextError>(0.., |c: char| {
                        c == '\n' || c == ';' || c == '}'
                    })
                    .parse_next(input);
                }
            }

            skip_opt_separator(input);
        }
        skip_ws_and_comments(input);
    }

    let _ = '}'.parse_next(input)?;

    // Default stroke if none provided
    if style.stroke.is_none() {
        style.stroke = Some(Stroke {
            paint: Paint::Solid(Color::rgba(0.42, 0.44, 0.5, 1.0)),
            width: 1.5,
            ..Stroke::default()
        });
    }

    Ok(Edge {
        id,
        from: from.unwrap_or_else(|| NodeId::intern("_missing")),
        to: to.unwrap_or_else(|| NodeId::intern("_missing")),
        label,
        style,
        use_styles: use_styles.into(),
        arrow,
        curve,
        annotations,
        animations: animations.into(),
        flow,
        label_offset,
    })
}

// ─── Constraint line parser ──────────────────────────────────────────────

fn parse_constraint_line(input: &mut &str) -> ModalResult<(NodeId, Constraint)> {
    let node_id = parse_node_id.parse_next(input)?;
    skip_space(input);
    let _ = "->".parse_next(input)?;
    skip_space(input);

    let constraint_type = parse_identifier.parse_next(input)?;
    skip_space(input);
    let _ = ':'.parse_next(input)?;
    skip_space(input);

    let constraint = match constraint_type {
        "center_in" => Constraint::CenterIn(NodeId::intern(parse_identifier.parse_next(input)?)),
        "offset" => {
            let from = parse_node_id.parse_next(input)?;
            let _ = space1.parse_next(input)?;
            let dx = parse_number.parse_next(input)?;
            skip_space(input);
            let _ = ','.parse_next(input)?;
            skip_space(input);
            let dy = parse_number.parse_next(input)?;
            Constraint::Offset { from, dx, dy }
        }
        "fill_parent" => {
            let pad = opt(parse_number).parse_next(input)?.unwrap_or(0.0);
            Constraint::FillParent { pad }
        }
        "absolute" | "position" => {
            let x = parse_number.parse_next(input)?;
            skip_space(input);
            let _ = ','.parse_next(input)?;
            skip_space(input);
            let y = parse_number.parse_next(input)?;
            Constraint::Position { x, y }
        }
        _ => {
            let _ = take_till::<_, _, ContextError>(0.., '\n').parse_next(input);
            Constraint::Position { x: 0.0, y: 0.0 }
        }
    };

    if input.starts_with('\n') {
        *input = &input[1..];
    }
    Ok((node_id, constraint))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_minimal_document() {
        let input = r#"
# Comment
rect @box {
  w: 100
  h: 50
  fill: #FF0000
}
"#;
        let graph = parse_document(input).expect("parse failed");
        let node = graph
            .get_by_id(NodeId::intern("box"))
            .expect("node not found");

        match &node.kind {
            NodeKind::Rect { width, height } => {
                assert_eq!(*width, 100.0);
                assert_eq!(*height, 50.0);
            }
            _ => panic!("expected Rect"),
        }
        assert!(node.style.fill.is_some());
    }

    #[test]
    fn parse_style_and_use() {
        let input = r#"
style accent {
  fill: #6C5CE7
}

rect @btn {
  w: 200
  h: 48
  use: accent
}
"#;
        let graph = parse_document(input).expect("parse failed");
        assert!(graph.styles.contains_key(&NodeId::intern("accent")));
        let btn = graph.get_by_id(NodeId::intern("btn")).unwrap();
        assert_eq!(btn.use_styles.len(), 1);
    }

    #[test]
    fn parse_nested_group() {
        let input = r#"
group @form {
  layout: column gap=16 pad=32

  text @title "Hello" {
    fill: #333333
  }

  rect @field {
    w: 280
    h: 44
  }
}
"#;
        let graph = parse_document(input).expect("parse failed");
        let form_idx = graph.index_of(NodeId::intern("form")).unwrap();
        let children = graph.children(form_idx);
        assert_eq!(children.len(), 2);
    }

    #[test]
    fn parse_animation() {
        let input = r#"
rect @btn {
  w: 100
  h: 40
  fill: #6C5CE7

  anim :hover {
    fill: #5A4BD1
    scale: 1.02
    ease: spring 300ms
  }
}
"#;
        let graph = parse_document(input).expect("parse failed");
        let btn = graph.get_by_id(NodeId::intern("btn")).unwrap();
        assert_eq!(btn.animations.len(), 1);
        assert_eq!(btn.animations[0].trigger, AnimTrigger::Hover);
        assert_eq!(btn.animations[0].duration_ms, 300);
    }

    #[test]
    fn parse_constraint() {
        let input = r#"
rect @box {
  w: 100
  h: 100
}

@box -> center_in: canvas
"#;
        let graph = parse_document(input).expect("parse failed");
        let node = graph.get_by_id(NodeId::intern("box")).unwrap();
        assert_eq!(node.constraints.len(), 1);
        match &node.constraints[0] {
            Constraint::CenterIn(target) => assert_eq!(target.as_str(), "canvas"),
            _ => panic!("expected CenterIn"),
        }
    }

    #[test]
    fn parse_inline_wh() {
        let input = r#"
rect @box {
  w: 280 h: 44
  fill: #FF0000
}
"#;
        let graph = parse_document(input).expect("parse failed");
        let node = graph.get_by_id(NodeId::intern("box")).unwrap();
        match &node.kind {
            NodeKind::Rect { width, height } => {
                assert_eq!(*width, 280.0);
                assert_eq!(*height, 44.0);
            }
            _ => panic!("expected Rect"),
        }
    }

    #[test]
    fn parse_empty_document() {
        let input = "";
        let graph = parse_document(input).expect("empty doc should parse");
        assert_eq!(graph.children(graph.root).len(), 0);
    }

    #[test]
    fn parse_comments_only() {
        let input = "# This is a comment\n# Another comment\n";
        let graph = parse_document(input).expect("comments-only should parse");
        assert_eq!(graph.children(graph.root).len(), 0);
    }

    #[test]
    fn parse_anonymous_node() {
        let input = "rect { w: 50 h: 50 }";
        let graph = parse_document(input).expect("anonymous node should parse");
        assert_eq!(graph.children(graph.root).len(), 1);
    }

    #[test]
    fn parse_ellipse() {
        let input = r#"
ellipse @dot {
  w: 30 h: 30
  fill: #FF5733
}
"#;
        let graph = parse_document(input).expect("ellipse should parse");
        let dot = graph.get_by_id(NodeId::intern("dot")).unwrap();
        match &dot.kind {
            NodeKind::Ellipse { rx, ry } => {
                assert_eq!(*rx, 30.0);
                assert_eq!(*ry, 30.0);
            }
            _ => panic!("expected Ellipse"),
        }
    }

    #[test]
    fn parse_text_with_content() {
        let input = r#"
text @greeting "Hello World" {
  font: "Inter" 600 24
  fill: #1A1A2E
}
"#;
        let graph = parse_document(input).expect("text should parse");
        let node = graph.get_by_id(NodeId::intern("greeting")).unwrap();
        match &node.kind {
            NodeKind::Text { content } => {
                assert_eq!(content, "Hello World");
            }
            _ => panic!("expected Text"),
        }
        assert!(node.style.font.is_some());
        let font = node.style.font.as_ref().unwrap();
        assert_eq!(font.family, "Inter");
        assert_eq!(font.weight, 600);
        assert_eq!(font.size, 24.0);
    }

    #[test]
    fn parse_stroke_property() {
        let input = r#"
rect @bordered {
  w: 100 h: 100
  stroke: #DDDDDD 2
}
"#;
        let graph = parse_document(input).expect("stroke should parse");
        let node = graph.get_by_id(NodeId::intern("bordered")).unwrap();
        assert!(node.style.stroke.is_some());
        let stroke = node.style.stroke.as_ref().unwrap();
        assert_eq!(stroke.width, 2.0);
    }

    #[test]
    fn parse_multiple_constraints() {
        let input = r#"
rect @a { w: 100 h: 100 }
rect @b { w: 50 h: 50 }
@a -> center_in: canvas
@a -> absolute: 10, 20
"#;
        let graph = parse_document(input).expect("multiple constraints should parse");
        let node = graph.get_by_id(NodeId::intern("a")).unwrap();
        // The last constraint wins in layout, but both should be stored
        assert_eq!(node.constraints.len(), 2);
    }

    #[test]
    fn parse_comments_between_nodes() {
        let input = r#"
# First node
rect @a { w: 100 h: 100 }
# Second node
rect @b { w: 200 h: 200 }
"#;
        let graph = parse_document(input).expect("interleaved comments should parse");
        assert_eq!(graph.children(graph.root).len(), 2);
    }
    #[test]
    fn parse_frame() {
        let input = r#"
frame @card {
  w: 400 h: 300
  clip: true
  fill: #FFFFFF
  corner: 16
  layout: column gap=12 pad=20
}
"#;
        let graph = parse_document(input).expect("parse failed");
        let node = graph
            .get_by_id(crate::id::NodeId::intern("card"))
            .expect("card not found");
        match &node.kind {
            NodeKind::Frame {
                width,
                height,
                clip,
                layout,
            } => {
                assert_eq!(*width, 400.0);
                assert_eq!(*height, 300.0);
                assert!(*clip);
                assert!(matches!(layout, LayoutMode::Column { .. }));
            }
            other => panic!("expected Frame, got {other:?}"),
        }
    }

    #[test]
    fn roundtrip_frame() {
        let input = r#"
frame @panel {
  w: 200 h: 150
  clip: true
  fill: #F0F0F0
  layout: row gap=8 pad=10

  rect @child {
    w: 50 h: 50
    fill: #FF0000
  }
}
"#;
        let graph = parse_document(input).expect("parse failed");
        let emitted = crate::emitter::emit_document(&graph);
        let reparsed = parse_document(&emitted).expect("re-parse failed");
        let node = reparsed
            .get_by_id(crate::id::NodeId::intern("panel"))
            .expect("panel not found");
        match &node.kind {
            NodeKind::Frame {
                width,
                height,
                clip,
                layout,
            } => {
                assert_eq!(*width, 200.0);
                assert_eq!(*height, 150.0);
                assert!(*clip);
                assert!(matches!(layout, LayoutMode::Row { .. }));
            }
            other => panic!("expected Frame, got {other:?}"),
        }
        // Verify child is present
        let child = reparsed
            .get_by_id(crate::id::NodeId::intern("child"))
            .expect("child not found");
        assert!(matches!(child.kind, NodeKind::Rect { .. }));
    }

    #[test]
    fn roundtrip_align() {
        let src = r#"
text @title "Hello" {
  fill: #FFFFFF
  font: "Inter" 600 24
  align: right bottom
}
"#;
        let graph = parse_document(src).unwrap();
        let node = graph
            .get_by_id(crate::id::NodeId::intern("title"))
            .expect("node not found");
        assert_eq!(node.style.text_align, Some(crate::model::TextAlign::Right));
        assert_eq!(
            node.style.text_valign,
            Some(crate::model::TextVAlign::Bottom)
        );

        // Emit and re-parse
        let emitted = crate::emitter::emit_document(&graph);
        assert!(emitted.contains("align: right bottom"));

        let reparsed = parse_document(&emitted).unwrap();
        let node2 = reparsed
            .get_by_id(crate::id::NodeId::intern("title"))
            .expect("node not found after roundtrip");
        assert_eq!(node2.style.text_align, Some(crate::model::TextAlign::Right));
        assert_eq!(
            node2.style.text_valign,
            Some(crate::model::TextVAlign::Bottom)
        );
    }

    #[test]
    fn parse_align_center_only() {
        let src = r#"
text @heading "Welcome" {
  align: center
}
"#;
        let graph = parse_document(src).unwrap();
        let node = graph
            .get_by_id(crate::id::NodeId::intern("heading"))
            .expect("node not found");
        assert_eq!(node.style.text_align, Some(crate::model::TextAlign::Center));
        // Vertical not specified — should be None
        assert_eq!(node.style.text_valign, None);
    }

    #[test]
    fn roundtrip_align_in_style_block() {
        let src = r#"
style heading_style {
  fill: #333333
  font: "Inter" 700 32
  align: left top
}

text @main_title "Hello" {
  use: heading_style
}
"#;
        let graph = parse_document(src).unwrap();

        // Style definition should have alignment
        let style = graph
            .styles
            .get(&crate::id::NodeId::intern("heading_style"))
            .expect("style not found");
        assert_eq!(style.text_align, Some(crate::model::TextAlign::Left));
        assert_eq!(style.text_valign, Some(crate::model::TextVAlign::Top));

        // Node using the style should inherit alignment
        let node = graph
            .get_by_id(crate::id::NodeId::intern("main_title"))
            .expect("node not found");
        let resolved = graph.resolve_style(node, &[]);
        assert_eq!(resolved.text_align, Some(crate::model::TextAlign::Left));
        assert_eq!(resolved.text_valign, Some(crate::model::TextVAlign::Top));

        // Emit and re-parse
        let emitted = crate::emitter::emit_document(&graph);
        assert!(emitted.contains("align: left top"));
        let reparsed = parse_document(&emitted).unwrap();
        let style2 = reparsed
            .styles
            .get(&crate::id::NodeId::intern("heading_style"))
            .expect("style not found after roundtrip");
        assert_eq!(style2.text_align, Some(crate::model::TextAlign::Left));
        assert_eq!(style2.text_valign, Some(crate::model::TextVAlign::Top));
    }

    #[test]
    fn parse_font_weight_names() {
        let src = r#"
text @heading "Hello" {
  font: "Inter" bold 24
}
"#;
        let graph = parse_document(src).unwrap();
        let node = graph
            .get_by_id(crate::id::NodeId::intern("heading"))
            .unwrap();
        let font = node.style.font.as_ref().unwrap();
        assert_eq!(font.weight, 700);
        assert_eq!(font.size, 24.0);
    }

    #[test]
    fn parse_font_weight_semibold() {
        let src = r#"text @t "Hi" { font: "Inter" semibold 16 }"#;
        let graph = parse_document(src).unwrap();
        let font = graph
            .get_by_id(crate::id::NodeId::intern("t"))
            .unwrap()
            .style
            .font
            .as_ref()
            .unwrap();
        assert_eq!(font.weight, 600);
        assert_eq!(font.size, 16.0);
    }

    #[test]
    fn parse_named_color() {
        let src = r#"rect @r { w: 100 h: 50 fill: purple }"#;
        let graph = parse_document(src).unwrap();
        let node = graph.get_by_id(crate::id::NodeId::intern("r")).unwrap();
        assert!(
            node.style.fill.is_some(),
            "fill should be set from named color"
        );
    }

    #[test]
    fn parse_named_color_blue() {
        let src = r#"rect @box { w: 50 h: 50 fill: blue }"#;
        let graph = parse_document(src).unwrap();
        let node = graph.get_by_id(crate::id::NodeId::intern("box")).unwrap();
        if let Some(crate::model::Paint::Solid(c)) = &node.style.fill {
            assert_eq!(c.to_hex(), "#3B82F6");
        } else {
            panic!("expected solid fill from named color");
        }
    }

    #[test]
    fn parse_property_alias_background() {
        let src = r#"rect @r { w: 100 h: 50 background: #FF0000 }"#;
        let graph = parse_document(src).unwrap();
        let node = graph.get_by_id(crate::id::NodeId::intern("r")).unwrap();
        assert!(node.style.fill.is_some(), "background: should map to fill");
    }

    #[test]
    fn parse_property_alias_rounded() {
        let src = r#"rect @r { w: 100 h: 50 rounded: 12 }"#;
        let graph = parse_document(src).unwrap();
        let node = graph.get_by_id(crate::id::NodeId::intern("r")).unwrap();
        assert_eq!(node.style.corner_radius, Some(12.0));
    }

    #[test]
    fn parse_property_alias_radius() {
        let src = r#"rect @r { w: 100 h: 50 radius: 8 }"#;
        let graph = parse_document(src).unwrap();
        let node = graph.get_by_id(crate::id::NodeId::intern("r")).unwrap();
        assert_eq!(node.style.corner_radius, Some(8.0));
    }

    #[test]
    fn parse_dimension_px_suffix() {
        let src = r#"rect @r { w: 320px h: 200px }"#;
        let graph = parse_document(src).unwrap();
        let node = graph.get_by_id(crate::id::NodeId::intern("r")).unwrap();
        if let crate::model::NodeKind::Rect { width, height } = &node.kind {
            assert_eq!(*width, 320.0);
            assert_eq!(*height, 200.0);
        } else {
            panic!("expected rect");
        }
    }

    #[test]
    fn parse_corner_px_suffix() {
        let src = r#"rect @r { w: 100 h: 50 corner: 10px }"#;
        let graph = parse_document(src).unwrap();
        let node = graph.get_by_id(crate::id::NodeId::intern("r")).unwrap();
        assert_eq!(node.style.corner_radius, Some(10.0));
    }

    #[test]
    fn roundtrip_font_weight_name() {
        let src = r#"text @t "Hello" { font: "Inter" bold 18 }"#;
        let graph = parse_document(src).unwrap();
        let emitted = crate::emitter::emit_document(&graph);
        assert!(
            emitted.contains("bold"),
            "emitted output should use 'bold' not '700'"
        );
        let reparsed = parse_document(&emitted).unwrap();
        let font = reparsed
            .get_by_id(crate::id::NodeId::intern("t"))
            .unwrap()
            .style
            .font
            .as_ref()
            .unwrap();
        assert_eq!(font.weight, 700);
    }

    #[test]
    fn roundtrip_named_color() {
        let src = r#"rect @r { w: 100 h: 50 fill: purple }"#;
        let graph = parse_document(src).unwrap();
        let emitted = crate::emitter::emit_document(&graph);
        // Named color gets emitted as hex with hint comment
        assert!(emitted.contains("#8B5CF6"), "purple should emit as #8B5CF6");
        let reparsed = parse_document(&emitted).unwrap();
        assert!(
            reparsed
                .get_by_id(crate::id::NodeId::intern("r"))
                .unwrap()
                .style
                .fill
                .is_some()
        );
    }

    #[test]
    fn roundtrip_property_aliases() {
        let src = r#"rect @r { w: 200 h: 100 background: #FF0000 rounded: 12 }"#;
        let graph = parse_document(src).unwrap();
        let emitted = crate::emitter::emit_document(&graph);
        // Emitter uses canonical names
        assert!(
            emitted.contains("fill:"),
            "background: should emit as fill:"
        );
        assert!(
            emitted.contains("corner:"),
            "rounded: should emit as corner:"
        );
        let reparsed = parse_document(&emitted).unwrap();
        let node = reparsed.get_by_id(crate::id::NodeId::intern("r")).unwrap();
        assert!(node.style.fill.is_some());
        assert_eq!(node.style.corner_radius, Some(12.0));
    }

    #[test]
    fn roundtrip_edge_label_offset() {
        let input = r#"
rect @a { w: 100 h: 50 }
rect @b { w: 100 h: 50 }

edge @link {
  from: @a
  to: @b
  arrow: end
  label_offset: 15.5 -8.3
}
"#;
        let graph = parse_document(input).expect("parse failed");
        assert_eq!(graph.edges.len(), 1);
        let edge = &graph.edges[0];
        assert_eq!(edge.id, crate::id::NodeId::intern("link"));
        assert_eq!(edge.label_offset, Some((15.5, -8.3)));

        // Emit and re-parse
        let emitted = crate::emitter::emit_document(&graph);
        assert!(
            emitted.contains("label_offset:"),
            "emitter should include label_offset"
        );

        let reparsed = parse_document(&emitted).expect("re-parse failed");
        assert_eq!(reparsed.edges.len(), 1);
        let re_edge = &reparsed.edges[0];
        assert_eq!(re_edge.label_offset, Some((15.5, -8.3)));
    }
}