// sw.js

const CACHE_NAME_ERR = 'svg-layer-editor-cache-v30'; // Behalte v2 oder erhöhe, wenn du testest
const urlsToCache = [
    '.',
    'index.html',
    'offline.html',
    'manifest.json',
    // CSS-Dateien (Pfade an deine Struktur anpassen!)
    'css/bootstrap.min.css',
    'css/material-icons.css', // Sicherstellen, dass dieser Pfad korrekt ist (liegt es im Root?)
    'css/css.css',      // Falls vorhanden
    // JavaScript-Dateien (Pfade an deine Struktur anpassen!)
    'js/main.js',
    'js/config.js',
    'js/layer.js',
    'js/canvasController.js',
    'js/uiController.js',
    'js/notifications.js',
    'js/dataLoader.js',
    // 'js/fontLoader.js', // Falls vorhanden und genutzt
    'js/bootstrap.bundle.min.js',
    // Font-Dateien (Pfade an deine Struktur anpassen!)
    'fonts/material-icons-v143-latin-regular.woff2', // Sicherstellen, dass dieser Pfad korrekt ist
    // App-Icons
    // 'icons/icon-192x192.png',
    // 'icons/icon-512x512.png',

    'layers/2023-Korporations-F-kleiner-Rat.png',
    'layers/2023-Korporations-F-Elferrat.png',
    'layers/2023-Korporations-F-Senat.png',
    'layers/2023-Korporations-F-Garde.png',
    'layers/2025-Korporations-F-Jofelinen.png',
    'layers/2023-Korporations-F-Kadetten.png',
    'layers/2023-Korporations-F-Tanzcorp.png',
];

self.addEventListener('install', event => {
    console.log('Service Worker: Installiere...');
    event.waitUntil(
        caches.open(CACHE_NAME)
            .then(cache => {
                console.log('Service Worker: Caching App Shell für:', CACHE_NAME);
                return cache.addAll(urlsToCache)
                    .catch(error => { // Detailliertere Fehlermeldung bei addAll-Fehler
                        console.error('Service Worker: Fehler beim cache.addAll:', error);
                        urlsToCache.forEach(url => {
                            fetch(url).then(res => {
                                if (!res.ok) console.error(`Fehlerhafte URL in urlsToCache: ${url} - Status: ${res.status}`);
                            }).catch(e => console.error(`Netzwerkfehler bei URL in urlsToCache: ${url}`, e));
                        });
                        throw error; // Fehler weiterwerfen, um Installation als fehlgeschlagen zu markieren
                    });
            })
            .then(() => {
                console.log('Service Worker: App Shell erfolgreich gecached.');
                return self.skipWaiting();
            })
            .catch(error => {
                // Dieser Catch fängt Fehler vom caches.open oder den äußeren Promises ab
                console.error('Service Worker: Caching der App Shell fehlgeschlagen:', error);
            })
    );
});

self.addEventListener('activate', event => {
    console.log('Service Worker: Aktiviere...');
    event.waitUntil(
        caches.keys().then(cacheNames => {
            return Promise.all(
                cacheNames.map(cacheName => {
                    if (cacheName !== CACHE_NAME) {
                        console.log('Service Worker: Lösche alten Cache', cacheName);
                        return caches.delete(cacheName);
                    }
                })
            );
        }).then(() => {
            console.log('Service Worker: Aktiv und kontrolliert Clients.');
            return self.clients.claim();
        })
    );
});

