presentar_test/

a11y.rs

//! Accessibility checking for WCAG 2.1 compliance.
//!
//! Implements comprehensive WCAG 2.1 AA checks including:
//! - Color contrast (1.4.3, 1.4.6)
//! - Keyboard accessibility (2.1.1)
//! - Focus indicators (2.4.7)
//! - Touch target size (2.5.5)
//! - Name/role/value (4.1.2)
//! - Heading hierarchy (1.3.1)

use presentar_core::widget::AccessibleRole;
use presentar_core::{Color, Widget};

/// Minimum touch target size in pixels (WCAG 2.5.5)
pub const MIN_TOUCH_TARGET_SIZE: f32 = 44.0;

/// Minimum focus indicator area (WCAG 2.4.11)
pub const MIN_FOCUS_INDICATOR_AREA: f32 = 2.0;

/// Accessibility checker.
pub struct A11yChecker;

impl A11yChecker {
    /// Check a widget tree for accessibility violations.
    #[must_use]
    pub fn check(widget: &dyn Widget) -> A11yReport {
        let mut violations = Vec::new();
        let mut context = CheckContext::default();
        Self::check_widget(widget, &mut violations, &mut context);
        A11yReport { violations }
    }

    /// Check with custom configuration.
    #[must_use]
    pub fn check_with_config(widget: &dyn Widget, config: &A11yConfig) -> A11yReport {
        let mut violations = Vec::new();
        let mut context = CheckContext {
            check_touch_targets: config.check_touch_targets,
            check_heading_hierarchy: config.check_heading_hierarchy,
            check_focus_indicators: config.check_focus_indicators,
            ..Default::default()
        };
        Self::check_widget(widget, &mut violations, &mut context);
        A11yReport { violations }
    }

    fn check_widget(
        widget: &dyn Widget,
        violations: &mut Vec<A11yViolation>,
        context: &mut CheckContext,
    ) {
        // Check for missing accessible name on interactive elements (WCAG 4.1.2)
        if widget.is_interactive() && widget.accessible_name().is_none() {
            violations.push(A11yViolation {
                rule: "aria-label".to_string(),
                message: "Interactive element missing accessible name".to_string(),
                wcag: "4.1.2".to_string(),
                impact: Impact::Critical,
            });
        }

        // Check for keyboard focusable elements (WCAG 2.1.1)
        if widget.is_interactive() && !widget.is_focusable() {
            violations.push(A11yViolation {
                rule: "keyboard".to_string(),
                message: "Interactive element is not keyboard focusable".to_string(),
                wcag: "2.1.1".to_string(),
                impact: Impact::Critical,
            });
        }

        // Check touch target size (WCAG 2.5.5)
        if context.check_touch_targets && widget.is_interactive() {
            let bounds = widget.bounds();
            if bounds.width < MIN_TOUCH_TARGET_SIZE || bounds.height < MIN_TOUCH_TARGET_SIZE {
                violations.push(A11yViolation {
                    rule: "touch-target".to_string(),
                    message: format!(
                        "Touch target too small: {}x{} (minimum {}x{})",
                        bounds.width, bounds.height, MIN_TOUCH_TARGET_SIZE, MIN_TOUCH_TARGET_SIZE
                    ),
                    wcag: "2.5.5".to_string(),
                    impact: Impact::Moderate,
                });
            }
        }

        // Check heading hierarchy (WCAG 1.3.1)
        if context.check_heading_hierarchy && widget.accessible_role() == AccessibleRole::Heading {
            if let Some(level) = Self::heading_level(widget) {
                let last_level = context.last_heading_level;
                if last_level > 0 && level > last_level + 1 {
                    violations.push(A11yViolation {
                        rule: "heading-order".to_string(),
                        message: format!(
                            "Heading level skipped: h{} followed by h{} (should be h{} or lower)",
                            last_level,
                            level,
                            last_level + 1
                        ),
                        wcag: "1.3.1".to_string(),
                        impact: Impact::Moderate,
                    });
                }
                context.last_heading_level = level;
            }
        }

        // Check focus indicator visibility (WCAG 2.4.7)
        if context.check_focus_indicators && widget.is_focusable() {
            if !Self::has_visible_focus_indicator(widget) {
                violations.push(A11yViolation {
                    rule: "focus-visible".to_string(),
                    message: "Focusable element may lack visible focus indicator".to_string(),
                    wcag: "2.4.7".to_string(),
                    impact: Impact::Serious,
                });
            }
        }

        // Check for images without alt text (WCAG 1.1.1)
        if widget.accessible_role() == AccessibleRole::Image && widget.accessible_name().is_none() {
            violations.push(A11yViolation {
                rule: "image-alt".to_string(),
                message: "Image missing alternative text".to_string(),
                wcag: "1.1.1".to_string(),
                impact: Impact::Critical,
            });
        }

        // Recurse into children
        for child in widget.children() {
            Self::check_widget(child.as_ref(), violations, context);
        }
    }

    /// Extract heading level from widget (if it's a heading)
    fn heading_level(widget: &dyn Widget) -> Option<u8> {
        // Check if the accessible name contains heading level info
        // Or use aria-level if available
        if let Some(name) = widget.accessible_name() {
            // Try to extract from pattern like "Heading Level 2" or "h2"
            if name.starts_with('h') || name.starts_with('H') {
                if let Ok(level) = name[1..2].parse::<u8>() {
                    if (1..=6).contains(&level) {
                        return Some(level);
                    }
                }
            }
        }
        // Default to level 2 if we can't determine
        Some(2)
    }

    /// Check if widget has a visible focus indicator
    fn has_visible_focus_indicator(widget: &dyn Widget) -> bool {
        // For now, assume all focusable widgets have focus indicators
        // In a real implementation, we'd check for focus ring styles
        widget.is_focusable()
    }

    /// Check contrast ratio between foreground and background colors.
    #[must_use]
    pub fn check_contrast(
        foreground: &Color,
        background: &Color,
        large_text: bool,
    ) -> ContrastResult {
        let ratio = foreground.contrast_ratio(background);

        // WCAG 2.1 thresholds
        let (aa_threshold, aaa_threshold) = if large_text {
            (3.0, 4.5) // Large text (14pt bold or 18pt regular)
        } else {
            (4.5, 7.0) // Normal text
        };

        ContrastResult {
            ratio,
            passes_aa: ratio >= aa_threshold,
            passes_aaa: ratio >= aaa_threshold,
        }
    }
}

/// Accessibility report.
#[derive(Debug)]
pub struct A11yReport {
    /// List of violations found
    pub violations: Vec<A11yViolation>,
}

impl A11yReport {
    /// Check if all accessibility tests passed.
    #[must_use]
    pub fn is_passing(&self) -> bool {
        self.violations.is_empty()
    }

    /// Get critical violations only.
    #[must_use]
    pub fn critical(&self) -> Vec<&A11yViolation> {
        self.violations
            .iter()
            .filter(|v| v.impact == Impact::Critical)
            .collect()
    }

    /// Assert that all accessibility tests pass.
    ///
    /// # Panics
    ///
    /// Panics if there are any violations.
    pub fn assert_pass(&self) {
        if !self.is_passing() {
            let messages: Vec<String> = self
                .violations
                .iter()
                .map(|v| {
                    format!(
                        "  [{:?}] {}: {} (WCAG {})",
                        v.impact, v.rule, v.message, v.wcag
                    )
                })
                .collect();

            panic!(
                "Accessibility check failed with {} violation(s):\n{}",
                self.violations.len(),
                messages.join("\n")
            );
        }
    }
}

/// A single accessibility violation.
#[derive(Debug, Clone)]
pub struct A11yViolation {
    /// Rule that was violated
    pub rule: String,
    /// Human-readable message
    pub message: String,
    /// WCAG success criterion
    pub wcag: String,
    /// Impact level
    pub impact: Impact,
}

/// Impact level of an accessibility violation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Impact {
    /// Minor issue
    Minor,
    /// Moderate issue
    Moderate,
    /// Serious issue
    Serious,
    /// Critical issue - must fix
    Critical,
}

/// Configuration for accessibility checks.
#[derive(Debug, Clone)]
pub struct A11yConfig {
    /// Check touch target sizes (WCAG 2.5.5)
    pub check_touch_targets: bool,
    /// Check heading hierarchy (WCAG 1.3.1)
    pub check_heading_hierarchy: bool,
    /// Check focus indicators (WCAG 2.4.7)
    pub check_focus_indicators: bool,
    /// Minimum contrast ratio for normal text (WCAG 1.4.3)
    pub min_contrast_normal: f32,
    /// Minimum contrast ratio for large text (WCAG 1.4.3)
    pub min_contrast_large: f32,
}

