dampen_dev/

reload.rs

//! Hot-reload state preservation and coordination
//!
//! This module handles the hot-reload process, including model snapshotting,
//! state restoration, and error recovery.

use dampen_core::binding::UiBindable;
use dampen_core::parser::error::ParseError;
use dampen_core::state::AppState;
use serde::{Serialize, de::DeserializeOwned};
use std::collections::HashMap;
use std::marker::PhantomData;
use std::time::{Duration, Instant};

/// Cache entry for parsed XML documents
#[derive(Clone)]
struct ParsedDocumentCache {
    /// Cached parsed document
    document: dampen_core::ir::DampenDocument,

    /// Timestamp when cached
    cached_at: Instant,
}

/// Tracks hot-reload state and history for debugging
pub struct HotReloadContext<M> {
    /// Last successful model snapshot (JSON)
    last_model_snapshot: Option<String>,

    /// Timestamp of last reload
    last_reload_timestamp: Instant,

    /// Reload count (for metrics)
    reload_count: usize,

    /// Current error state (if any)
    error: Option<String>,

    /// Cache of parsed XML documents (keyed by content hash)
    /// This avoids re-parsing the same XML content repeatedly
    parse_cache: HashMap<u64, ParsedDocumentCache>,

    /// Maximum number of cached documents
    max_cache_size: usize,

    _marker: PhantomData<M>,
}

impl<M: UiBindable> HotReloadContext<M> {
    /// Create a new hot-reload context
    pub fn new() -> Self {
        Self {
            last_model_snapshot: None,
            last_reload_timestamp: Instant::now(),
            reload_count: 0,
            error: None,
            parse_cache: HashMap::new(),
            max_cache_size: 10,
            _marker: PhantomData,
        }
    }

    /// Create a new hot-reload context with custom cache size
    pub fn with_cache_size(cache_size: usize) -> Self {
        Self {
            last_model_snapshot: None,
            last_reload_timestamp: Instant::now(),
            reload_count: 0,
            error: None,
            parse_cache: HashMap::new(),
            max_cache_size: cache_size,
            _marker: PhantomData,
        }
    }

    /// Try to get a parsed document from cache
    fn get_cached_document(&self, xml_source: &str) -> Option<dampen_core::ir::DampenDocument> {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        let mut hasher = DefaultHasher::new();
        xml_source.hash(&mut hasher);
        let content_hash = hasher.finish();

        self.parse_cache
            .get(&content_hash)
            .map(|entry| entry.document.clone())
    }

    /// Cache a parsed document
    fn cache_document(&mut self, xml_source: &str, document: dampen_core::ir::DampenDocument) {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        // Evict oldest entry if cache is full
        if self.parse_cache.len() >= self.max_cache_size {
            if let Some(oldest_key) = self
                .parse_cache
                .iter()
                .min_by_key(|(_, entry)| entry.cached_at)
                .map(|(key, _)| *key)
            {
                self.parse_cache.remove(&oldest_key);
            }
        }

        let mut hasher = DefaultHasher::new();
        xml_source.hash(&mut hasher);
        let content_hash = hasher.finish();

        self.parse_cache.insert(
            content_hash,
            ParsedDocumentCache {
                document,
                cached_at: Instant::now(),
            },
        );
    }

    /// Clear the parse cache
    pub fn clear_cache(&mut self) {
        self.parse_cache.clear();
    }

    /// Get cache statistics
    pub fn cache_stats(&self) -> (usize, usize) {
        (self.parse_cache.len(), self.max_cache_size)
    }

    /// Get detailed performance metrics from the last reload
    pub fn performance_metrics(&self) -> ReloadPerformanceMetrics {
        ReloadPerformanceMetrics {
            reload_count: self.reload_count,
            last_reload_latency: self.last_reload_latency(),
            cache_hit_rate: self.calculate_cache_hit_rate(),
            cache_size: self.parse_cache.len(),
        }
    }

    /// Calculate cache hit rate (placeholder - would need to track hits/misses)
    fn calculate_cache_hit_rate(&self) -> f64 {
        // For now, return 0.0 as we'd need to add hit/miss tracking
        // This is a placeholder for future enhancement
        0.0
    }

    /// Snapshot the current model state to JSON
    pub fn snapshot_model(&mut self, model: &M) -> Result<(), String>
    where
        M: Serialize,
    {
        match serde_json::to_string(model) {
            Ok(json) => {
                self.last_model_snapshot = Some(json);
                Ok(())
            }
            Err(e) => Err(format!("Failed to serialize model: {}", e)),
        }
    }

    /// Restore the model from the last snapshot
    pub fn restore_model(&self) -> Result<M, String>
    where
        M: DeserializeOwned,
    {
        match &self.last_model_snapshot {
            Some(json) => serde_json::from_str(json)
                .map_err(|e| format!("Failed to deserialize model: {}", e)),
            None => Err("No model snapshot available".to_string()),
        }
    }

