// sw.js - Service Worker Blindado (v10)
const CACHE_NAME = 'gestao-pro-cache-v11';
const DATA_CACHE_NAME = 'gestao-pro-data-v10';

const urlsToCache = [
    '/',
    '/index.html',
    '/login.html',
    '/style.css',
    '/script.js',
    '/login.js',
    '/api.js',
    // MÓDULO DE PONTO
    '/gestao_ponto/index.html',
    '/gestao_ponto/admin.html',
    '/gestao_ponto/style_ponto.css',
    '/gestao_ponto/style_admin.css',
    '/gestao_ponto/logic_admin.js',
    
    // *** ATENÇÃO: O ARQUIVO ABAIXO PRECISA EXISTIR NA PASTA ***
    '/gestao_ponto/logic_ponto_v3.js', 
    // **********************************************************
    
    'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css',
    'https://cdn.jsdelivr.net/npm/chart.js',
    'https://cdn.jsdelivr.net/npm/localforage@1.10.0/dist/localforage.min.js'
];

// Instalação: Tenta cachear, mas não quebra se um arquivo falhar
self.addEventListener('install', event => {
    console.log('[SW] Instalando v10...');
    self.skipWaiting();
    
    event.waitUntil(
        caches.open(CACHE_NAME).then(cache => {
            // Usa 'addAll' num bloco try/catch ou individualmente para não falhar tudo se um arquivo sumir
            return Promise.all(
                urlsToCache.map(url => {
                    return cache.add(url).catch(err => {
                        console.warn('[SW] Falha ao cachear arquivo (pode não existir):', url);
                    });
                })
            );
        })
    );
});

// Ativação: Limpa caches velhos (v9, v8...)
self.addEventListener('activate', event => {
    console.log('[SW] Ativando v10 e limpando lixo...');
    event.waitUntil(
        caches.keys().then(cacheNames => {
            return Promise.all(
                cacheNames.map(cacheName => {
                    if (cacheName !== CACHE_NAME && cacheName !== DATA_CACHE_NAME) {
                        return caches.delete(cacheName);
                    }
                })
            );
        }).then(() => self.clients.claim())
    );
});

// Interceptação (Estratégia Híbrida Segura)
self.addEventListener('fetch', event => {
    const request = event.request;
    const url = new URL(request.url);

    // 1. Navegação (HTML) -> Network First, Fallback Cache
    if (request.mode === 'navigate') {
        event.respondWith(
            fetch(request).catch(() => {
                return caches.match(request).then(response => {
                    if (response) return response;
                    // Fallback para index se tudo falhar
                    if (url.pathname.includes('/gestao_ponto/')) {
                        return caches.match('/gestao_ponto/index.html');
                    }
                    return caches.match('/index.html');
                });
            })
        );
        return;
    }

    // 2. Arquivos Estáticos (JS, CSS, Imagens) -> Stale-While-Revalidate
    // Mostra o cache rápido, atualiza em background.
    if (urlsToCache.some(u => url.pathname.endsWith(u))) {
        event.respondWith(
            caches.open(CACHE_NAME).then(cache => {
                return cache.match(request).then(cachedResponse => {
                    // Faz o fetch de atualização independente do cache
                    const fetchPromise = fetch(request).then(networkResponse => {
                        // Só atualiza o cache se a resposta for válida (Status 200)
                        if (networkResponse && networkResponse.status === 200) {
                            cache.put(request, networkResponse.clone());
                        }
                        return networkResponse;
                    }).catch(err => {
                        // Se der erro de rede, apenas ignora (o usuário verá o cache)
                        // console.log('Sem rede para atualizar:', request.url);
                    });

                    // Retorna o cache se tiver, senão espera a rede
                    return cachedResponse || fetchPromise;
                });
            })
        );
        return;
    }

    // 3. Outras requisições (API, etc) -> Network Only
    event.respondWith(fetch(request));
});

// Mensagens do Sistema
self.addEventListener('message', event => {
    if (event.data && event.data.type === 'SKIP_WAITING') {
        self.skipWaiting();
    }
});