dampen_core/codegen/

view.rs

//! View function generation
//!
//! This module generates static Rust code for widget trees with inlined bindings.

use crate::DampenDocument;
use crate::codegen::bindings::generate_expr;
use crate::ir::layout::{LayoutConstraints, Length as LayoutLength};
use crate::ir::node::{AttributeValue, InterpolatedPart, WidgetKind};
use crate::ir::style::{
    Background, Border, BorderRadius, Color, Gradient, Shadow, StyleProperties,
};
use crate::ir::theme::StyleClass;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use std::collections::HashMap;

/// Generate the view function body from a Dampen document
pub fn generate_view(
    document: &DampenDocument,
    _model_name: &str,
    message_name: &str,
) -> Result<TokenStream, super::CodegenError> {
    let message_ident = syn::Ident::new(message_name, proc_macro2::Span::call_site());
    let model_ident = syn::Ident::new("model", proc_macro2::Span::call_site());

    let root_widget = generate_widget(
        &document.root,
        &model_ident,
        &message_ident,
        &document.style_classes,
    )?;

    Ok(quote! {
        #root_widget
    })
}

/// Get merged layout constraints from node.layout and style classes
fn get_merged_layout<'a>(
    node: &'a crate::WidgetNode,
    style_classes: &'a HashMap<String, StyleClass>,
) -> Option<MergedLayout<'a>> {
    // Priority: node.layout > style_class.layout
    let node_layout = node.layout.as_ref();
    let class_layout = node
        .classes
        .first()
        .and_then(|class_name| style_classes.get(class_name))
        .and_then(|class| class.layout.as_ref());

    if node_layout.is_some() || class_layout.is_some() {
        Some(MergedLayout {
            node_layout,
            class_layout,
        })
    } else {
        None
    }
}

/// Helper struct to hold merged layout info from node and style class
struct MergedLayout<'a> {
    node_layout: Option<&'a LayoutConstraints>,
    class_layout: Option<&'a LayoutConstraints>,
}

impl<'a> MergedLayout<'a> {
    fn padding(&self) -> Option<f32> {
        self.node_layout
            .and_then(|l| l.padding.as_ref())
            .map(|p| p.top)
            .or_else(|| {
                self.class_layout
                    .and_then(|l| l.padding.as_ref())
                    .map(|p| p.top)
            })
    }

    fn spacing(&self) -> Option<f32> {
        self.node_layout
            .and_then(|l| l.spacing)
            .or_else(|| self.class_layout.and_then(|l| l.spacing))
    }

    fn width(&self) -> Option<&'a LayoutLength> {
        self.node_layout
            .and_then(|l| l.width.as_ref())
            .or_else(|| self.class_layout.and_then(|l| l.width.as_ref()))
    }

    fn height(&self) -> Option<&'a LayoutLength> {
        self.node_layout
            .and_then(|l| l.height.as_ref())
            .or_else(|| self.class_layout.and_then(|l| l.height.as_ref()))
    }
}

/// Generate code for a widget node
fn generate_widget(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    match node.kind {
        WidgetKind::Text => generate_text(node, model_ident, style_classes),
        WidgetKind::Button => generate_button(node, model_ident, message_ident, style_classes),
        WidgetKind::Column => {
            generate_container(node, "column", model_ident, message_ident, style_classes)
        }
        WidgetKind::Row => {
            generate_container(node, "row", model_ident, message_ident, style_classes)
        }
        WidgetKind::Container => {
            generate_container(node, "container", model_ident, message_ident, style_classes)
        }
        WidgetKind::Scrollable => generate_container(
            node,
            "scrollable",
            model_ident,
            message_ident,
            style_classes,
        ),
        WidgetKind::Stack => generate_stack(node, model_ident, message_ident, style_classes),
        WidgetKind::Space => generate_space(node),
        WidgetKind::Rule => generate_rule(node),
        WidgetKind::Checkbox => generate_checkbox(node, model_ident, message_ident, style_classes),
        WidgetKind::Toggler => generate_toggler(node, model_ident, message_ident, style_classes),
        WidgetKind::Slider => generate_slider(node, model_ident, message_ident, style_classes),
        WidgetKind::Radio => generate_radio(node, model_ident, message_ident, style_classes),
        WidgetKind::ProgressBar => generate_progress_bar(node, model_ident, style_classes),
        WidgetKind::TextInput => {
            generate_text_input(node, model_ident, message_ident, style_classes)
        }
        WidgetKind::Image => generate_image(node),
        WidgetKind::Svg => generate_svg(node),
        WidgetKind::PickList => generate_pick_list(node, model_ident, message_ident, style_classes),
        WidgetKind::ComboBox => generate_combo_box(node, model_ident, message_ident, style_classes),
        WidgetKind::Tooltip => generate_tooltip(node, model_ident, message_ident, style_classes),
        WidgetKind::Grid => generate_grid(node, model_ident, message_ident, style_classes),
        WidgetKind::Canvas => generate_canvas(node, model_ident, message_ident, style_classes),
        WidgetKind::Float => generate_float(node, model_ident, message_ident, style_classes),
        WidgetKind::For => generate_for(node, model_ident, message_ident, style_classes),
        WidgetKind::Custom(ref name) => {
            generate_custom_widget(node, name, model_ident, message_ident, style_classes)
        }
    }
}

// ============================================================================
// Style Application Functions
// ============================================================================

/// Apply inline styles or CSS classes to a widget
///
/// Priority order:
/// 1. Inline styles (node.style) - highest priority
/// 2. CSS classes (node.classes) - medium priority
/// 3. Default Iced styles - lowest priority (fallback)
fn apply_widget_style(
    widget: TokenStream,
    node: &crate::WidgetNode,
    widget_type: &str,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    // Check if widget has any styling
    let has_inline_style = node.style.is_some();
    let has_classes = !node.classes.is_empty();

    if !has_inline_style && !has_classes {
        // No styling needed, return widget as-is
        return Ok(widget);
    }

    // Get style class if widget has classes
    let style_class = if let Some(class_name) = node.classes.first() {
        style_classes.get(class_name)
    } else {
        None
    };

    // Generate style closure based on priority
    if let Some(ref style_props) = node.style {
        // Priority 1: Inline styles
        let style_closure =
            generate_inline_style_closure(style_props, widget_type, &node.kind, style_class)?;
        Ok(quote! {
            #widget.style(#style_closure)
        })
    } else if let Some(class_name) = node.classes.first() {
        // Priority 2: CSS class (use first class for now)
        let style_fn_ident = format_ident!("style_{}", class_name.replace('-', "_"));
        Ok(quote! {
            #widget.style(#style_fn_ident)
        })
    } else {
        Ok(widget)
    }
}

/// Generate state-specific style application code
///
/// Creates a match expression that applies different styles based on widget state.
/// Merges base style with state-specific overrides.
///
/// # Arguments
/// * `base_style` - The base style struct (used when state is None)
/// * `style_class` - The style class containing state variants
/// * `widget_state_ident` - Identifier for the widget_state variable
/// * `style_struct_fn` - Function to generate style struct from StyleProperties
fn generate_state_style_match(
    base_style: TokenStream,
    style_class: &StyleClass,
    widget_state_ident: &syn::Ident,
    style_struct_fn: fn(&StyleProperties) -> Result<TokenStream, super::CodegenError>,
) -> Result<TokenStream, super::CodegenError> {
    use crate::ir::theme::WidgetState;

    // Collect all state variants
    let mut state_arms = Vec::new();

    for (state, state_props) in &style_class.state_variants {
        let state_variant = match state {
            WidgetState::Hover => quote! { dampen_core::ir::WidgetState::Hover },
            WidgetState::Focus => quote! { dampen_core::ir::WidgetState::Focus },
            WidgetState::Active => quote! { dampen_core::ir::WidgetState::Active },
            WidgetState::Disabled => quote! { dampen_core::ir::WidgetState::Disabled },
        };

        // Generate style struct for this state
        let state_style = style_struct_fn(state_props)?;

        state_arms.push(quote! {
            Some(#state_variant) => #state_style
        });
    }

    // Generate match expression
    Ok(quote! {
        match #widget_state_ident {
            #(#state_arms,)*
            None => #base_style
        }
    })
}