    /// Record a reload attempt
    pub fn record_reload(&mut self, success: bool) {
        self.reload_count += 1;
        self.last_reload_timestamp = Instant::now();
        if !success {
            self.error = Some("Reload failed".to_string());
        } else {
            self.error = None;
        }
    }

    /// Record a reload with timing information
    pub fn record_reload_with_timing(&mut self, success: bool, elapsed: Duration) {
        self.reload_count += 1;
        self.last_reload_timestamp = Instant::now();
        if !success {
            self.error = Some("Reload failed".to_string());
        } else {
            self.error = None;
        }

        // Log performance if it exceeds target
        if success && elapsed.as_millis() > 300 {
            eprintln!(
                "Warning: Hot-reload took {}ms (target: <300ms)",
                elapsed.as_millis()
            );
        }
    }

    /// Get the latency of the last reload
    pub fn last_reload_latency(&self) -> Duration {
        self.last_reload_timestamp.elapsed()
    }
}

impl<M: UiBindable> Default for HotReloadContext<M> {
    fn default() -> Self {
        Self::new()
    }
}

/// Performance metrics for hot-reload operations
#[derive(Debug, Clone, Copy)]
pub struct ReloadPerformanceMetrics {
    /// Total number of reloads performed
    pub reload_count: usize,

    /// Latency of the last reload operation
    pub last_reload_latency: Duration,

    /// Cache hit rate (0.0 to 1.0)
    pub cache_hit_rate: f64,

    /// Current cache size
    pub cache_size: usize,
}

impl ReloadPerformanceMetrics {
    /// Check if the last reload met the performance target (<300ms)
    pub fn meets_target(&self) -> bool {
        self.last_reload_latency.as_millis() < 300
    }

    /// Get latency in milliseconds
    pub fn latency_ms(&self) -> u128 {
        self.last_reload_latency.as_millis()
    }
}

/// Result type for hot-reload attempts with detailed error information
#[derive(Debug)]
pub enum ReloadResult<M: UiBindable> {
    /// Reload succeeded
    Success(AppState<M>),

    /// XML parse error (reject reload)
    ParseError(ParseError),

    /// Schema validation error (reject reload)
    ValidationError(Vec<String>),

    /// Model deserialization failed, using default (accept reload with warning)
    StateRestoreWarning(AppState<M>, String),
}

