using Microsoft.EntityFrameworkCore;
using NotificationsDemo.Models;
using NotificationsDemo.Services;

namespace NotificationsDemo.Services;

public class NotificationSimulator : BackgroundService
{
    // IServiceScopeFactory — для отримання Scoped-сервісів із Singleton
    // Детально про це — нижче в статті
    private readonly IServiceScopeFactory _scopeFactory;

    private readonly NotificationBroadcaster _broadcaster;
    private readonly ILogger<NotificationSimulator> _logger;

    // Тестові сценарії — імітуємо різні типи подій
    private static readonly (string Type, string Message)[] EventTemplates =
    [
        ("like",    "Олена поставила лайк на вашу публікацію"),
        ("comment", "Іван прокоментував: \"Цікава думка!\""),
        ("follow",  "Марія підписалась на вас"),
        ("system",  "Ваш обліковий запис успішно верифіковано"),
        ("like",    "5 людей оцінили вашу фотографію"),
    ];

    public NotificationSimulator(
        IServiceScopeFactory scopeFactory,
        NotificationBroadcaster broadcaster,
        ILogger<NotificationSimulator> logger)
    {
        _scopeFactory = scopeFactory;
        _broadcaster = broadcaster;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Симулятор нотифікацій запущено.");

        // stoppingToken.IsCancellationRequested стає true при зупинці застосунку
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                // Чекаємо випадково від 5 до 15 секунд перед наступною нотифікацією
                var delay = TimeSpan.FromSeconds(Random.Shared.Next(5, 15));
                await Task.Delay(delay, stoppingToken); // Передаємо stoppingToken — зупиниться разом з додатком

                await SimulateNotification(stoppingToken);
            }
            catch (OperationCanceledException)
            {
                // Нормальне завершення — stoppingToken скасовано при зупинці застосунку
                break;
            }
            catch (Exception ex)
            {
                // Будь-який інший виняток — логуємо, але НЕ зупиняємо сервіс
                // Без цього одна помилка вбила б весь фоновий цикл назавжди
                _logger.LogError(ex, "Помилка в симуляторі нотифікацій");

                // Коротка пауза щоб не зациклитися при повторюваних помилках
                await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
            }
        }

        _logger.LogInformation("Симулятор нотифікацій зупинено.");
    }

    private async Task SimulateNotification(CancellationToken cancellationToken)
    {
        // Обираємо випадковий шаблон події
        var template = EventTemplates[Random.Shared.Next(EventTemplates.Length)];

        // Зберігаємо в базу даних — але як?
        // BackgroundService реєструється як Singleton (один на весь додаток),
        // а AppDbContext — Scoped (новий екземпляр для кожного HTTP-запиту).
        // Не можна вставляти Scoped у Singleton безпосередньо!
        // Рішення: IServiceScopeFactory — створюємо тимчасовий scope вручну.
        await using var scope = _scopeFactory.CreateAsyncScope();
        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();

        var notification = new Notification
        {
            UserId = 1, // Для демо — фіксований userId
            Type = template.Type,
            Message = template.Message,
            IsRead = false,
            CreatedAt = DateTime.UtcNow
        };

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

        _logger.LogInformation("Симульовано нотифікацію: {Type} - {Message}", template.Type, template.Message);

        // Після збереження в БД — розсилаємо через SSE всім активним клієнтам
        var response = new NotificationResponse(
            notification.Id, notification.Type, notification.Message,
            notification.ActionUrl, notification.IsRead, notification.CreatedAt);

        _broadcaster.Broadcast(notification.UserId, response);
    }
}

using System.Threading.Channels;

namespace NotificationsDemo.Services;

// Контракт черги — описує, що можна з нею зробити
public interface IBackgroundTaskQueue
{
    // Поставити задачу в чергу
    void Enqueue(Func<IServiceProvider, CancellationToken, Task> task);

    // Отримати задачу з черги (очікує якщо черга порожня)
    ValueTask<Func<IServiceProvider, CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken);
}

// Реалізація на базі System.Threading.Channels
public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    // Channel<T> — потокобезпечна асинхронна черга
    // Func<IServiceProvider, CancellationToken, Task> — задача, яка приймає DI-провайдер і токен
    private readonly Channel<Func<IServiceProvider, CancellationToken, Task>> _queue;

    // capacity: 100 — максимум 100 задач у черзі одночасно
    // FullMode.Wait: якщо черга повна — Enqueue блокується до звільнення місця
    public BackgroundTaskQueue(int capacity = 100)
    {
        _queue = Channel.CreateBounded<Func<IServiceProvider, CancellationToken, Task>>(
            new BoundedChannelOptions(capacity)
            {
                FullMode = BoundedChannelFullMode.Wait
            });
    }

    public void Enqueue(Func<IServiceProvider, CancellationToken, Task> task)
    {
        // TryWrite — намагається записати без очікування
        // За нашою конфігурацією (Wait) це завжди успішно, якщо черга не повна
        _queue.Writer.TryWrite(task);
    }

    public async ValueTask<Func<IServiceProvider, CancellationToken, Task>> DequeueAsync(
        CancellationToken cancellationToken)
    {
        // ReadAsync очікує (без блокування потоку!), поки в черзі не з'явиться задача
        return await _queue.Reader.ReadAsync(cancellationToken);
    }
}

