Optimalisatie van schaduwprestaties voor snel ladende webapplicaties

// Performance monitoring for shadow rendering
function measureShadowPerformance() {
  const observer = new PerformanceObserver((list) => {
    for (const entry of list.getEntries()) {
      if (entry.entryType === 'paint') {
        console.log(`${entry.name}: ${entry.startTime}ms`);
      }
    }
  });
  
  observer.observe({ entryTypes: ['paint', 'measure'] });
  
  // Measure shadow-specific operations
  performance.mark('shadow-start');
  
  // Your shadow-heavy operations here
  const shadowElements = document.querySelectorAll('.shadow-heavy');
  shadowElements.forEach(el => {
    el.style.boxShadow = 'optimized-shadow-value';
  });
  
  performance.mark('shadow-end');
  performance.measure('shadow-rendering', 'shadow-start', 'shadow-end');
}

// Monitor frame rate during shadow animations
function monitorShadowAnimationPerformance() {
  let frameCount = 0;
  let startTime = performance.now();
  
  function countFrames() {
    frameCount++;
    const currentTime = performance.now();
    
    if (currentTime - startTime >= 1000) {
      console.log(`FPS during shadow animations: ${frameCount}`);
      frameCount = 0;
      startTime = currentTime;
    }
    
    requestAnimationFrame(countFrames);
  }
  
  requestAnimationFrame(countFrames);
}

/* Performance-optimized shadow system */
:root {
  /* Optimized blur values (divisible by 2 for GPU efficiency) */
  --shadow-blur-sm: 2px;
  --shadow-blur-md: 4px;
  --shadow-blur-lg: 8px;
  --shadow-blur-xl: 12px;
  
  /* Efficient offset patterns */
  --shadow-offset-sm: 0 1px;
  --shadow-offset-md: 0 2px;
  --shadow-offset-lg: 0 4px;
  --shadow-offset-xl: 0 6px;
  
  /* Optimized opacity levels */
  --shadow-opacity-light: 0.05;
  --shadow-opacity-medium: 0.1;
  --shadow-opacity-strong: 0.15;
}

/* High-performance shadow classes */
.shadow-optimized-sm {
  box-shadow: var(--shadow-offset-sm) var(--shadow-blur-sm) 
              rgba(0, 0, 0, var(--shadow-opacity-light));
}

.shadow-optimized-md {
  box-shadow: var(--shadow-offset-md) var(--shadow-blur-md) 
              rgba(0, 0, 0, var(--shadow-opacity-medium));
}

.shadow-optimized-lg {
  box-shadow: var(--shadow-offset-lg) var(--shadow-blur-lg) 
              rgba(0, 0, 0, var(--shadow-opacity-strong));
}

/* Performance-critical elements */
.performance-critical {
  /* Single shadow, minimal blur */
  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
  
  /* Hardware acceleration hints */
  will-change: transform;
  transform: translateZ(0);
}

/* Avoid these performance-heavy patterns */
.avoid-heavy-shadows {
  /* DON'T: Multiple complex layers */
  /* box-shadow: 
    0 2px 4px rgba(0, 0, 0, 0.1),
    0 8px 16px rgba(0, 0, 0, 0.1),
    0 16px 32px rgba(0, 0, 0, 0.1),
    0 32px 64px rgba(0, 0, 0, 0.1); */
  
  /* DON'T: Large blur radius */
  /* box-shadow: 0 0 50px rgba(0, 0, 0, 0.3); */
  
  /* DO: Single optimized shadow */
  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.12);
}

/* Hardware acceleration for shadow performance */
.hw-accelerated-shadow {
  /* Enable hardware acceleration */
  will-change: transform;
  transform: translateZ(0);
  
  /* Optimized shadow for GPU processing */
  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.12);
  
  /* Smooth transitions */
  transition: transform 0.2s ease-out;
}

/* Animation-optimized approach */
.animated-shadow-element {
  /* Base shadow */
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
  
  /* Hardware acceleration */
  transform: translateZ(0);
  will-change: transform;
}