impl Default for A11yConfig {
    fn default() -> Self {
        Self {
            check_touch_targets: true,
            check_heading_hierarchy: true,
            check_focus_indicators: false, // Disabled by default as requires style info
            min_contrast_normal: 4.5,
            min_contrast_large: 3.0,
        }
    }
}

impl A11yConfig {
    /// Create a new config with all checks enabled.
    #[must_use]
    pub fn strict() -> Self {
        Self {
            check_touch_targets: true,
            check_heading_hierarchy: true,
            check_focus_indicators: true,
            min_contrast_normal: 7.0, // AAA level
            min_contrast_large: 4.5,  // AAA level
        }
    }

    /// Create a config for mobile apps.
    #[must_use]
    pub fn mobile() -> Self {
        Self {
            check_touch_targets: true,
            check_heading_hierarchy: true,
            check_focus_indicators: false,
            min_contrast_normal: 4.5,
            min_contrast_large: 3.0,
        }
    }
}

/// Internal context for walking the widget tree.
#[derive(Debug, Default)]
struct CheckContext {
    /// Last heading level seen (for hierarchy check)
    last_heading_level: u8,
    /// Whether to check touch target sizes
    check_touch_targets: bool,
    /// Whether to check heading hierarchy
    check_heading_hierarchy: bool,
    /// Whether to check focus indicators
    check_focus_indicators: bool,
}

/// Result of a contrast check.
#[derive(Debug, Clone)]
pub struct ContrastResult {
    /// Calculated contrast ratio
    pub ratio: f32,
    /// Passes WCAG AA
    pub passes_aa: bool,
    /// Passes WCAG AAA
    pub passes_aaa: bool,
}

// =============================================================================
// ARIA Attribute Generation
// =============================================================================

/// ARIA attributes for a widget.
#[derive(Debug, Clone, Default)]
pub struct AriaAttributes {
    /// The ARIA role
    pub role: Option<String>,
    /// Accessible label
    pub label: Option<String>,
    /// Accessible description
    pub described_by: Option<String>,
    /// Whether element is hidden from accessibility tree
    pub hidden: bool,
    /// Whether element is expanded (for expandable elements)
    pub expanded: Option<bool>,
    /// Whether element is selected
    pub selected: Option<bool>,
    /// Whether element is checked (for checkboxes/switches)
    pub checked: Option<AriaChecked>,
    /// Whether element is pressed (for toggle buttons)
    pub pressed: Option<AriaChecked>,
    /// Whether element is disabled
    pub disabled: bool,
    /// Whether element is required
    pub required: bool,
    /// Whether element is invalid
    pub invalid: bool,
    /// Current value for range widgets
    pub value_now: Option<f64>,
    /// Minimum value for range widgets
    pub value_min: Option<f64>,
    /// Maximum value for range widgets
    pub value_max: Option<f64>,
    /// Text representation of value
    pub value_text: Option<String>,
    /// Level (for headings)
    pub level: Option<u8>,
    /// Position in set
    pub pos_in_set: Option<u32>,
    /// Set size
    pub set_size: Option<u32>,
    /// Controls another element (ID reference)
    pub controls: Option<String>,
    /// Has popup indicator
    pub has_popup: Option<String>,
    /// Is busy/loading
    pub busy: bool,
    /// Live region politeness
    pub live: Option<AriaLive>,
    /// Atomic live region
    pub atomic: bool,
}

/// ARIA checked state.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AriaChecked {
    /// Checked
    True,
    /// Not checked
    False,
    /// Mixed/indeterminate
    Mixed,
}

impl AriaChecked {
    /// Return string representation.
    #[must_use]
    pub const fn as_str(&self) -> &'static str {
        match self {
            AriaChecked::True => "true",
            AriaChecked::False => "false",
            AriaChecked::Mixed => "mixed",
        }
    }
}

/// ARIA live region politeness.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AriaLive {
    /// Polite announcements
    Polite,
    /// Assertive announcements
    Assertive,
    /// No announcements
    Off,
}

impl AriaLive {
    /// Return string representation.
    #[must_use]
    pub const fn as_str(&self) -> &'static str {
        match self {
            AriaLive::Polite => "polite",
            AriaLive::Assertive => "assertive",
            AriaLive::Off => "off",
        }
    }
}

impl AriaAttributes {
    /// Create new empty ARIA attributes.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the role.
    #[must_use]
    pub fn with_role(mut self, role: impl Into<String>) -> Self {
        self.role = Some(role.into());
        self
    }

    /// Set the label.
    #[must_use]
    pub fn with_label(mut self, label: impl Into<String>) -> Self {
        self.label = Some(label.into());
        self
    }

    /// Set hidden.
    #[must_use]
    pub const fn with_hidden(mut self, hidden: bool) -> Self {
        self.hidden = hidden;
        self
    }

    /// Set expanded state.
    #[must_use]
    pub const fn with_expanded(mut self, expanded: bool) -> Self {
        self.expanded = Some(expanded);
        self
    }

    /// Set selected state.
    #[must_use]
    pub const fn with_selected(mut self, selected: bool) -> Self {
        self.selected = Some(selected);
        self
    }

    /// Set checked state.
    #[must_use]
    pub const fn with_checked(mut self, checked: AriaChecked) -> Self {
        self.checked = Some(checked);
        self
    }

    /// Set pressed state (for toggle buttons).
    #[must_use]
    pub const fn with_pressed(mut self, pressed: AriaChecked) -> Self {
        self.pressed = Some(pressed);
        self
    }

    /// Set disabled state.
    #[must_use]
    pub const fn with_disabled(mut self, disabled: bool) -> Self {
        self.disabled = disabled;
        self
    }

    /// Set busy state.
    #[must_use]
    pub const fn with_busy(mut self, busy: bool) -> Self {
        self.busy = busy;
        self
    }

    /// Set atomic.
    #[must_use]
    pub const fn with_atomic(mut self, atomic: bool) -> Self {
        self.atomic = atomic;
        self
    }

    /// Set range values.
    #[must_use]
    pub fn with_range(mut self, min: f64, max: f64, now: f64) -> Self {
        self.value_min = Some(min);
        self.value_max = Some(max);
        self.value_now = Some(now);
        self
    }

    /// Set current value.
    #[must_use]
    pub const fn with_value_now(mut self, value: f64) -> Self {
        self.value_now = Some(value);
        self
    }

    /// Set minimum value.
    #[must_use]
    pub const fn with_value_min(mut self, value: f64) -> Self {
        self.value_min = Some(value);
        self
    }

    /// Set maximum value.
    #[must_use]
    pub const fn with_value_max(mut self, value: f64) -> Self {
        self.value_max = Some(value);
        self
    }

    /// Set controls reference.
    #[must_use]
    pub fn with_controls(mut self, controls: impl Into<String>) -> Self {
        self.controls = Some(controls.into());
        self
    }

    /// Set described by reference.
    #[must_use]
    pub fn with_described_by(mut self, described_by: impl Into<String>) -> Self {
        self.described_by = Some(described_by.into());
        self
    }

    /// Set has popup.
    #[must_use]
    pub fn with_has_popup(mut self, has_popup: impl Into<String>) -> Self {
        self.has_popup = Some(has_popup.into());
        self
    }

    /// Set heading level.
    #[must_use]
    pub const fn with_level(mut self, level: u8) -> Self {
        self.level = Some(level);
        self
    }

    /// Set position in set.
    #[must_use]
    pub const fn with_pos_in_set(mut self, pos: u32, size: u32) -> Self {
        self.pos_in_set = Some(pos);
        self.set_size = Some(size);
        self
    }

    /// Set live region.
    #[must_use]
    pub const fn with_live(mut self, live: AriaLive) -> Self {
        self.live = Some(live);
        self
    }

