Service Worker Caching

/**
 * Comprehensive Service Worker Caching Framework
 * 
 * This system provides advanced Service Worker caching capabilities with
 * intelligent cache strategies, offline-first patterns, background
 * synchronization, and sophisticated cache management for Progressive
 * Web Applications.
 * 
 * Key Capabilities:
 * - Intelligent cache strategy selection and implementation
 * - Advanced offline-first patterns and architectures
 * - Background synchronization with conflict resolution
 * - Performance-optimized cache management
 * - Seamless online/offline user experience transitions
 */

class ServiceWorkerCachingFramework {
  constructor(config = {}) {
    this.config = {
      // Cache Configuration
      cacheNamePrefix: config.cacheNamePrefix || 'sw-cache',
      staticCacheName: config.staticCacheName || 'static-v1',
      dynamicCacheName: config.dynamicCacheName || 'dynamic-v1',
      enableVersioning: config.enableVersioning !== false,
      
      // Cache Strategies
      defaultStrategy: config.defaultStrategy || 'staleWhileRevalidate',
      enableIntelligentStrategies: config.enableIntelligentStrategies !== false,
      enableAdaptiveStrategies: config.enableAdaptiveStrategies || false,
      
      // Cache Limits and Management
      maxCacheEntries: config.maxCacheEntries || 100,
      maxCacheAge: config.maxCacheAge || 86400000, // 24 hours in milliseconds
      enableAutomaticCleanup: config.enableAutomaticCleanup !== false,
      
      // Offline-First Configuration
      enableOfflineFirst: config.enableOfflineFirst !== false,
      enableBackgroundSync: config.enableBackgroundSync !== false,
      enablePersistentStorage: config.enablePersistentStorage || false,
      
      // Performance Optimization
      enablePrecaching: config.enablePrecaching !== false,
      enableLazyLoading: config.enableLazyLoading || false,
      enableCompression: config.enableCompression || false,
      enableCacheWarmup: config.enableCacheWarmup || false,
      
      // Synchronization and Conflict Resolution
      syncStrategies: config.syncStrategies || ['background', 'immediate'],
      conflictResolution: config.conflictResolution || 'lastWriteWins',
      enableConflictDetection: config.enableConflictDetection || false,
      
      // Development and Debugging
      enableLogging: config.enableLogging || false,
      enablePerformanceTracking: config.enablePerformanceTracking || false,
      enableDebugMode: config.enableDebugMode || false,
      
      ...config
    };

    // Initialize caching components
    this.cacheManager = new CacheManager(this.config);
    this.strategyManager = new CacheStrategyManager(this.config);
    this.syncManager = new BackgroundSyncManager(this.config);
    this.offlineManager = new OfflineManager(this.config);
    this.performanceMonitor = new CachePerformanceMonitor(this.config);
    
    // Cache state management
    this.cacheInstances = new Map();
    this.strategyRegistry = new Map();
    this.syncQueue = [];
    this.performanceMetrics = new Map();
    
    // Initialize Service Worker
    this.initialize();
  }

  initialize() {
    // Set up Service Worker event listeners
    this.setupServiceWorkerEvents();
    
    // Initialize cache strategies
    this.initializeCacheStrategies();
    
    // Set up background synchronization
    this.setupBackgroundSync();
    
    // Initialize performance monitoring
    this.initializePerformanceMonitoring();
  }

  setupServiceWorkerEvents() {
    // Install event: Pre-cache critical resources
    self.addEventListener('install', (event) => {
      event.waitUntil(this.handleInstall(event));
    });

    // Activate event: Clean up old caches and take control
    self.addEventListener('activate', (event) => {
      event.waitUntil(this.handleActivate(event));
    });

    // Fetch event: Intercept and handle network requests
    self.addEventListener('fetch', (event) => {
      event.respondWith(this.handleFetch(event));
    });

    // Message event: Communication with main thread
    self.addEventListener('message', (event) => {
      this.handleMessage(event);
    });

    // Background sync event: Handle queued operations
    if (this.config.enableBackgroundSync) {
      self.addEventListener('sync', (event) => {
        this.handleBackgroundSync(event);
      });
    }
  }