/* Use pseudo-elements for complex shadow animations */
.complex-shadow-animation {
  position: relative;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

.complex-shadow-animation::after {
  content: '';
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  box-shadow: 0 8px 16px rgba(0, 0, 0, 0.15);
  opacity: 0;
  transition: opacity 0.3s ease-out;
  pointer-events: none;
  z-index: -1;
}

.complex-shadow-animation:hover::after {
  opacity: 1;
}

/* Performance monitoring */
@media (prefers-reduced-motion: reduce) {
  .hw-accelerated-shadow,
  .animated-shadow-element,
  .complex-shadow-animation::after {
    transition: none;
    will-change: auto;
  }
}

/* Mobile-first performance optimization */
.responsive-shadow {
  /* Mobile: Minimal shadow for performance */
  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
}

/* Tablet: Moderate enhancement */
@media (min-width: 768px) and (min-resolution: 1.5dppx) {
  .responsive-shadow {
    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.12);
  }
}

/* Desktop: Full shadow effects */
@media (min-width: 1024px) {
  .responsive-shadow {
    box-shadow: 
      0 1px 3px rgba(0, 0, 0, 0.12),
      0 4px 8px rgba(0, 0, 0, 0.08);
  }
}

/* High-performance devices */
@media (min-width: 1024px) and (min-resolution: 2dppx) {
  .responsive-shadow {
    box-shadow: 
      0 1px 3px rgba(0, 0, 0, 0.12),
      0 8px 16px rgba(0, 0, 0, 0.1);
  }
}

/* Performance-based adaptations */
@media (prefers-reduced-motion: reduce) {
  .responsive-shadow {
    /* Disable shadow animations */
    transition: none;
  }
}

/* Battery-saving mode detection */
@media (prefers-reduced-data: reduce) {
  .responsive-shadow {
    /* Simplified shadows for data savings */
    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
  }
}

/* Network-aware optimization */
@media (max-bandwidth: 1mbps) {
  .responsive-shadow {
    /* Ultra-minimal shadows for slow connections */
    box-shadow: none;
    border: 1px solid rgba(0, 0, 0, 0.1);
  }
}

/* High-performance shadow animation system */
.optimized-shadow-animation {
  /* Static shadow - never animated */
  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.12);
  
  /* Animation through transforms only */
  transform: translateY(0);
  transition: transform 0.3s cubic-bezier(0.4, 0, 0.2, 1);
  
  /* Hardware acceleration */
  will-change: transform;
}

/* Hover effect using transform instead of shadow change */
.optimized-shadow-animation:hover {
  transform: translateY(-2px);
}

/* Complex shadow animation using pseudo-elements */
.advanced-shadow-animation {
  position: relative;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
  transition: transform 0.3s ease-out;
}

.advanced-shadow-animation::before {
  content: '';
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
  opacity: 0;
  transition: opacity 0.3s ease-out;
  z-index: -1;
  pointer-events: none;
}

.advanced-shadow-animation:hover {
  transform: translateY(-4px);
}

.advanced-shadow-animation:hover::before {
  opacity: 1;
}

/* Performance-critical animation */
.performance-critical-animation {
  /* Minimal base shadow */
  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
  
  /* Use transform for elevation effect */
  transform: translateZ(0);
  transition: transform 0.2s ease-out;
}

.performance-critical-animation:active {
  transform: translateZ(0) scale(0.95);
}

/* Disable animations for performance-sensitive users */
@media (prefers-reduced-motion: reduce) {
  .optimized-shadow-animation,
  .advanced-shadow-animation,
  .performance-critical-animation {
    transition: none;
    will-change: auto;
  }
  
  .advanced-shadow-animation::before {
    transition: none;
  }
}

// Shadow performance monitoring system
class ShadowPerformanceMonitor {
  constructor() {
    this.metrics = {
      paintTimes: [],
      frameRates: [],
      shadowComplexity: new Map(),
      renderingErrors: []
    };
    
    this.initializeMonitoring();
  }
  
