{{-- v1.4 §5.4 — Enregistrement du service worker et gestion de l'abonnement push.
     Le service worker ne met RIEN en cache (voir public/sw.js) : il ne sert qu'aux notifications.
     Aucune demande de permission n'est faite ici — elle part uniquement d'un clic de l'utilisateur
     sur l'écran « Notifications », comme l'exigent les navigateurs.

     v3.12.0 — `data-navigate-once` : le panneau navigue désormais côté client (mode SPA), et
     Livewire ré-exécute par défaut les scripts du corps à chaque changement d'écran. Ce script
     n'a de sens qu'une fois — il pose `window.soclePush` et un écouteur `load` qui ne se
     redéclenchera jamais. Sans cet attribut, on empilerait un écouteur mort par clic.

     v4.14.0 §C — `$routesPush` permet à un autre HÔTE de servir le même script vers SES adresses.
     Le nouvel espace client vit sur son propre sous-domaine : appeler `push.key` de APP_DOMAIN
     depuis là partirait vers un autre domaine, sans le cookie de session. Absent — le cas des
     quatre panneaux — rien ne change d'un caractère.

     v4.17.1 §B — La brique annonce qu'elle est PRÊTE (`socle:push-pret`) : un écran qui l'a lue
     trop tôt ré-évalue l'état au lieu d'afficher « indisponible » à tort. Dans les deux apps
     (client, Studio), elle est en outre montée AVANT l'écran, dans le gabarit.

     v4.16.1 §C — LA DÉTECTION SUR IPHONE, corrigée ICI et nulle part ailleurs. Ce script est le
     point unique consommé par QUATRE écrans (le Compte du nouvel espace, l'ancien espace client,
     le profil des panneaux, et les quatre panneaux qui le chargent). Il exigeait `window.Notification`,
     qu'une application iOS INSTALLÉE n'expose pas alors que le push y fonctionne par le service
     worker (iOS 16.4+) : l'écran disait « Indisponibles ici » à tort. Désormais :
       - `supporte()` ne demande que le service worker et `PushManager` ;
       - tout ce qui lit `Notification` le fait à condition qu'il existe ;
       - la permission passe par `Notification.requestPermission` quand elle existe, sinon par
         `pushManager.subscribe`, qui déclenche l'invite native d'iOS ;
       - un état NEUF, `installer-dabord`, dit qu'on est sur iPhone dans Safari sans l'app sur
         l'écran d'accueil — là, le push n'existe pas encore, mais ce n'est pas « non supporté ». --}}
@php
    $routesPush = $routesPush ?? ['cle' => route('push.key'), 'abonnement' => route('push.subscribe')];