    /// Generate HTML ARIA attributes.
    #[must_use]
    pub fn to_html_attrs(&self) -> Vec<(String, String)> {
        let mut attrs = Vec::new();

        if let Some(ref role) = self.role {
            attrs.push(("role".to_string(), role.clone()));
        }
        if let Some(ref label) = self.label {
            attrs.push(("aria-label".to_string(), label.clone()));
        }
        if let Some(ref desc) = self.described_by {
            attrs.push(("aria-describedby".to_string(), desc.clone()));
        }
        if self.hidden {
            attrs.push(("aria-hidden".to_string(), "true".to_string()));
        }
        if let Some(expanded) = self.expanded {
            attrs.push(("aria-expanded".to_string(), expanded.to_string()));
        }
        if let Some(selected) = self.selected {
            attrs.push(("aria-selected".to_string(), selected.to_string()));
        }
        if let Some(checked) = self.checked {
            attrs.push(("aria-checked".to_string(), checked.as_str().to_string()));
        }
        if let Some(pressed) = self.pressed {
            attrs.push(("aria-pressed".to_string(), pressed.as_str().to_string()));
        }
        if let Some(ref popup) = self.has_popup {
            attrs.push(("aria-haspopup".to_string(), popup.clone()));
        }
        if self.disabled {
            attrs.push(("aria-disabled".to_string(), "true".to_string()));
        }
        if self.required {
            attrs.push(("aria-required".to_string(), "true".to_string()));
        }
        if self.invalid {
            attrs.push(("aria-invalid".to_string(), "true".to_string()));
        }
        if let Some(val) = self.value_now {
            attrs.push(("aria-valuenow".to_string(), val.to_string()));
        }
        if let Some(val) = self.value_min {
            attrs.push(("aria-valuemin".to_string(), val.to_string()));
        }
        if let Some(val) = self.value_max {
            attrs.push(("aria-valuemax".to_string(), val.to_string()));
        }
        if let Some(ref text) = self.value_text {
            attrs.push(("aria-valuetext".to_string(), text.clone()));
        }
        if let Some(level) = self.level {
            attrs.push(("aria-level".to_string(), level.to_string()));
        }
        if let Some(pos) = self.pos_in_set {
            attrs.push(("aria-posinset".to_string(), pos.to_string()));
        }
        if let Some(size) = self.set_size {
            attrs.push(("aria-setsize".to_string(), size.to_string()));
        }
        if let Some(ref controls) = self.controls {
            attrs.push(("aria-controls".to_string(), controls.clone()));
        }
        if self.busy {
            attrs.push(("aria-busy".to_string(), "true".to_string()));
        }
        if let Some(live) = self.live {
            attrs.push(("aria-live".to_string(), live.as_str().to_string()));
        }
        if self.atomic {
            attrs.push(("aria-atomic".to_string(), "true".to_string()));
        }

        attrs
    }

    /// Generate HTML attribute string.
    #[must_use]
    pub fn to_html_string(&self) -> String {
        self.to_html_attrs()
            .into_iter()
            .map(|(k, v)| {
                // Escape HTML special characters in values
                let escaped = v
                    .replace('&', "&amp;")
                    .replace('"', "&quot;")
                    .replace('<', "&lt;")
                    .replace('>', "&gt;");
                format!("{}=\"{}\"", k, escaped)
            })
            .collect::<Vec<_>>()
            .join(" ")
    }
}

/// Generate ARIA attributes from a widget.
pub fn aria_from_widget(widget: &dyn Widget) -> AriaAttributes {
    use presentar_core::widget::AccessibleRole;

    let mut attrs = AriaAttributes::new();

    // Set role from widget
    let role = match widget.accessible_role() {
        AccessibleRole::Generic => None,
        AccessibleRole::Button => Some("button"),
        AccessibleRole::Checkbox => Some("checkbox"),
        AccessibleRole::TextInput => Some("textbox"),
        AccessibleRole::Link => Some("link"),
        AccessibleRole::Heading => Some("heading"),
        AccessibleRole::Image => Some("img"),
        AccessibleRole::List => Some("list"),
        AccessibleRole::ListItem => Some("listitem"),
        AccessibleRole::Table => Some("table"),
        AccessibleRole::TableRow => Some("row"),
        AccessibleRole::TableCell => Some("cell"),
        AccessibleRole::Menu => Some("menu"),
        AccessibleRole::MenuItem => Some("menuitem"),
        AccessibleRole::ComboBox => Some("combobox"),
        AccessibleRole::Slider => Some("slider"),
        AccessibleRole::ProgressBar => Some("progressbar"),
        AccessibleRole::Tab => Some("tab"),
        AccessibleRole::TabPanel => Some("tabpanel"),
        AccessibleRole::RadioGroup => Some("radiogroup"),
        AccessibleRole::Radio => Some("radio"),
    };

    if let Some(role) = role {
        attrs.role = Some(role.to_string());
    }

    // Set label from widget
    if let Some(name) = widget.accessible_name() {
        attrs.label = Some(name.to_string());
    }

    // Set disabled if not interactive but has a focusable role
    if !widget.is_interactive() && widget.accessible_role() != AccessibleRole::Generic {
        attrs.disabled = true;
    }

    attrs
}

// =============================================================================
// Form Accessibility Validation (WCAG 1.3.1, 1.3.5, 3.3.1, 3.3.2, 4.1.2)
// =============================================================================

/// Form accessibility checker for validating form-specific WCAG requirements.
pub struct FormA11yChecker;

impl FormA11yChecker {
    /// Check a form for accessibility violations.
    ///
    /// Validates:
    /// - Label associations (WCAG 1.3.1, 2.4.6)
    /// - Required field indicators (WCAG 3.3.2)
    /// - Error messaging (WCAG 3.3.1)
    /// - Input purpose/autocomplete (WCAG 1.3.5)
    /// - Form grouping (WCAG 1.3.1)
    #[must_use]
    pub fn check(form: &FormAccessibility) -> FormA11yReport {
        let mut violations = Vec::new();

        // Check all fields
        for field in &form.fields {
            Self::check_field(field, &mut violations);
        }

        // Check form-level requirements
        Self::check_form_level(form, &mut violations);

        FormA11yReport { violations }
    }

    /// Check a single form field.
    fn check_field(field: &FormFieldA11y, violations: &mut Vec<FormViolation>) {
        // WCAG 1.3.1, 2.4.6: Label association
        if field.label.is_none() && field.aria_label.is_none() && field.aria_labelledby.is_none() {
            violations.push(FormViolation {
                field_id: field.id.clone(),
                rule: FormA11yRule::MissingLabel,
                message: format!("Field '{}' has no associated label", field.id),
                wcag: "1.3.1, 2.4.6".to_string(),
                impact: Impact::Critical,
            });
        }

        // WCAG 3.3.2: Required field indicators
        if field.required {
            if !field.aria_required {
                violations.push(FormViolation {
                    field_id: field.id.clone(),
                    rule: FormA11yRule::MissingRequiredIndicator,
                    message: format!(
                        "Required field '{}' does not have aria-required=\"true\"",
                        field.id
                    ),
                    wcag: "3.3.2".to_string(),
                    impact: Impact::Serious,
                });
            }
            if !field.has_visual_required_indicator {
                violations.push(FormViolation {
                    field_id: field.id.clone(),
                    rule: FormA11yRule::MissingVisualRequired,
                    message: format!(
                        "Required field '{}' lacks visual required indicator (asterisk or text)",
                        field.id
                    ),
                    wcag: "3.3.2".to_string(),
                    impact: Impact::Moderate,
                });
            }
        }

        // WCAG 3.3.1: Error identification
        if field.has_error {
            if !field.aria_invalid {
                violations.push(FormViolation {
                    field_id: field.id.clone(),
                    rule: FormA11yRule::MissingErrorState,
                    message: format!(
                        "Field '{}' in error state does not have aria-invalid=\"true\"",
                        field.id
                    ),
                    wcag: "3.3.1".to_string(),
                    impact: Impact::Serious,
                });
            }
            if field.error_message.is_none() {
                violations.push(FormViolation {
                    field_id: field.id.clone(),
                    rule: FormA11yRule::MissingErrorMessage,
                    message: format!("Field '{}' in error state has no error message", field.id),
                    wcag: "3.3.1".to_string(),
                    impact: Impact::Serious,
                });
            }
            if field.aria_describedby.is_none() && field.aria_errormessage.is_none() {
                violations.push(FormViolation {
                    field_id: field.id.clone(),
                    rule: FormA11yRule::ErrorNotAssociated,
                    message: format!(
                        "Error message for '{}' not associated via aria-describedby or aria-errormessage",
                        field.id
                    ),
                    wcag: "3.3.1".to_string(),
                    impact: Impact::Serious,
                });
            }
        }

        // WCAG 1.3.5: Input purpose (autocomplete)
        if let Some(ref input_type) = field.input_type {
            if input_type.should_have_autocomplete() && field.autocomplete.is_none() {
                violations.push(FormViolation {
                    field_id: field.id.clone(),
                    rule: FormA11yRule::MissingAutocomplete,
                    message: format!(
                        "Field '{}' of type {:?} should have autocomplete attribute for autofill",
                        field.id, input_type
                    ),
                    wcag: "1.3.5".to_string(),
                    impact: Impact::Moderate,
                });
            }
        }

        // Check for placeholder-only labeling (anti-pattern)
        if field.placeholder.is_some() && field.label.is_none() && field.aria_label.is_none() {
            violations.push(FormViolation {
                field_id: field.id.clone(),
                rule: FormA11yRule::PlaceholderAsLabel,
                message: format!(
                    "Field '{}' uses placeholder as sole label; placeholders disappear on input",
                    field.id
                ),
                wcag: "3.3.2".to_string(),
                impact: Impact::Serious,
            });
        }
    }