namespace NotificationsDemo.Services;

// Цей сервіс читає задачі з черги і виконує їх одну за одною
public class QueuedHostedService : BackgroundService
{
    private readonly IBackgroundTaskQueue _taskQueue;
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ILogger<QueuedHostedService> _logger;

    public QueuedHostedService(
        IBackgroundTaskQueue taskQueue,
        IServiceScopeFactory scopeFactory,
        ILogger<QueuedHostedService> logger)
    {
        _taskQueue = taskQueue;
        _scopeFactory = scopeFactory;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Черга задач запущена.");

        // Безкінечний цикл: чекаємо нову задачу → виконуємо → знову чекаємо
        await foreach (var _ in ProcessQueueAsync(stoppingToken)) { }

        _logger.LogInformation("Черга задач зупинена.");
    }

    private async IAsyncEnumerable<bool> ProcessQueueAsync(
        [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            Func<IServiceProvider, CancellationToken, Task>? task = null;

            try
            {
                // Чекаємо на нову задачу — не блокує потік
                task = await _taskQueue.DequeueAsync(stoppingToken);
            }
            catch (OperationCanceledException)
            {
                break; // Застосунок зупиняється
            }

            try
            {
                // Виконуємо задачу у власному scope
                await using var scope = _scopeFactory.CreateAsyncScope();
                await task(scope.ServiceProvider, stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Помилка виконання фонової задачі");
                // Не зупиняємо сервіс — обробляємо наступну задачу
            }

            yield return true; // Дозволяємо перевірити stoppingToken між ітераціями
        }
    }
}

namespace NotificationsDemo.Models;

public record BulkNotificationRequest(
    int[] UserIds,
    string Type,
    string Message
);

// Ендпоінт масової розсилки — ставить задачу в чергу і відповідає одразу
private static IResult ScheduleBulkNotification(
    IBackgroundTaskQueue queue,
    BulkNotificationRequest request)
{
    // Ставимо задачу в чергу — Func<IServiceProvider, CancellationToken, Task>
    queue.Enqueue(async (services, cancellationToken) =>
    {
        var db = services.GetRequiredService<AppDbContext>();
        var broadcaster = services.GetRequiredService<NotificationBroadcaster>();

        // Логіка може бути довільно складною і тривалою
        foreach (var userId in request.UserIds)
        {
            if (cancellationToken.IsCancellationRequested) break;

            var notification = new Notification
            {
                UserId = userId,
                Type = request.Type,
                Message = request.Message,
                IsRead = false,
                CreatedAt = DateTime.UtcNow
            };

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

            broadcaster.Broadcast(userId, new NotificationResponse(
                notification.Id, notification.Type, notification.Message,
                null, false, notification.CreatedAt));
        }
    });

    // Повертаємо 202 Accepted — «зрозумів, обробляю у фоні»
    return Results.Accepted("/notifications/status", new
    {
        message = $"Масова розсилка для {request.UserIds.Length} користувачів поставлена в чергу"
    });
}

// Реєструємо ендпоінт в групі
public static void MapNotificationEndpoints(this IEndpointRouteBuilder routes)
{
    var group = routes.MapGroup("/notifications");
    group.MapPost("/bulk-async", ScheduleBulkNotification);
    // ... інші ендпоінти
}

### Масова розсилка через фонову чергу (Background Services)
POST {{baseUrl}}/notifications/bulk-async
Content-Type: application/json

{
  "userIds": [1, 2, 3, 4, 5],
  "type": "system",
  "message": "Увага! Завтра о 12:00 на сервері відбудуться технічні роботи. Застосунок може бути недоступний до 10 хвилин."
}

### Відповідь буде миттєвою (202 Accepted), а нотифікації створяться у фоні.

// Черга — Singleton, бо має жити весь час роботи
builder.Services.AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>();

// Фонові сервіси — AddHostedService реєструє як Singleton автоматично
builder.Services.AddHostedService<NotificationSimulator>();
builder.Services.AddHostedService<QueuedHostedService>();