  /**
   * Advanced Cache Strategy Implementation
   * 
   * This system implements sophisticated caching strategies that adapt
   * to resource characteristics, network conditions, and user patterns
   * to provide optimal performance and user experience.
   * 
   * Strategy Features:
   * - Intelligent strategy selection based on resource analysis
   * - Adaptive strategies that change based on network conditions
   * - Performance-optimized cache operations
   * - Sophisticated fallback and error handling
   * - Real-time strategy effectiveness monitoring
   */
  async handleFetch(event) {
    const request = event.request;
    
    try {
      // Analyze request to determine optimal strategy
      const requestAnalysis = this.analyzeRequest(request);
      const strategy = this.selectCacheStrategy(requestAnalysis);
      
      // Execute selected cache strategy
      const response = await this.executeCacheStrategy(strategy, request, requestAnalysis);
      
      // Track strategy performance
      if (this.config.enablePerformanceTracking) {
        this.trackStrategyPerformance(strategy, request, response);
      }

      return response;

    } catch (error) {
      return this.handleFetchError(request, error);
    }
  }

  analyzeRequest(request) {
    const url = new URL(request.url);
    
    const analysis = {
      url: request.url,
      method: request.method,
      destination: request.destination,
      mode: request.mode,
      resourceType: this.detectResourceType(request),
      priority: this.calculateRequestPriority(request),
      cacheable: this.isCacheable(request),
      networkDependency: this.analyzeNetworkDependency(request),
      userContext: this.getUserContext(request)
    };

    return analysis;
  }

  selectCacheStrategy(analysis) {
    // Use configured strategy map if available
    if (this.strategyRegistry.has(analysis.resourceType)) {
      return this.strategyRegistry.get(analysis.resourceType);
    }

    // Intelligent strategy selection based on resource analysis
    if (this.config.enableIntelligentStrategies) {
      return this.selectIntelligentStrategy(analysis);
    }

    // Adaptive strategy selection based on network conditions
    if (this.config.enableAdaptiveStrategies) {
      return this.selectAdaptiveStrategy(analysis);
    }

    // Return default strategy
    return this.config.defaultStrategy;
  }

  selectIntelligentStrategy(analysis) {
    // Static assets with versioning - Cache First
    if (analysis.resourceType === 'static-asset' && this.hasVersioning(analysis.url)) {
      return 'cacheFirst';
    }

    // API responses - Network First with cache fallback
    if (analysis.resourceType === 'api-response') {
      return analysis.networkDependency === 'high' ? 'networkFirst' : 'staleWhileRevalidate';
    }

    // HTML pages - Stale While Revalidate for fast loading with freshness
    if (analysis.resourceType === 'html-page') {
      return 'staleWhileRevalidate';
    }

    // Images and media - Cache First for performance
    if (analysis.resourceType === 'image' || analysis.resourceType === 'media') {
      return 'cacheFirst';
    }

    // Fonts - Cache First with long expiry
    if (analysis.resourceType === 'font') {
      return 'cacheFirst';
    }

    // Default to balanced approach
    return 'staleWhileRevalidate';
  }

  async executeCacheStrategy(strategy, request, analysis) {
    const strategyHandlers = {
      cacheFirst: () => this.executeCacheFirst(request, analysis),
      networkFirst: () => this.executeNetworkFirst(request, analysis),
      staleWhileRevalidate: () => this.executeStaleWhileRevalidate(request, analysis),
      cacheOnly: () => this.executeCacheOnly(request, analysis),
      networkOnly: () => this.executeNetworkOnly(request, analysis)
    };

    const handler = strategyHandlers[strategy];
    if (!handler) {
      throw new Error(`Unknown cache strategy: ${strategy}`);
    }

    return await handler();
  }

  async executeCacheFirst(request, analysis) {
    const cacheName = this.getCacheNameForRequest(request, analysis);
    const cache = await caches.open(cacheName);
    
    // Try cache first
    const cachedResponse = await cache.match(request);
    if (cachedResponse) {
      if (this.config.enableLogging) {
        console.log('Cache hit:', request.url);
      }
      return cachedResponse;
    }

    // Fallback to network
    try {
      const networkResponse = await fetch(request);
      
      // Cache successful responses
      if (networkResponse.ok) {
        await this.cacheResponse(cache, request, networkResponse.clone());
      }
      
      return networkResponse;
    } catch (error) {
      throw new Error(`Cache first strategy failed: ${error.message}`);
    }
  }

