{
  "Vapid": {
    "Subject": "mailto:admin@yourdomain.com",
    "PublicKey": "BEl62iUYgUivxIkv69yViEuiBIa-Ib9-SkvMeAtA3LFgDzkrxZJjSgSnfckjBJuBkr3qBUYIHBQFLXYp5Nksh8U",
    "PrivateKey": "UUxI4O8-FbRouAevSmBQ6co-EEYr-exiV7q79bsO8K0"
  }
}

namespace NotificationsDemo.Models;

// Зберігаємо дані підписки в БД — вони потрібні при кожній відправці Push
public class PushSubscriptionEntity
{
    public int Id { get; set; }
    public int UserId { get; set; }

    // Унікальна URL Push Service для цього конкретного браузера/пристрою.
    // Це і є "адреса доставки" — саме сюди ваш сервер надсилатиме повідомлення.
    public string Endpoint { get; set; } = string.Empty;

    // P256DH — публічний ECDH-ключ браузера для шифрування payload.
    // Ваш сервер шифрує повідомлення цим ключем — розшифрувати може тільки цей браузер.
    public string P256DH { get; set; } = string.Empty;

    // Auth — 16-байтовий секрет аутентифікації.
    // Захищає від підміни: підтверджує, що payload зашифровано для правильного одержувача.
    public string Auth { get; set; } = string.Empty;

    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
}

public DbSet<PushSubscriptionEntity> PushSubscriptions => Set<PushSubscriptionEntity>();

// Service Worker для Web Push нотифікацій
// Цей файл виконується у фоні, ОКРЕМО від JavaScript-коду вашої сторінки.

// === Lifecycle Events ===

// 'install' — викликається при першій реєстрації або оновленні файлу sw.js.
// self.skipWaiting() форсує миттєву активацію нового SW (тільки для розробки!).
// У продакшені — краще дати користувачеві вибір «Оновити сторінку для нової версії».
self.addEventListener('install', (event) => {
    console.log('[SW] Встановлюється...');
    // self.skipWaiting(); // Розкоментуйте для форсованого оновлення при розробці
});

// 'activate' — SW стає активним і бере контроль над сторінками.
// clients.claim() дозволяє SW одразу контролювати вже відкриті вкладки
// (без цього — лише нові вкладки будуть під контролем нового SW).
self.addEventListener('activate', (event) => {
    console.log('[SW] Активовано.');
    event.waitUntil(clients.claim());
});

// === Push Events ===

// 'push' — основна подія: викликається браузером при отриманні push-повідомлення.
// Це відбувається НАВІТЬ ЯКЩО всі вкладки сайту закриті.
self.addEventListener('push', (event) => {
    // event.data — це PushMessageData. Може бути null якщо відправлено «silent push» без payload.
    const data = event.data?.json() ?? {
        title: 'Нотифікація',
        body: 'Нове повідомлення',
        actionUrl: '/'
    };

    // event.waitUntil() ОБОВ'ЯЗКОВИЙ: браузер не закриє SW поки Promise не завершиться.
    // Без нього SW може "вбитися" до того як showNotification() відпрацює.
    event.waitUntil(
        self.registration.showNotification(data.title, {
            body: data.body,
            icon: '/icon-192.png',       // Іконка 192x192px у сповіщенні
            badge: '/badge-72.png',      // Мала монохромна іконка 72px (Android status bar)
            data: { url: data.actionUrl }, // Зберігаємо URL — використаємо при кліку
            tag: 'notification',         // Якщо прийде нова нотифікація — замінить стару (не буде дублів)
            renotify: true,              // Але все одно покаже звук/вібрацію при заміні
            // vibrate: [200, 100, 200], // Паттерн вібрації (тільки Android Chrome)
        })
    );
});

// 'notificationclick' — користувач клікнув на сповіщення.
self.addEventListener('notificationclick', (event) => {
    event.notification.close(); // Закриваємо сповіщення зі списку

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

    event.waitUntil(
        // clients.matchAll — отримуємо список всіх відкритих вкладок цього сайту
        clients.matchAll({ type: 'window', includeUncontrolled: true }).then((windowClients) => {
            // Якщо вкладка з потрібним URL вже відкрита — фокусуємо її
            for (const client of windowClients) {
                if (client.url.startsWith(self.location.origin) && 'focus' in client) {
                    client.navigate(url);
                    return client.focus();
                }
            }
            // Якщо жодної вкладки немає — відкриваємо нову
            if (clients.openWindow) {
                return clients.openWindow(url);
            }
        })
    );
});

