leptos-motion-layout 1.1.0

//! Performance Regression Tests for Layout Operations
//!
//! These tests ensure that layout-related performance characteristics are maintained
//! across code changes and detect performance regressions early in development.
//!
//! The tests establish baseline performance metrics for layout operations and fail
//! if performance degrades beyond acceptable thresholds.

use super::*;
use std::time::Instant;

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

    /// Performance regression test for LayoutInfo creation
    #[test]
    fn test_layout_info_creation_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let _layout_info = LayoutInfo::new(
                (i as f64) * 0.1,
                (i as f64) * 0.1,
                100.0 + (i as f64) * 0.1,
                200.0 + (i as f64) * 0.1,
            );
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should create at least 2,000,000 layout infos per second
        assert!(
            operations_per_second > 2_000_000.0,
            "LayoutInfo creation performance regression: {} ops/sec (expected > 2,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 50ms
        assert!(
            duration.as_millis() < 50,
            "LayoutInfo creation too slow: {}ms for {} operations (expected < 50ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for LayoutAnimationConfig creation
    #[test]
    fn test_layout_animation_config_creation_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let _config = LayoutAnimationConfig::new()
                .with_duration(0.3 + (i as f64) * 0.0001)
                .with_easing(EasingFunction::EaseOut)
                .hardware_accelerated(i % 2 == 0)
                .enabled(true);
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should create at least 1,000,000 configs per second
        assert!(
            operations_per_second > 1_000_000.0,
            "LayoutAnimationConfig creation performance regression: {} ops/sec (expected > 1,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 100ms
        assert!(
            duration.as_millis() < 100,
            "LayoutAnimationConfig creation too slow: {}ms for {} operations (expected < 100ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for FLIPState creation
    #[test]
    fn test_flip_state_creation_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let _flip_state = FLIPState {
                first: web_sys::DomRect::new_with_x_and_y_and_width_and_height(
                    (i as f64) * 0.1,
                    (i as f64) * 0.1,
                    100.0,
                    200.0,
                ).unwrap(),
                last: web_sys::DomRect::new_with_x_and_y_and_width_and_height(
                    (i as f64) * 0.1 + 50.0,
                    (i as f64) * 0.1 + 50.0,
                    100.0,
                    200.0,
                ).unwrap(),
                inverted: TransformValues {
                    translate_x: (i as f64) * 0.1,
                    translate_y: (i as f64) * 0.1,
                    scale_x: 1.0,
                    scale_y: 1.0,
                    rotation: 0.0,
                },
                progress: 0.0,
                active: false,
            };
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should create at least 1,000,000 FLIP states per second
        assert!(
            operations_per_second > 1_000_000.0,
            "FLIPState creation performance regression: {} ops/sec (expected > 1,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 100ms
        assert!(
            duration.as_millis() < 100,
            "FLIPState creation too slow: {}ms for {} operations (expected < 100ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for TransformValues operations
    #[test]
    fn test_transform_values_operations_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let mut transform = TransformValues {
                translate_x: (i as f64) * 0.1,
                translate_y: (i as f64) * 0.1,
                scale_x: 1.0 + (i as f64) * 0.001,
                scale_y: 1.0 + (i as f64) * 0.001,
                rotation: 0.0,
            };

            // Test various operations
            let _x = transform.translate_x;
            let _y = transform.translate_y;
            let _scale_x = transform.scale_x;
            let _scale_y = transform.scale_y;

            // Test updates
            transform.translate_x = (i as f64) * 0.2;
            transform.translate_y = (i as f64) * 0.2;
            transform.scale_x = 1.0 + (i as f64) * 0.002;
            transform.scale_y = 1.0 + (i as f64) * 0.002;
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should handle at least 2,000,000 operations per second
        assert!(
            operations_per_second > 2_000_000.0,
            "TransformValues operations performance regression: {} ops/sec (expected > 2,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 50ms
        assert!(
            duration.as_millis() < 50,
            "TransformValues operations too slow: {}ms for {} operations (expected < 50ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for SharedElementConfig creation
    #[test]
    fn test_shared_element_config_creation_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let _config = SharedElementConfig {
                duration: 0.3 + (i as f64) * 0.0001,
                easing: EasingFunction::EaseOut,
                maintain_aspect_ratio: i % 2 == 0,
                hardware_accelerated: i % 3 == 0,
            };
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should create at least 1,000,000 configs per second
        assert!(
            operations_per_second > 1_000_000.0,
            "SharedElementConfig creation performance regression: {} ops/sec (expected > 1,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 100ms
        assert!(
            duration.as_millis() < 100,
            "SharedElementConfig creation too slow: {}ms for {} operations (expected < 100ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for ZIndexStrategy operations
    #[test]
    fn test_z_index_strategy_operations_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let strategies = vec![
                ZIndexStrategy::Fixed { base: 1000, increment: 1 },
                ZIndexStrategy::Dynamic { base: 1000, max: 2000 },
                ZIndexStrategy::Elevate,
            ];

            let strategy = &strategies[i % strategies.len()];

            // Test strategy operations
            match strategy {
                ZIndexStrategy::Fixed { base, increment } => {
                    let _z_index = *base + (i as i32) * *increment;
                }
                ZIndexStrategy::Dynamic { base, max } => {
                    let _z_index = *base + (i as i32) % (*max - *base);
                }
                ZIndexStrategy::Elevate => {
                    let _z_index = 1000 + i as i32;
                }
                ZIndexStrategy::CustomProperty { property } => {
                    let _z_index = 1000 + i as i32;
                    let _prop = property;
                }
                ZIndexStrategy::Custom(value) => {
                    let _z_index = *value + i as i32;
                }
                ZIndexStrategy::Maintain => {
                    let _z_index = 1000 + i as i32;
                }
            }
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should handle at least 1,000,000 operations per second
        assert!(
            operations_per_second > 1_000_000.0,
            "ZIndexStrategy operations performance regression: {} ops/sec (expected > 1,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 100ms
        assert!(
            duration.as_millis() < 100,
            "ZIndexStrategy operations too slow: {}ms for {} operations (expected < 100ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for SimplifiedLayoutConfig creation
    #[test]
    fn test_simplified_layout_config_creation_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let _config = SimplifiedLayoutConfig {
                duration: 0.3 + (i as f64) * 0.0001,
                easing: SimplifiedEasing::EaseOut,
                hardware_accelerated: i % 2 == 0,
                enable_flip: i % 3 == 0,
                enable_shared_elements: i % 4 == 0,
            };
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should create at least 2,000,000 configs per second
        assert!(
            operations_per_second > 2_000_000.0,
            "SimplifiedLayoutConfig creation performance regression: {} ops/sec (expected > 2,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 50ms
        assert!(
            duration.as_millis() < 50,
            "SimplifiedLayoutConfig creation too slow: {}ms for {} operations (expected < 50ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for SimplifiedEasing operations
    #[test]
    fn test_simplified_easing_operations_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let easings = vec![
                SimplifiedEasing::Linear,
                SimplifiedEasing::EaseIn,
                SimplifiedEasing::EaseOut,
                SimplifiedEasing::EaseInOut,
            ];

            let easing = &easings[i % easings.len()];
            let progress = (i as f64) / iterations as f64;

            // Test easing calculations
            let _result = match easing {
                SimplifiedEasing::Linear => progress,
                SimplifiedEasing::EaseIn => progress * progress,
                SimplifiedEasing::EaseOut => 1.0 - (1.0 - progress) * (1.0 - progress),
                SimplifiedEasing::EaseInOut => {
                    if progress < 0.5 {
                        2.0 * progress * progress
                    } else {
                        1.0 - 2.0 * (1.0 - progress) * (1.0 - progress)
                    }
                }
                SimplifiedEasing::EaseInCubic => progress * progress * progress,
                SimplifiedEasing::EaseOutCubic => 1.0 - (1.0 - progress).powi(3),
                SimplifiedEasing::EaseInOutCubic => {
                    if progress < 0.5 {
                        4.0 * progress * progress * progress
                    } else {
                        1.0 - 4.0 * (1.0 - progress).powi(3)
                    }
                }
            };
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should handle at least 1,000,000 easing operations per second
        assert!(
            operations_per_second > 1_000_000.0,
            "SimplifiedEasing operations performance regression: {} ops/sec (expected > 1,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 100ms
        assert!(
            duration.as_millis() < 100,
            "SimplifiedEasing operations too slow: {}ms for {} operations (expected < 100ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for SimplifiedAnimationStatus operations
    #[test]
    fn test_simplified_animation_status_operations_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let _status = SimplifiedAnimationStatus {
                is_animating: i % 2 == 0,
                is_paused: i % 3 == 0,
                progress: (i as f64) / iterations as f64,
                start_time: Some(Instant::now()),
                duration: 0.3 + (i as f64) * 0.0001,
            };

            // Test status operations
            let _is_animating = _status.is_animating;
            let _is_paused = _status.is_paused;
            let _progress = _status.progress;
            let _duration = _status.duration;
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should handle at least 2,000,000 operations per second
        assert!(
            operations_per_second > 2_000_000.0,
            "SimplifiedAnimationStatus operations performance regression: {} ops/sec (expected > 2,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 50ms
        assert!(
            duration.as_millis() < 50,
            "SimplifiedAnimationStatus operations too slow: {}ms for {} operations (expected < 50ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for SimplifiedPerformanceMetrics operations
    #[test]
    fn test_simplified_performance_metrics_operations_performance_regression() {
        let iterations = 100_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            let mut metrics = SimplifiedPerformanceMetrics {
                total_animations: i,
                average_duration: 0.3 + (i as f64) * 0.0001,
                frame_rate: 60.0 - (i as f64) * 0.001,
                memory_usage: i * 1024,
                cpu_usage: 10.0 + (i as f64) * 0.001,
            };

            // Test metrics operations
            let _total_animations = metrics.total_animations;
            let _average_duration = metrics.average_duration;
            let _frame_rate = metrics.frame_rate;
            let _memory_usage = metrics.memory_usage;
            let _cpu_usage = metrics.cpu_usage;

            // Test metrics updates
            metrics.total_animations += 1;
            metrics.average_duration = 0.3 + ((i + 1) as f64) * 0.0001;
            metrics.frame_rate = 60.0 - ((i + 1) as f64) * 0.001;
            metrics.memory_usage = (i + 1) * 1024;
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should handle at least 2,000,000 operations per second
        assert!(
            operations_per_second > 2_000_000.0,
            "SimplifiedPerformanceMetrics operations performance regression: {} ops/sec (expected > 2,000,000)",
            operations_per_second
        );

        // Should complete 100,000 operations in under 50ms
        assert!(
            duration.as_millis() < 50,
            "SimplifiedPerformanceMetrics operations too slow: {}ms for {} operations (expected < 50ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for layout calculations simulation
    #[test]
    fn test_layout_calculations_simulation_performance_regression() {
        let iterations = 10_000;
        let start_time = Instant::now();

        for i in 0..iterations {
            // Simulate layout calculations
            let first_layout = LayoutInfo::new(
                (i as f64) * 0.1,
                (i as f64) * 0.1,
                100.0,
                200.0,
            );

            let last_layout = LayoutInfo::new(
                (i as f64) * 0.1 + 50.0,
                (i as f64) * 0.1 + 50.0,
                100.0,
                200.0,
            );

            // Calculate differences
            let delta_x = last_layout.x - first_layout.x;
            let delta_y = last_layout.y - first_layout.y;
            let delta_width = last_layout.width - first_layout.width;
            let delta_height = last_layout.height - first_layout.height;

            // Calculate scale factors
            let scale_x = if first_layout.width > 0.0 {
                last_layout.width / first_layout.width
            } else {
                1.0
            };
            let scale_y = if first_layout.height > 0.0 {
                last_layout.height / first_layout.height
            } else {
                1.0
            };

            // Create inverted transform
            let inverted = TransformValues {
                translate_x: -delta_x,
                translate_y: -delta_y,
                scale_x: 1.0 / scale_x,
                scale_y: 1.0 / scale_y,
                rotation: 0.0,
            };

            // Simulate FLIP state creation
            let _flip_state = FLIPState {
                first: web_sys::DomRect::new_with_x_and_y_and_width_and_height(
                    first_layout.x,
                    first_layout.y,
                    first_layout.width,
                    first_layout.height,
                ).unwrap(),
                last: web_sys::DomRect::new_with_x_and_y_and_width_and_height(
                    last_layout.x,
                    last_layout.y,
                    last_layout.width,
                    last_layout.height,
                ).unwrap(),
                inverted,
                progress: 0.0,
                active: false,
            };
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should handle at least 100,000 layout calculations per second
        assert!(
            operations_per_second > 100_000.0,
            "Layout calculations simulation performance regression: {} ops/sec (expected > 100,000)",
            operations_per_second
        );

        // Should complete 10,000 operations in under 100ms
        assert!(
            duration.as_millis() < 100,
            "Layout calculations simulation too slow: {}ms for {} operations (expected < 100ms)",
            duration.as_millis(),
            iterations
        );
    }

    /// Performance regression test for memory allocation patterns
    #[test]
    fn test_layout_memory_allocation_performance_regression() {
        let iterations = 5_000;
        let start_time = Instant::now();

        // Test memory allocation patterns that might occur in real usage
        let mut layout_infos = Vec::with_capacity(iterations);
        let mut configs = Vec::with_capacity(iterations);
        
        for i in 0..iterations {
            let layout_info = LayoutInfo::new(
                (i as f64) * 0.1,
                (i as f64) * 0.1,
                100.0 + (i as f64) * 0.1,
                200.0 + (i as f64) * 0.1,
            );
            layout_infos.push(layout_info);

            let config = LayoutAnimationConfig::new()
                .with_duration(0.3 + (i as f64) * 0.0001)
                .with_easing(EasingFunction::EaseOut)
                .hardware_accelerated(i % 2 == 0)
                .enabled(true);
            configs.push(config);
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should allocate at least 20,000 objects per second
        assert!(
            operations_per_second > 20_000.0,
            "Layout memory allocation performance regression: {} ops/sec (expected > 20,000)",
            operations_per_second
        );

        // Should complete 5,000 allocations in under 250ms
        assert!(
            duration.as_millis() < 250,
            "Layout memory allocation too slow: {}ms for {} operations (expected < 250ms)",
            duration.as_millis(),
            iterations
        );

        // Verify all objects were created
        assert_eq!(layout_infos.len(), iterations);
        assert_eq!(configs.len(), iterations);
        
        // Test memory cleanup
        drop(layout_infos);
        drop(configs);
    }

    /// Performance regression test for concurrent access simulation
    #[test]
    fn test_layout_concurrent_access_simulation_performance_regression() {
        let iterations = 2_500;
        let start_time = Instant::now();

        // Simulate concurrent access patterns
        let mut shared_layout = LayoutInfo::new(0.0, 0.0, 100.0, 200.0);
        
        for i in 0..iterations {
            // Simulate multiple threads accessing the same layout
            for thread_id in 0..4 {
                // Simulate read operations
                let _x = shared_layout.x;
                let _y = shared_layout.y;
                let _width = shared_layout.width;
                let _height = shared_layout.height;
                
                // Simulate write operations
                shared_layout.x = (i as f64) * 0.1 + thread_id as f64;
                shared_layout.y = (i as f64) * 0.1 + thread_id as f64;
            }
        }

        let duration = start_time.elapsed();
        let operations_per_second = iterations as f64 / duration.as_secs_f64();

        // Performance regression threshold: should handle at least 50,000 operations per second
        assert!(
            operations_per_second > 50_000.0,
            "Layout concurrent access simulation performance regression: {} ops/sec (expected > 50,000)",
            operations_per_second
        );

        // Should complete 2,500 iterations in under 50ms
        assert!(
            duration.as_millis() < 50,
            "Layout concurrent access simulation too slow: {}ms for {} operations (expected < 50ms)",
            duration.as_millis(),
            iterations
        );
    }
}