  async executeNetworkFirst(request, analysis) {
    const cacheName = this.getCacheNameForRequest(request, analysis);
    const cache = await caches.open(cacheName);

    try {
      // Try network first
      const networkResponse = await fetch(request);
      
      // Cache successful responses
      if (networkResponse.ok) {
        await this.cacheResponse(cache, request, networkResponse.clone());
      }
      
      return networkResponse;
    } catch (error) {
      // Fallback to cache
      const cachedResponse = await cache.match(request);
      if (cachedResponse) {
        if (this.config.enableLogging) {
          console.log('Network failed, serving from cache:', request.url);
        }
        return cachedResponse;
      }
      
      throw new Error(`Network first strategy failed: ${error.message}`);
    }
  }

  async executeStaleWhileRevalidate(request, analysis) {
    const cacheName = this.getCacheNameForRequest(request, analysis);
    const cache = await caches.open(cacheName);

    // Get cached response immediately
    const cachedResponse = await cache.match(request);
    
    // Start background network request for cache update
    const networkPromise = fetch(request).then(async (networkResponse) => {
      if (networkResponse.ok) {
        await this.cacheResponse(cache, request, networkResponse.clone());
      }
      return networkResponse;
    }).catch(error => {
      if (this.config.enableLogging) {
        console.warn('Background network update failed:', error);
      }
    });

    // Return cached response immediately if available
    if (cachedResponse) {
      if (this.config.enableLogging) {
        console.log('Serving stale from cache, updating in background:', request.url);
      }
      return cachedResponse;
    }

    // If no cached response, wait for network
    try {
      return await networkPromise;
    } catch (error) {
      throw new Error(`Stale while revalidate strategy failed: ${error.message}`);
    }
  }

  /**
   * Sophisticated Cache Management and Optimization
   * 
   * Advanced cache management system that handles cache versioning,
   * automatic cleanup, size limits, and performance optimization to
   * ensure optimal cache utilization and application performance.
   * 
   * Management Features:
   * - Automatic cache versioning and migration
   * - Intelligent cache cleanup based on usage and age
   * - Cache size management with LRU eviction
   * - Performance-optimized cache operations
   * - Cache warming and preloading strategies
   */
  async handleInstall(event) {
    if (this.config.enableLogging) {
      console.log('Service Worker installing...');
    }

    // Skip waiting to activate immediately
    await self.skipWaiting();

    // Precache critical resources
    if (this.config.enablePrecaching) {
      await this.precacheCriticalResources();
    }

    // Warm up cache if configured
    if (this.config.enableCacheWarmup) {
      await this.warmupCache();
    }
  }

  async handleActivate(event) {
    if (this.config.enableLogging) {
      console.log('Service Worker activating...');
    }

    // Claim all clients immediately
    await self.clients.claim();

    // Clean up old cache versions
    if (this.config.enableVersioning) {
      await this.cleanupOldCaches();
    }

    // Perform cache maintenance
    if (this.config.enableAutomaticCleanup) {
      await this.performCacheMaintenance();
    }

    // Request persistent storage if configured
    if (this.config.enablePersistentStorage) {
      await this.requestPersistentStorage();
    }
  }

  async precacheCriticalResources() {
    const criticalResources = [
      '/',
      '/css/app.css',
      '/js/app.js',
      '/images/icons/icon-192.png',
      '/manifest.json'
    ];

    const cache = await caches.open(this.config.staticCacheName);
    
    for (const resource of criticalResources) {
      try {
        const response = await fetch(resource);
        if (response.ok) {
          await cache.put(resource, response);
          if (this.config.enableLogging) {
            console.log('Precached:', resource);
          }
        }
      } catch (error) {
        console.warn('Failed to precache:', resource, error);
      }
    }
  }