/// Generate inline style closure for a widget
///
/// Creates a closure like: |_theme: &iced::Theme, status| { ... }
///
/// # State-Aware Styling
///
/// When a widget has state variants (hover, focus, etc.), this generates
/// code that maps the status parameter to WidgetState and applies the
/// appropriate style.
///
/// # Arguments
/// * `style_props` - Base style properties for the widget
/// * `widget_type` - Type of widget ("button", "text_input", etc.)
/// * `widget_kind` - The WidgetKind enum (needed for status mapping)
/// * `style_class` - Optional style class with state variants
fn generate_inline_style_closure(
    style_props: &StyleProperties,
    widget_type: &str,
    widget_kind: &WidgetKind,
    style_class: Option<&StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    // Check if we have state-specific styling
    let has_state_variants = style_class
        .map(|sc| !sc.state_variants.is_empty())
        .unwrap_or(false);

    match widget_type {
        "button" => {
            let base_style = generate_button_style_struct(style_props)?;

            if has_state_variants {
                // Generate state-aware closure
                let status_ident = format_ident!("status");
                if let Some(status_mapping) =
                    super::status_mapping::generate_status_mapping(widget_kind, &status_ident)
                {
                    let widget_state_ident = format_ident!("widget_state");
                    // Safe: has_state_variants guarantees style_class.is_some()
                    let class = style_class.ok_or_else(|| {
                        super::CodegenError::InvalidWidget(
                            "Expected style class with state variants".to_string(),
                        )
                    })?;
                    let style_match = generate_state_style_match(
                        base_style,
                        class,
                        &widget_state_ident,
                        generate_button_style_struct,
                    )?;

                    Ok(quote! {
                        |_theme: &iced::Theme, #status_ident: iced::widget::button::Status| {
                            // Map Iced status to WidgetState
                            let #widget_state_ident = #status_mapping;

                            // Apply state-specific styling
                            #style_match
                        }
                    })
                } else {
                    // Widget kind doesn't support status mapping, fall back to simple closure
                    Ok(quote! {
                        |_theme: &iced::Theme, _status: iced::widget::button::Status| {
                            #base_style
                        }
                    })
                }
            } else {
                // No state variants, use simple closure
                Ok(quote! {
                    |_theme: &iced::Theme, _status: iced::widget::button::Status| {
                        #base_style
                    }
                })
            }
        }
        "container" => {
            let style_struct = generate_container_style_struct(style_props)?;
            Ok(quote! {
                |_theme: &iced::Theme| {
                    #style_struct
                }
            })
        }
        "text_input" => {
            let base_style = generate_text_input_style_struct(style_props)?;

            if has_state_variants {
                // Generate state-aware closure
                let status_ident = format_ident!("status");
                if let Some(status_mapping) =
                    super::status_mapping::generate_status_mapping(widget_kind, &status_ident)
                {
                    let widget_state_ident = format_ident!("widget_state");
                    let class = style_class.ok_or_else(|| {
                        super::CodegenError::InvalidWidget(
                            "Expected style class with state variants".to_string(),
                        )
                    })?;
                    let style_match = generate_state_style_match(
                        base_style,
                        class,
                        &widget_state_ident,
                        generate_text_input_style_struct,
                    )?;

                    Ok(quote! {
                        |_theme: &iced::Theme, #status_ident: iced::widget::text_input::Status| {
                            // Map Iced status to WidgetState
                            let #widget_state_ident = #status_mapping;

                            // Apply state-specific styling
                            #style_match
                        }
                    })
                } else {
                    // Widget kind doesn't support status mapping, fall back to simple closure
                    Ok(quote! {
                        |_theme: &iced::Theme, _status: iced::widget::text_input::Status| {
                            #base_style
                        }
                    })
                }
            } else {
                // No state variants, use simple closure
                Ok(quote! {
                    |_theme: &iced::Theme, _status: iced::widget::text_input::Status| {
                        #base_style
                    }
                })
            }
        }
        "checkbox" => {
            let base_style = generate_checkbox_style_struct(style_props)?;

            if has_state_variants {
                let status_ident = format_ident!("status");
                if let Some(status_mapping) =
                    super::status_mapping::generate_status_mapping(widget_kind, &status_ident)
                {
                    let widget_state_ident = format_ident!("widget_state");
                    let class = style_class.ok_or_else(|| {
                        super::CodegenError::InvalidWidget(
                            "Expected style class with state variants".to_string(),
                        )
                    })?;
                    let style_match = generate_state_style_match(
                        base_style,
                        class,
                        &widget_state_ident,
                        generate_checkbox_style_struct,
                    )?;

                    Ok(quote! {
                        |_theme: &iced::Theme, #status_ident: iced::widget::checkbox::Status| {
                            let #widget_state_ident = #status_mapping;
                            #style_match
                        }
                    })
                } else {
                    Ok(quote! {
                        |_theme: &iced::Theme, _status: iced::widget::checkbox::Status| {
                            #base_style
                        }
                    })
                }
            } else {
                Ok(quote! {
                    |_theme: &iced::Theme, _status: iced::widget::checkbox::Status| {
                        #base_style
                    }
                })
            }
        }
        "toggler" => {
            let base_style = generate_toggler_style_struct(style_props)?;

            if has_state_variants {
                let status_ident = format_ident!("status");
                if let Some(status_mapping) =
                    super::status_mapping::generate_status_mapping(widget_kind, &status_ident)
                {
                    let widget_state_ident = format_ident!("widget_state");
                    let class = style_class.ok_or_else(|| {
                        super::CodegenError::InvalidWidget(
                            "Expected style class with state variants".to_string(),
                        )
                    })?;
                    let style_match = generate_state_style_match(
                        base_style,
                        class,
                        &widget_state_ident,
                        generate_toggler_style_struct,
                    )?;

                    Ok(quote! {
                        |_theme: &iced::Theme, #status_ident: iced::widget::toggler::Status| {
                            let #widget_state_ident = #status_mapping;
                            #style_match
                        }
                    })
                } else {
                    Ok(quote! {
                        |_theme: &iced::Theme, _status: iced::widget::toggler::Status| {
                            #base_style
                        }
                    })
                }
            } else {
                Ok(quote! {
                    |_theme: &iced::Theme, _status: iced::widget::toggler::Status| {
                        #base_style
                    }
                })
            }
        }
        "slider" => {
            let base_style = generate_slider_style_struct(style_props)?;

            if has_state_variants {
                let status_ident = format_ident!("status");
                if let Some(status_mapping) =
                    super::status_mapping::generate_status_mapping(widget_kind, &status_ident)
                {
                    let widget_state_ident = format_ident!("widget_state");
                    let class = style_class.ok_or_else(|| {
                        super::CodegenError::InvalidWidget(
                            "Expected style class with state variants".to_string(),
                        )
                    })?;
                    let style_match = generate_state_style_match(
                        base_style,
                        class,
                        &widget_state_ident,
                        generate_slider_style_struct,
                    )?;

                    Ok(quote! {
                        |_theme: &iced::Theme, #status_ident: iced::widget::slider::Status| {
                            let #widget_state_ident = #status_mapping;
                            #style_match
                        }
                    })
                } else {
                    Ok(quote! {
                        |_theme: &iced::Theme, _status: iced::widget::slider::Status| {
                            #base_style
                        }
                    })
                }
            } else {
                Ok(quote! {
                    |_theme: &iced::Theme, _status: iced::widget::slider::Status| {
                        #base_style
                    }
                })
            }
        }
        _ => {
            // For unsupported widgets, return a no-op closure
            Ok(quote! {
                |_theme: &iced::Theme| iced::widget::container::Style::default()
            })
        }
    }
}

// ============================================================================
// Helper Functions (copied from theme.rs for reuse)
// ============================================================================

