Web Push

return [
    'vapid' => [
        'subject' => env('VAPID_SUBJECT', ''),
        'public_key' => env('VAPID_PUBLIC_KEY', ''),
        'private_key' => env('VAPID_PRIVATE_KEY', ''),
    ],
];

// Service Worker for Web Push Notifications
self.addEventListener('push', (event) => {
  if (!event.data) return

  const payload = event.data.json()

  const options = {
    body: payload.body || '',
    icon: '/favicon.ico',
    tag: payload.type || 'notification',
    data: { url: '/', ...payload.data },
  }

  event.waitUntil(
    self.registration.showNotification(payload.title || 'Notification', options)
  )
})

self.addEventListener('notificationclick', (event) => {
  event.notification.close()

  const url = event.notification.data?.url || '/'

  event.waitUntil(
    clients.matchAll({ type: 'window', includeUncontrolled: true }).then((windowClients) => {
      // Focus existing tab if available
      for (const client of windowClients) {
        if (client.url.includes(self.location.origin) && 'focus' in client) {
          return client.focus()
        }
      }
      // Open new tab
      return clients.openWindow(url)
    })
  )
})

export function usePushSubscription() {
  const config = useRuntimeConfig()
  const pushApi = usePushApi()

  async function subscribe(): Promise<boolean> {
    if (!('serviceWorker' in navigator)) return false

    const vapidKey = config.public.vapidPublicKey as string
    if (!vapidKey) {
      console.error('[PushSubscription] VAPID public key is not configured')
      return false
    }

    const registration = await navigator.serviceWorker.register('/sw.js')
    const subscription = await registration.pushManager.subscribe({
      userVisibleOnly: true,
      applicationServerKey: urlBase64ToUint8Array(vapidKey),
    })
    await pushApi.storePushSubscription(subscription)
    return true
  }

  async function unsubscribe(): Promise<boolean> {
    const registration = await navigator.serviceWorker.ready
    const subscription = await registration.pushManager.getSubscription()
    if (subscription) {
      await pushApi.deletePushSubscription(subscription.endpoint)
      await subscription.unsubscribe()
    }
    return true
  }

  async function getExistingSubscription(): Promise<PushSubscription | null> {
    const registration = await navigator.serviceWorker.ready
    return await registration.pushManager.getSubscription()
  }

  return {
    subscribe,
    unsubscribe,
    getExistingSubscription,
    isRegistering: readonly(isRegistering),
    isUnregistering: readonly(isUnregistering),
  }
}

final class PushSubscription extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'endpoint',
        'p256dh_key',
        'auth_token',
        'content_encoding',
    ];

    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}

interface WebPushGatewayInterface
{
    /**
     * Send a push notification to multiple subscriptions.
     * Returns the list of expired/invalid subscription IDs to clean up.
     */
    public function sendBatch(Collection $subscriptions, PushPayloadData $payload): array;
}

final readonly class PushPayloadData
{
    public function __construct(
        public string $title,
        public string $body,
        public string $type,
        public string $severity,
        public array $data = [],
    ) {}

    public function toJson(): string
    {
        return (string) json_encode([
            'title' => $this->title,
            'body' => $this->body,
            'type' => $this->type,
            'severity' => $this->severity,
            'data' => $this->data,
        ]);
    }
}

final class MinishWebPushGateway implements WebPushGatewayInterface
{
    private WebPush $webPush;

    public function __construct()
    {
        $this->webPush = new WebPush([
            'VAPID' => [
                'subject' => (string) (config('webpush.vapid.subject') ?? ''),
                'publicKey' => (string) (config('webpush.vapid.public_key') ?? ''),
                'privateKey' => (string) (config('webpush.vapid.private_key') ?? ''),
            ],
        ]);
    }

    public function sendBatch(Collection $subscriptions, PushPayloadData $payload): array
    {
        $json = $payload->toJson();
        $expiredIds = [];

        foreach ($subscriptions as $sub) {
            $this->webPush->queueNotification(
                Subscription::create([
                    'endpoint' => $sub->endpoint,
                    'publicKey' => $sub->p256dh_key,
                    'authToken' => $sub->auth_token,
                    'contentEncoding' => $sub->content_encoding ?? 'aesgcm',
                ]),
                $json,
            );
        }

        foreach ($this->webPush->flush() as $report) {
            if (is_object($report) && method_exists($report, 'isSubscriptionExpired') && $report->isSubscriptionExpired()) {
                $endpoint = method_exists($report, 'getEndpoint') ? $report->getEndpoint() : null;
                $expired = $subscriptions->first(
                    fn (PushSubscription $s) => $s->endpoint === $endpoint
                );
                if ($expired !== null) {
                    $expiredIds[] = $expired->id;
                }
            }
        }

        return $expiredIds;
    }
}

final class SendTenantPushNotificationsJob implements ShouldQueue
{
    public int $tries = 3;

    public function __construct(
        private readonly array $userIds,
        private readonly array $broadcastPayload,
    ) {
        $this->onQueue('default');
    }

    public function backoff(): array
    {
        return [10, 30, 60]; // Progressive backoff in seconds
    }

    public function handle(WebPushGatewayInterface $gateway): void
    {
        $subscriptions = PushSubscription::query()
            ->whereIn('user_id', $this->userIds)
            ->get();

        if ($subscriptions->isEmpty()) {
            return;
        }

        $payload = new PushPayloadData(
            title: (string) ($this->broadcastPayload['title'] ?? ''),
            body: (string) ($this->broadcastPayload['body'] ?? ''),
            type: (string) ($this->broadcastPayload['type'] ?? ''),
            severity: (string) ($this->broadcastPayload['severity'] ?? 'info'),
        );

        $expiredIds = $gateway->sendBatch($subscriptions, $payload);

        if ($expiredIds !== []) {
            PushSubscription::query()->whereIn('id', $expiredIds)->delete();
        }
    }
}