// Service Worker para PWA Minhas Entregas
const CACHE_NAME = 'minhas-entregas-v1';
const STATIC_CACHE_NAME = 'minhas-entregas-static-v1';
const DYNAMIC_CACHE_NAME = 'minhas-entregas-dynamic-v1';

// Recursos para cache estático
const STATIC_ASSETS = [
  '/',
  '/index.html',
  '/static/js/bundle.js',
  '/static/css/main.css',
  '/manifest.json',
  '/icons/icon-192x192.png',
  '/icons/icon-512x512.png'
];

// Instalar Service Worker
self.addEventListener('install', event => {
  console.log('Service Worker: Installing...');
  
  event.waitUntil(
    caches.open(STATIC_CACHE_NAME)
      .then(cache => {
        console.log('Service Worker: Caching static assets');
        return cache.addAll(STATIC_ASSETS);
      })
      .catch(err => {
        console.log('Service Worker: Error caching static assets', err);
      })
  );
  
  // Força a ativação imediata
  self.skipWaiting();
});

// Ativar Service Worker
self.addEventListener('activate', event => {
  console.log('Service Worker: Activating...');
  
  event.waitUntil(
    caches.keys().then(cacheNames => {
      return Promise.all(
        cacheNames.map(cacheName => {
          // Remove caches antigos
          if (cacheName !== STATIC_CACHE_NAME && cacheName !== DYNAMIC_CACHE_NAME) {
            console.log('Service Worker: Removing old cache', cacheName);
            return caches.delete(cacheName);
          }
        })
      );
    })
  );
  
  // Toma controle de todas as páginas
  self.clients.claim();
});

// Interceptar requisições
self.addEventListener('fetch', event => {
  const { request } = event;
  const url = new URL(request.url);
  
  // Ignora requisições não-HTTP
  if (!request.url.startsWith('http')) {
    return;
  }
  
  // Estratégia Cache First para recursos estáticos
  if (STATIC_ASSETS.some(asset => request.url.includes(asset))) {
    event.respondWith(
      caches.match(request)
        .then(response => {
          return response || fetch(request);
        })
    );
    return;
  }
  
  // Estratégia Network First para dados dinâmicos
  if (request.url.includes('/api/') || request.method === 'POST') {
    event.respondWith(
      fetch(request)
        .then(response => {
          // Clona a resposta para cache
          const responseClone = response.clone();
          
          if (response.status === 200) {
            caches.open(DYNAMIC_CACHE_NAME)
              .then(cache => {
                cache.put(request, responseClone);
              });
          }
          
          return response;
        })
        .catch(() => {
          // Fallback para cache se offline
          return caches.match(request);
        })
    );
    return;
  }
  
  // Estratégia Stale While Revalidate para outros recursos
  event.respondWith(
    caches.match(request)
      .then(response => {
        const fetchPromise = fetch(request)
          .then(networkResponse => {
            if (networkResponse.status === 200) {
              const responseClone = networkResponse.clone();
              caches.open(DYNAMIC_CACHE_NAME)
                .then(cache => {
                  cache.put(request, responseClone);
                });
            }
            return networkResponse;
          })
          .catch(() => {
            // Se falhar, retorna do cache
            return response;
          });
        
        // Retorna do cache imediatamente, mas atualiza em background
        return response || fetchPromise;
      })
  );
});

// Sincronização em background
self.addEventListener('sync', event => {
  console.log('Service Worker: Background sync', event.tag);
  
  if (event.tag === 'delivery-status-sync') {
    event.waitUntil(syncDeliveryStatus());
  }
  
  if (event.tag === 'observations-sync') {
    event.waitUntil(syncObservations());
  }
});

// Função para sincronizar status de entregas
async function syncDeliveryStatus() {
  try {
    // Recupera dados pendentes do IndexedDB ou localStorage
    const pendingUpdates = JSON.parse(localStorage.getItem('pendingStatusUpdates') || '[]');
    
    for (const update of pendingUpdates) {
      try {
        const response = await fetch('/api/delivery/status', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          },
          body: JSON.stringify(update)
        });
        
        if (response.ok) {
          // Remove da lista de pendentes
          const updatedPending = pendingUpdates.filter(u => u.id !== update.id);
          localStorage.setItem('pendingStatusUpdates', JSON.stringify(updatedPending));
        }
      } catch (error) {
        console.log('Erro ao sincronizar status:', error);
      }
    }
  } catch (error) {
    console.log('Erro na sincronização:', error);
  }
}

// Função para sincronizar observações
async function syncObservations() {
  try {
    const pendingObservations = JSON.parse(localStorage.getItem('pendingObservations') || '[]');
    
    for (const observation of pendingObservations) {
      try {
        const response = await fetch('/api/delivery/observations', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          },
          body: JSON.stringify(observation)
        });
        
        if (response.ok) {
          const updatedPending = pendingObservations.filter(o => o.id !== observation.id);
          localStorage.setItem('pendingObservations', JSON.stringify(updatedPending));
        }
      } catch (error) {
        console.log('Erro ao sincronizar observações:', error);
      }
    }
  } catch (error) {
    console.log('Erro na sincronização:', error);
  }
}

// Notificações push (se implementado no futuro)
self.addEventListener('push', event => {
  console.log('Service Worker: Push received');
  
  const options = {
    body: event.data ? event.data.text() : 'Nova entrega disponível!',
    icon: '/icons/icon-192x192.png',
    badge: '/icons/icon-72x72.png',
    vibrate: [200, 100, 200],
    data: {
      dateOfArrival: Date.now(),
      primaryKey: 1
    },
    actions: [
      {
        action: 'explore',
        title: 'Ver Entregas',
        icon: '/icons/icon-96x96.png'
      },
      {
        action: 'close',
        title: 'Fechar',
        icon: '/icons/icon-96x96.png'
      }
    ]
  };
  
  event.waitUntil(
    self.registration.showNotification('Minhas Entregas', options)
  );
});

// Clique em notificação
self.addEventListener('notificationclick', event => {
  console.log('Service Worker: Notification click received');
  
  event.notification.close();
  
  if (event.action === 'explore') {
    event.waitUntil(
      clients.openWindow('/')
    );
  }
});