self.addEventListener('fetch', event => {

    const request = event.request;
    const url = new URL(request.url); // URL-Objekt für einfachere Handhabung

    if (url.pathname.startsWith('/admin/')) {
    // Für /admin/-Pfade: Den Request NICHT vom Service Worker behandeln lassen.
    // Der Browser soll die Anfrage direkt ans Netzwerk senden.
    // console.log('SW: Ignoriere Request für /admin/ Pfad:', event.request.url);
    return; // WICHTIG: KEIN event.respondWith() aufrufen!
            // Alternativ, um sicherzustellen, dass es ans Netzwerk geht:
            // return fetch(event.request);
  }
    // ----- BEGINN DER WICHTIGEN PRÜFUNGEN -----

    // 1. Anfragen von Browser-Erweiterungen oder andere nicht-HTTP(S) Protokolle FRÜHZEITIG IGNORIEREN
    //    und den Browser normal behandeln lassen (kein event.respondWith).
    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
        // console.log('SW Fetch: Ignoriere Anfrage mit nicht unterstütztem Protokoll (z.B. chrome-extension):', url.href);
        // Durch einfaches `return;` ohne `event.respondWith()` wird die Anfrage
        // vom Browser normal ohne Service Worker Interferenz behandelt.
        return;
    }

    // 2. Spezifische Behandlung für das PHP-Skript (Network-First, dann Cache-Fallback)
    if (url.pathname.endsWith('/php/list_layers.php') || url.pathname.endsWith('list_layers.php')) {
        // console.log('SW Fetch: Bearbeite API-Anfrage (Network-First):', url.href);
        event.respondWith(
            fetch(request)
                .then(networkResponse => {
                    if (networkResponse && networkResponse.ok) {
                        const responseToCache = networkResponse.clone();
                        caches.open(CACHE_NAME).then(cache => {
                            cache.put(request, responseToCache);
                        });
                    } else if (networkResponse) {
                        console.warn(`SW Fetch: API-Antwort von ${url.href} nicht OK: ${networkResponse.status}`);
                    }
                    return networkResponse;
                })
                .catch(error => {
                    console.warn(`SW Fetch: Netzwerkfehler für API ${url.href}. Versuche Cache.`, error.message);
                    return caches.match(request, { cacheName: CACHE_NAME })
                        .then(cachedResponse => {
                            if (cachedResponse) {
                                return cachedResponse;
                            }
                            const errorBody = JSON.stringify({ error: "Netzwerkfehler und kein API-Cache verfügbar." });
                            return new Response(errorBody, {
                                status: 503,
                                statusText: "Service Unavailable",
                                headers: { 'Content-Type': 'application/json' }
                            });
                        });
                })
        );
        return; // Wichtig: Bearbeitung für diese Anfrage hier beenden
    }

    // ----- ENDE DER SPEZIFISCHEN BEHANDLUNGEN -----


    // 3. Cache-First-Strategie für alle anderen (statischen) Anfragen
    event.respondWith(
        caches.match(request)
            .then(cachedResponse => {
                if (cachedResponse) {
                    return cachedResponse;
                }

                return fetch(request).then(
                    networkResponse => {
                        // Nur gültige, erfolgreiche Antworten dynamisch cachen
                        if (!networkResponse || networkResponse.status !== 200 || request.method !== 'GET') {
                            return networkResponse;
                        }

                        // Wichtige Prüfung: Stelle sicher, dass wir nicht versuchen, eine opake Antwort zu cachen,
                        // es sei denn, wir wissen genau, was wir tun. Für 'basic' (same-origin) und 'cors' ist es ok.
                        // Aber da wir Extension-Requests oben schon abfangen, ist dies hier weniger kritisch.
                        // if (networkResponse.type !== 'basic' && networkResponse.type !== 'cors') {
                        //    return networkResponse;
                        // }


                        const responseToCache = networkResponse.clone();
                        caches.open(CACHE_NAME)
                            .then(cache => {
                                cache.put(request, responseToCache);
                            });
                        return networkResponse;
                    }
                ).catch(error => {
                    console.warn('SW Fetch: Netzwerkfehler für statisches Asset:', url.href, error.message);
                    if (request.mode === 'navigate') {
                        return caches.match('offline.html');
                    }
                    // Für andere Assets lassen wir den Fehler durch, damit der Browser ihn anzeigt.
                });
            })
    );
});