  initializeMonitoring() {
    // Monitor paint performance
    const paintObserver = new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) {
        if (entry.name.includes('paint')) {
          this.metrics.paintTimes.push({
            timestamp: entry.startTime,
            duration: entry.duration,
            type: entry.name
          });
        }
      }
    });
    
    paintObserver.observe({ entryTypes: ['paint', 'measure'] });
    
    // Monitor frame rate during shadow animations
    this.monitorFrameRate();
    
    // Track shadow complexity metrics
    this.auditShadowComplexity();
    
    // Set up automated reporting
    this.setupAutomatedReporting();
  }
  
  monitorFrameRate() {
    let lastFrameTime = performance.now();
    let frameCount = 0;
    
    const measureFrameRate = (currentTime) => {
      frameCount++;
      
      if (currentTime - lastFrameTime >= 1000) {
        const fps = frameCount;
        this.metrics.frameRates.push({
          timestamp: currentTime,
          fps: fps,
          target: 60
        });
        
        // Alert if performance drops below threshold
        if (fps < 45) {
          this.reportPerformanceIssue('Low frame rate', fps);
        }
        
        frameCount = 0;
        lastFrameTime = currentTime;
      }
      
      requestAnimationFrame(measureFrameRate);
    };
    
    requestAnimationFrame(measureFrameRate);
  }
  
  auditShadowComplexity() {
    const shadowElements = document.querySelectorAll('[style*="box-shadow"], [class*="shadow"]');
    
    shadowElements.forEach((element, index) => {
      const computedStyle = getComputedStyle(element);
      const boxShadow = computedStyle.boxShadow;
      
      if (boxShadow && boxShadow !== 'none') {
        const complexity = this.calculateShadowComplexity(boxShadow);
        
        this.metrics.shadowComplexity.set(element, {
          complexity: complexity,
          shadowValue: boxShadow,
          elementType: element.tagName,
          className: element.className
        });
        
        // Flag high-complexity shadows
        if (complexity > 0.8) {
          this.reportPerformanceIssue('High shadow complexity', {
            element: element,
            complexity: complexity
          });
        }
      }
    });
  }
  
  calculateShadowComplexity(shadowValue) {
    // Calculate complexity score based on shadow properties
    const shadowLayers = shadowValue.split(',').length;
    const hasLargeBlur = /\s([2-9]\d|\d{3,})px/.test(shadowValue);
    const hasMultipleColors = (shadowValue.match(/rgba?\(/g) || []).length > 1;
    
    let complexityScore = 0;
    complexityScore += shadowLayers * 0.2;
    complexityScore += hasLargeBlur ? 0.4 : 0;
    complexityScore += hasMultipleColors ? 0.3 : 0;
    
    return Math.min(complexityScore, 1);
  }
  
  reportPerformanceIssue(type, data) {
    console.warn(`Shadow Performance Issue: ${type}`, data);
    
    // Send to analytics service
    if (typeof gtag !== 'undefined') {
      gtag('event', 'shadow_performance_issue', {
        issue_type: type,
        issue_data: JSON.stringify(data),
        user_agent: navigator.userAgent
      });
    }
  }
  
  setupAutomatedReporting() {
    // Report metrics every 30 seconds
    setInterval(() => {
      this.generatePerformanceReport();
    }, 30000);
  }
  
  generatePerformanceReport() {
    const report = {
      timestamp: Date.now(),
      averagePaintTime: this.calculateAverage(this.metrics.paintTimes.map(p => p.duration)),
      averageFrameRate: this.calculateAverage(this.metrics.frameRates.map(f => f.fps)),
      shadowComplexityDistribution: this.analyzeShadowComplexity(),
      performanceScore: this.calculateOverallScore()
    };
    
    // Send to monitoring service
    this.sendToMonitoringService(report);
    
    // Clear old metrics to prevent memory leaks
    this.cleanupOldMetrics();
  }
  
  calculateAverage(values) {
    return values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
  }
  
  analyzeShadowComplexity() {
    const complexities = Array.from(this.metrics.shadowComplexity.values())
      .map(item => item.complexity);
    
    return {
      low: complexities.filter(c => c < 0.3).length,
      medium: complexities.filter(c => c >= 0.3 && c < 0.7).length,
      high: complexities.filter(c => c >= 0.7).length
    };
  }
  
  calculateOverallScore() {
    const avgFrameRate = this.calculateAverage(this.metrics.frameRates.map(f => f.fps));
    const avgPaintTime = this.calculateAverage(this.metrics.paintTimes.map(p => p.duration));
    
    // Score based on frame rate (0-100)
    const frameRateScore = Math.min((avgFrameRate / 60) * 100, 100);
    
    // Score based on paint time (lower is better)
    const paintTimeScore = Math.max(100 - (avgPaintTime * 2), 0);
    
    return Math.round((frameRateScore + paintTimeScore) / 2);
  }
  
  sendToMonitoringService(report) {
    // Implementation depends on your monitoring service
    console.log('Performance Report:', report);
  }
  
  cleanupOldMetrics() {
    const cutoffTime = Date.now() - (5 * 60 * 1000); // Keep last 5 minutes
    
    this.metrics.paintTimes = this.metrics.paintTimes.filter(
      p => p.timestamp > cutoffTime
    );
    
    this.metrics.frameRates = this.metrics.frameRates.filter(
      f => f.timestamp > cutoffTime
    );
  }
}