  async cleanupOldCaches() {
    const cacheNames = await caches.keys();
    const currentCaches = new Set([
      this.config.staticCacheName,
      this.config.dynamicCacheName
    ]);

    const deletionPromises = cacheNames
      .filter(cacheName => !currentCaches.has(cacheName))
      .map(cacheName => {
        if (this.config.enableLogging) {
          console.log('Deleting old cache:', cacheName);
        }
        return caches.delete(cacheName);
      });

    await Promise.all(deletionPromises);
  }

  async performCacheMaintenance() {
    const maintenanceTasks = [
      this.cleanupExpiredEntries(),
      this.enforceCacheLimits(),
      this.optimizeCacheStorage()
    ];

    await Promise.all(maintenanceTasks);
  }

  async cleanupExpiredEntries() {
    const cacheNames = await caches.keys();
    
    for (const cacheName of cacheNames) {
      const cache = await caches.open(cacheName);
      const requests = await cache.keys();
      
      for (const request of requests) {
        const response = await cache.match(request);
        if (response && this.isResponseExpired(response)) {
          await cache.delete(request);
          if (this.config.enableLogging) {
            console.log('Removed expired entry:', request.url);
          }
        }
      }
    }
  }

  async enforceCacheLimits() {
    const cache = await caches.open(this.config.dynamicCacheName);
    const requests = await cache.keys();
    
    if (requests.length > this.config.maxCacheEntries) {
      // Sort by last access time (if available) or use LRU estimation
      const sortedRequests = await this.sortRequestsByAccessTime(requests, cache);
      
      // Remove oldest entries
      const entriesToRemove = sortedRequests.slice(this.config.maxCacheEntries);
      for (const request of entriesToRemove) {
        await cache.delete(request);
        if (this.config.enableLogging) {
          console.log('Removed LRU entry:', request.url);
        }
      }
    }
  }

  /**
   * Background Synchronization and Offline Support
   * 
   * Comprehensive offline-first system with background synchronization,
   * conflict resolution, and seamless online/offline transitions that
   * provide native-like application experiences.
   * 
   * Sync Features:
   * - Queue-based operation management for offline scenarios
   * - Intelligent conflict resolution with multiple strategies
   * - Background data synchronization with retry mechanisms
   * - Real-time sync status and progress reporting
   * - Optimistic UI updates with rollback capabilities
   */
  async handleBackgroundSync(event) {
    if (event.tag === 'background-sync') {
      await this.processSyncQueue();
    }
  }

  async queueOperation(operation) {
    // Store operation in IndexedDB for persistence
    const queueStore = await this.openSyncQueueStore();
    const transaction = queueStore.transaction(['sync-queue'], 'readwrite');
    const objectStore = transaction.objectStore('sync-queue');
    
    const queuedOperation = {
      id: this.generateOperationId(),
      operation: operation,
      timestamp: Date.now(),
      retryCount: 0,
      status: 'pending'
    };

    await objectStore.add(queuedOperation);
    
    // Register for background sync
    if ('serviceWorker' in navigator && 'sync' in window.ServiceWorkerRegistration.prototype) {
      const registration = await navigator.serviceWorker.ready;
      await registration.sync.register('background-sync');
    } else {
      // Fallback: attempt immediate sync
      await this.attemptImmediateSync(queuedOperation);
    }

    return queuedOperation.id;
  }

  async processSyncQueue() {
    const queueStore = await this.openSyncQueueStore();
    const transaction = queueStore.transaction(['sync-queue'], 'readwrite');
    const objectStore = transaction.objectStore('sync-queue');
    
    const pendingOperations = await objectStore.getAll();
    const pendingOps = pendingOperations.filter(op => op.status === 'pending');

    for (const operation of pendingOps) {
      try {
        await this.executeQueuedOperation(operation);
        
        // Mark as completed
        operation.status = 'completed';
        operation.completedAt = Date.now();
        await objectStore.put(operation);
        
        if (this.config.enableLogging) {
          console.log('Successfully synced operation:', operation.id);
        }
      } catch (error) {
        // Handle retry logic
        operation.retryCount++;
        
        if (operation.retryCount < 3) {
          operation.status = 'pending';
          operation.lastError = error.message;
          await objectStore.put(operation);
        } else {
          operation.status = 'failed';
          operation.failedAt = Date.now();
          operation.lastError = error.message;
          await objectStore.put(operation);
        }
        
        console.warn('Sync operation failed:', operation.id, error);
      }
    }
  }