using Microsoft.EntityFrameworkCore;
using NotificationsDemo.Models;

namespace NotificationsDemo.Endpoints;

public static class PushEndpoints
{
    public static void MapPushEndpoints(this WebApplication app)
    {
        var group = app.MapGroup("/push");

        group.MapGet("/vapid-public-key", GetVapidPublicKey);
        group.MapPost("/subscribe", Subscribe);
        group.MapDelete("/unsubscribe", Unsubscribe);
    }

    // GET /push/vapid-public-key
    // Клієнт отримує публічний VAPID-ключ для того щоб передати його
    // в pushManager.subscribe(). Приватний ключ НІКОЛИ не покидає сервер.
    private static IResult GetVapidPublicKey(IConfiguration config)
    {
        var publicKey = config["Vapid:PublicKey"]
            ?? throw new InvalidOperationException("VAPID PublicKey не налаштовано в конфігурації");

        return Results.Ok(new { publicKey });
    }

    // POST /push/subscribe — зберігаємо PushSubscription від браузера
    private static async Task<IResult> Subscribe(
        AppDbContext db,
        SubscribeRequest request)
    {
        // Ідемпотентна операція: якщо підписка вже є — нічого не робимо.
        // Endpoint унікальний для кожного браузера/пристрою — це надійний ідентифікатор.
        var existing = await db.PushSubscriptions
            .FirstOrDefaultAsync(s => s.Endpoint == request.Endpoint);

        if (existing is not null)
            return Results.Ok(new { message = "Підписку вже зареєстровано." });

        var subscription = new PushSubscriptionEntity
        {
            UserId = request.UserId,
            Endpoint = request.Endpoint,
            P256DH = request.P256DH,
            Auth = request.Auth
        };

        db.PushSubscriptions.Add(subscription);
        await db.SaveChangesAsync();

        return Results.Created("/push/subscribe", new { message = "Підписку зареєстровано." });
    }

    // DELETE /push/unsubscribe — видаляємо підписку при відмові від сповіщень
    private static async Task<IResult> Unsubscribe(AppDbContext db, UnsubscribeRequest request)
    {
        await db.PushSubscriptions
            .Where(s => s.Endpoint == request.Endpoint)
            .ExecuteDeleteAsync();

        return Results.Ok(new { message = "Підписку скасовано." });
    }
}

public record SubscribeRequest(int UserId, string Endpoint, string P256DH, string Auth);
public record UnsubscribeRequest(string Endpoint);

using WebPush;
using System.Text.Json;
using NotificationsDemo.Models;

namespace NotificationsDemo.Services;

