using System.Threading.Channels;
using NotificationsDemo.Models;

namespace NotificationsDemo.Services;

// Singleton-сервіс: один екземпляр на весь час роботи застосунку.
// Зберігає Channel<T> для кожного підключеного SSE-клієнта.
public class NotificationBroadcaster
{
    // Ключ — userId, значення — список каналів цього користувача
    // (один користувач може мати кілька вкладок відкритих)
    private readonly Dictionary<int, List<Channel<NotificationResponse>>> _userChannels = new();

    // Lock для thread-safety при модифікації словника
    private readonly Lock _lock = new();

    // Реєструємо новий SSE-клієнт і повертаємо його канал
    public Channel<NotificationResponse> Subscribe(int userId)
    {
        // Bounded channel: якщо клієнт не встигає читати — буфер до 100 повідомлень
        // після чого нові будуть відхилені (щоб не переповнити пам'ять)
        var channel = Channel.CreateBounded<NotificationResponse>(new BoundedChannelOptions(100)
        {
            FullMode = BoundedChannelFullMode.DropOldest // Витісняємо старі, якщо повний
        });

        lock (_lock)
        {
            if (!_userChannels.ContainsKey(userId))
                _userChannels[userId] = new List<Channel<NotificationResponse>>();

            _userChannels[userId].Add(channel);
        }

        return channel;
    }

    // Відписуємо клієнта (з'єднання завершилося)
    public void Unsubscribe(int userId, Channel<NotificationResponse> channel)
    {
        lock (_lock)
        {
            if (_userChannels.TryGetValue(userId, out var channels))
            {
                channels.Remove(channel);
                if (channels.Count == 0)
                    _userChannels.Remove(userId);
            }
        }

        // Завершуємо writer — це сигналізує reader-у, що більше даних не буде
        channel.Writer.TryComplete();
    }

    // Надсилаємо нотифікацію всім активним SSE-з'єднанням користувача
    public void Broadcast(int userId, NotificationResponse notification)
    {
        List<Channel<NotificationResponse>>? channels;

        lock (_lock)
        {
            if (!_userChannels.TryGetValue(userId, out channels))
                return; // Немає активних SSE-клієнтів для цього userId
            channels = new List<Channel<NotificationResponse>>(channels); // Копія для безпечної ітерації
        }

        foreach (var channel in channels)
        {
            // TryWrite — не блокує; якщо канал повний — подія буде відхилена (DropOldest)
            channel.Writer.TryWrite(notification);
        }
    }
}

using NotificationsDemo.Services;

// Реєструємо як Singleton — один екземпляр зберігає стан усіх підключень
builder.Services.AddSingleton<NotificationBroadcaster>();

// Додайте в MapNotificationEndpoints():
group.MapGet("/stream", StreamNotifications);

// GET /notifications/stream?userId=1
private static async Task StreamNotifications(
    HttpContext context,
    NotificationBroadcaster broadcaster,
    int userId,
    CancellationToken cancellationToken)
{
    // Встановлюємо правильні заголовки для SSE
    context.Response.Headers.Append("Content-Type", "text/event-stream");
    context.Response.Headers.Append("Cache-Control", "no-cache");
    context.Response.Headers.Append("X-Accel-Buffering", "no"); // Для nginx: вимикаємо буферизацію

    // Підписуємося — отримуємо канал для цього клієнта
    var channel = broadcaster.Subscribe(userId);

    try
    {
        // Надсилаємо перше повідомлення — "привіт" щоб клієнт знав, що з'єднання встановлено
        await context.Response.WriteAsync("data: {\"type\":\"connected\"}\n\n", cancellationToken);
        await context.Response.Body.FlushAsync(cancellationToken); // Flush обов'язковий!

        // Читаємо повідомлення з каналу й надсилаємо клієнту
        // ReadAllAsync повертає IAsyncEnumerable — завершується коли channel.Writer.Complete() викликано
        await foreach (var notification in channel.Reader.ReadAllAsync(cancellationToken))
        {
            // Серіалізуємо нотифікацію в JSON
            var json = System.Text.Json.JsonSerializer.Serialize(notification,
                new System.Text.Json.JsonSerializerOptions { PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase });

            // Формат SSE: "data: <json>\n\n"
            // Два символи \n обов'язкові — це роздільник між подіями в SSE-протоколі
            await context.Response.WriteAsync($"data: {json}\n\n", cancellationToken);
            await context.Response.Body.FlushAsync(cancellationToken);
        }
    }
    catch (OperationCanceledException)
    {
        // Клієнт закрив вкладку або від'єднався — це нормальна ситуація
    }
    finally
    {
        // Завжди відписуємося, щоб видалити канал зі словника
        broadcaster.Unsubscribe(userId, channel);
    }
}