  async executeQueuedOperation(queuedOperation) {
    const { operation } = queuedOperation;
    
    switch (operation.type) {
      case 'CREATE':
        return await this.syncCreateOperation(operation);
      case 'UPDATE':
        return await this.syncUpdateOperation(operation);
      case 'DELETE':
        return await this.syncDeleteOperation(operation);
      default:
        throw new Error(`Unknown sync operation type: ${operation.type}`);
    }
  }

  async syncUpdateOperation(operation) {
    const { endpoint, data, conflictResolution } = operation;
    
    try {
      // Attempt to update on server
      const response = await fetch(endpoint, {
        method: 'PUT',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(data)
      });

      if (response.ok) {
        return await response.json();
      } else if (response.status === 409) {
        // Handle conflict
        return await this.resolveUpdateConflict(operation, response, conflictResolution);
      } else {
        throw new Error(`Server error: ${response.status}`);
      }
    } catch (error) {
      throw new Error(`Network error during sync: ${error.message}`);
    }
  }

  async resolveUpdateConflict(operation, conflictResponse, strategy) {
    const serverData = await conflictResponse.json();
    
    switch (strategy) {
      case 'clientWins':
        // Force update with client data
        return await this.forceServerUpdate(operation);
      
      case 'serverWins':
        // Accept server data and update local cache
        return await this.updateLocalData(operation.data.id, serverData);
      
      case 'merge':
        // Attempt to merge changes
        const mergedData = await this.mergeConflictingData(operation.data, serverData);
        return await this.updateWithMergedData(operation.endpoint, mergedData);
      
      case 'lastWriteWins':
        // Compare timestamps and choose latest
        return this.operation.data.updatedAt > serverData.updatedAt ?
          await this.forceServerUpdate(operation) :
          await this.updateLocalData(operation.data.id, serverData);
      
      default:
        throw new Error(`Unknown conflict resolution strategy: ${strategy}`);
    }
  }

  /**
   * Offline-First User Experience Patterns
   * 
   * Sophisticated offline UX system that provides seamless transitions
   * between online and offline states, with clear user communication,
   * optimistic updates, and intelligent offline content management.
   * 
   * UX Features:
   * - Real-time network status monitoring and user communication
   * - Optimistic UI updates with rollback capabilities
   * - Offline-first content strategy with intelligent preloading
   * - Queue management with user visibility and control
   * - Seamless online/offline state transitions
   */
  initializeOfflineUX() {
    // Monitor network status
    this.setupNetworkStatusMonitoring();
    
    // Set up offline indicators
    this.setupOfflineIndicators();
    
    // Initialize optimistic updates
    this.setupOptimisticUpdates();
    
    // Configure offline content strategy
    this.setupOfflineContentStrategy();
  }

  setupNetworkStatusMonitoring() {
    // Listen for online/offline events
    window.addEventListener('online', () => {
      this.handleOnlineStatusChange(true);
    });

    window.addEventListener('offline', () => {
      this.handleOnlineStatusChange(false);
    });

    // Initial status check
    this.networkStatus = navigator.onLine;
  }

  handleOnlineStatusChange(isOnline) {
    this.networkStatus = isOnline;
    
    // Update UI indicators
    this.updateNetworkStatusUI(isOnline);
    
    // Process sync queue when coming back online
    if (isOnline && this.config.enableBackgroundSync) {
      this.processSyncQueue();
    }
    
    // Notify main application
    this.notifyNetworkStatusChange(isOnline);
  }

  async implementOptimisticUpdate(operation) {
    // Apply update to UI immediately
    const optimisticResult = await this.applyOptimisticUpdate(operation);
    
    try {
      // Attempt actual operation
      const actualResult = await this.executeOperation(operation);
      
      // Confirm optimistic update if successful
      await this.confirmOptimisticUpdate(optimisticResult, actualResult);
      
      return actualResult;
    } catch (error) {
      // Rollback optimistic update on failure
      await this.rollbackOptimisticUpdate(optimisticResult);
      
      // Queue for background sync if offline
      if (!this.networkStatus) {
        await this.queueOperation(operation);
      }
      
      throw error;
    }
  }