public class WebPushSenderService : BackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly IConfiguration _configuration;
    private readonly ILogger<WebPushSenderService> _logger;

    public WebPushSenderService(
        IServiceScopeFactory scopeFactory,
        IConfiguration configuration,
        ILogger<WebPushSenderService> logger)
    {
        _scopeFactory = scopeFactory;
        _configuration = configuration;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try { await SendPendingPushNotifications(stoppingToken); }
            catch (OperationCanceledException) { break; }
            catch (Exception ex) { _logger.LogError(ex, "Помилка відправки Web Push"); }

            await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
        }
    }

    private async Task SendPendingPushNotifications(CancellationToken cancellationToken)
    {
        await using var scope = _scopeFactory.CreateAsyncScope();
        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();

        // Вибираємо нотифікації, що з'явилися за ОСТАННІ 30 секунд
        // (інтервал опитування = 30с, тому 30с достатньо щоб не пропустити)
        var cutoff = DateTime.UtcNow.AddSeconds(-30);
        var recentNotifications = await db.Notifications
            .Where(n => !n.IsRead && n.CreatedAt >= cutoff)
            .GroupBy(n => n.UserId)
            .ToListAsync(cancellationToken);

        if (!recentNotifications.Any()) return;

        // VapidDetails вказує Push Service хто відправник — підписується приватним ключем.
        // Subject — контактна інформація (mailto: або https://), Push Service може
        // написати вам якщо виникнуть проблеми з доставкою.
        var vapidDetails = new VapidDetails(
            subject: _configuration["Vapid:Subject"]!,
            publicKey: _configuration["Vapid:PublicKey"]!,
            privateKey: _configuration["Vapid:PrivateKey"]!);

        var client = new WebPushClient();

        foreach (var userGroup in recentNotifications)
        {
            var userId = userGroup.Key;
            var notifications = userGroup.ToList();

            var subscriptions = await db.PushSubscriptions
                .Where(s => s.UserId == userId)
                .ToListAsync(cancellationToken);

            foreach (var sub in subscriptions)
            {
                var pushSubscription = new WebPush.PushSubscription(
                    endpoint: sub.Endpoint,
                    p256dh: sub.P256DH,
                    auth: sub.Auth);

                // Payload автоматично шифрується бібліотекою за допомогою P256DH + Auth.
                // Push Service отримує зашифровані байти і не може прочитати вміст.
                var payload = JsonSerializer.Serialize(new
                {
                    title = notifications.Count == 1
                        ? $"🔔 {notifications[0].Type}"
                        : $"🔔 {notifications.Count} нових нотифікацій",
                    body = notifications[0].Message,
                    actionUrl = notifications[0].ActionUrl ?? "/notifications"
                });

                try
                {
                    // WebPushOptions.TimeToLive визначає скільки секунд Push Service
                    // зберігатиме повідомлення якщо браузер офлайн.
                    // За замовчуванням ~2 тижні; для нотифікації про лайк 24 години достатньо.
                    var options = new WebPushOptions
                    {
                        VapidDetails = vapidDetails,
                        TimeToLive = (int)TimeSpan.FromHours(24).TotalSeconds
                    };

                    await client.SendNotificationAsync(pushSubscription, payload, options);
                    _logger.LogInformation("Web Push надіслано userId={UserId}", userId);
                }
                catch (WebPushException ex) when (ex.StatusCode == System.Net.HttpStatusCode.Gone)
                {
                    // 410 Gone: браузер відписався або підписка протермінована.
                    // Це нормальна ситуація — просто видаляємо запис з БД.
                    db.PushSubscriptions.Remove(sub);
                    _logger.LogInformation("Видалено недійсну підписку userId={UserId}", userId);
                }
                catch (WebPushException ex) when (ex.StatusCode == System.Net.HttpStatusCode.TooManyRequests)
                {
                    // 429 Too Many Requests: ваш сервер відправляє занадто багато push.
                    // Push Service обмежує кількість повідомлень. Потрібен rate limiting.
                    _logger.LogWarning("Rate limit Push Service userId={UserId}", userId);
                }
            }
        }

        await db.SaveChangesAsync(cancellationToken);
    }
}

<!DOCTYPE html>
<html lang="uk">
<head>
    <meta charset="UTF-8">
    <title>Push Notifications Demo</title>
    <style>
        body { font-family: sans-serif; max-width: 600px; margin: 40px auto; padding: 0 20px; }
        .push-banner { background: #eff6ff; border: 1px solid #bfdbfe; border-radius: 8px;
                       padding: 16px; margin: 20px 0; display: none; }
        .push-banner.visible { display: block; }
        .btn-primary { background: #3b82f6; color: white; border: none; border-radius: 6px;
                       padding: 10px 20px; cursor: pointer; font-size: 14px; }
        .btn-secondary { background: transparent; color: #64748b; border: none;
                         padding: 10px 20px; cursor: pointer; }
        #push-status { font-size: 13px; color: #64748b; margin-top: 8px; }
    </style>