/// Attempts to hot-reload the UI from a new XML source while preserving application state.
///
/// This function orchestrates the entire hot-reload process:
/// 1. Snapshot the current model state
/// 2. Parse the new XML
/// 3. Rebuild the handler registry
/// 4. Validate the document (all referenced handlers exist)
/// 5. Restore the model (or use default on failure)
/// 6. Create a new AppState with the updated UI
///
/// # Arguments
///
/// * `xml_source` - New XML UI definition as a string
/// * `current_state` - Current application state (for model snapshotting)
/// * `context` - Hot-reload context for state preservation
/// * `create_handlers` - Function to rebuild the handler registry
///
/// # Returns
///
/// A `ReloadResult` indicating success or the specific type of failure:
/// - `Success`: Reload succeeded with model restored
/// - `ParseError`: XML parse failed (reject reload, keep old state)
/// - `ValidationError`: Handler validation failed (reject reload, keep old state)
/// - `StateRestoreWarning`: Reload succeeded but model used default (accept with warning)
///
/// # Error Handling Matrix
///
/// | Error Type | Action | State Preservation |
/// |------------|--------|-------------------|
/// | Parse error | Reject reload | Keep old state completely |
/// | Validation error | Reject reload | Keep old state completely |
/// | Model restore failure | Accept reload | Use M::default() with warning |
///
/// # Example
///
/// ```no_run
/// use dampen_dev::reload::{attempt_hot_reload, HotReloadContext};
/// use dampen_core::{AppState, handler::HandlerRegistry};
/// # use dampen_core::binding::UiBindable;
/// # #[derive(Default, serde::Serialize, serde::Deserialize)]
/// # struct Model;
/// # impl UiBindable for Model {
/// #     fn get_field(&self, _path: &[&str]) -> Option<dampen_core::binding::BindingValue> { None }
/// #     fn available_fields() -> Vec<String> { vec![] }
/// # }
///
/// fn handle_file_change(
///     new_xml: &str,
///     app_state: &AppState<Model>,
///     context: &mut HotReloadContext<Model>,
/// ) {
///     let result = attempt_hot_reload(
///         new_xml,
///         app_state,
///         context,
///         || create_handler_registry(),
///     );
///
///     match result {
///         dampen_dev::reload::ReloadResult::Success(new_state) => {
///             // Apply the new state
///         }
///         dampen_dev::reload::ReloadResult::ParseError(err) => {
///             // Show error overlay, keep old UI
///             eprintln!("Parse error: {}", err.message);
///         }
///         _ => {
///             // Handle other cases
///         }
///     }
/// }
///
/// fn create_handler_registry() -> dampen_core::handler::HandlerRegistry {
///     dampen_core::handler::HandlerRegistry::new()
/// }
/// ```
pub fn attempt_hot_reload<M, F>(
    xml_source: &str,
    current_state: &AppState<M>,
    context: &mut HotReloadContext<M>,
    create_handlers: F,
) -> ReloadResult<M>
where
    M: UiBindable + Serialize + DeserializeOwned + Default,
    F: FnOnce() -> dampen_core::handler::HandlerRegistry,
{
    let reload_start = Instant::now();

    // Step 1: Snapshot current model state
    if let Err(e) = context.snapshot_model(&current_state.model) {
        // If we can't snapshot, continue with reload but warn
        eprintln!("Warning: Failed to snapshot model: {}", e);
    }

    // Step 2: Parse new XML (with caching)
    let new_document = if let Some(cached_doc) = context.get_cached_document(xml_source) {
        // Cache hit - reuse parsed document
        cached_doc
    } else {
        // Cache miss - parse and cache
        match dampen_core::parser::parse(xml_source) {
            Ok(doc) => {
                context.cache_document(xml_source, doc.clone());
                doc
            }
            Err(err) => {
                context.record_reload(false);
                return ReloadResult::ParseError(err);
            }
        }
    };

    // Step 3: Rebuild handler registry (before validation)
    let new_handlers = create_handlers();

    // Step 4: Validate the parsed document against the handler registry
    if let Err(missing_handlers) = validate_handlers(&new_document, &new_handlers) {
        context.record_reload(false);
        let error_messages: Vec<String> = missing_handlers
            .iter()
            .map(|h| format!("Handler '{}' is referenced but not registered", h))
            .collect();
        return ReloadResult::ValidationError(error_messages);
    }

    // Step 5: Restore model from snapshot
    let restored_model = match context.restore_model() {
        Ok(model) => {
            // Successfully restored
            model
        }
        Err(e) => {
            // Failed to restore, use default
            eprintln!("Warning: Failed to restore model ({}), using default", e);

            // Create new state with default model
            let new_state = AppState::with_all(new_document, M::default(), new_handlers);

            context.record_reload(true);
            return ReloadResult::StateRestoreWarning(new_state, e);
        }
    };

    // Step 6: Create new AppState with restored model and new UI
    let new_state = AppState::with_all(new_document, restored_model, new_handlers);

    let elapsed = reload_start.elapsed();
    context.record_reload_with_timing(true, elapsed);
    ReloadResult::Success(new_state)
}