  // Utility methods
  detectResourceType(request) {
    const url = new URL(request.url);
    const pathname = url.pathname.toLowerCase();
    
    // API endpoints
    if (pathname.includes('/api/')) {
      return 'api-response';
    }
    
    // Static assets
    if (pathname.match(/\.(js|css|woff|woff2|ttf|eot)$/)) {
      return 'static-asset';
    }
    
    // Images
    if (pathname.match(/\.(jpg|jpeg|png|gif|webp|svg)$/)) {
      return 'image';
    }
    
    // Media
    if (pathname.match(/\.(mp4|webm|mp3|wav|ogg)$/)) {
      return 'media';
    }
    
    // Fonts
    if (pathname.match(/\.(woff|woff2|ttf|eot)$/)) {
      return 'font';
    }
    
    // HTML pages
    if (pathname.endsWith('/') || pathname.endsWith('.html') || !pathname.includes('.')) {
      return 'html-page';
    }
    
    return 'other';
  }

  getCacheNameForRequest(request, analysis) {
    if (analysis.resourceType === 'static-asset') {
      return this.config.staticCacheName;
    }
    return this.config.dynamicCacheName;
  }

  async cacheResponse(cache, request, response) {
    // Only cache successful responses
    if (!response.ok) {
      return;
    }

    // Add cache timestamp for management
    const responseWithTimestamp = new Response(response.body, {
      status: response.status,
      statusText: response.statusText,
      headers: {
        ...Object.fromEntries(response.headers.entries()),
        'sw-cached-at': Date.now().toString()
      }
    });

    await cache.put(request, responseWithTimestamp);
  }

  isResponseExpired(response) {
    const cachedAt = response.headers.get('sw-cached-at');
    if (!cachedAt) return false;
    
    const age = Date.now() - parseInt(cachedAt);
    return age > this.config.maxCacheAge;
  }