    /// Check form-level accessibility requirements.
    fn check_form_level(form: &FormAccessibility, violations: &mut Vec<FormViolation>) {
        // Check for related fields that should be grouped (WCAG 1.3.1)
        let radio_fields: Vec<_> = form
            .fields
            .iter()
            .filter(|f| f.input_type == Some(InputType::Radio))
            .collect();

        if radio_fields.len() > 1 {
            // Radio buttons should be in a fieldset/group
            let has_group = form.field_groups.iter().any(|g| {
                g.field_ids
                    .iter()
                    .any(|id| radio_fields.iter().any(|f| &f.id == id))
            });

            if !has_group {
                violations.push(FormViolation {
                    field_id: "form".to_string(),
                    rule: FormA11yRule::RelatedFieldsNotGrouped,
                    message: "Related radio buttons should be grouped in a fieldset with legend"
                        .to_string(),
                    wcag: "1.3.1".to_string(),
                    impact: Impact::Moderate,
                });
            }
        }

        // Check field groups have legends
        for group in &form.field_groups {
            if group.legend.is_none() && group.aria_label.is_none() {
                violations.push(FormViolation {
                    field_id: group.id.clone(),
                    rule: FormA11yRule::GroupMissingLegend,
                    message: format!("Field group '{}' has no legend or aria-label", group.id),
                    wcag: "1.3.1".to_string(),
                    impact: Impact::Serious,
                });
            }
        }

        // Check form has accessible name
        if form.accessible_name.is_none() && form.aria_labelledby.is_none() {
            violations.push(FormViolation {
                field_id: "form".to_string(),
                rule: FormA11yRule::FormMissingName,
                message: "Form should have an accessible name (aria-label or aria-labelledby)"
                    .to_string(),
                wcag: "4.1.2".to_string(),
                impact: Impact::Moderate,
            });
        }
    }
}

/// Form accessibility data for validation.
#[derive(Debug, Clone, Default)]
pub struct FormAccessibility {
    /// Form's accessible name
    pub accessible_name: Option<String>,
    /// Referenced labelledby ID
    pub aria_labelledby: Option<String>,
    /// Form fields
    pub fields: Vec<FormFieldA11y>,
    /// Field groups (fieldsets)
    pub field_groups: Vec<FormFieldGroup>,
}

impl FormAccessibility {
    /// Create a new form accessibility descriptor.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Add a field.
    #[must_use]
    pub fn field(mut self, field: FormFieldA11y) -> Self {
        self.fields.push(field);
        self
    }

    /// Add a field group.
    #[must_use]
    pub fn group(mut self, group: FormFieldGroup) -> Self {
        self.field_groups.push(group);
        self
    }

    /// Set accessible name.
    #[must_use]
    pub fn with_name(mut self, name: impl Into<String>) -> Self {
        self.accessible_name = Some(name.into());
        self
    }
}

/// Form field accessibility descriptor.
#[derive(Debug, Clone, Default)]
pub struct FormFieldA11y {
    /// Field ID
    pub id: String,
    /// Associated label text
    pub label: Option<String>,
    /// Input type
    pub input_type: Option<InputType>,
    /// Is required
    pub required: bool,
    /// Has visual required indicator
    pub has_visual_required_indicator: bool,
    /// aria-required attribute
    pub aria_required: bool,
    /// aria-label attribute
    pub aria_label: Option<String>,
    /// aria-labelledby attribute
    pub aria_labelledby: Option<String>,
    /// aria-describedby attribute
    pub aria_describedby: Option<String>,
    /// Has error state
    pub has_error: bool,
    /// aria-invalid attribute
    pub aria_invalid: bool,
    /// aria-errormessage attribute
    pub aria_errormessage: Option<String>,
    /// Error message text
    pub error_message: Option<String>,
    /// Autocomplete attribute
    pub autocomplete: Option<AutocompleteValue>,
    /// Placeholder text
    pub placeholder: Option<String>,
}

impl FormFieldA11y {
    /// Create a new field.
    #[must_use]
    pub fn new(id: impl Into<String>) -> Self {
        Self {
            id: id.into(),
            ..Default::default()
        }
    }

    /// Set label.
    #[must_use]
    pub fn with_label(mut self, label: impl Into<String>) -> Self {
        self.label = Some(label.into());
        self
    }

    /// Set input type.
    #[must_use]
    pub fn with_type(mut self, input_type: InputType) -> Self {
        self.input_type = Some(input_type);
        self
    }

    /// Mark as required.
    #[must_use]
    pub fn required(mut self) -> Self {
        self.required = true;
        self.aria_required = true;
        self.has_visual_required_indicator = true;
        self
    }

    /// Set required with specific options.
    #[must_use]
    pub fn with_required(mut self, visual: bool, aria: bool) -> Self {
        self.required = true;
        self.has_visual_required_indicator = visual;
        self.aria_required = aria;
        self
    }

    /// Set error state.
    #[must_use]
    pub fn with_error(mut self, message: impl Into<String>, associated: bool) -> Self {
        self.has_error = true;
        self.aria_invalid = true;
        self.error_message = Some(message.into());
        if associated {
            self.aria_describedby = Some(format!("{}-error", self.id));
        }
        self
    }

    /// Set autocomplete.
    #[must_use]
    pub fn with_autocomplete(mut self, value: AutocompleteValue) -> Self {
        self.autocomplete = Some(value);
        self
    }

    /// Set placeholder.
    #[must_use]
    pub fn with_placeholder(mut self, placeholder: impl Into<String>) -> Self {
        self.placeholder = Some(placeholder.into());
        self
    }

    /// Set aria-label.
    #[must_use]
    pub fn with_aria_label(mut self, label: impl Into<String>) -> Self {
        self.aria_label = Some(label.into());
        self
    }
}

/// Form field group (fieldset).
#[derive(Debug, Clone, Default)]
pub struct FormFieldGroup {
    /// Group ID
    pub id: String,
    /// Legend text
    pub legend: Option<String>,
    /// aria-label (alternative to legend)
    pub aria_label: Option<String>,
    /// Field IDs in this group
    pub field_ids: Vec<String>,
}

impl FormFieldGroup {
    /// Create a new field group.
    #[must_use]
    pub fn new(id: impl Into<String>) -> Self {
        Self {
            id: id.into(),
            ..Default::default()
        }
    }

    /// Set legend.
    #[must_use]
    pub fn with_legend(mut self, legend: impl Into<String>) -> Self {
        self.legend = Some(legend.into());
        self
    }

    /// Add field ID to group.
    #[must_use]
    pub fn with_field(mut self, field_id: impl Into<String>) -> Self {
        self.field_ids.push(field_id.into());
        self
    }
}

/// Input type for form fields.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InputType {
    Text,
    Email,
    Password,
    Tel,
    Url,
    Number,
    Date,
    Time,
    Search,
    Radio,
    Checkbox,
    Select,
    Textarea,
    Hidden,
}

impl InputType {
    /// Check if this input type should have autocomplete for WCAG 1.3.5.
    #[must_use]
    pub const fn should_have_autocomplete(&self) -> bool {
        matches!(
            self,
            Self::Text | Self::Email | Self::Password | Self::Tel | Self::Url | Self::Number
        )
    }
}

/// Autocomplete attribute values (WCAG 1.3.5).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AutocompleteValue {
    /// User's name
    Name,
    /// Given (first) name
    GivenName,
    /// Family (last) name
    FamilyName,
    /// Email address
    Email,
    /// Telephone number
    Tel,
    /// Street address
    StreetAddress,
    /// Address level 1 (city)
    AddressLevel1,
    /// Address level 2 (state/province)
    AddressLevel2,
    /// Postal code
    PostalCode,
    /// Country name
    Country,
    /// Organization
    Organization,
    /// Username
    Username,
    /// Current password
    CurrentPassword,
    /// New password
    NewPassword,
    /// Credit card number
    CcNumber,
    /// Credit card expiration
    CcExp,
    /// Credit card CVV
    CcCsc,
    /// One-time code
    OneTimeCode,
    /// Turn off autocomplete
    Off,
}

impl AutocompleteValue {
    /// Get the HTML attribute value.
    #[must_use]
    pub const fn as_str(&self) -> &'static str {
        match self {
            Self::Name => "name",
            Self::GivenName => "given-name",
            Self::FamilyName => "family-name",
            Self::Email => "email",
            Self::Tel => "tel",
            Self::StreetAddress => "street-address",
            Self::AddressLevel1 => "address-level1",
            Self::AddressLevel2 => "address-level2",
            Self::PostalCode => "postal-code",
            Self::Country => "country",
            Self::Organization => "organization",
            Self::Username => "username",
            Self::CurrentPassword => "current-password",
            Self::NewPassword => "new-password",
            Self::CcNumber => "cc-number",
            Self::CcExp => "cc-exp",
            Self::CcCsc => "cc-csc",
            Self::OneTimeCode => "one-time-code",
            Self::Off => "off",
        }
    }
}

