PWA Configuration

// public/sw.js:9
const PRECACHE_URLS = [
  '/',
  '/index.html',
  '/offline.html',
  '/manifest.webmanifest',
  '/apple-touch-icon.png',
  '/pwa-192x192.png',
  '/pwa-512x512.png',
  '/pwa-maskable-512x512.png',
];

// public/sw.js:196
self.addEventListener('notificationclick', (event) => {
  event.notification.close();

  const targetUrl = new URL(
    event.notification.data?.url || '/notificaciones',
    self.location.origin
  ).href;

  event.waitUntil(
    self.clients.matchAll({ type: 'window', includeUncontrolled: true })
      .then((clients) => {
        // Focus existing tab if URL matches
        for (const client of clients) {
          if (client.url === targetUrl && 'focus' in client) {
            return client.focus();
          }
        }
        // Otherwise open new window
        if (self.clients.openWindow) {
          return self.clients.openWindow(targetUrl);
        }
      })
  );
});

// src/main.tsx (service worker registration)
if ('serviceWorker' in navigator && window.isSecureContext) {
  navigator.serviceWorker
    .register(`/sw.js?v=${__APP_VERSION__}`, {
      updateViaCache: 'none',
    })
    .then((registration) => {
      console.log('Service Worker registered:', registration);
    })
    .catch((error) => {
      console.error('Service Worker registration failed:', error);
    });
}

// src/services/pushNotificationsService.ts:83
export async function subscribeCurrentDeviceToPush(
  vapidPublicKey: string
): Promise<void> {
  // 1. Request notification permission
  const permission = await Notification.requestPermission();
  if (permission !== 'granted') {
    throw new Error('El permiso de notificaciones fue denegado.');
  }

  // 2. Ensure service worker is active
  const registration = await ensureServiceWorkerRegistration();

  // 3. Subscribe to push manager
  let subscription = await registration.pushManager.getSubscription();
  if (!subscription) {
    subscription = await registration.pushManager.subscribe({
      userVisibleOnly: true,
      applicationServerKey: urlBase64ToUint8Array(vapidPublicKey),
    });
  }

  // 4. Save subscription to database
  const json = subscription.toJSON();
  await supabase.from('push_subscriptions').upsert({
    user_id: userId,
    endpoint: json.endpoint,
    p256dh: json.keys.p256dh,
    auth: json.keys.auth,
    user_agent: navigator.userAgent,
    platform: navigator.userAgentData?.platform ?? navigator.platform,
    last_seen_at: new Date().toISOString(),
  }, { onConflict: 'user_id,endpoint' });
}

// src/services/pushNotificationsService.ts:144
export async function unsubscribeCurrentDeviceFromPush(): Promise<void> {
  const registration = await navigator.serviceWorker.getRegistration();
  const subscription = await registration?.pushManager.getSubscription();
  
  // 1. Unsubscribe from browser
  if (subscription) {
    await subscription.unsubscribe();
  }

  // 2. Remove from database
  await supabase
    .from('push_subscriptions')
    .delete()
    .eq('user_id', userId)
    .eq('endpoint', subscription?.endpoint);
}

// src/services/pushNotificationsService.ts:73
export function isPushSupported() {
  return (
    typeof window !== 'undefined' &&
    window.isSecureContext &&
    'Notification' in window &&
    'PushManager' in window &&
    'serviceWorker' in navigator
  );
}

// src/services/notificationCenterService.ts:565
export function subscribeToMyNotificationDeliveries(
  userId: string,
  onChange: () => void
) {
  const channelName = `notification-deliveries:${userId}:${crypto.randomUUID()}`;

  const channel = supabase
    .channel(channelName)
    .on(
      'postgres_changes',
      {
        event: '*',
        schema: 'public',
        table: 'notification_deliveries',
        filter: `recipient_user_id=eq.${userId}`,
      },
      () => onChange()
    )
    .subscribe();

  return () => {
    void supabase.removeChannel(channel);
  };
}

// src/main.tsx (message listener)
navigator.serviceWorker.addEventListener('message', (event) => {
  if (event.data?.type === 'notification:push_received') {
    // Trigger notification center refresh
    window.dispatchEvent(new CustomEvent('notification:received', {
      detail: { url: event.data.url }
    }));
  }
});

-- Send test notification to specific user
SELECT send_self_test_notification(
  'Prueba manual',
  'Este es un mensaje de prueba desde SQL',
  true  -- send_push
);

-- Admin test (requires permissions)
SELECT admin_send_test_notification(
  '<recipient-user-id>'::uuid,
  'Prueba de admin',
  'Mensaje enviado por administrador',
  '/tickets/123',
  true  -- send_push
);

// Check if service worker is registered
navigator.serviceWorker.getRegistration().then(reg => {
  console.log('SW registration:', reg);
});

// Check push subscription
navigator.serviceWorker.ready.then(reg => {
  reg.pushManager.getSubscription().then(sub => {
    console.log('Push subscription:', sub?.toJSON());
  });
});

// Check notification permission
console.log('Notification permission:', Notification.permission);

// public/sw.js:6
const MAX_RUNTIME_ENTRIES = 120;  // Reduce to 60 for slower devices

if (!isPushSupported()) {
  // Hide push subscription UI
  return;
}

// Optional: Check connection speed
if (navigator.connection?.effectiveType === '2g') {
  // Warn user about data usage
}

// Only include essential fields
const payload = {
  title: notification.title,
  body: notification.message.slice(0, 200),  // Truncate long messages
  url: notification.url,
  tag: notification.deliveryId,  // For deduplication
};

// src/services/notificationCenterService.ts:145
function resolveNotificationUrl(
  payload: Record<string, unknown>,
  entityType: string,
  entityId: string
) {
  const payloadUrl = payload.url;
  // Only allow internal paths starting with '/'
  if (typeof payloadUrl === 'string' && payloadUrl.startsWith('/')) {
    return payloadUrl;
  }
  // Default safe fallback
  if (entityType === 'ticket') {
    return `/tickets/${entityId}`;
  }
  return '/inicio';
}