</head>
<body>
    <h1>🔔 Web Push Demo</h1>

    <!-- Власний UI-діалог — показуємо ПЕРЕД запитом браузера -->
    <!-- Лише після кліку "Увімкнути" — викликаємо requestPermission() -->
    <div id="push-banner" class="push-banner">
        <strong>Отримуйте сповіщення про нові активності</strong>
        <p style="color:#475569;margin:8px 0;">Ми надсилатимемо вам push-сповіщення про нові лайки,
           коментарі та важливі оновлення. Без спаму.</p>
        <button class="btn-primary" onclick="enablePush()">🔔 Увімкнути сповіщення</button>
        <button class="btn-secondary" onclick="dismissBanner()">Пізніше</button>
    </div>

    <p id="push-status"></p>

    <script>
        const USER_ID = 1;
        const PUSH_DISMISSED_KEY = 'push_banner_dismissed';

        // При завантаженні — перевіряємо поточний стан підписки
        window.addEventListener('load', async () => {
            // Перевіряємо підтримку браузером
            if (!('serviceWorker' in navigator) || !('PushManager' in window)) {
                document.getElementById('push-status').textContent =
                    'Ваш браузер не підтримує Web Push';
                return;
            }

            const permission = Notification.permission;

            if (permission === 'granted') {
                // Вже є дозвіл — перевіряємо чи є активна підписка
                const reg = await navigator.serviceWorker.getRegistration();
                const sub = await reg?.pushManager.getSubscription();

                if (sub) {
                    // Підписка вже є — нічого не робимо
                    document.getElementById('push-status').textContent =
                        '✅ Push-сповіщення увімкнено';
                } else {
                    // Дозвіл є, але підписки немає — підписуємося автоматично
                    await subscribeToPush();
                }
            } else if (permission === 'default') {
                // Ще не запитували — показуємо наш банер (якщо не відхилили раніше)
                if (!localStorage.getItem(PUSH_DISMISSED_KEY)) {
                    document.getElementById('push-banner').classList.add('visible');
                }
            }
            // permission === 'denied': користувач заблокував — мовчимо, не набридаємо
        });

        async function enablePush() {
            document.getElementById('push-banner').classList.remove('visible');

            // Тільки тут — після явної згоди — запитуємо браузерний дозвіл
            const permission = await Notification.requestPermission();

            if (permission !== 'granted') {
                document.getElementById('push-status').textContent =
                    '❌ Дозвіл відхилено. Змініть налаштування сайту в браузері.';
                return;
            }

            await subscribeToPush();
        }

        function dismissBanner() {
            document.getElementById('push-banner').classList.remove('visible');
            // Запам'ятовуємо відмову — не показуємо банер знову у цій сесії
            localStorage.setItem(PUSH_DISMISSED_KEY, '1');
        }

        async function subscribeToPush() {
            const statusEl = document.getElementById('push-status');
            statusEl.textContent = '⏳ Реєстрація...';

            try {
                // Реєструємо Service Worker (якщо вже зареєстровано — повертає існуючу реєстрацію)
                const registration = await navigator.serviceWorker.register('/sw.js');

                // Очікуємо поки SW стане активним (може бути у стані 'installing' або 'waiting')
                await navigator.serviceWorker.ready;

                // Отримуємо VAPID публічний ключ від сервера
                const keyRes = await fetch('/push/vapid-public-key');
                const { publicKey } = await keyRes.json();

                // Підписуємося на Push Service.
                // applicationServerKey: сервер Push Service переконається,
                // що надалі push надсилатиме саме власник цього publicKey.
                // userVisibleOnly: true — обов'язковий параметр у Chrome.
                // Означає: кожен push ПОВИНЕН показати сповіщення користувачеві.
                // Silent push (без showNotification) Chrome забороняє.
                const subscription = await registration.pushManager.subscribe({
                    userVisibleOnly: true,
                    applicationServerKey: urlBase64ToUint8Array(publicKey)
                });

                // Відправляємо PushSubscription на сервер
                const subJson = subscription.toJSON();
                await fetch('/push/subscribe', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({
                        userId: USER_ID,
                        endpoint: subJson.endpoint,
                        p256dh: subJson.keys.p256dh,
                        auth: subJson.keys.auth
                    })
                });

                statusEl.textContent = '✅ Push-сповіщення увімкнено!';
            } catch (err) {
                console.error('Помилка підписки:', err);
                statusEl.textContent = `❌ Помилка: ${err.message}`;
            }
        }

        // Конвертує base64url-рядок у Uint8Array.
        // Браузерний API pushManager.subscribe() очікує саме Uint8Array, а не рядок.
        // Base64url відрізняється від звичайного Base64: використовує '-' і '_' замість '+' і '/'.
        function urlBase64ToUint8Array(base64String) {
            const padding = '='.repeat((4 - base64String.length % 4) % 4);
            const base64 = (base64String + padding)
                .replace(/-/g, '+')
                .replace(/_/g, '/');
            const rawData = atob(base64);
            return Uint8Array.from([...rawData].map(c => c.charCodeAt(0)));
        }
    </script>
</body>
</html>

builder.Services.AddHostedService<WebPushSenderService>();

// Після app.Build():
app.UseStaticFiles(); // Потрібно для роздачі sw.js
app.MapPushEndpoints();