  generateOperationId() {
    return `op_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  hasVersioning(url) {
    return /\.[a-f0-9]{8,}\.(js|css|jpg|png|gif|webp|woff|woff2)$/i.test(url);
  }

  calculateRequestPriority(request) {
    const destination = request.destination;
    const priorityMap = {
      'document': 10,
      'script': 8,
      'style': 8,
      'image': 5,
      'font': 6,
      'fetch': 7
    };

    return priorityMap[destination] || 5;
  }

  isCacheable(request) {
    // Don't cache non-GET requests
    if (request.method !== 'GET') {
      return false;
    }

    // Don't cache requests with no-cache header
    if (request.headers.get('cache-control')?.includes('no-cache')) {
      return false;
    }

    // Don't cache requests to exclude patterns
    const excludePatterns = ['/api/auth/', '/api/user/'];
    return !excludePatterns.some(pattern => request.url.includes(pattern));
  }
}

// Usage Examples and Integration
const swCaching = new ServiceWorkerCachingFramework({
  staticCacheName: 'app-static-v2',
  dynamicCacheName: 'app-dynamic-v2',
  enableIntelligentStrategies: true,
  enableBackgroundSync: true,
  enablePrecaching: true,
  maxCacheEntries: 150,
  enableLogging: true
});

// Example: Custom cache strategy registration
function registerCustomCacheStrategies() {
  // API responses: Network first with short cache fallback
  swCaching.strategyRegistry.set('api-response', 'networkFirst');
  
  // Static assets: Cache first for performance
  swCaching.strategyRegistry.set('static-asset', 'cacheFirst');
  
  // Images: Stale while revalidate for balance
  swCaching.strategyRegistry.set('image', 'staleWhileRevalidate');
  
  // HTML pages: Stale while revalidate for fresh content
  swCaching.strategyRegistry.set('html-page', 'staleWhileRevalidate');
}

// Example: Offline data synchronization
async function syncOfflineData(data) {
  try {
    const operation = {
      type: 'UPDATE',
      endpoint: '/api/user/profile',
      data: data,
      conflictResolution: 'merge'
    };

    const operationId = await swCaching.queueOperation(operation);
    
    console.log('Operation queued for sync:', operationId);
    return operationId;
  } catch (error) {
    console.error('Failed to queue sync operation:', error);
    throw error;
  }
}

// Example: Optimistic UI updates
async function updateUserProfile(profileData) {
  try {
    const operation = {
      type: 'UPDATE',
      endpoint: '/api/user/profile',
      data: profileData,
      optimistic: true
    };

    const result = await swCaching.implementOptimisticUpdate(operation);
    
    console.log('Profile updated successfully:', result);
    return result;
  } catch (error) {
    console.error('Profile update failed:', error);
    
    // Show user that operation was queued for later sync
    showOfflineQueueNotification('Profile update queued for when you\'re back online');
    throw error;
  }
}

// Example: Cache warming for critical resources
async function warmCriticalResources() {
  const criticalResources = [
    '/api/user/dashboard',
    '/api/notifications/recent',
    '/images/avatar-placeholder.png'
  ];

  for (const resource of criticalResources) {
    try {
      await fetch(resource);
      console.log('Warmed cache for:', resource);
    } catch (error) {
      console.warn('Failed to warm cache for:', resource, error);
    }
  }
}

export { ServiceWorkerCachingFramework };

analyzeRequest(request) {
  const analysis = {
    resourceType: this.detectResourceType(request),        // js, css, image, api-response, etc.
    priority: this.calculateRequestPriority(request),      // Request importance for loading order
    cacheable: this.isCacheable(request),                  // Whether request should be cached
    networkDependency: this.analyzeNetworkDependency(request), // How much request depends on network
    userContext: this.getUserContext(request)              // User-specific context for personalization
  };

  return analysis;
}

selectIntelligentStrategy(analysis) {
  // Static assets with versioning - Cache First for maximum performance
  if (analysis.resourceType === 'static-asset' && this.hasVersioning(analysis.url)) {
    return 'cacheFirst';
  }

  // API responses - Network First with cache fallback for freshness
  if (analysis.resourceType === 'api-response') {
    return analysis.networkDependency === 'high' ? 'networkFirst' : 'staleWhileRevalidate';
  }

  // HTML pages - Stale While Revalidate for fast loading with fresh content
  if (analysis.resourceType === 'html-page') {
    return 'staleWhileRevalidate';
  }

  return 'staleWhileRevalidate'; // Balanced default
}

async executeStaleWhileRevalidate(request, analysis) {
  const cacheName = this.getCacheNameForRequest(request, analysis);
  const cache = await caches.open(cacheName);

  // Get cached response immediately
  const cachedResponse = await cache.match(request);
  
  // Start background network request for cache update
  const networkPromise = fetch(request).then(async (networkResponse) => {
    if (networkResponse.ok) {
      await this.cacheResponse(cache, request, networkResponse.clone());
    }
    return networkResponse;
  }).catch(error => {
    console.warn('Background network update failed:', error);
  });

  // Return cached response immediately if available
  if (cachedResponse) {
    console.log('Serving stale from cache, updating in background:', request.url);
    return cachedResponse;
  }

  // If no cached response, wait for network
  return await networkPromise;
}

async executeCacheFirst(request, analysis) {
  const cache = await caches.open(this.getCacheNameForRequest(request, analysis));
  
  // Try cache first
  const cachedResponse = await cache.match(request);
  if (cachedResponse) {
    return cachedResponse;
  }

  // Fallback to network and cache the response
  try {
    const networkResponse = await fetch(request);
    
    if (networkResponse.ok) {
      await this.cacheResponse(cache, request, networkResponse.clone());
    }
    
    return networkResponse;
  } catch (error) {
    throw new Error(`Cache first strategy failed: ${error.message}`);
  }
}

async handleInstall(event) {
  // Skip waiting to activate immediately
  await self.skipWaiting();

  // Precache critical resources for instant availability
  if (this.config.enablePrecaching) {
    await this.precacheCriticalResources();
  }

  // Warm up cache for better initial performance
  if (this.config.enableCacheWarmup) {
    await this.warmupCache();
  }
}

async precacheCriticalResources() {
  const criticalResources = ['/', '/css/app.css', '/js/app.js', '/images/icons/icon-192.png'];
  const cache = await caches.open(this.config.staticCacheName);
  
  for (const resource of criticalResources) {
    try {
      const response = await fetch(resource);
      if (response.ok) {
        await cache.put(resource, response);
      }
    } catch (error) {
      console.warn('Failed to precache:', resource, error);
    }
  }
}

async performCacheMaintenance() {
  await Promise.all([
    this.cleanupExpiredEntries(),      // Remove expired cache entries
    this.enforceCacheLimits(),         // Maintain cache size limits
    this.optimizeCacheStorage()        // Optimize cache organization
  ]);
}

async enforceCacheLimits() {
  const cache = await caches.open(this.config.dynamicCacheName);
  const requests = await cache.keys();
  
  if (requests.length > this.config.maxCacheEntries) {
    // Use LRU (Least Recently Used) eviction
    const sortedRequests = await this.sortRequestsByAccessTime(requests, cache);
    
    const entriesToRemove = sortedRequests.slice(this.config.maxCacheEntries);
    for (const request of entriesToRemove) {
      await cache.delete(request);
    }
  }
}

async queueOperation(operation) {
  // Store operation in persistent storage (IndexedDB)
  const queuedOperation = {
    id: this.generateOperationId(),
    operation: operation,
    timestamp: Date.now(),
    retryCount: 0,
    status: 'pending'
  };

  await this.persistOperation(queuedOperation);
  
  // Register for background sync
  const registration = await navigator.serviceWorker.ready;
  await registration.sync.register('background-sync');

  return queuedOperation.id;
}

async processSyncQueue() {
  const pendingOperations = await this.getPendingOperations();

  for (const operation of pendingOperations) {
    try {
      await this.executeQueuedOperation(operation);
      
      // Mark as completed
      await this.markOperationCompleted(operation.id);
    } catch (error) {
      // Handle retry logic
      if (operation.retryCount < 3) {
        await this.incrementRetryCount(operation.id);
      } else {
        await this.markOperationFailed(operation.id, error);
      }
    }
  }
}

async resolveUpdateConflict(operation, conflictResponse, strategy) {
  const serverData = await conflictResponse.json();
  
  switch (strategy) {
    case 'clientWins':
      // Force update with client data
      return await this.forceServerUpdate(operation);
    
    case 'serverWins':
      // Accept server data and update local cache
      return await this.updateLocalData(operation.data.id, serverData);
    
    case 'merge':
      // Attempt to intelligently merge changes
      const mergedData = await this.mergeConflictingData(operation.data, serverData);
      return await this.updateWithMergedData(operation.endpoint, mergedData);
    
    case 'lastWriteWins':
      // Compare timestamps and choose latest
      return operation.data.updatedAt > serverData.updatedAt ?
        await this.forceServerUpdate(operation) :
        await this.updateLocalData(operation.data.id, serverData);
  }
}

async implementOptimisticUpdate(operation) {
  // Apply update to UI immediately for instant feedback
  const optimisticResult = await this.applyOptimisticUpdate(operation);
  
  try {
    // Attempt actual operation
    const actualResult = await this.executeOperation(operation);
    
    // Confirm optimistic update if successful
    await this.confirmOptimisticUpdate(optimisticResult, actualResult);
    
    return actualResult;
  } catch (error) {
    // Rollback optimistic update on failure
    await this.rollbackOptimisticUpdate(optimisticResult);
    
    // Queue for background sync if offline
    if (!this.networkStatus) {
      await this.queueOperation(operation);
    }
    
    throw error;
  }
}

handleOnlineStatusChange(isOnline) {
  this.networkStatus = isOnline;
  
  // Update UI indicators for user awareness
  this.updateNetworkStatusUI(isOnline);
  
  // Process sync queue when coming back online
  if (isOnline && this.config.enableBackgroundSync) {
    this.processSyncQueue();
  }
  
  // Notify main application of status change
  this.notifyNetworkStatusChange(isOnline);
}