/// Form accessibility violation rule.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FormA11yRule {
    /// Field missing label (1.3.1, 2.4.6)
    MissingLabel,
    /// Required field missing aria-required (3.3.2)
    MissingRequiredIndicator,
    /// Required field missing visual indicator (3.3.2)
    MissingVisualRequired,
    /// Error field missing aria-invalid (3.3.1)
    MissingErrorState,
    /// Error field missing error message (3.3.1)
    MissingErrorMessage,
    /// Error message not associated (3.3.1)
    ErrorNotAssociated,
    /// Field should have autocomplete (1.3.5)
    MissingAutocomplete,
    /// Placeholder used as sole label (3.3.2)
    PlaceholderAsLabel,
    /// Related fields not grouped (1.3.1)
    RelatedFieldsNotGrouped,
    /// Field group missing legend (1.3.1)
    GroupMissingLegend,
    /// Form missing accessible name (4.1.2)
    FormMissingName,
}

impl FormA11yRule {
    /// Get the rule name.
    #[must_use]
    pub const fn name(&self) -> &'static str {
        match self {
            Self::MissingLabel => "missing-label",
            Self::MissingRequiredIndicator => "missing-required-indicator",
            Self::MissingVisualRequired => "missing-visual-required",
            Self::MissingErrorState => "missing-error-state",
            Self::MissingErrorMessage => "missing-error-message",
            Self::ErrorNotAssociated => "error-not-associated",
            Self::MissingAutocomplete => "missing-autocomplete",
            Self::PlaceholderAsLabel => "placeholder-as-label",
            Self::RelatedFieldsNotGrouped => "related-fields-not-grouped",
            Self::GroupMissingLegend => "group-missing-legend",
            Self::FormMissingName => "form-missing-name",
        }
    }
}

/// Form accessibility violation.
#[derive(Debug, Clone)]
pub struct FormViolation {
    /// Field ID where violation occurred
    pub field_id: String,
    /// Rule that was violated
    pub rule: FormA11yRule,
    /// Human-readable message
    pub message: String,
    /// WCAG success criterion
    pub wcag: String,
    /// Impact level
    pub impact: Impact,
}

/// Form accessibility report.
#[derive(Debug)]
pub struct FormA11yReport {
    /// List of violations
    pub violations: Vec<FormViolation>,
}

impl FormA11yReport {
    /// Check if form passes accessibility.
    #[must_use]
    pub fn is_passing(&self) -> bool {
        self.violations.is_empty()
    }

    /// Check if form passes with no critical/serious issues.
    #[must_use]
    pub fn is_acceptable(&self) -> bool {
        !self
            .violations
            .iter()
            .any(|v| matches!(v.impact, Impact::Critical | Impact::Serious))
    }

    /// Get violations by rule.
    #[must_use]
    pub fn violations_for_rule(&self, rule: FormA11yRule) -> Vec<&FormViolation> {
        self.violations.iter().filter(|v| v.rule == rule).collect()
    }

    /// Get violations for a specific field.
    #[must_use]
    pub fn violations_for_field(&self, field_id: &str) -> Vec<&FormViolation> {
        self.violations
            .iter()
            .filter(|v| v.field_id == field_id)
            .collect()
    }

    /// Assert form passes accessibility.
    ///
    /// # Panics
    ///
    /// Panics with violation details if form fails accessibility checks.
    pub fn assert_pass(&self) {
        if !self.is_passing() {
            let messages: Vec<String> = self
                .violations
                .iter()
                .map(|v| {
                    format!(
                        "  [{:?}] {} ({}): {} (WCAG {})",
                        v.impact,
                        v.rule.name(),
                        v.field_id,
                        v.message,
                        v.wcag
                    )
                })
                .collect();

            panic!(
                "Form accessibility check failed with {} violation(s):\n{}",
                self.violations.len(),
                messages.join("\n")
            );
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use presentar_core::{
        widget::{AccessibleRole, LayoutResult},
        Canvas, Constraints, Event, Rect, Size, TypeId,
    };
    use std::any::Any;

    // Mock interactive widget
    struct MockButton {
        accessible_name: Option<String>,
        focusable: bool,
    }

    impl MockButton {
        fn new() -> Self {
            Self {
                accessible_name: None,
                focusable: true,
            }
        }

        fn with_name(mut self, name: &str) -> Self {
            self.accessible_name = Some(name.to_string());
            self
        }

        fn not_focusable(mut self) -> Self {
            self.focusable = false;
            self
        }
    }

    impl Widget for MockButton {
        fn type_id(&self) -> TypeId {
            TypeId::of::<Self>()
        }
        fn measure(&self, c: Constraints) -> Size {
            c.smallest()
        }
        fn layout(&mut self, b: Rect) -> LayoutResult {
            LayoutResult { size: b.size() }
        }
        fn paint(&self, _: &mut dyn Canvas) {}
        fn event(&mut self, _: &Event) -> Option<Box<dyn Any + Send>> {
            None
        }
        fn children(&self) -> &[Box<dyn Widget>] {
            &[]
        }
        fn children_mut(&mut self) -> &mut [Box<dyn Widget>] {
            &mut []
        }
        fn is_interactive(&self) -> bool {
            true
        }
        fn is_focusable(&self) -> bool {
            self.focusable
        }
        fn accessible_name(&self) -> Option<&str> {
            self.accessible_name.as_deref()
        }
        fn accessible_role(&self) -> AccessibleRole {
            AccessibleRole::Button
        }
    }

    #[test]
    fn test_a11y_passing() {
        let widget = MockButton::new().with_name("Submit");
        let report = A11yChecker::check(&widget);
        assert!(report.is_passing());
    }

    #[test]
    fn test_a11y_missing_name() {
        let widget = MockButton::new();
        let report = A11yChecker::check(&widget);
        assert!(!report.is_passing());
        assert_eq!(report.violations.len(), 1);
        assert_eq!(report.violations[0].rule, "aria-label");
    }

    #[test]
    fn test_a11y_not_focusable() {
        let widget = MockButton::new().with_name("OK").not_focusable();
        let report = A11yChecker::check(&widget);
        assert!(!report.is_passing());
        assert!(report.violations.iter().any(|v| v.rule == "keyboard"));
    }

    #[test]
    fn test_contrast_black_white() {
        let result = A11yChecker::check_contrast(&Color::BLACK, &Color::WHITE, false);
        assert!(result.passes_aa);
        assert!(result.passes_aaa);
        assert!((result.ratio - 21.0).abs() < 0.5);
    }

    #[test]
    fn test_contrast_low() {
        let light_gray = Color::rgb(0.7, 0.7, 0.7);
        let white = Color::WHITE;
        let result = A11yChecker::check_contrast(&light_gray, &white, false);
        assert!(!result.passes_aa);
    }

    #[test]
    fn test_contrast_large_text_threshold() {
        // Gray that passes AA for large text but not for normal text
        let gray = Color::rgb(0.5, 0.5, 0.5);
        let white = Color::WHITE;

        let normal = A11yChecker::check_contrast(&gray, &white, false);
        let large = A11yChecker::check_contrast(&gray, &white, true);

        // Large text has lower threshold, should pass more easily
        assert!(large.passes_aa || large.ratio > normal.ratio - 1.0);
    }

    #[test]
    fn test_report_critical() {
        let widget = MockButton::new().not_focusable();
        let report = A11yChecker::check(&widget);
        let critical = report.critical();
        assert!(!critical.is_empty());
    }

    #[test]
    #[should_panic(expected = "Accessibility check failed")]
    fn test_assert_pass_fails() {
        let widget = MockButton::new();
        let report = A11yChecker::check(&widget);
        report.assert_pass();
    }

    // =============================================================================
    // AriaAttributes tests
    // =============================================================================

    #[test]
    fn test_aria_attributes_new() {
        let attrs = AriaAttributes::new();
        assert!(attrs.role.is_none());
        assert!(attrs.label.is_none());
        assert!(!attrs.disabled);
    }

    #[test]
    fn test_aria_attributes_with_role() {
        let attrs = AriaAttributes::new().with_role("button");
        assert_eq!(attrs.role, Some("button".to_string()));
    }

    #[test]
    fn test_aria_attributes_with_label() {
        let attrs = AriaAttributes::new().with_label("Submit form");
        assert_eq!(attrs.label, Some("Submit form".to_string()));
    }

    #[test]
    fn test_aria_attributes_with_expanded() {
        let attrs = AriaAttributes::new().with_expanded(true);
        assert_eq!(attrs.expanded, Some(true));
    }

    #[test]
    fn test_aria_attributes_with_checked() {
        let attrs = AriaAttributes::new().with_checked(AriaChecked::True);
        assert_eq!(attrs.checked, Some(AriaChecked::True));
    }

    #[test]
    fn test_aria_attributes_with_disabled() {
        let attrs = AriaAttributes::new().with_disabled(true);
        assert!(attrs.disabled);
    }

    #[test]
    fn test_aria_attributes_with_value() {
        let attrs = AriaAttributes::new()
            .with_value_min(0.0)
            .with_value_max(100.0)
            .with_value_now(50.0);
        assert_eq!(attrs.value_min, Some(0.0));
        assert_eq!(attrs.value_max, Some(100.0));
        assert_eq!(attrs.value_now, Some(50.0));
    }

    #[test]
    fn test_aria_attributes_with_live() {
        let attrs = AriaAttributes::new().with_live(AriaLive::Polite);
        assert_eq!(attrs.live, Some(AriaLive::Polite));
    }

    #[test]
    fn test_aria_attributes_with_busy() {
        let attrs = AriaAttributes::new().with_busy(true);
        assert!(attrs.busy);
    }

    #[test]
    fn test_aria_attributes_with_atomic() {
        let attrs = AriaAttributes::new().with_atomic(true);
        assert!(attrs.atomic);
    }

    #[test]
    fn test_aria_attributes_with_has_popup() {
        let attrs = AriaAttributes::new().with_has_popup("menu");
        assert_eq!(attrs.has_popup, Some("menu".to_string()));
    }

    #[test]
    fn test_aria_attributes_with_controls() {
        let attrs = AriaAttributes::new().with_controls("panel-1");
        assert_eq!(attrs.controls, Some("panel-1".to_string()));
    }

    #[test]
    fn test_aria_attributes_with_described_by() {
        let attrs = AriaAttributes::new().with_described_by("desc-1");
        assert_eq!(attrs.described_by, Some("desc-1".to_string()));
    }

    #[test]
    fn test_aria_attributes_with_hidden() {
        let attrs = AriaAttributes::new().with_hidden(true);
        assert!(attrs.hidden);
    }

    #[test]
    fn test_aria_attributes_with_pressed() {
        let attrs = AriaAttributes::new().with_pressed(AriaChecked::Mixed);
        assert_eq!(attrs.pressed, Some(AriaChecked::Mixed));
    }

    #[test]
    fn test_aria_attributes_with_selected() {
        let attrs = AriaAttributes::new().with_selected(true);
        assert_eq!(attrs.selected, Some(true));
    }

    #[test]
    fn test_aria_attributes_with_level() {
        let attrs = AriaAttributes::new().with_level(2);
        assert_eq!(attrs.level, Some(2));
    }

    #[test]
    fn test_aria_attributes_chained_builder() {
        let attrs = AriaAttributes::new()
            .with_role("checkbox")
            .with_label("Accept terms")
            .with_checked(AriaChecked::False)
            .with_disabled(false);

        assert_eq!(attrs.role, Some("checkbox".to_string()));
        assert_eq!(attrs.label, Some("Accept terms".to_string()));
        assert_eq!(attrs.checked, Some(AriaChecked::False));
        assert!(!attrs.disabled);
    }

    // =============================================================================
    // AriaChecked tests
    // =============================================================================

    #[test]
    fn test_aria_checked_as_str() {
        assert_eq!(AriaChecked::True.as_str(), "true");
        assert_eq!(AriaChecked::False.as_str(), "false");
        assert_eq!(AriaChecked::Mixed.as_str(), "mixed");
    }

    // =============================================================================
    // AriaLive tests
    // =============================================================================

    #[test]
    fn test_aria_live_as_str() {
        assert_eq!(AriaLive::Off.as_str(), "off");
        assert_eq!(AriaLive::Polite.as_str(), "polite");
        assert_eq!(AriaLive::Assertive.as_str(), "assertive");
    }

    // =============================================================================
    // to_html_attrs tests
    // =============================================================================

    #[test]
    fn test_to_html_attrs_empty() {
        let attrs = AriaAttributes::new();
        let html_attrs = attrs.to_html_attrs();
        assert!(html_attrs.is_empty());
    }

    #[test]
    fn test_to_html_attrs_role() {
        let attrs = AriaAttributes::new().with_role("button");
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 1);
        assert_eq!(html_attrs[0], ("role".to_string(), "button".to_string()));
    }

    #[test]
    fn test_to_html_attrs_label() {
        let attrs = AriaAttributes::new().with_label("Submit");
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 1);
        assert_eq!(
            html_attrs[0],
            ("aria-label".to_string(), "Submit".to_string())
        );
    }