/// Async version of `attempt_hot_reload` that performs XML parsing asynchronously.
///
/// This function is optimized for non-blocking hot-reload by offloading the CPU-intensive
/// XML parsing to a background thread using `tokio::task::spawn_blocking`.
///
/// # Performance Benefits
///
/// - XML parsing happens on a thread pool, avoiding UI blocking
/// - Reduces hot-reload latency for large XML files
/// - Maintains UI responsiveness during reload
///
/// # Arguments
///
/// * `xml_source` - New XML UI definition as a string
/// * `current_state` - Current application state (for model snapshotting)
/// * `context` - Hot-reload context for state preservation
/// * `create_handlers` - Function to rebuild the handler registry
///
/// # Returns
///
/// A `ReloadResult` wrapped in a future, indicating success or failure
///
/// # Example
///
/// ```no_run
/// use dampen_dev::reload::{attempt_hot_reload_async, HotReloadContext};
/// use dampen_core::{AppState, handler::HandlerRegistry};
/// # use dampen_core::binding::UiBindable;
/// # #[derive(Default, serde::Serialize, serde::Deserialize)]
/// # struct Model;
/// # impl UiBindable for Model {
/// #     fn get_field(&self, _path: &[&str]) -> Option<dampen_core::binding::BindingValue> { None }
/// #     fn available_fields() -> Vec<String> { vec![] }
/// # }
///
/// async fn handle_file_change_async(
///     new_xml: String,
///     app_state: AppState<Model>,
///     mut context: HotReloadContext<Model>,
/// ) {
///     let result = attempt_hot_reload_async(
///         new_xml,
///         &app_state,
///         &mut context,
///         || create_handler_registry(),
///     ).await;
///
///     match result {
///         dampen_dev::reload::ReloadResult::Success(new_state) => {
///             // Apply the new state
///         }
///         _ => {
///             // Handle errors
///         }
///     }
/// }
///
/// fn create_handler_registry() -> dampen_core::handler::HandlerRegistry {
///     dampen_core::handler::HandlerRegistry::new()
/// }
/// ```
pub async fn attempt_hot_reload_async<M, F>(
    xml_source: String,
    current_state: &AppState<M>,
    context: &mut HotReloadContext<M>,
    create_handlers: F,
) -> ReloadResult<M>
where
    M: UiBindable + Serialize + DeserializeOwned + Default + Send + 'static,
    F: FnOnce() -> dampen_core::handler::HandlerRegistry + Send + 'static,
{
    let reload_start = Instant::now();

    // Step 1: Snapshot current model state (fast, can do synchronously)
    if let Err(e) = context.snapshot_model(&current_state.model) {
        eprintln!("Warning: Failed to snapshot model: {}", e);
    }

    // Clone snapshot for async context
    let model_snapshot = context.last_model_snapshot.clone();

    // Step 2: Parse new XML asynchronously (CPU-intensive work offloaded, with caching)
    let new_document = if let Some(cached_doc) = context.get_cached_document(&xml_source) {
        // Cache hit - reuse parsed document
        cached_doc
    } else {
        // Cache miss - parse asynchronously and cache
        let xml_for_parse = xml_source.clone();
        let parse_result =
            tokio::task::spawn_blocking(move || dampen_core::parser::parse(&xml_for_parse)).await;

        match parse_result {
            Ok(Ok(doc)) => {
                context.cache_document(&xml_source, doc.clone());
                doc
            }
            Ok(Err(err)) => {
                context.record_reload(false);
                return ReloadResult::ParseError(err);
            }
            Err(join_err) => {
                context.record_reload(false);
                let error = ParseError {
                    kind: dampen_core::parser::error::ParseErrorKind::XmlSyntax,
                    span: dampen_core::ir::span::Span::default(),
                    message: format!("Async parsing failed: {}", join_err),
                    suggestion: Some(
                        "Check if the XML file is accessible and not corrupted".to_string(),
                    ),
                };
                return ReloadResult::ParseError(error);
            }
        }
    };

    // Step 3: Rebuild handler registry (before validation)
    let new_handlers = create_handlers();

    // Step 4: Validate the parsed document against the handler registry
    if let Err(missing_handlers) = validate_handlers(&new_document, &new_handlers) {
        context.record_reload(false);
        let error_messages: Vec<String> = missing_handlers
            .iter()
            .map(|h| format!("Handler '{}' is referenced but not registered", h))
            .collect();
        return ReloadResult::ValidationError(error_messages);
    }

    // Step 5: Restore model from snapshot
    let restored_model = match model_snapshot {
        Some(json) => match serde_json::from_str::<M>(&json) {
            Ok(model) => model,
            Err(e) => {
                eprintln!("Warning: Failed to restore model ({}), using default", e);
                let new_state = AppState::with_all(new_document, M::default(), new_handlers);
                context.record_reload(true);
                return ReloadResult::StateRestoreWarning(
                    new_state,
                    format!("Failed to deserialize model: {}", e),
                );
            }
        },
        None => {
            eprintln!("Warning: No model snapshot available, using default");
            let new_state = AppState::with_all(new_document, M::default(), new_handlers);
            context.record_reload(true);
            return ReloadResult::StateRestoreWarning(
                new_state,
                "No model snapshot available".to_string(),
            );
        }
    };

    // Step 6: Create new AppState with restored model and new UI
    let new_state = AppState::with_all(new_document, restored_model, new_handlers);

    let elapsed = reload_start.elapsed();
    context.record_reload_with_timing(true, elapsed);
    ReloadResult::Success(new_state)
}

/// Collects all handler names referenced in a document.
///
/// This function recursively traverses the widget tree and collects all unique
/// handler names from event bindings.
///
/// # Arguments
///
/// * `document` - The parsed UI document to scan
///
/// # Returns
///
/// A vector of unique handler names referenced in the document
fn collect_handler_names(document: &dampen_core::ir::DampenDocument) -> Vec<String> {
    use std::collections::HashSet;

    let mut handlers = HashSet::new();
    collect_handlers_from_node(&document.root, &mut handlers);
    handlers.into_iter().collect()
}

/// Recursively collects handler names from a widget node and its children.
fn collect_handlers_from_node(
    node: &dampen_core::ir::node::WidgetNode,
    handlers: &mut std::collections::HashSet<String>,
) {
    // Collect handlers from events
    for event in &node.events {
        handlers.insert(event.handler.clone());
    }

    // Recursively collect from children
    for child in &node.children {
        collect_handlers_from_node(child, handlers);
    }
}