// Оновлена сигнатура — додаємо NotificationBroadcaster
private static async Task<IResult> CreateNotification(
    AppDbContext db,
    NotificationBroadcaster broadcaster, // Отримуємо через DI
    CreateNotificationRequest request)
{
    var notification = new Notification
    {
        UserId = request.UserId,
        Type = request.Type,
        Message = request.Message,
        ActionUrl = request.ActionUrl,
        IsRead = false,
        CreatedAt = DateTime.UtcNow
    };

    db.Notifications.Add(notification);
    await db.SaveChangesAsync();

    var response = new NotificationResponse(
        notification.Id, notification.Type, notification.Message,
        notification.ActionUrl, notification.IsRead, notification.CreatedAt);

    // Надсилаємо нотифікацію всім активним SSE-клієнтам цього користувача
    // Це синхронний виклик (TryWrite не блокує)
    broadcaster.Broadcast(notification.UserId, response);

    return Results.Created($"/notifications/{notification.Id}", response);
}

<!DOCTYPE html>
<html lang="uk">
<head>
    <meta charset="UTF-8">
    <title>Нотифікації — SSE Demo</title>
    <style>
        body { font-family: sans-serif; max-width: 700px; margin: 40px auto; padding: 0 20px; }
        #badge { display: inline-block; background: #ef4444; color: white;
                 border-radius: 50%; width: 24px; height: 24px; text-align: center;
                 line-height: 24px; font-size: 14px; font-weight: bold; }
        #badge.zero { background: #94a3b8; }
        #status { font-size: 13px; margin: 4px 0; }
        #status.connected { color: #16a34a; }
        #status.disconnected { color: #dc2626; }
        .controls { display: flex; gap: 10px; margin: 16px 0; }
        button { padding: 8px 16px; border-radius: 6px; border: none; cursor: pointer;
                 background: #3b82f6; color: white; }
        button.stop { background: #ef4444; }
        #notifications { margin-top: 20px; }
        .notification-item { padding: 10px; border-left: 3px solid #3b82f6;
                              margin-bottom: 8px; background: #f8fafc; border-radius: 0 4px 4px 0; }
        .notification-item.unread { border-left-color: #ef4444; font-weight: bold; }
    </style>
</head>
<body>
    <h1>🔔 <span id="badge" class="zero">0</span> непрочитаних</h1>
    <p id="status" class="disconnected">● Відключено</p>

    <div class="controls">
        <button onclick="connect()">Підключитися (SSE)</button>
        <button class="stop" onclick="disconnect()">Відключитися</button>
    </div>

    <div id="notifications"></div>

    <script>
        const USER_ID = 1;
        let eventSource = null;     // Зберігаємо посилання на EventSource
        let unreadCount = 0;

        function connect() {
            if (eventSource) return; // Вже підключені

            // EventSource — вбудований браузерний API для SSE.
            // Автоматично: встановлює з'єднання, перепідключається при розриві,
            // передає Last-Event-ID при перепідключенні.
            eventSource = new EventSource(`/notifications/stream?userId=${USER_ID}`);

            // Стандартний обробник — викликається для подій без імені
            eventSource.onmessage = (event) => {
                const notification = JSON.parse(event.data);

                // Перша подія — підтвердження з'єднання від сервера
                if (notification.type === 'connected') return;

                addNotificationToUI(notification);
                unreadCount++;
                updateBadge();
            };

            // Подія відкриття з'єднання
            eventSource.onopen = () => {
                const status = document.getElementById('status');
                status.textContent = '● Підключено';
                status.className = 'connected';
            };

            // Подія помилки — браузер автоматично спробує перепідключитися
            eventSource.onerror = () => {
                const status = document.getElementById('status');
                status.textContent = '● Помилка з\'єднання, перепідключення...';
                status.className = 'disconnected';
            };
        }

        function disconnect() {
            if (!eventSource) return;
            eventSource.close(); // Закриваємо з'єднання
            eventSource = null;
            document.getElementById('status').textContent = '● Відключено';
            document.getElementById('status').className = 'disconnected';
        }

        function addNotificationToUI(notification) {
            const container = document.getElementById('notifications');
            const el = document.createElement('div');
            el.className = 'notification-item unread';
            el.innerHTML = `
                <strong>${notification.type}</strong>: ${notification.message}
                <br><small>${new Date(notification.createdAt).toLocaleTimeString('uk-UA')}</small>
            `;
            container.prepend(el); // Нові — зверху
        }

        function updateBadge() {
            const badge = document.getElementById('badge');
            badge.textContent = unreadCount;
            badge.className = unreadCount === 0 ? 'zero' : '';
        }
    </script>
</body>
</html>