@endphp
<script data-navigate-once>
    window.soclePush = (function () {
        const routes = {
            cle: @json($routesPush['cle']),
            abonnement: @json($routesPush['abonnement']),
        };

        function base64UrlVersUint8Array(base64) {
            const padding = '='.repeat((4 - (base64.length % 4)) % 4);
            const brut = atob((base64 + padding).replace(/-/g, '+').replace(/_/g, '/'));
            return Uint8Array.from([...brut].map((c) => c.charCodeAt(0)));
        }

        function jeton() {
            const meta = document.querySelector('meta[name="csrf-token"]');
            return meta ? meta.getAttribute('content') : '';
        }

        async function enregistrerLeServiceWorker() {
            if (!('serviceWorker' in navigator)) {
                return null;
            }
            try {
                return await navigator.serviceWorker.register('/sw.js', { scope: '/' });
            } catch (e) {
                console.warn('[socle] Service worker non enregistré :', e);
                return null;
            }
        }

        async function supporte() {
            // ⚠️ Sans exiger l'objet global des notifications : une application iOS installée ne
            // l'expose pas, et le push y marche pourtant par le service worker.
            return 'serviceWorker' in navigator && 'PushManager' in window;
        }

        // L'application est-elle ouverte depuis l'écran d'accueil ? Le même test que la page
        // publique de l'espace : `display-mode: standalone`, ou le drapeau propre à iOS.
        function installee() {
            try {
                return (window.matchMedia && window.matchMedia('(display-mode: standalone)').matches)
                    || window.navigator.standalone === true;
            } catch (e) {
                return false;
            }
        }

        // iPhone, iPad (y compris ceux qui se présentent en Mac avec écran tactile) et iPod.
        function surIos() {
            const ua = navigator.userAgent || '';
            return /iPhone|iPad|iPod/i.test(ua)
                || (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
        }

        async function etat() {
            // Sur iOS, hors de l'application installée, le push n'existe pas ENCORE : ce n'est pas
            // un défaut du navigateur, c'est une étape à franchir. On la nomme.
            if (surIos() && !installee()) {
                return 'installer-dabord';
            }
            if (!(await supporte())) {
                return 'non-supporte';
            }
            if (window.Notification && Notification.permission === 'denied') {
                return 'refuse';
            }
            const registration = await navigator.serviceWorker.getRegistration('/');
            if (!registration) {
                return 'inactif';
            }
            const abonnement = await registration.pushManager.getSubscription();
            return abonnement ? 'actif' : 'inactif';
        }

        async function demanderLaPermission(registration, clePublique) {
            // Quand l'API existe, on la demande explicitement : c'est elle qui sait dire « refusé ».
            if (window.Notification && typeof Notification.requestPermission === 'function') {
                const permission = await Notification.requestPermission();
                if (permission !== 'granted') {
                    throw new Error('Notifications refusées par le navigateur.');
                }
                return;
            }

            // Sans elle (application iOS installée), c'est l'abonnement lui-même qui ouvre l'invite
            // native. Un refus sort en exception — on la traduit.
            try {
                await registration.pushManager.subscribe({
                    userVisibleOnly: true,
                    applicationServerKey: base64UrlVersUint8Array(clePublique),
                });
            } catch (e) {
                throw new Error('Notifications refusées sur cet appareil.');
            }
        }

        async function activer() {
            if (surIos() && !installee()) {
                throw new Error('Installez d\'abord l\'application sur votre écran d\'accueil, puis activez les notifications.');
            }

            if (!(await supporte())) {
                throw new Error('Ce navigateur ne prend pas en charge les notifications.');
            }

            const reponse = await fetch(routes.cle, { headers: { Accept: 'application/json' } });
            const { active, public_key: clePublique } = await reponse.json();

            if (!active || !clePublique) {
                throw new Error('Les notifications ne sont pas encore configurées côté serveur.');
            }

            const registration = (await navigator.serviceWorker.getRegistration('/'))
                || (await enregistrerLeServiceWorker());

            if (!registration) {
                throw new Error('Service worker indisponible.');
            }

            await navigator.serviceWorker.ready;

            await demanderLaPermission(registration, clePublique);

            // Déjà abonné par l'invite native ci-dessus ? On reprend l'abonnement tel quel :
            // `subscribe` sur un abonnement existant avec la même clé le renvoie sans en créer un
            // second.
            const abonnement = (await registration.pushManager.getSubscription())
                || (await registration.pushManager.subscribe({
                    userVisibleOnly: true,
                    applicationServerKey: base64UrlVersUint8Array(clePublique),
                }));

            await fetch(routes.abonnement, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRF-TOKEN': jeton(),
                    Accept: 'application/json',
                },
                body: JSON.stringify(abonnement.toJSON()),
            });

            return true;
        }

        async function desactiver() {
            const registration = await navigator.serviceWorker.getRegistration('/');
            if (!registration) {
                return true;
            }
            const abonnement = await registration.pushManager.getSubscription();
            if (!abonnement) {
                return true;
            }

            await fetch(routes.abonnement, {
                method: 'DELETE',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRF-TOKEN': jeton(),
                    Accept: 'application/json',
                },
                body: JSON.stringify({ endpoint: abonnement.endpoint }),
            });

            await abonnement.unsubscribe();

            return true;
        }

        // Le service worker s'enregistre dès le chargement : sans lui, aucune notification ne peut
        // arriver, même si la permission a déjà été accordée sur un autre appareil.
        if ('serviceWorker' in navigator) {
            window.addEventListener('load', enregistrerLeServiceWorker);
        }

        return { etat, activer, desactiver, supporte, installee, surIos };
    })();

    // v4.17.1 §B — LA BRIQUE EST PRÊTE. Les écrans qui lisent `window.soclePush` ne doivent
    // JAMAIS conclure « non supporté » parce qu'ils ont regardé trop tôt : ce script vit en bas
    // de page dans les panneaux (crochet de rendu) et un écran monté avant lui retombait sur le
    // repli. Chaque écran écoute cet événement et ré-évalue l'état quand il arrive.
    window.soclePushPret = true;
    try { window.dispatchEvent(new CustomEvent('socle:push-pret')); } catch (e) {}
</script>