// Initialize monitoring
const shadowMonitor = new ShadowPerformanceMonitor();

// Export for external access
window.shadowPerformanceMonitor = shadowMonitor;

// Dynamic shadow loading system
class DynamicShadowLoader {
  constructor() {
    this.performanceThresholds = {
      excellent: { fps: 55, paintTime: 8 },
      good: { fps: 45, paintTime: 12 },
      poor: { fps: 30, paintTime: 20 }
    };
    
    this.shadowComplexityLevels = {
      minimal: 'shadow-minimal',
      standard: 'shadow-standard', 
      enhanced: 'shadow-enhanced',
      premium: 'shadow-premium'
    };
    
    this.initializePerformanceDetection();
  }
  
  initializePerformanceDetection() {
    // Detect device capabilities
    this.deviceCapabilities = this.assessDeviceCapabilities();
    
    // Start with minimal shadows
    this.applyShadowLevel('minimal');
    
    // Monitor performance and upgrade shadows progressively
    this.startPerformanceMonitoring();
  }
  
  assessDeviceCapabilities() {
    const canvas = document.createElement('canvas');
    const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
    
    return {
      hasWebGL: !!gl,
      hardwareConcurrency: navigator.hardwareConcurrency || 2,
      memoryGB: navigator.deviceMemory || 4,
      connectionType: navigator.connection?.effectiveType || '4g',
      pixelRatio: window.devicePixelRatio || 1
    };
  }
  
  startPerformanceMonitoring() {
    let frameCount = 0;
    let startTime = performance.now();
    let paintTimes = [];
    
    const measurePerformance = () => {
      frameCount++;
      const currentTime = performance.now();
      
      // Calculate FPS every second
      if (currentTime - startTime >= 1000) {
        const fps = frameCount;
        const avgPaintTime = paintTimes.length > 0 
          ? paintTimes.reduce((a, b) => a + b, 0) / paintTimes.length 
          : 0;
        
        // Determine appropriate shadow level
        const shadowLevel = this.determineShadowLevel(fps, avgPaintTime);
        this.applyShadowLevel(shadowLevel);
        
        // Reset counters
        frameCount = 0;
        startTime = currentTime;
        paintTimes = [];
      }
      
      requestAnimationFrame(measurePerformance);
    };
    
    // Monitor paint times
    const paintObserver = new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) {
        if (entry.entryType === 'measure' && entry.name.includes('paint')) {
          paintTimes.push(entry.duration);
        }
      }
    });
    
    paintObserver.observe({ entryTypes: ['measure'] });
    requestAnimationFrame(measurePerformance);
  }
  
  determineShadowLevel(fps, paintTime) {
    const { excellent, good, poor } = this.performanceThresholds;
    
    if (fps >= excellent.fps && paintTime <= excellent.paintTime) {
      return 'premium';
    } else if (fps >= good.fps && paintTime <= good.paintTime) {
      return 'enhanced';
    } else if (fps >= poor.fps && paintTime <= poor.paintTime) {
      return 'standard';
    } else {
      return 'minimal';
    }
  }
  
  applyShadowLevel(level) {
    const elements = document.querySelectorAll('[data-dynamic-shadow]');
    
    elements.forEach(element => {
      // Remove existing shadow classes
      Object.values(this.shadowComplexityLevels).forEach(className => {
        element.classList.remove(className);
      });
      
      // Apply new shadow level
      element.classList.add(this.shadowComplexityLevels[level]);
      
      // Store current level for debugging
      element.dataset.shadowLevel = level;
    });
    
    // Log shadow level changes
    console.log(`Applied shadow level: ${level}`);
  }
  
  // Manual override for testing
  setShadowLevel(level) {
    if (this.shadowComplexityLevels[level]) {
      this.applyShadowLevel(level);
    }
  }
}

// Initialize dynamic shadow loading
const shadowLoader = new DynamicShadowLoader();

// Make available globally for debugging
window.dynamicShadowLoader = shadowLoader;