/// Validates that all handlers referenced in the document exist in the registry.
///
/// # Arguments
///
/// * `document` - The parsed UI document to validate
/// * `registry` - The handler registry to check against
///
/// # Returns
///
/// `Ok(())` if all handlers exist, or `Err(Vec<String>)` with a list of missing handlers
fn validate_handlers(
    document: &dampen_core::ir::DampenDocument,
    registry: &dampen_core::handler::HandlerRegistry,
) -> Result<(), Vec<String>> {
    let referenced_handlers = collect_handler_names(document);
    let mut missing_handlers = Vec::new();

    for handler_name in referenced_handlers {
        if registry.get(&handler_name).is_none() {
            missing_handlers.push(handler_name);
        }
    }

    if missing_handlers.is_empty() {
        Ok(())
    } else {
        Err(missing_handlers)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde::{Deserialize, Serialize};

    #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
    struct TestModel {
        count: i32,
        name: String,
    }

    impl UiBindable for TestModel {
        fn get_field(&self, _path: &[&str]) -> Option<dampen_core::binding::BindingValue> {
            None
        }

        fn available_fields() -> Vec<String> {
            vec![]
        }
    }

    impl Default for TestModel {
        fn default() -> Self {
            Self {
                count: 0,
                name: "default".to_string(),
            }
        }
    }

    #[test]
    fn test_snapshot_model_success() {
        let mut context = HotReloadContext::<TestModel>::new();
        let model = TestModel {
            count: 42,
            name: "Alice".to_string(),
        };

        let result = context.snapshot_model(&model);
        assert!(result.is_ok());
        assert!(context.last_model_snapshot.is_some());
    }

    #[test]
    fn test_restore_model_success() {
        let mut context = HotReloadContext::<TestModel>::new();
        let original = TestModel {
            count: 42,
            name: "Alice".to_string(),
        };

        // First snapshot
        context.snapshot_model(&original).unwrap();

        // Then restore
        let restored = context.restore_model().unwrap();
        assert_eq!(restored, original);
    }

    #[test]
    fn test_restore_model_no_snapshot() {
        let context = HotReloadContext::<TestModel>::new();

        // Try to restore without snapshot
        let result = context.restore_model();
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("No model snapshot"));
    }

    #[test]
    fn test_snapshot_restore_round_trip() {
        let mut context = HotReloadContext::<TestModel>::new();
        let original = TestModel {
            count: 999,
            name: "Bob".to_string(),
        };

        // Snapshot, modify, and restore
        context.snapshot_model(&original).unwrap();

        let mut modified = original.clone();
        modified.count = 0;
        modified.name = "Changed".to_string();

        // Restore should get original back
        let restored = context.restore_model().unwrap();
        assert_eq!(restored, original);
        assert_ne!(restored, modified);
    }

    #[test]
    fn test_multiple_snapshots() {
        let mut context = HotReloadContext::<TestModel>::new();

        // First snapshot
        let model1 = TestModel {
            count: 1,
            name: "First".to_string(),
        };
        context.snapshot_model(&model1).unwrap();

        // Second snapshot (should overwrite first)
        let model2 = TestModel {
            count: 2,
            name: "Second".to_string(),
        };
        context.snapshot_model(&model2).unwrap();

        // Restore should get the second model
        let restored = context.restore_model().unwrap();
        assert_eq!(restored, model2);
        assert_ne!(restored, model1);
    }

    #[test]
    fn test_record_reload() {
        let mut context = HotReloadContext::<TestModel>::new();

        assert_eq!(context.reload_count, 0);
        assert!(context.error.is_none());

        // Record successful reload
        context.record_reload(true);
        assert_eq!(context.reload_count, 1);
        assert!(context.error.is_none());

        // Record failed reload
        context.record_reload(false);
        assert_eq!(context.reload_count, 2);
        assert!(context.error.is_some());

        // Record successful reload again
        context.record_reload(true);
        assert_eq!(context.reload_count, 3);
        assert!(context.error.is_none());
    }

    #[test]
    fn test_attempt_hot_reload_success() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // Create initial state with a model
        let xml_v1 = r#"<dampen><column><text value="Version 1" /></column></dampen>"#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 42,
            name: "Alice".to_string(),
        };
        let registry_v1 = HandlerRegistry::new();
        let state_v1 = AppState::with_all(doc_v1, model_v1, registry_v1);

        // Create hot-reload context
        let mut context = HotReloadContext::<TestModel>::new();

        // New XML with changes
        let xml_v2 = r#"<dampen><column><text value="Version 2" /></column></dampen>"#;

        // Attempt hot-reload
        let result = attempt_hot_reload(xml_v2, &state_v1, &mut context, || HandlerRegistry::new());

        // Should succeed and preserve model
        match result {
            ReloadResult::Success(new_state) => {
                assert_eq!(new_state.model.count, 42);
                assert_eq!(new_state.model.name, "Alice");
                assert_eq!(context.reload_count, 1);
            }
            _ => panic!("Expected Success, got {:?}", result),
        }
    }

    #[test]
    fn test_attempt_hot_reload_parse_error() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // Create initial state
        let xml_v1 = r#"<dampen><column><text value="Version 1" /></column></dampen>"#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 10,
            name: "Bob".to_string(),
        };
        let state_v1 = AppState::with_all(doc_v1, model_v1, HandlerRegistry::new());

        let mut context = HotReloadContext::<TestModel>::new();

        // Invalid XML (unclosed tag)
        let xml_invalid = r#"<dampen><column><text value="Broken"#;

        // Attempt hot-reload
        let result = attempt_hot_reload(xml_invalid, &state_v1, &mut context, || {
            HandlerRegistry::new()
        });

        // Should return ParseError
        match result {
            ReloadResult::ParseError(_err) => {
                // Expected
                assert_eq!(context.reload_count, 1); // Failed reload is recorded
            }
            _ => panic!("Expected ParseError, got {:?}", result),
        }
    }

    #[test]
    fn test_attempt_hot_reload_model_restore_failure() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // Create initial state
        let xml_v1 = r#"<dampen><column><text value="Version 1" /></column></dampen>"#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 99,
            name: "Charlie".to_string(),
        };
        let state_v1 = AppState::with_all(doc_v1, model_v1, HandlerRegistry::new());

        // Create context and manually corrupt the snapshot to trigger restore failure
        let mut context = HotReloadContext::<TestModel>::new();
        context.last_model_snapshot = Some("{ invalid json }".to_string()); // Invalid JSON

        // New valid XML
        let xml_v2 = r#"<dampen><column><text value="Version 2" /></column></dampen>"#;

        // Attempt hot-reload (will snapshot current model, then try to restore from corrupted snapshot)
        let result = attempt_hot_reload(xml_v2, &state_v1, &mut context, || HandlerRegistry::new());

        // The function snapshots the current model first, so it will actually succeed
        // because the new snapshot overwrites the corrupted one.
        // To truly test restore failure, we need to test the restore_model method directly,
        // which we already do in test_restore_model_no_snapshot.

        // This test actually validates that the snapshot-before-parse strategy works correctly.
        match result {
            ReloadResult::Success(new_state) => {
                // Model preserved via the snapshot taken at the start of attempt_hot_reload
                assert_eq!(new_state.model.count, 99);
                assert_eq!(new_state.model.name, "Charlie");
                assert_eq!(context.reload_count, 1);
            }
            _ => panic!("Expected Success, got {:?}", result),
        }
    }

    #[test]
    fn test_attempt_hot_reload_preserves_model_across_multiple_reloads() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // Create initial state
        let xml_v1 = r#"<dampen><column><text value="V1" /></column></dampen>"#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 100,
            name: "Dave".to_string(),
        };
        let state_v1 = AppState::with_all(doc_v1, model_v1, HandlerRegistry::new());

        let mut context = HotReloadContext::<TestModel>::new();

        // First reload
        let xml_v2 = r#"<dampen><column><text value="V2" /></column></dampen>"#;
        let result = attempt_hot_reload(xml_v2, &state_v1, &mut context, || HandlerRegistry::new());

        let state_v2 = match result {
            ReloadResult::Success(s) => s,
            _ => panic!("First reload failed"),
        };

        assert_eq!(state_v2.model.count, 100);
        assert_eq!(state_v2.model.name, "Dave");

        // Second reload
        let xml_v3 = r#"<dampen><column><text value="V3" /></column></dampen>"#;
        let result = attempt_hot_reload(xml_v3, &state_v2, &mut context, || HandlerRegistry::new());

        let state_v3 = match result {
            ReloadResult::Success(s) => s,
            _ => panic!("Second reload failed"),
        };

        // Model still preserved
        assert_eq!(state_v3.model.count, 100);
        assert_eq!(state_v3.model.name, "Dave");
        assert_eq!(context.reload_count, 2);
    }

    #[test]
    fn test_attempt_hot_reload_with_handler_registry() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // Create initial state
        let xml_v1 =
            r#"<dampen><column><button label="Click" on_click="test" /></column></dampen>"#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 5,
            name: "Eve".to_string(),
        };

        let registry_v1 = HandlerRegistry::new();
        registry_v1.register_simple("test", |_model| {
            // Handler v1
        });

        let state_v1 = AppState::with_all(doc_v1, model_v1, registry_v1);

        let mut context = HotReloadContext::<TestModel>::new();

        // New XML with different handler
        let xml_v2 =
            r#"<dampen><column><button label="Click Me" on_click="test2" /></column></dampen>"#;

        // Create NEW handler registry (simulating code change)
        let result = attempt_hot_reload(xml_v2, &state_v1, &mut context, || {
            let registry = HandlerRegistry::new();
            registry.register_simple("test2", |_model| {
                // Handler v2
            });
            registry
        });

        // Should succeed
        match result {
            ReloadResult::Success(new_state) => {
                // Model preserved
                assert_eq!(new_state.model.count, 5);
                assert_eq!(new_state.model.name, "Eve");

                // Handler registry updated
                assert!(new_state.handler_registry.get("test2").is_some());
            }
            _ => panic!("Expected Success, got {:?}", result),
        }
    }

    #[test]
    fn test_collect_handler_names() {
        use dampen_core::parser;

        // XML with multiple handlers
        let xml = r#"
            <dampen>
                <column>
                    <button label="Click" on_click="handle_click" />
                    <text_input placeholder="Type" on_input="handle_input" />
                    <button label="Submit" on_click="handle_submit" />
                </column>
            </dampen>
        "#;

        let doc = parser::parse(xml).unwrap();
        let handlers = collect_handler_names(&doc);

        // Should collect all three unique handlers
        assert_eq!(handlers.len(), 3);
        assert!(handlers.contains(&"handle_click".to_string()));
        assert!(handlers.contains(&"handle_input".to_string()));
        assert!(handlers.contains(&"handle_submit".to_string()));
    }

    #[test]
    fn test_collect_handler_names_nested() {
        use dampen_core::parser;

        // XML with nested handlers
        let xml = r#"
            <dampen>
                <column>
                    <row>
                        <button label="A" on_click="handler_a" />
                    </row>
                    <row>
                        <button label="B" on_click="handler_b" />
                        <column>
                            <button label="C" on_click="handler_c" />
                        </column>
                    </row>
                </column>
            </dampen>
        "#;

        let doc = parser::parse(xml).unwrap();
        let handlers = collect_handler_names(&doc);

        // Should collect handlers from all nesting levels
        assert_eq!(handlers.len(), 3);
        assert!(handlers.contains(&"handler_a".to_string()));
        assert!(handlers.contains(&"handler_b".to_string()));
        assert!(handlers.contains(&"handler_c".to_string()));
    }

    #[test]
    fn test_collect_handler_names_duplicates() {
        use dampen_core::parser;

        // XML with duplicate handler names
        let xml = r#"
            <dampen>
                <column>
                    <button label="1" on_click="same_handler" />
                    <button label="2" on_click="same_handler" />
                    <button label="3" on_click="same_handler" />
                </column>
            </dampen>
        "#;

        let doc = parser::parse(xml).unwrap();
        let handlers = collect_handler_names(&doc);

        // Should deduplicate
        assert_eq!(handlers.len(), 1);
        assert!(handlers.contains(&"same_handler".to_string()));
    }

    #[test]
    fn test_validate_handlers_all_present() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        let xml = r#"
            <dampen>
                <column>
                    <button label="Click" on_click="test_handler" />
                </column>
            </dampen>
        "#;

        let doc = parser::parse(xml).unwrap();
        let registry = HandlerRegistry::new();
        registry.register_simple("test_handler", |_model| {});

        let result = validate_handlers(&doc, &registry);
        assert!(result.is_ok());
    }

    #[test]
    fn test_validate_handlers_missing() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        let xml = r#"
            <dampen>
                <column>
                    <button label="Click" on_click="missing_handler" />
                </column>
            </dampen>
        "#;

        let doc = parser::parse(xml).unwrap();
        let registry = HandlerRegistry::new();
        // Registry is empty, handler not registered

        let result = validate_handlers(&doc, &registry);
        assert!(result.is_err());

        let missing = result.unwrap_err();
        assert_eq!(missing.len(), 1);
        assert_eq!(missing[0], "missing_handler");
    }

    #[test]
    fn test_validate_handlers_multiple_missing() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        let xml = r#"
            <dampen>
                <column>
                    <button label="A" on_click="handler_a" />
                    <button label="B" on_click="handler_b" />
                    <button label="C" on_click="handler_c" />
                </column>
            </dampen>
        "#;

        let doc = parser::parse(xml).unwrap();
        let registry = HandlerRegistry::new();
        // Only register handler_b
        registry.register_simple("handler_b", |_model| {});

        let result = validate_handlers(&doc, &registry);
        assert!(result.is_err());

        let missing = result.unwrap_err();
        assert_eq!(missing.len(), 2);
        assert!(missing.contains(&"handler_a".to_string()));
        assert!(missing.contains(&"handler_c".to_string()));
    }

    #[test]
    fn test_attempt_hot_reload_validation_error() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // Create initial state
        let xml_v1 = r#"<dampen><column><text value="V1" /></column></dampen>"#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 10,
            name: "Test".to_string(),
        };
        let state_v1 = AppState::with_all(doc_v1, model_v1, HandlerRegistry::new());

        let mut context = HotReloadContext::<TestModel>::new();

        // New XML with a handler that won't be registered
        let xml_v2 = r#"
            <dampen>
                <column>
                    <button label="Click" on_click="unregistered_handler" />
                </column>
            </dampen>
        "#;

        // Create handler registry WITHOUT the required handler
        let result = attempt_hot_reload(xml_v2, &state_v1, &mut context, || {
            HandlerRegistry::new() // Empty registry
        });

        // Should return ValidationError
        match result {
            ReloadResult::ValidationError(errors) => {
                assert!(!errors.is_empty());
                assert!(errors[0].contains("unregistered_handler"));
                assert_eq!(context.reload_count, 1); // Failed reload is recorded
            }
            _ => panic!("Expected ValidationError, got {:?}", result),
        }
    }

    #[test]
    fn test_attempt_hot_reload_validation_success() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // Create initial state
        let xml_v1 = r#"<dampen><column><text value="V1" /></column></dampen>"#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 20,
            name: "Valid".to_string(),
        };
        let state_v1 = AppState::with_all(doc_v1, model_v1, HandlerRegistry::new());

        let mut context = HotReloadContext::<TestModel>::new();

        // New XML with a handler
        let xml_v2 = r#"
            <dampen>
                <column>
                    <button label="Click" on_click="registered_handler" />
                </column>
            </dampen>
        "#;

        // Create handler registry WITH the required handler
        let result = attempt_hot_reload(xml_v2, &state_v1, &mut context, || {
            let registry = HandlerRegistry::new();
            registry.register_simple("registered_handler", |_model| {});
            registry
        });

        // Should succeed
        match result {
            ReloadResult::Success(new_state) => {
                assert_eq!(new_state.model.count, 20);
                assert_eq!(new_state.model.name, "Valid");
                assert_eq!(context.reload_count, 1);
            }
            _ => panic!("Expected Success, got {:?}", result),
        }
    }

    #[test]
    fn test_handler_registry_complete_replacement() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // Create initial state with handler "old_handler"
        let xml_v1 = r#"
            <dampen>
                <column>
                    <button label="Old" on_click="old_handler" />
                </column>
            </dampen>
        "#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 1,
            name: "Initial".to_string(),
        };

        let registry_v1 = HandlerRegistry::new();
        registry_v1.register_simple("old_handler", |_model| {});

        let state_v1 = AppState::with_all(doc_v1, model_v1, registry_v1);

        // Verify old handler exists
        assert!(state_v1.handler_registry.get("old_handler").is_some());

        let mut context = HotReloadContext::<TestModel>::new();

        // New XML with completely different handler
        let xml_v2 = r#"
            <dampen>
                <column>
                    <button label="New" on_click="new_handler" />
                    <button label="Another" on_click="another_handler" />
                </column>
            </dampen>
        "#;

        // Rebuild registry with NEW handlers only (old_handler not included)
        let result = attempt_hot_reload(xml_v2, &state_v1, &mut context, || {
            let registry = HandlerRegistry::new();
            registry.register_simple("new_handler", |_model| {});
            registry.register_simple("another_handler", |_model| {});
            registry
        });

        // Should succeed
        match result {
            ReloadResult::Success(new_state) => {
                // Model preserved
                assert_eq!(new_state.model.count, 1);
                assert_eq!(new_state.model.name, "Initial");

                // Old handler should NOT exist in new registry
                assert!(new_state.handler_registry.get("old_handler").is_none());

                // New handlers should exist
                assert!(new_state.handler_registry.get("new_handler").is_some());
                assert!(new_state.handler_registry.get("another_handler").is_some());
            }
            _ => panic!("Expected Success, got {:?}", result),
        }
    }

    #[test]
    fn test_handler_registry_rebuild_before_validation() {
        use dampen_core::handler::HandlerRegistry;
        use dampen_core::parser;

        // This test validates that registry is rebuilt BEFORE validation happens
        // Scenario: Old state has handler A, new XML needs handler B
        // If registry is rebuilt before validation, it should succeed

        let xml_v1 =
            r#"<dampen><column><button on_click="handler_a" label="A" /></column></dampen>"#;
        let doc_v1 = parser::parse(xml_v1).unwrap();
        let model_v1 = TestModel {
            count: 100,
            name: "Test".to_string(),
        };

        let registry_v1 = HandlerRegistry::new();
        registry_v1.register_simple("handler_a", |_model| {});

        let state_v1 = AppState::with_all(doc_v1, model_v1, registry_v1);

        let mut context = HotReloadContext::<TestModel>::new();

        // New XML references handler_b (different from handler_a)
        let xml_v2 =
            r#"<dampen><column><button on_click="handler_b" label="B" /></column></dampen>"#;

        // Registry rebuild provides handler_b
        let result = attempt_hot_reload(xml_v2, &state_v1, &mut context, || {
            let registry = HandlerRegistry::new();
            registry.register_simple("handler_b", |_model| {}); // Different handler!
            registry
        });

        // Should succeed because registry was rebuilt with handler_b BEFORE validation
        match result {
            ReloadResult::Success(new_state) => {
                assert_eq!(new_state.model.count, 100);
                // Verify new handler exists
                assert!(new_state.handler_registry.get("handler_b").is_some());
                // Verify old handler is gone
                assert!(new_state.handler_registry.get("handler_a").is_none());
            }
            _ => panic!(
                "Expected Success (registry rebuilt before validation), got {:?}",
                result
            ),
        }
    }
}