    #[test]
    fn test_to_html_attrs_disabled() {
        let attrs = AriaAttributes::new().with_disabled(true);
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 1);
        assert_eq!(
            html_attrs[0],
            ("aria-disabled".to_string(), "true".to_string())
        );
    }

    #[test]
    fn test_to_html_attrs_checked() {
        let attrs = AriaAttributes::new().with_checked(AriaChecked::Mixed);
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 1);
        assert_eq!(
            html_attrs[0],
            ("aria-checked".to_string(), "mixed".to_string())
        );
    }

    #[test]
    fn test_to_html_attrs_expanded() {
        let attrs = AriaAttributes::new().with_expanded(false);
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 1);
        assert_eq!(
            html_attrs[0],
            ("aria-expanded".to_string(), "false".to_string())
        );
    }

    #[test]
    fn test_to_html_attrs_value_range() {
        let attrs = AriaAttributes::new()
            .with_value_now(50.0)
            .with_value_min(0.0)
            .with_value_max(100.0);
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 3);
        assert!(html_attrs.contains(&("aria-valuenow".to_string(), "50".to_string())));
        assert!(html_attrs.contains(&("aria-valuemin".to_string(), "0".to_string())));
        assert!(html_attrs.contains(&("aria-valuemax".to_string(), "100".to_string())));
    }

    #[test]
    fn test_to_html_attrs_live() {
        let attrs = AriaAttributes::new().with_live(AriaLive::Assertive);
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 1);
        assert_eq!(
            html_attrs[0],
            ("aria-live".to_string(), "assertive".to_string())
        );
    }

    #[test]
    fn test_to_html_attrs_hidden() {
        let attrs = AriaAttributes::new().with_hidden(true);
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 1);
        assert_eq!(
            html_attrs[0],
            ("aria-hidden".to_string(), "true".to_string())
        );
    }

    #[test]
    fn test_to_html_attrs_multiple() {
        let attrs = AriaAttributes::new()
            .with_role("slider")
            .with_label("Volume")
            .with_value_now(75.0)
            .with_value_min(0.0)
            .with_value_max(100.0);
        let html_attrs = attrs.to_html_attrs();
        assert_eq!(html_attrs.len(), 5);
    }

    // =============================================================================
    // to_html_string tests
    // =============================================================================

    #[test]
    fn test_to_html_string_empty() {
        let attrs = AriaAttributes::new();
        let html = attrs.to_html_string();
        assert_eq!(html, "");
    }

    #[test]
    fn test_to_html_string_single() {
        let attrs = AriaAttributes::new().with_role("button");
        let html = attrs.to_html_string();
        assert_eq!(html, "role=\"button\"");
    }

    #[test]
    fn test_to_html_string_multiple() {
        let attrs = AriaAttributes::new()
            .with_role("checkbox")
            .with_checked(AriaChecked::True);
        let html = attrs.to_html_string();
        assert!(html.contains("role=\"checkbox\""));
        assert!(html.contains("aria-checked=\"true\""));
    }

    #[test]
    fn test_to_html_string_escapes_quotes() {
        let attrs = AriaAttributes::new().with_label("Click \"here\"");
        let html = attrs.to_html_string();
        assert!(html.contains("aria-label=\"Click &quot;here&quot;\""));
    }

    // =============================================================================
    // aria_from_widget tests
    // =============================================================================

    #[test]
    fn test_aria_from_widget_button() {
        let widget = MockButton::new().with_name("Submit");
        let attrs = aria_from_widget(&widget);
        assert_eq!(attrs.role, Some("button".to_string()));
        assert_eq!(attrs.label, Some("Submit".to_string()));
        assert!(!attrs.disabled);
    }

    #[test]
    fn test_aria_from_widget_no_name() {
        let widget = MockButton::new();
        let attrs = aria_from_widget(&widget);
        assert_eq!(attrs.role, Some("button".to_string()));
        assert!(attrs.label.is_none());
    }

    // Mock non-interactive widget for testing disabled state
    struct MockLabel {
        text: String,
    }

    impl MockLabel {
        fn new(text: &str) -> Self {
            Self {
                text: text.to_string(),
            }
        }
    }

    impl Widget for MockLabel {
        fn type_id(&self) -> TypeId {
            TypeId::of::<Self>()
        }
        fn measure(&self, c: Constraints) -> Size {
            c.smallest()
        }
        fn layout(&mut self, b: Rect) -> LayoutResult {
            LayoutResult { size: b.size() }
        }
        fn paint(&self, _: &mut dyn Canvas) {}
        fn event(&mut self, _: &Event) -> Option<Box<dyn Any + Send>> {
            None
        }
        fn children(&self) -> &[Box<dyn Widget>] {
            &[]
        }
        fn children_mut(&mut self) -> &mut [Box<dyn Widget>] {
            &mut []
        }
        fn is_interactive(&self) -> bool {
            false
        }
        fn is_focusable(&self) -> bool {
            false
        }
        fn accessible_name(&self) -> Option<&str> {
            Some(&self.text)
        }
        fn accessible_role(&self) -> AccessibleRole {
            AccessibleRole::Heading
        }
    }

    #[test]
    fn test_aria_from_widget_non_interactive() {
        let widget = MockLabel::new("Welcome");
        let attrs = aria_from_widget(&widget);
        assert_eq!(attrs.role, Some("heading".to_string()));
        assert_eq!(attrs.label, Some("Welcome".to_string()));
        assert!(attrs.disabled);
    }

    // Mock generic widget that returns Generic role
    struct MockGenericWidget;

    impl Widget for MockGenericWidget {
        fn type_id(&self) -> TypeId {
            TypeId::of::<Self>()
        }
        fn measure(&self, c: Constraints) -> Size {
            c.smallest()
        }
        fn layout(&mut self, b: Rect) -> LayoutResult {
            LayoutResult { size: b.size() }
        }
        fn paint(&self, _: &mut dyn Canvas) {}
        fn event(&mut self, _: &Event) -> Option<Box<dyn Any + Send>> {
            None
        }
        fn children(&self) -> &[Box<dyn Widget>] {
            &[]
        }
        fn children_mut(&mut self) -> &mut [Box<dyn Widget>] {
            &mut []
        }
        fn is_interactive(&self) -> bool {
            false
        }
        fn is_focusable(&self) -> bool {
            false
        }
        fn accessible_name(&self) -> Option<&str> {
            None
        }
        fn accessible_role(&self) -> AccessibleRole {
            AccessibleRole::Generic
        }
    }

    #[test]
    fn test_aria_from_widget_generic() {
        let widget = MockGenericWidget;
        let attrs = aria_from_widget(&widget);
        assert!(attrs.role.is_none());
        assert!(attrs.label.is_none());
        // Generic role shouldn't trigger disabled state
        assert!(!attrs.disabled);
    }

    // =============================================================================
    // A11yConfig tests
    // =============================================================================

    #[test]
    fn test_a11y_config_default() {
        let config = A11yConfig::default();
        assert!(config.check_touch_targets);
        assert!(config.check_heading_hierarchy);
        assert!(!config.check_focus_indicators);
        assert!((config.min_contrast_normal - 4.5).abs() < 0.01);
    }

    #[test]
    fn test_a11y_config_strict() {
        let config = A11yConfig::strict();
        assert!(config.check_touch_targets);
        assert!(config.check_heading_hierarchy);
        assert!(config.check_focus_indicators);
        assert!((config.min_contrast_normal - 7.0).abs() < 0.01);
    }

    #[test]
    fn test_a11y_config_mobile() {
        let config = A11yConfig::mobile();
        assert!(config.check_touch_targets);
        assert!(config.check_heading_hierarchy);
        assert!(!config.check_focus_indicators);
    }

    // =============================================================================
    // WCAG constant tests
    // =============================================================================

    #[test]
    fn test_min_touch_target_size() {
        assert_eq!(MIN_TOUCH_TARGET_SIZE, 44.0);
    }

    #[test]
    fn test_min_focus_indicator_area() {
        assert_eq!(MIN_FOCUS_INDICATOR_AREA, 2.0);
    }

    // =============================================================================
    // Check with config tests
    // =============================================================================

    #[test]
    fn test_check_with_config() {
        let widget = MockButton::new().with_name("OK");
        // Use config without touch target check since mock widgets have 0x0 bounds
        let config = A11yConfig {
            check_touch_targets: false,
            check_heading_hierarchy: true,
            check_focus_indicators: false,
            min_contrast_normal: 4.5,
            min_contrast_large: 3.0,
        };
        let report = A11yChecker::check_with_config(&widget, &config);
        assert!(report.is_passing());
    }

    // =============================================================================
    // Image alt text tests
    // =============================================================================

    struct MockImage {
        alt_text: Option<String>,
    }

    impl MockImage {
        fn new() -> Self {
            Self { alt_text: None }
        }

        fn with_alt(mut self, alt: &str) -> Self {
            self.alt_text = Some(alt.to_string());
            self
        }
    }

    impl Widget for MockImage {
        fn type_id(&self) -> TypeId {
            TypeId::of::<Self>()
        }
        fn measure(&self, c: Constraints) -> Size {
            c.smallest()
        }
        fn layout(&mut self, b: Rect) -> LayoutResult {
            LayoutResult { size: b.size() }
        }
        fn paint(&self, _: &mut dyn Canvas) {}
        fn event(&mut self, _: &Event) -> Option<Box<dyn Any + Send>> {
            None
        }
        fn children(&self) -> &[Box<dyn Widget>] {
            &[]
        }
        fn children_mut(&mut self) -> &mut [Box<dyn Widget>] {
            &mut []
        }
        fn is_interactive(&self) -> bool {
            false
        }
        fn is_focusable(&self) -> bool {
            false
        }
        fn accessible_name(&self) -> Option<&str> {
            self.alt_text.as_deref()
        }
        fn accessible_role(&self) -> AccessibleRole {
            AccessibleRole::Image
        }
    }

    #[test]
    fn test_image_missing_alt() {
        let widget = MockImage::new();
        let report = A11yChecker::check(&widget);
        assert!(!report.is_passing());
        assert!(report.violations.iter().any(|v| v.rule == "image-alt"));
    }

    #[test]
    fn test_image_with_alt() {
        let widget = MockImage::new().with_alt("A sunset over the ocean");
        let report = A11yChecker::check(&widget);
        // Image with alt text should pass the image-alt check
        assert!(!report.violations.iter().any(|v| v.rule == "image-alt"));
    }

    // =============================================================================
    // Impact ordering tests
    // =============================================================================

    #[test]
    fn test_impact_equality() {
        assert_eq!(Impact::Minor, Impact::Minor);
        assert_eq!(Impact::Moderate, Impact::Moderate);
        assert_eq!(Impact::Serious, Impact::Serious);
        assert_eq!(Impact::Critical, Impact::Critical);
        assert_ne!(Impact::Minor, Impact::Critical);
    }

    // =============================================================================
    // Form Accessibility Tests
    // =============================================================================

    #[test]
    fn test_form_field_passing() {
        let form = FormAccessibility::new().with_name("Login Form").field(
            FormFieldA11y::new("email")
                .with_label("Email Address")
                .with_type(InputType::Email)
                .with_autocomplete(AutocompleteValue::Email),
        );

        let report = FormA11yChecker::check(&form);
        assert!(report.is_passing());
    }

    #[test]
    fn test_form_field_missing_label() {
        let form = FormAccessibility::new()
            .with_name("Test Form")
            .field(FormFieldA11y::new("email").with_type(InputType::Email));

        let report = FormA11yChecker::check(&form);
        assert!(!report.is_passing());
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::MissingLabel));
    }

    #[test]
    fn test_form_field_aria_label_counts() {
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("search")
                .with_type(InputType::Search)
                .with_aria_label("Search products"),
        );

        let report = FormA11yChecker::check(&form);
        // aria-label should satisfy label requirement
        assert!(!report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::MissingLabel));
    }

    #[test]
    fn test_form_required_missing_aria() {
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("name")
                .with_label("Full Name")
                .with_required(true, false), // Visual but no aria
        );

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::MissingRequiredIndicator));
    }

    #[test]
    fn test_form_required_missing_visual() {
        let form = FormAccessibility::new().with_name("Test Form").field({
            let mut field = FormFieldA11y::new("name").with_label("Full Name");
            field.required = true;
            field.aria_required = true;
            field.has_visual_required_indicator = false;
            field
        });

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::MissingVisualRequired));
    }

    #[test]
    fn test_form_required_proper() {
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("name")
                .with_label("Full Name")
                .required(), // Sets both visual and aria
        );

        let report = FormA11yChecker::check(&form);
        // Should not have required-related violations
        assert!(!report.violations.iter().any(|v| matches!(
            v.rule,
            FormA11yRule::MissingRequiredIndicator | FormA11yRule::MissingVisualRequired
        )));
    }

    #[test]
    fn test_form_error_without_aria_invalid() {
        let form = FormAccessibility::new().with_name("Test Form").field({
            let mut field = FormFieldA11y::new("email")
                .with_label("Email")
                .with_type(InputType::Email);
            field.has_error = true;
            field.aria_invalid = false;
            field.error_message = Some("Invalid email".to_string());
            field
        });

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::MissingErrorState));
    }

    #[test]
    fn test_form_error_without_message() {
        let form = FormAccessibility::new().with_name("Test Form").field({
            let mut field = FormFieldA11y::new("email")
                .with_label("Email")
                .with_type(InputType::Email);
            field.has_error = true;
            field.aria_invalid = true;
            // No error message
            field
        });

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::MissingErrorMessage));
    }

    #[test]
    fn test_form_error_not_associated() {
        let form = FormAccessibility::new().with_name("Test Form").field({
            let mut field = FormFieldA11y::new("email")
                .with_label("Email")
                .with_type(InputType::Email);
            field.has_error = true;
            field.aria_invalid = true;
            field.error_message = Some("Invalid email".to_string());
            // No aria-describedby or aria-errormessage
            field
        });

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::ErrorNotAssociated));
    }

    #[test]
    fn test_form_error_properly_associated() {
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("email")
                .with_label("Email")
                .with_type(InputType::Email)
                .with_autocomplete(AutocompleteValue::Email)
                .with_error("Please enter a valid email address", true),
        );

        let report = FormA11yChecker::check(&form);
        // Should not have error-related violations
        assert!(!report.violations.iter().any(|v| matches!(
            v.rule,
            FormA11yRule::MissingErrorState
                | FormA11yRule::MissingErrorMessage
                | FormA11yRule::ErrorNotAssociated
        )));
    }

    #[test]
    fn test_form_missing_autocomplete() {
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("email")
                .with_label("Email")
                .with_type(InputType::Email),
            // No autocomplete
        );

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::MissingAutocomplete));
    }

    #[test]
    fn test_form_autocomplete_not_needed_for_checkbox() {
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("terms")
                .with_label("I agree to terms")
                .with_type(InputType::Checkbox),
        );

        let report = FormA11yChecker::check(&form);
        // Checkbox doesn't need autocomplete
        assert!(!report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::MissingAutocomplete));
    }

    #[test]
    fn test_form_placeholder_as_label() {
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("email")
                .with_type(InputType::Email)
                .with_placeholder("Enter your email"),
        );

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::PlaceholderAsLabel));
    }

    #[test]
    fn test_form_placeholder_with_label_ok() {
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("email")
                .with_label("Email")
                .with_type(InputType::Email)
                .with_autocomplete(AutocompleteValue::Email)
                .with_placeholder("e.g., user@example.com"),
        );

        let report = FormA11yChecker::check(&form);
        // Placeholder with label is fine
        assert!(!report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::PlaceholderAsLabel));
    }

    #[test]
    fn test_form_radio_buttons_not_grouped() {
        let form = FormAccessibility::new()
            .with_name("Test Form")
            .field(
                FormFieldA11y::new("option1")
                    .with_label("Option 1")
                    .with_type(InputType::Radio),
            )
            .field(
                FormFieldA11y::new("option2")
                    .with_label("Option 2")
                    .with_type(InputType::Radio),
            );

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::RelatedFieldsNotGrouped));
    }

    #[test]
    fn test_form_radio_buttons_properly_grouped() {
        let form = FormAccessibility::new()
            .with_name("Test Form")
            .field(
                FormFieldA11y::new("option1")
                    .with_label("Option 1")
                    .with_type(InputType::Radio),
            )
            .field(
                FormFieldA11y::new("option2")
                    .with_label("Option 2")
                    .with_type(InputType::Radio),
            )
            .group(
                FormFieldGroup::new("options")
                    .with_legend("Choose an option")
                    .with_field("option1")
                    .with_field("option2"),
            );

        let report = FormA11yChecker::check(&form);
        assert!(!report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::RelatedFieldsNotGrouped));
    }

    #[test]
    fn test_form_group_missing_legend() {
        let form = FormAccessibility::new().with_name("Test Form").group(
            FormFieldGroup::new("address")
                .with_field("street")
                .with_field("city"),
        );

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::GroupMissingLegend));
    }

    #[test]
    fn test_form_missing_accessible_name() {
        let form = FormAccessibility::new().field(
            FormFieldA11y::new("email")
                .with_label("Email")
                .with_type(InputType::Email)
                .with_autocomplete(AutocompleteValue::Email),
        );

        let report = FormA11yChecker::check(&form);
        assert!(report
            .violations
            .iter()
            .any(|v| v.rule == FormA11yRule::FormMissingName));
    }

    #[test]
    fn test_form_report_violations_for_field() {
        let form = FormAccessibility::new()
            .with_name("Test Form")
            .field(FormFieldA11y::new("bad_field").with_type(InputType::Email))
            .field(
                FormFieldA11y::new("good_field")
                    .with_label("Good Field")
                    .with_type(InputType::Text),
            );

        let report = FormA11yChecker::check(&form);
        let bad_violations = report.violations_for_field("bad_field");
        assert!(!bad_violations.is_empty());

        let good_violations = report.violations_for_field("good_field");
        // good_field should only have autocomplete warning (if text type)
        assert!(good_violations.len() <= 1);
    }

    #[test]
    fn test_form_report_is_acceptable() {
        // Form with only moderate violations should be acceptable
        let form = FormAccessibility::new().with_name("Test Form").field(
            FormFieldA11y::new("email")
                .with_label("Email")
                .with_type(InputType::Email),
            // Missing autocomplete is Moderate impact
        );

        let report = FormA11yChecker::check(&form);
        assert!(report.is_acceptable()); // Only Moderate violations
    }

    #[test]
    fn test_input_type_should_have_autocomplete() {
        assert!(InputType::Email.should_have_autocomplete());
        assert!(InputType::Password.should_have_autocomplete());
        assert!(InputType::Tel.should_have_autocomplete());
        assert!(InputType::Text.should_have_autocomplete());
        assert!(!InputType::Checkbox.should_have_autocomplete());
        assert!(!InputType::Radio.should_have_autocomplete());
        assert!(!InputType::Date.should_have_autocomplete());
    }

    #[test]
    fn test_autocomplete_value_as_str() {
        assert_eq!(AutocompleteValue::Email.as_str(), "email");
        assert_eq!(AutocompleteValue::GivenName.as_str(), "given-name");
        assert_eq!(
            AutocompleteValue::CurrentPassword.as_str(),
            "current-password"
        );
        assert_eq!(AutocompleteValue::Off.as_str(), "off");
    }

    #[test]
    fn test_form_a11y_rule_name() {
        assert_eq!(FormA11yRule::MissingLabel.name(), "missing-label");
        assert_eq!(
            FormA11yRule::MissingRequiredIndicator.name(),
            "missing-required-indicator"
        );
        assert_eq!(
            FormA11yRule::PlaceholderAsLabel.name(),
            "placeholder-as-label"
        );
    }

    #[test]
    fn test_form_violations_for_rule() {
        let form = FormAccessibility::new()
            .with_name("Test Form")
            .field(FormFieldA11y::new("field1").with_type(InputType::Email))
            .field(FormFieldA11y::new("field2").with_type(InputType::Email));

        let report = FormA11yChecker::check(&form);
        let missing_labels = report.violations_for_rule(FormA11yRule::MissingLabel);
        assert_eq!(missing_labels.len(), 2); // Both fields missing labels
    }

    #[test]
    fn test_form_complete_signup_form() {
        // Test a complete, accessible signup form
        let form = FormAccessibility::new()
            .with_name("Create Account")
            .field(
                FormFieldA11y::new("first_name")
                    .with_label("First Name")
                    .with_type(InputType::Text)
                    .with_autocomplete(AutocompleteValue::GivenName)
                    .required(),
            )
            .field(
                FormFieldA11y::new("last_name")
                    .with_label("Last Name")
                    .with_type(InputType::Text)
                    .with_autocomplete(AutocompleteValue::FamilyName)
                    .required(),
            )
            .field(
                FormFieldA11y::new("email")
                    .with_label("Email Address")
                    .with_type(InputType::Email)
                    .with_autocomplete(AutocompleteValue::Email)
                    .required(),
            )
            .field(
                FormFieldA11y::new("password")
                    .with_label("Password")
                    .with_type(InputType::Password)
                    .with_autocomplete(AutocompleteValue::NewPassword)
                    .required(),
            )
            .field(
                FormFieldA11y::new("terms")
                    .with_label("I agree to the Terms of Service")
                    .with_type(InputType::Checkbox)
                    .required(),
            );

        let report = FormA11yChecker::check(&form);
        assert!(
            report.is_passing(),
            "Complete signup form should pass: {:?}",
            report.violations
        );
    }
}