/// Generate iced::Color from Color IR
fn generate_color_expr(color: &Color) -> TokenStream {
    let r = color.r;
    let g = color.g;
    let b = color.b;
    let a = color.a;
    quote! {
        iced::Color::from_rgba(#r, #g, #b, #a)
    }
}

/// Generate iced::Background from Background IR
fn generate_background_expr(bg: &Background) -> TokenStream {
    match bg {
        Background::Color(color) => {
            let color_expr = generate_color_expr(color);
            quote! { iced::Background::Color(#color_expr) }
        }
        Background::Gradient(gradient) => generate_gradient_expr(gradient),
        Background::Image { .. } => {
            quote! { iced::Background::Color(iced::Color::TRANSPARENT) }
        }
    }
}

/// Generate iced::Gradient from Gradient IR
fn generate_gradient_expr(gradient: &Gradient) -> TokenStream {
    match gradient {
        Gradient::Linear { angle, stops } => {
            let radians = angle * (std::f32::consts::PI / 180.0);
            let color_exprs: Vec<_> = stops
                .iter()
                .map(|s| generate_color_expr(&s.color))
                .collect();
            let offsets: Vec<_> = stops.iter().map(|s| s.offset).collect();

            quote! {
                iced::Background::Gradient(iced::Gradient::Linear(
                    iced::gradient::Linear::new(#radians)
                        #(.add_stop(#offsets, #color_exprs))*
                ))
            }
        }
        Gradient::Radial { stops, .. } => {
            // Fallback to linear for radial (Iced limitation)
            let color_exprs: Vec<_> = stops
                .iter()
                .map(|s| generate_color_expr(&s.color))
                .collect();
            let offsets: Vec<_> = stops.iter().map(|s| s.offset).collect();

            quote! {
                iced::Background::Gradient(iced::Gradient::Linear(
                    iced::gradient::Linear::new(0.0)
                        #(.add_stop(#offsets, #color_exprs))*
                ))
            }
        }
    }
}

/// Generate iced::Border from Border IR
fn generate_border_expr(border: &Border) -> TokenStream {
    let width = border.width;
    let color_expr = generate_color_expr(&border.color);
    let radius_expr = generate_border_radius_expr(&border.radius);

    quote! {
        iced::Border {
            width: #width,
            color: #color_expr,
            radius: #radius_expr,
        }
    }
}

/// Generate iced::border::Radius from BorderRadius IR
fn generate_border_radius_expr(radius: &BorderRadius) -> TokenStream {
    let tl = radius.top_left;
    let tr = radius.top_right;
    let br = radius.bottom_right;
    let bl = radius.bottom_left;

    quote! {
        iced::border::Radius::from(#tl).top_right(#tr).bottom_right(#br).bottom_left(#bl)
    }
}

/// Generate iced::Shadow from Shadow IR
fn generate_shadow_expr(shadow: &Shadow) -> TokenStream {
    let offset_x = shadow.offset_x;
    let offset_y = shadow.offset_y;
    let blur = shadow.blur_radius;
    let color_expr = generate_color_expr(&shadow.color);

    quote! {
        iced::Shadow {
            offset: iced::Vector::new(#offset_x, #offset_y),
            blur_radius: #blur,
            color: #color_expr,
        }
    }
}

/// Generate iced::widget::button::Style struct from StyleProperties
fn generate_button_style_struct(
    props: &StyleProperties,
) -> Result<TokenStream, super::CodegenError> {
    let background_expr = props
        .background
        .as_ref()
        .map(|bg| {
            let expr = generate_background_expr(bg);
            quote! { Some(#expr) }
        })
        .unwrap_or_else(|| quote! { None });

    let text_color_expr = props
        .color
        .as_ref()
        .map(generate_color_expr)
        .unwrap_or_else(|| quote! { iced::Color::BLACK });

    let border_expr = props
        .border
        .as_ref()
        .map(generate_border_expr)
        .unwrap_or_else(|| quote! { iced::Border::default() });

    let shadow_expr = props
        .shadow
        .as_ref()
        .map(generate_shadow_expr)
        .unwrap_or_else(|| quote! { iced::Shadow::default() });

    Ok(quote! {
        iced::widget::button::Style {
            background: #background_expr,
            text_color: #text_color_expr,
            border: #border_expr,
            shadow: #shadow_expr,
            snap: false,
        }
    })
}

/// Generate iced::widget::container::Style struct from StyleProperties
fn generate_container_style_struct(
    props: &StyleProperties,
) -> Result<TokenStream, super::CodegenError> {
    let background_expr = props
        .background
        .as_ref()
        .map(|bg| {
            let expr = generate_background_expr(bg);
            quote! { Some(#expr) }
        })
        .unwrap_or_else(|| quote! { None });

    let text_color_expr = props
        .color
        .as_ref()
        .map(|color| {
            let color_expr = generate_color_expr(color);
            quote! { Some(#color_expr) }
        })
        .unwrap_or_else(|| quote! { None });

    let border_expr = props
        .border
        .as_ref()
        .map(generate_border_expr)
        .unwrap_or_else(|| quote! { iced::Border::default() });

    let shadow_expr = props
        .shadow
        .as_ref()
        .map(generate_shadow_expr)
        .unwrap_or_else(|| quote! { iced::Shadow::default() });

    Ok(quote! {
        iced::widget::container::Style {
            background: #background_expr,
            text_color: #text_color_expr,
            border: #border_expr,
            shadow: #shadow_expr,
            snap: false,
        }
    })
}

/// Generate iced::widget::text_input::Style struct from StyleProperties
fn generate_text_input_style_struct(
    props: &StyleProperties,
) -> Result<TokenStream, super::CodegenError> {
    let background_expr = props
        .background
        .as_ref()
        .map(|bg| {
            let expr = generate_background_expr(bg);
            quote! { #expr }
        })
        .unwrap_or_else(|| quote! { iced::Background::Color(iced::Color::WHITE) });

    let border_expr = props
        .border
        .as_ref()
        .map(generate_border_expr)
        .unwrap_or_else(|| quote! { iced::Border::default() });

    Ok(quote! {
        iced::widget::text_input::Style {
            background: #background_expr,
            border: #border_expr,
            icon: iced::Color::BLACK,
            placeholder: iced::Color::from_rgb(0.4, 0.4, 0.4),
            value: iced::Color::BLACK,
            selection: iced::Color::from_rgb(0.8, 0.8, 1.0),
        }
    })
}

/// Generate checkbox style struct from StyleProperties
fn generate_checkbox_style_struct(
    props: &StyleProperties,
) -> Result<TokenStream, super::CodegenError> {
    let background_expr = props
        .background
        .as_ref()
        .map(|bg| {
            let expr = generate_background_expr(bg);
            quote! { #expr }
        })
        .unwrap_or_else(|| quote! { iced::Background::Color(iced::Color::WHITE) });

    let border_expr = props
        .border
        .as_ref()
        .map(generate_border_expr)
        .unwrap_or_else(|| quote! { iced::Border::default() });

    let text_color = props
        .color
        .as_ref()
        .map(generate_color_expr)
        .unwrap_or_else(|| quote! { iced::Color::BLACK });

    Ok(quote! {
        iced::widget::checkbox::Style {
            background: #background_expr,
            icon_color: #text_color,
            border: #border_expr,
            text_color: None,
        }
    })
}

/// Generate toggler style struct from StyleProperties
fn generate_toggler_style_struct(
    props: &StyleProperties,
) -> Result<TokenStream, super::CodegenError> {
    let background_expr = props
        .background
        .as_ref()
        .map(|bg| {
            let expr = generate_background_expr(bg);
            quote! { #expr }
        })
        .unwrap_or_else(
            || quote! { iced::Background::Color(iced::Color::from_rgb(0.5, 0.5, 0.5)) },
        );

    Ok(quote! {
        iced::widget::toggler::Style {
            background: #background_expr,
            background_border_width: 0.0,
            background_border_color: iced::Color::TRANSPARENT,
            foreground: iced::Background::Color(iced::Color::WHITE),
            foreground_border_width: 0.0,
            foreground_border_color: iced::Color::TRANSPARENT,
        }
    })
}

/// Generate slider style struct from StyleProperties
fn generate_slider_style_struct(
    props: &StyleProperties,
) -> Result<TokenStream, super::CodegenError> {
    let border_expr = props
        .border
        .as_ref()
        .map(generate_border_expr)
        .unwrap_or_else(|| quote! { iced::Border::default() });

    Ok(quote! {
        iced::widget::slider::Style {
            rail: iced::widget::slider::Rail {
                colors: (
                    iced::Color::from_rgb(0.6, 0.6, 0.6),
                    iced::Color::from_rgb(0.2, 0.6, 1.0),
                ),
                width: 4.0,
                border: #border_expr,
            },
            handle: iced::widget::slider::Handle {
                shape: iced::widget::slider::HandleShape::Circle { radius: 8.0 },
                color: iced::Color::WHITE,
                border_width: 1.0,
                border_color: iced::Color::from_rgb(0.6, 0.6, 0.6),
            },
        }
    })
}

/// Generate text widget
fn generate_text(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    _style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let value_attr = node.attributes.get("value").ok_or_else(|| {
        super::CodegenError::InvalidWidget("text requires value attribute".to_string())
    })?;

    let value_expr = generate_attribute_value(value_attr, model_ident);

    let mut text_widget = quote! {
        iced::widget::text(#value_expr)
    };

    // Apply size attribute
    if let Some(size) = node.attributes.get("size").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    }) {
        text_widget = quote! { #text_widget.size(#size) };
    }

    // Apply weight attribute (bold, normal, etc.)
    if let Some(weight) = node.attributes.get("weight").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    }) {
        let weight_expr = match weight.to_lowercase().as_str() {
            "bold" => quote! { iced::font::Weight::Bold },
            "semibold" => quote! { iced::font::Weight::Semibold },
            "medium" => quote! { iced::font::Weight::Medium },
            "light" => quote! { iced::font::Weight::Light },
            _ => quote! { iced::font::Weight::Normal },
        };
        text_widget = quote! {
            #text_widget.font(iced::Font { weight: #weight_expr, ..Default::default() })
        };
    }

    // Apply inline style color if present
    if let Some(ref style_props) = node.style {
        if let Some(ref color) = style_props.color {
            let color_expr = generate_color_expr(color);
            text_widget = quote! { #text_widget.color(#color_expr) };
        }
    }

    // Use helper to wrap in container if layout attributes are present
    Ok(maybe_wrap_in_container(text_widget, node))
}

/// Generate Length expression from string
fn generate_length_expr(s: &str) -> TokenStream {
    let s = s.trim().to_lowercase();
    if s == "fill" {
        quote! { iced::Length::Fill }
    } else if s == "shrink" {
        quote! { iced::Length::Shrink }
    } else if let Some(pct) = s.strip_suffix('%') {
        if let Ok(p) = pct.parse::<f32>() {
            // Iced doesn't have a direct percentage, use FillPortion as approximation
            let portion = ((p / 100.0) * 16.0).round() as u16;
            let portion = portion.max(1);
            quote! { iced::Length::FillPortion(#portion) }
        } else {
            quote! { iced::Length::Shrink }
        }
    } else if let Ok(px) = s.parse::<f32>() {
        quote! { iced::Length::Fixed(#px) }
    } else {
        quote! { iced::Length::Shrink }
    }
}

/// Generate Length expression from LayoutLength IR type
fn generate_layout_length_expr(length: &LayoutLength) -> TokenStream {
    match length {
        LayoutLength::Fixed(px) => quote! { iced::Length::Fixed(#px) },
        LayoutLength::Fill => quote! { iced::Length::Fill },
        LayoutLength::Shrink => quote! { iced::Length::Shrink },
        LayoutLength::FillPortion(portion) => {
            let p = *portion as u16;
            quote! { iced::Length::FillPortion(#p) }
        }
        LayoutLength::Percentage(pct) => {
            // Iced doesn't have direct percentage, approximate with FillPortion
            let portion = ((pct / 100.0) * 16.0).round() as u16;
            let portion = portion.max(1);
            quote! { iced::Length::FillPortion(#portion) }
        }
    }
}

/// Generate horizontal alignment expression
fn generate_horizontal_alignment_expr(s: &str) -> TokenStream {
    match s.trim().to_lowercase().as_str() {
        "center" => quote! { iced::alignment::Horizontal::Center },
        "end" | "right" => quote! { iced::alignment::Horizontal::Right },
        _ => quote! { iced::alignment::Horizontal::Left },
    }
}

/// Generate vertical alignment expression
fn generate_vertical_alignment_expr(s: &str) -> TokenStream {
    match s.trim().to_lowercase().as_str() {
        "center" => quote! { iced::alignment::Vertical::Center },
        "end" | "bottom" => quote! { iced::alignment::Vertical::Bottom },
        _ => quote! { iced::alignment::Vertical::Top },
    }
}

/// Wraps a widget in a container if layout attributes are present.
///
/// This helper provides consistent layout attribute support across all widgets
/// by wrapping them in a container when needed.
///
/// # Arguments
///
/// * `widget` - The widget expression to potentially wrap
/// * `node` - The widget node containing attributes
///
/// # Returns
///
/// Returns the widget wrapped in a container if layout attributes are present,
/// otherwise returns the original widget.
fn maybe_wrap_in_container(widget: TokenStream, node: &crate::WidgetNode) -> TokenStream {
    // Check if we need to wrap in container for layout/alignment/classes
    let needs_container = node.layout.is_some()
        || !node.classes.is_empty()
        || node.attributes.contains_key("align_x")
        || node.attributes.contains_key("align_y")
        || node.attributes.contains_key("width")
        || node.attributes.contains_key("height")
        || node.attributes.contains_key("padding");

    if !needs_container {
        return quote! { #widget.into() };
    }

    let mut container = quote! {
        iced::widget::container(#widget)
    };

    // Apply width
    if let Some(width) = node.attributes.get("width").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    }) {
        let width_expr = generate_length_expr(&width);
        container = quote! { #container.width(#width_expr) };
    }

    // Apply height
    if let Some(height) = node.attributes.get("height").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    }) {
        let height_expr = generate_length_expr(&height);
        container = quote! { #container.height(#height_expr) };
    }

    // Apply padding
    if let Some(padding) = node.attributes.get("padding").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    }) {
        container = quote! { #container.padding(#padding) };
    }

    // Apply align_x
    if let Some(align_x) = node.attributes.get("align_x").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    }) {
        let align_expr = generate_horizontal_alignment_expr(&align_x);
        container = quote! { #container.align_x(#align_expr) };
    }

    // Apply align_y
    if let Some(align_y) = node.attributes.get("align_y").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    }) {
        let align_expr = generate_vertical_alignment_expr(&align_y);
        container = quote! { #container.align_y(#align_expr) };
    }

    // Apply class style if present
    if let Some(class_name) = node.classes.first() {
        let style_fn_ident = format_ident!("style_{}", class_name.replace('-', "_"));
        container = quote! { #container.style(#style_fn_ident) };
    }

    quote! { #container.into() }
}

/// Generate button widget
fn generate_button(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let label_attr = node.attributes.get("label").ok_or_else(|| {
        super::CodegenError::InvalidWidget("button requires label attribute".to_string())
    })?;

    let label_expr = generate_attribute_value(label_attr, model_ident);

    let on_click = node
        .events
        .iter()
        .find(|e| e.event == crate::EventKind::Click);

    let mut button = quote! {
        iced::widget::button(iced::widget::text(#label_expr))
    };

    // Handle enabled attribute
    let enabled_condition = node.attributes.get("enabled").map(|attr| match attr {
        AttributeValue::Static(s) => {
            // Static enabled values
            match s.to_lowercase().as_str() {
                "true" | "1" | "yes" | "on" => quote! { true },
                "false" | "0" | "no" | "off" => quote! { false },
                _ => quote! { true }, // Default to enabled
            }
        }
        AttributeValue::Binding(binding_expr) => {
            // Dynamic binding expression - use generate_bool_expr for native boolean
            super::bindings::generate_bool_expr(&binding_expr.expr)
        }
        AttributeValue::Interpolated(_) => {
            // Interpolated strings treated as enabled if non-empty
            let expr_tokens = generate_attribute_value(attr, model_ident);
            quote! { !#expr_tokens.is_empty() && #expr_tokens != "false" && #expr_tokens != "0" }
        }
    });

    if let Some(event) = on_click {
        let variant_name = to_upper_camel_case(&event.handler);
        let handler_ident = format_ident!("{}", variant_name);

        let param_expr = if let Some(ref param) = event.param {
            let param_tokens = generate_expr(&param.expr);
            quote! { (#param_tokens) }
        } else {
            quote! {}
        };

        // Generate on_press call based on enabled condition
        button = match enabled_condition {
            None => {
                // No enabled attribute - always enabled
                quote! {
                    #button.on_press(#message_ident::#handler_ident #param_expr)
                }
            }
            Some(condition) => {
                // Conditional enabled - use on_press_maybe
                quote! {
                    #button.on_press_maybe(
                        if #condition {
                            Some(#message_ident::#handler_ident #param_expr)
                        } else {
                            None
                        }
                    )
                }
            }
        };
    }

    // Apply styles (inline or classes)
    button = apply_widget_style(button, node, "button", style_classes)?;

    Ok(quote! { #button.into() })
}

/// Helper function to convert snake_case to UpperCamelCase
fn to_upper_camel_case(s: &str) -> String {
    let mut result = String::new();
    let mut capitalize_next = true;
    for c in s.chars() {
        if c == '_' {
            capitalize_next = true;
        } else if capitalize_next {
            result.push(c.to_ascii_uppercase());
            capitalize_next = false;
        } else {
            result.push(c);
        }
    }
    result
}

/// Generate container widget (column, row, container, scrollable)
fn generate_container(
    node: &crate::WidgetNode,
    widget_type: &str,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let children: Vec<TokenStream> = node
        .children
        .iter()
        .map(|child| generate_widget(child, model_ident, message_ident, style_classes))
        .collect::<Result<_, _>>()?;

    let widget_ident = format_ident!("{}", widget_type);

    // Get merged layout from node.layout and style classes
    let merged_layout = get_merged_layout(node, style_classes);

    // Get spacing from attributes or merged layout
    let spacing = node
        .attributes
        .get("spacing")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                s.parse::<f32>().ok()
            } else {
                None
            }
        })
        .or_else(|| merged_layout.as_ref().and_then(|l| l.spacing()));

    // Get padding from attributes or merged layout
    let padding = node
        .attributes
        .get("padding")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                s.parse::<f32>().ok()
            } else {
                None
            }
        })
        .or_else(|| merged_layout.as_ref().and_then(|l| l.padding()));

    let mut widget = if widget_type == "container" {
        // Container in Iced can only have one child
        // If multiple children provided, wrap them in a column automatically
        // Use let binding with explicit type to help inference when child is a column/row
        if children.is_empty() {
            quote! {
                iced::widget::container(iced::widget::Space::new())
            }
        } else if children.len() == 1 {
            let child = &children[0];
            quote! {
                {
                    let content: iced::Element<'_, _, _> = #child;
                    iced::widget::container(content)
                }
            }
        } else {
            // Multiple children - wrap in a column
            quote! {
                {
                    let content: iced::Element<'_, _, _> = iced::widget::column(vec![#(#children),*]).into();
                    iced::widget::container(content)
                }
            }
        }
    } else if widget_type == "scrollable" {
        // Scrollable in Iced can only have one child
        // If multiple children provided, wrap them in a column automatically
        // Use let binding with explicit type to help inference when child is a column/row
        if children.is_empty() {
            quote! {
                iced::widget::scrollable(iced::widget::Space::new())
            }
        } else if children.len() == 1 {
            let child = &children[0];
            quote! {
                {
                    let content: iced::Element<'_, _, _> = #child;
                    iced::widget::scrollable(content)
                }
            }
        } else {
            // Multiple children - wrap in a column
            quote! {
                {
                    let content: iced::Element<'_, _, _> = iced::widget::column(vec![#(#children),*]).into();
                    iced::widget::scrollable(content)
                }
            }
        }
    } else {
        quote! {
            iced::widget::#widget_ident(vec![#(#children),*])
        }
    };

    if let Some(s) = spacing {
        widget = quote! { #widget.spacing(#s) };
    }

    if let Some(p) = padding {
        widget = quote! { #widget.padding(#p) };
    }

    // Apply width from attributes or merged layout
    let width_from_attr = node.attributes.get("width").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    });
    let width_from_layout = merged_layout.as_ref().and_then(|l| l.width());

    if let Some(width) = width_from_attr {
        let width_expr = generate_length_expr(&width);
        widget = quote! { #widget.width(#width_expr) };
    } else if let Some(layout_width) = width_from_layout {
        let width_expr = generate_layout_length_expr(layout_width);
        widget = quote! { #widget.width(#width_expr) };
    }

    // Apply height from attributes or merged layout
    let height_from_attr = node.attributes.get("height").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    });
    let height_from_layout = merged_layout.as_ref().and_then(|l| l.height());

    if let Some(height) = height_from_attr {
        let height_expr = generate_length_expr(&height);
        widget = quote! { #widget.height(#height_expr) };
    } else if let Some(layout_height) = height_from_layout {
        let height_expr = generate_layout_length_expr(layout_height);
        widget = quote! { #widget.height(#height_expr) };
    }

    // Apply align_x attribute (for containers)
    if widget_type == "container" {
        if let Some(align_x) = node.attributes.get("align_x").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = generate_horizontal_alignment_expr(&align_x);
            widget = quote! { #widget.align_x(#align_expr) };
        }

        // Apply align_y attribute
        if let Some(align_y) = node.attributes.get("align_y").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = generate_vertical_alignment_expr(&align_y);
            widget = quote! { #widget.align_y(#align_expr) };
        }
    }

    // Apply align_items for column/row (vertical alignment of children)
    if widget_type == "column" || widget_type == "row" {
        if let Some(align) = node.attributes.get("align_items").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = match align.to_lowercase().as_str() {
                "center" => quote! { iced::Alignment::Center },
                "end" => quote! { iced::Alignment::End },
                _ => quote! { iced::Alignment::Start },
            };
            widget = quote! { #widget.align_items(#align_expr) };
        }
    }

    // Apply styles (only for container, not column/row/scrollable)
    if widget_type == "container" {
        widget = apply_widget_style(widget, node, "container", style_classes)?;
    }

    // Check if Column/Row needs to be wrapped in a container for align_x/align_y
    // These attributes position the Column/Row itself within its parent,
    // which requires an outer container wrapper
    if (widget_type == "column" || widget_type == "row")
        && (node.attributes.contains_key("align_x") || node.attributes.contains_key("align_y"))
    {
        let mut container = quote! { iced::widget::container(#widget) };

        if let Some(align_x) = node.attributes.get("align_x").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = generate_horizontal_alignment_expr(&align_x);
            container = quote! { #container.align_x(#align_expr) };
        }

        if let Some(align_y) = node.attributes.get("align_y").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = generate_vertical_alignment_expr(&align_y);
            container = quote! { #container.align_y(#align_expr) };
        }

        // Container needs explicit width/height to enable alignment
        container = quote! { #container.width(iced::Length::Fill).height(iced::Length::Fill) };

        return Ok(quote! { #container.into() });
    }

    Ok(quote! { #widget.into() })
}

/// Generate stack widget
fn generate_stack(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let children: Vec<TokenStream> = node
        .children
        .iter()
        .map(|child| generate_widget(child, model_ident, message_ident, style_classes))
        .collect::<Result<_, _>>()?;

    Ok(quote! {
        iced::widget::stack(vec![#(#children),*]).into()
    })
}

/// Generate space widget
fn generate_space(node: &crate::WidgetNode) -> Result<TokenStream, super::CodegenError> {
    // Get width attribute
    let width = node.attributes.get("width").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    });

    // Get height attribute
    let height = node.attributes.get("height").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    });

    let mut space = quote! { iced::widget::Space::new() };

    // Apply width
    if let Some(w) = width {
        let width_expr = generate_length_expr(&w);
        space = quote! { #space.width(#width_expr) };
    }

    // Apply height
    if let Some(h) = height {
        let height_expr = generate_length_expr(&h);
        space = quote! { #space.height(#height_expr) };
    }

    Ok(quote! { #space.into() })
}

/// Generate rule (horizontal/vertical line) widget
fn generate_rule(node: &crate::WidgetNode) -> Result<TokenStream, super::CodegenError> {
    // Get direction (default to horizontal)
    let direction = node
        .attributes
        .get("direction")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        })
        .unwrap_or_else(|| "horizontal".to_string());

    // Get thickness (default to 1)
    let thickness = node
        .attributes
        .get("thickness")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                s.parse::<f32>().ok()
            } else {
                None
            }
        })
        .unwrap_or(1.0);

    let rule = if direction.to_lowercase() == "vertical" {
        quote! { iced::widget::rule::vertical(#thickness) }
    } else {
        quote! { iced::widget::rule::horizontal(#thickness) }
    };

    Ok(quote! { #rule.into() })
}

/// Generate checkbox widget
fn generate_checkbox(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let label = node
        .attributes
        .get("label")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        })
        .unwrap_or_default();
    let label_lit = proc_macro2::Literal::string(&label);
    let label_expr = quote! { #label_lit.to_string() };

    let checked_attr = node.attributes.get("checked");
    let checked_expr = checked_attr
        .map(|attr| generate_attribute_value(attr, model_ident))
        .unwrap_or(quote! { false });

    let on_toggle = node
        .events
        .iter()
        .find(|e| e.event == crate::EventKind::Toggle);

    let checkbox = if let Some(event) = on_toggle {
        let variant_name = to_upper_camel_case(&event.handler);
        let handler_ident = format_ident!("{}", variant_name);
        quote! {
            iced::widget::checkbox(#label_expr, #checked_expr)
                .on_toggle(#message_ident::#handler_ident)
        }
    } else {
        quote! {
            iced::widget::checkbox(#label_expr, #checked_expr)
        }
    };

    // Apply styles
    let checkbox = apply_widget_style(checkbox, node, "checkbox", style_classes)?;

    Ok(quote! { #checkbox.into() })
}

/// Generate toggler widget
fn generate_toggler(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let label = node
        .attributes
        .get("label")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        })
        .unwrap_or_default();
    let label_lit = proc_macro2::Literal::string(&label);
    let label_expr = quote! { #label_lit.to_string() };

    let is_toggled_attr = node.attributes.get("toggled");
    let is_toggled_expr = is_toggled_attr
        .map(|attr| generate_attribute_value(attr, model_ident))
        .unwrap_or(quote! { false });

    let on_toggle = node
        .events
        .iter()
        .find(|e| e.event == crate::EventKind::Toggle);

    let toggler = if let Some(event) = on_toggle {
        let variant_name = to_upper_camel_case(&event.handler);
        let handler_ident = format_ident!("{}", variant_name);
        quote! {
            iced::widget::toggler(#label_expr, #is_toggled_expr, None)
                .on_toggle(|_| #message_ident::#handler_ident)
        }
    } else {
        quote! {
            iced::widget::toggler(#label_expr, #is_toggled_expr, None)
        }
    };

    // Apply styles
    let toggler = apply_widget_style(toggler, node, "toggler", style_classes)?;

    Ok(quote! { #toggler.into() })
}

/// Generate slider widget
fn generate_slider(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let min = node.attributes.get("min").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    let max = node.attributes.get("max").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    let value_attr = node.attributes.get("value").ok_or_else(|| {
        super::CodegenError::InvalidWidget("slider requires value attribute".to_string())
    })?;
    let value_expr = generate_attribute_value(value_attr, model_ident);

    let on_change = node
        .events
        .iter()
        .find(|e| e.event == crate::EventKind::Change);

    let mut slider = quote! {
        iced::widget::slider(0.0..=100.0, #value_expr, |v| {})
    };

    if let Some(m) = min {
        slider = quote! { #slider.min(#m) };
    }
    if let Some(m) = max {
        slider = quote! { #slider.max(#m) };
    }

    // Apply step attribute (increment size)
    let step = node.attributes.get("step").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    if let Some(s) = step {
        slider = quote! { #slider.step(#s) };
    }

    if let Some(event) = on_change {
        let variant_name = to_upper_camel_case(&event.handler);
        let handler_ident = format_ident!("{}", variant_name);
        slider = quote! {
            iced::widget::slider(0.0..=100.0, #value_expr, |v| #message_ident::#handler_ident(v))
        };
    }

    // Apply styles
    slider = apply_widget_style(slider, node, "slider", style_classes)?;

    Ok(quote! { #slider.into() })
}

/// Generate radio widget
fn generate_radio(
    node: &crate::WidgetNode,
    _model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    _style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let label = node
        .attributes
        .get("label")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        })
        .unwrap_or_default();
    let label_lit = proc_macro2::Literal::string(&label);
    let label_expr = quote! { #label_lit.to_string() };

    let value_attr = node.attributes.get("value").ok_or_else(|| {
        super::CodegenError::InvalidWidget("radio requires value attribute".to_string())
    })?;
    let value_expr = match value_attr {
        AttributeValue::Binding(expr) => generate_expr(&expr.expr),
        _ => quote! { String::new() },
    };

    let selected_attr = node.attributes.get("selected");
    let selected_expr = match selected_attr {
        Some(AttributeValue::Binding(expr)) => generate_expr(&expr.expr),
        _ => quote! { None },
    };

    let on_select = node
        .events
        .iter()
        .find(|e| e.event == crate::EventKind::Select);

    if let Some(event) = on_select {
        let variant_name = to_upper_camel_case(&event.handler);
        let handler_ident = format_ident!("{}", variant_name);
        Ok(quote! {
            iced::widget::radio(#label_expr, #value_expr, #selected_expr, |v| #message_ident::#handler_ident(v)).into()
        })
    } else {
        Ok(quote! {
            iced::widget::radio(#label_expr, #value_expr, #selected_expr, |_| ()).into()
        })
    }
}

/// Generate progress bar widget
fn generate_progress_bar(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    _style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let value_attr = node.attributes.get("value").ok_or_else(|| {
        super::CodegenError::InvalidWidget("progress_bar requires value attribute".to_string())
    })?;
    let value_expr = generate_attribute_value(value_attr, model_ident);

    let max_attr = node.attributes.get("max").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    if let Some(max) = max_attr {
        Ok(quote! {
            iced::widget::progress_bar(0.0..=#max, #value_expr).into()
        })
    } else {
        Ok(quote! {
            iced::widget::progress_bar(0.0..=100.0, #value_expr).into()
        })
    }
}

/// Generate text input widget
fn generate_text_input(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let value_expr = node
        .attributes
        .get("value")
        .map(|attr| generate_attribute_value(attr, model_ident))
        .unwrap_or(quote! { String::new() });

    let placeholder = node.attributes.get("placeholder").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            Some(s.clone())
        } else {
            None
        }
    });

    let on_input = node
        .events
        .iter()
        .find(|e| e.event == crate::EventKind::Input);

    let mut text_input = match placeholder {
        Some(ph) => {
            let ph_lit = proc_macro2::Literal::string(&ph);
            quote! {
                iced::widget::text_input(#ph_lit, &#value_expr)
            }
        }
        None => quote! {
            iced::widget::text_input("", &#value_expr)
        },
    };

    if let Some(event) = on_input {
        let variant_name = to_upper_camel_case(&event.handler);
        let handler_ident = format_ident!("{}", variant_name);
        text_input = quote! {
            #text_input.on_input(|v| #message_ident::#handler_ident(v))
        };
    }

    // Apply password/secure attribute (masks input)
    let is_password = node
        .attributes
        .get("password")
        .or_else(|| node.attributes.get("secure"))
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.to_lowercase() == "true" || s == "1")
            } else {
                None
            }
        })
        .unwrap_or(false);

    if is_password {
        text_input = quote! { #text_input.password() };
    }

    // Apply styles
    text_input = apply_widget_style(text_input, node, "text_input", style_classes)?;

    Ok(quote! { #text_input.into() })
}

/// Generate image widget
fn generate_image(node: &crate::WidgetNode) -> Result<TokenStream, super::CodegenError> {
    let src_attr = node.attributes.get("src").ok_or_else(|| {
        super::CodegenError::InvalidWidget("image requires src attribute".to_string())
    })?;

    let src = match src_attr {
        AttributeValue::Static(s) => s.clone(),
        _ => String::new(),
    };
    let src_lit = proc_macro2::Literal::string(&src);

    let width = node.attributes.get("width").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<u32>().ok()
        } else {
            None
        }
    });

    let height = node.attributes.get("height").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<u32>().ok()
        } else {
            None
        }
    });

    let mut image = quote! {
        iced::widget::image::Image::new(iced::widget::image::Handle::from_memory(std::fs::read(#src_lit).unwrap_or_default()))
    };

    // Apply native width/height if specified with integer values
    if let (Some(w), Some(h)) = (width, height) {
        image = quote! { #image.width(#w).height(#h) };
    } else if let Some(w) = width {
        image = quote! { #image.width(#w) };
    } else if let Some(h) = height {
        image = quote! { #image.height(#h) };
    }

    // Check if we need container for NON-native layout attributes
    // (padding, alignment, classes - NOT width/height since those are native)
    // For Image, only wrap if there are alignment/padding/classes
    let needs_container = !node.classes.is_empty()
        || node.attributes.contains_key("align_x")
        || node.attributes.contains_key("align_y")
        || node.attributes.contains_key("padding");

    if needs_container {
        // Wrap with container for layout attributes, but skip width/height (already applied)
        let mut container = quote! { iced::widget::container(#image) };

        if let Some(padding) = node.attributes.get("padding").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                s.parse::<f32>().ok()
            } else {
                None
            }
        }) {
            container = quote! { #container.padding(#padding) };
        }

        if let Some(align_x) = node.attributes.get("align_x").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = generate_horizontal_alignment_expr(&align_x);
            container = quote! { #container.align_x(#align_expr) };
        }

        if let Some(align_y) = node.attributes.get("align_y").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = generate_vertical_alignment_expr(&align_y);
            container = quote! { #container.align_y(#align_expr) };
        }

        if let Some(class_name) = node.classes.first() {
            let style_fn_ident = format_ident!("style_{}", class_name.replace('-', "_"));
            container = quote! { #container.style(#style_fn_ident) };
        }

        Ok(quote! { #container.into() })
    } else {
        Ok(quote! { #image.into() })
    }
}

/// Generate SVG widget
fn generate_svg(node: &crate::WidgetNode) -> Result<TokenStream, super::CodegenError> {
    // Support both "src" (standard) and "path" (legacy) for backward compatibility
    let path_attr = node
        .attributes
        .get("src")
        .or_else(|| node.attributes.get("path"))
        .ok_or_else(|| {
            super::CodegenError::InvalidWidget("svg requires src attribute".to_string())
        })?;

    let path = match path_attr {
        AttributeValue::Static(s) => s.clone(),
        _ => String::new(),
    };
    let path_lit = proc_macro2::Literal::string(&path);

    let width = node.attributes.get("width").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<u32>().ok()
        } else {
            None
        }
    });

    let height = node.attributes.get("height").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<u32>().ok()
        } else {
            None
        }
    });

    let mut svg = quote! {
        iced::widget::svg::Svg::new(iced::widget::svg::Handle::from_path(#path_lit))
    };

    // Apply native width/height if specified with integer values
    if let (Some(w), Some(h)) = (width, height) {
        svg = quote! { #svg.width(#w).height(#h) };
    } else if let Some(w) = width {
        svg = quote! { #svg.width(#w) };
    } else if let Some(h) = height {
        svg = quote! { #svg.height(#h) };
    }

    // Check if we need container for NON-native layout attributes
    // (padding, alignment, classes - NOT width/height since those are native)
    // For SVG, only wrap if there are alignment/padding/classes
    let needs_container = !node.classes.is_empty()
        || node.attributes.contains_key("align_x")
        || node.attributes.contains_key("align_y")
        || node.attributes.contains_key("padding");

    if needs_container {
        // Wrap with container for layout attributes, but skip width/height (already applied)
        let mut container = quote! { iced::widget::container(#svg) };

        if let Some(padding) = node.attributes.get("padding").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                s.parse::<f32>().ok()
            } else {
                None
            }
        }) {
            container = quote! { #container.padding(#padding) };
        }

        if let Some(align_x) = node.attributes.get("align_x").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = generate_horizontal_alignment_expr(&align_x);
            container = quote! { #container.align_x(#align_expr) };
        }

        if let Some(align_y) = node.attributes.get("align_y").and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        }) {
            let align_expr = generate_vertical_alignment_expr(&align_y);
            container = quote! { #container.align_y(#align_expr) };
        }

        if let Some(class_name) = node.classes.first() {
            let style_fn_ident = format_ident!("style_{}", class_name.replace('-', "_"));
            container = quote! { #container.style(#style_fn_ident) };
        }

        Ok(quote! { #container.into() })
    } else {
        Ok(quote! { #svg.into() })
    }
}

/// Generate pick list widget
fn generate_pick_list(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    _style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let options_attr = node.attributes.get("options").ok_or_else(|| {
        super::CodegenError::InvalidWidget("pick_list requires options attribute".to_string())
    })?;

    let options: Vec<String> = match options_attr {
        AttributeValue::Static(s) => s.split(',').map(|s| s.trim().to_string()).collect(),
        _ => Vec::new(),
    };
    let options_ref: Vec<&str> = options.iter().map(|s| s.as_str()).collect();

    let selected_attr = node.attributes.get("selected");
    let selected_expr = selected_attr
        .map(|attr| generate_attribute_value(attr, model_ident))
        .unwrap_or(quote! { None });

    let on_select = node
        .events
        .iter()
        .find(|e| e.event == crate::EventKind::Select);

    if let Some(event) = on_select {
        let variant_name = to_upper_camel_case(&event.handler);
        let handler_ident = format_ident!("{}", variant_name);
        Ok(quote! {
            iced::widget::pick_list(&[#(#options_ref),*], #selected_expr, |v| #message_ident::#handler_ident(v)).into()
        })
    } else {
        Ok(quote! {
            iced::widget::pick_list(&[#(#options_ref),*], #selected_expr, |_| ()).into()
        })
    }
}

/// Generate combo box widget
fn generate_combo_box(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    _style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let options_attr = node.attributes.get("options").ok_or_else(|| {
        super::CodegenError::InvalidWidget("combobox requires options attribute".to_string())
    })?;

    let options: Vec<String> = match options_attr {
        AttributeValue::Static(s) => s.split(',').map(|s| s.trim().to_string()).collect(),
        _ => Vec::new(),
    };
    let options_ref: Vec<&str> = options.iter().map(|s| s.as_str()).collect();

    let selected_attr = node.attributes.get("selected");
    let selected_expr = selected_attr
        .map(|attr| generate_attribute_value(attr, model_ident))
        .unwrap_or(quote! { None });

    let on_select = node
        .events
        .iter()
        .find(|e| e.event == crate::EventKind::Select);

    if let Some(event) = on_select {
        let variant_name = to_upper_camel_case(&event.handler);
        let handler_ident = format_ident!("{}", variant_name);
        Ok(quote! {
            iced::widget::combo_box(&[#(#options_ref),*], "", #selected_expr, |v, _| #message_ident::#handler_ident(v)).into()
        })
    } else {
        Ok(quote! {
            iced::widget::combo_box(&[#(#options_ref),*], "", #selected_expr, |_, _| ()).into()
        })
    }
}

/// Generate tooltip widget
fn generate_tooltip(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let child = node.children.first().ok_or_else(|| {
        super::CodegenError::InvalidWidget("tooltip must have exactly one child".to_string())
    })?;
    let child_widget = generate_widget(child, model_ident, message_ident, style_classes)?;

    let message_attr = node.attributes.get("message").ok_or_else(|| {
        super::CodegenError::InvalidWidget("tooltip requires message attribute".to_string())
    })?;
    let message_expr = generate_attribute_value(message_attr, model_ident);

    Ok(quote! {
        iced::widget::tooltip(#child_widget, #message_expr, iced::widget::tooltip::Position::FollowCursor).into()
    })
}

/// Generate grid widget
fn generate_grid(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let children: Vec<TokenStream> = node
        .children
        .iter()
        .map(|child| generate_widget(child, model_ident, message_ident, style_classes))
        .collect::<Result<_, _>>()?;

    let columns = node
        .attributes
        .get("columns")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                s.parse::<u32>().ok()
            } else {
                None
            }
        })
        .unwrap_or(1);

    let spacing = node.attributes.get("spacing").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    let padding = node.attributes.get("padding").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    let grid = quote! {
        iced::widget::grid::Grid::new_with_children(vec![#(#children),*], #columns)
    };

    let grid = if let Some(s) = spacing {
        quote! { #grid.spacing(#s) }
    } else {
        grid
    };

    let grid = if let Some(p) = padding {
        quote! { #grid.padding(#p) }
    } else {
        grid
    };

    Ok(quote! { #grid.into() })
}

/// Generate canvas widget
fn generate_canvas(
    node: &crate::WidgetNode,
    _model_ident: &syn::Ident,
    _message_ident: &syn::Ident,
    _style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let width = node.attributes.get("width").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    let height = node.attributes.get("height").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    let size = match (width, height) {
        (Some(w), Some(h)) => quote! { iced::Size::new(#w, #h) },
        (Some(w), None) => quote! { iced::Size::new(#w, 100.0) },
        (None, Some(h)) => quote! { iced::Size::new(100.0, #h) },
        _ => quote! { iced::Size::new(100.0, 100.0) },
    };

    Ok(quote! {
        iced::widget::canvas(#size).into()
    })
}

/// Generate float widget
fn generate_float(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let child = node.children.first().ok_or_else(|| {
        super::CodegenError::InvalidWidget("float must have exactly one child".to_string())
    })?;
    let child_widget = generate_widget(child, model_ident, message_ident, style_classes)?;

    let position = node
        .attributes
        .get("position")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        })
        .unwrap_or_else(|| "TopRight".to_string());

    let offset_x = node.attributes.get("offset_x").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    let offset_y = node.attributes.get("offset_y").and_then(|attr| {
        if let AttributeValue::Static(s) = attr {
            s.parse::<f32>().ok()
        } else {
            None
        }
    });

    let float = match position.as_str() {
        "TopLeft" => quote! { iced::widget::float::float_top_left(#child_widget) },
        "TopRight" => quote! { iced::widget::float::float_top_right(#child_widget) },
        "BottomLeft" => quote! { iced::widget::float::float_bottom_left(#child_widget) },
        "BottomRight" => quote! { iced::widget::float::float_bottom_right(#child_widget) },
        _ => quote! { iced::widget::float::float_top_right(#child_widget) },
    };

    let float = if let (Some(ox), Some(oy)) = (offset_x, offset_y) {
        quote! { #float.offset_x(#ox).offset_y(#oy) }
    } else if let Some(ox) = offset_x {
        quote! { #float.offset_x(#ox) }
    } else if let Some(oy) = offset_y {
        quote! { #float.offset_y(#oy) }
    } else {
        float
    };

    Ok(quote! { #float.into() })
}

/// Generate for loop widget (iterates over collection)
fn generate_for(
    node: &crate::WidgetNode,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let items_attr = node.attributes.get("items").ok_or_else(|| {
        super::CodegenError::InvalidWidget("for requires items attribute".to_string())
    })?;

    let item_name = node
        .attributes
        .get("item")
        .and_then(|attr| {
            if let AttributeValue::Static(s) = attr {
                Some(s.clone())
            } else {
                None
            }
        })
        .unwrap_or_else(|| "item".to_string());

    let _children: Vec<TokenStream> = node
        .children
        .iter()
        .map(|child| generate_widget(child, model_ident, message_ident, style_classes))
        .collect::<Result<_, _>>()?;

    let _items_expr = generate_attribute_value(items_attr, model_ident);
    let _item_ident = format_ident!("{}", item_name);

    Ok(quote! {
        {
            let _items = _items_expr;
            iced::widget::column(vec![]).into()
        }
    })
}

/// Generate custom widget
fn generate_custom_widget(
    node: &crate::WidgetNode,
    name: &str,
    model_ident: &syn::Ident,
    message_ident: &syn::Ident,
    style_classes: &HashMap<String, StyleClass>,
) -> Result<TokenStream, super::CodegenError> {
    let widget_ident = format_ident!("{}", name);
    let children: Vec<TokenStream> = node
        .children
        .iter()
        .map(|child| generate_widget(child, model_ident, message_ident, style_classes))
        .collect::<Result<_, _>>()?;

    Ok(quote! {
        #widget_ident(vec![#(#children),*]).into()
    })
}

/// Generate attribute value expression with inlined bindings
fn generate_attribute_value(attr: &AttributeValue, _model_ident: &syn::Ident) -> TokenStream {
    match attr {
        AttributeValue::Static(s) => {
            let lit = proc_macro2::Literal::string(s);
            quote! { #lit.to_string() }
        }
        AttributeValue::Binding(expr) => generate_expr(&expr.expr),
        AttributeValue::Interpolated(parts) => {
            let parts_str: Vec<String> = parts
                .iter()
                .map(|part| match part {
                    InterpolatedPart::Literal(s) => s.clone(),
                    InterpolatedPart::Binding(_) => "{}".to_string(),
                })
                .collect();
            let binding_exprs: Vec<TokenStream> = parts
                .iter()
                .filter_map(|part| {
                    if let InterpolatedPart::Binding(expr) = part {
                        Some(generate_expr(&expr.expr))
                    } else {
                        None
                    }
                })
                .collect();

            let format_string = parts_str.join("");
            let lit = proc_macro2::Literal::string(&format_string);

            quote! { format!(#lit, #(#binding_exprs),*) }
        }
    }
}

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

    #[test]
    fn test_view_generation() {
        let xml = r#"<column><text value="Hello" /></column>"#;
        let doc = parse(xml).unwrap();

        let result = generate_view(&doc, "Model", "Message").unwrap();
        let code = result.to_string();

        assert!(code.contains("text"));
        assert!(code.contains("column"));
    }

    #[test]
    fn test_view_generation_with_binding() {
        let xml = r#"<column><text value="{name}" /></column>"#;
        let doc = parse(xml).unwrap();

        let result = generate_view(&doc, "Model", "Message").unwrap();
        let code = result.to_string();

        assert!(code.contains("name"));
        assert!(code.contains("to_string"));
    }

    #[test]
    fn test_button_with_handler() {
        let xml = r#"<column><button label="Click" on_click="handle_click" /></column>"#;
        let doc = parse(xml).unwrap();

        let result = generate_view(&doc, "Model", "Message").unwrap();
        let code = result.to_string();

        assert!(code.contains("button"));
        assert!(code.contains("HandleClick"));
    }

    #[test]
    fn test_container_with_children() {
        let xml = r#"<column spacing="10"><text value="A" /><text value="B" /></column>"#;
        let doc = parse(xml).unwrap();

        let result = generate_view(&doc, "Model", "Message").unwrap();
        let code = result.to_string();

        assert!(code.contains("column"));
        assert!(code.contains("spacing"));
    }

    #[test]
    fn test_button_with_inline_style() {
        use crate::ir::node::WidgetNode;
        use crate::ir::style::{Background, Color, StyleProperties};
        use std::collections::HashMap;

        // Manually construct a button with inline style
        let button_node = WidgetNode {
            kind: WidgetKind::Button,
            id: None,
            attributes: {
                let mut attrs = HashMap::new();
                attrs.insert(
                    "label".to_string(),
                    AttributeValue::Static("Test".to_string()),
                );
                attrs
            },
            events: vec![],
            children: vec![],
            span: Default::default(),
            style: Some(StyleProperties {
                background: Some(Background::Color(Color::from_rgb8(52, 152, 219))),
                color: Some(Color::from_rgb8(255, 255, 255)),
                border: None,
                shadow: None,
                opacity: None,
                transform: None,
            }),
            layout: None,
            theme_ref: None,
            classes: vec![],
            breakpoint_attributes: HashMap::new(),
            inline_state_variants: HashMap::new(),
        };

        let model_ident = syn::Ident::new("model", proc_macro2::Span::call_site());
        let message_ident = syn::Ident::new("Message", proc_macro2::Span::call_site());
        let style_classes = HashMap::new();

        let result =
            generate_button(&button_node, &model_ident, &message_ident, &style_classes).unwrap();
        let code = result.to_string();

        // Should contain style closure (note: quote! adds spaces)
        assert!(code.contains("style"));
        assert!(code.contains("button :: Status"));
        assert!(code.contains("button :: Style"));
        assert!(code.contains("background"));
        assert!(code.contains("text_color"));
    }

    #[test]
    fn test_button_with_css_class() {
        use crate::ir::node::WidgetNode;
        use crate::ir::theme::StyleClass;
        use std::collections::HashMap;

        // Manually construct a button with CSS class
        let button_node = WidgetNode {
            kind: WidgetKind::Button,
            id: None,
            attributes: {
                let mut attrs = HashMap::new();
                attrs.insert(
                    "label".to_string(),
                    AttributeValue::Static("Test".to_string()),
                );
                attrs
            },
            events: vec![],
            children: vec![],
            span: Default::default(),
            style: None,
            layout: None,
            theme_ref: None,
            classes: vec!["primary-button".to_string()],
            breakpoint_attributes: HashMap::new(),
            inline_state_variants: HashMap::new(),
        };

        let model_ident = syn::Ident::new("model", proc_macro2::Span::call_site());
        let message_ident = syn::Ident::new("Message", proc_macro2::Span::call_site());
        let style_classes: HashMap<String, StyleClass> = HashMap::new();

        let result =
            generate_button(&button_node, &model_ident, &message_ident, &style_classes).unwrap();
        let code = result.to_string();

        // Should call style function (note: quote! adds spaces)
        assert!(code.contains("style"));
        assert!(code.contains("style_primary_button"));
    }

    #[test]
    fn test_container_with_inline_style() {
        use crate::ir::node::WidgetNode;
        use crate::ir::style::{
            Background, Border, BorderRadius, BorderStyle, Color, StyleProperties,
        };
        use crate::ir::theme::StyleClass;
        use std::collections::HashMap;

        let container_node = WidgetNode {
            kind: WidgetKind::Container,
            id: None,
            attributes: HashMap::new(),
            events: vec![],
            children: vec![],
            span: Default::default(),
            style: Some(StyleProperties {
                background: Some(Background::Color(Color::from_rgb8(240, 240, 240))),
                color: None,
                border: Some(Border {
                    width: 2.0,
                    color: Color::from_rgb8(200, 200, 200),
                    radius: BorderRadius {
                        top_left: 8.0,
                        top_right: 8.0,
                        bottom_right: 8.0,
                        bottom_left: 8.0,
                    },
                    style: BorderStyle::Solid,
                }),
                shadow: None,
                opacity: None,
                transform: None,
            }),
            layout: None,
            theme_ref: None,
            classes: vec![],
            breakpoint_attributes: HashMap::new(),
            inline_state_variants: HashMap::new(),
        };

        let model_ident = syn::Ident::new("model", proc_macro2::Span::call_site());
        let message_ident = syn::Ident::new("Message", proc_macro2::Span::call_site());
        let style_classes: HashMap<String, StyleClass> = HashMap::new();

        let result = generate_container(
            &container_node,
            "container",
            &model_ident,
            &message_ident,
            &style_classes,
        )
        .unwrap();
        let code = result.to_string();

        // Should contain style closure (note: quote! adds spaces)
        assert!(code.contains("style"));
        assert!(code.contains("container :: Style"));
        assert!(code.contains("background"));
        assert!(code.contains("border"));
    }
}