using Microsoft.EntityFrameworkCore;

namespace NotificationsDemo.Models;

public class AppDbContext : DbContext
{
    // Конструктор передає параметри конфігурації базовому класу DbContext
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    // DbSet<Notification> — це "шлюз" до таблиці Notifications у базі даних.
    // Через нього ми виконуємо всі CRUD-операції.
    public DbSet<Notification> Notifications => Set<Notification>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Notification>().ToTable("Notifications");

        // 1. Базовий індекс для фільтрації за користувачем
        // Допомагає при: .Where(n => n.UserId == userId)
        modelBuilder.Entity<Notification>()
            .HasIndex(n => n.UserId);

        // 2. Складений індекс для отримання кількості непрочитаних
        // Допомагає при: .CountAsync(n => n.UserId == userId && !n.IsRead)
        modelBuilder.Entity<Notification>()
            .HasIndex(n => new { n.UserId, n.IsRead });

        // 3. Складений індекс для пагінації та стрічки нотифікацій
        // Це найважливіший індекс! Більшість запитів вимагають сортування за часом.
        // Допомагає при: .Where(n => n.UserId == userId).OrderByDescending(n => n.CreatedAt)
        modelBuilder.Entity<Notification>()
            .HasIndex(n => new { n.UserId, n.CreatedAt })
            .IsDescending(false, true); // UserId - звичайний (ASC), CreatedAt - DESC
            
        // 4. (Опціонально) Супер-індекс для фільтрації непрочитаних з пагінацією
        // Допомагає при: .Where(n => n.UserId == userId && !n.IsRead).OrderByDescending(n => n.CreatedAt)
        modelBuilder.Entity<Notification>()
            .HasIndex(n => new { n.UserId, n.IsRead, n.CreatedAt })
            .IsDescending(false, false, true);
    }
}

namespace NotificationsDemo.Models;

// Відповідь клієнту: те, що ми хочемо показати
public record NotificationResponse(
    int Id,
    string Type,
    string Message,
    string? ActionUrl,
    bool IsRead,
    DateTime CreatedAt
);

// Запит на створення нотифікації: те, що приймаємо від клієнта (або сервісу)
public record CreateNotificationRequest(
    int UserId,
    string Type,
    string Message,
    string? ActionUrl
);

// Кількість непрочитаних — простий wrapper
public record UnreadCountResponse(int Count);

// Запит на масове створення нотифікацій — надсилаємо багатьом користувачам одразу
public record BulkCreateNotificationRequest(
    int[] UserIds,       // Список адресатів
    string Type,
    string Message,
    string? ActionUrl
);

// Результат масового створення
public record BulkCreateResult(int Created, int[] Ids);

using Microsoft.EntityFrameworkCore;
using NotificationsDemo.Models;
using NotificationsDemo.Endpoints;

var builder = WebApplication.CreateBuilder(args);

// Реєструємо AppDbContext у контейнері залежностей.
// AddSqlite — зручний extension-метод для SQLite.
// "Data Source=notifications.db" — SQLite зберігає базу у файлі notifications.db
// поруч із виконуваним файлом проєкту.
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlite("Data Source=notifications.db"));

var app = builder.Build();

// Автоматичне застосування міграцій при старті.
// В продакшені так робити не варто, але для навчального проєкту — зручно.
using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    db.Database.Migrate(); // Створює базу та застосовує міграції
}

// Підключаємо ендпоінти нотифікацій (групуємо в окремий файл для чистоти)
app.MapNotificationEndpoints();

app.Run();

using Microsoft.EntityFrameworkCore;
using NotificationsDemo.Models;

namespace NotificationsDemo.Endpoints;

public static class NotificationEndpoints
{
    // Extension-метод — дозволяє викликати app.MapNotificationEndpoints()
    // замість прямого виклику статичного методу. Це поширений патерн у Minimal API.
    public static void MapNotificationEndpoints(this WebApplication app)
    {
        // Групуємо всі ендпоінти під префіксом /notifications
        var group = app.MapGroup("/notifications");

        group.MapGet("/", GetAllNotifications);
        group.MapGet("/unread-count", GetUnreadCount);
        group.MapGet("/{id:int}", GetNotificationById);
        group.MapPost("/", CreateNotification);
        group.MapPost("/bulk", CreateBulkNotifications);
        group.MapPatch("/{id:int}/read", MarkAsRead);
        group.MapPatch("/read-all", MarkAllAsRead);
        group.MapDelete("/{id:int}", DeleteNotification);
    }

    // GET /notifications?userId=1&onlyUnread=true
    private static async Task<IResult> GetAllNotifications(
        AppDbContext db,
        int userId,                 // Обов'язковий query-параметр: /notifications?userId=1
        bool onlyUnread = false,    // Необов'язковий, за замовчуванням false
        int page = 1,
        int pageSize = 20)
    {
        // Формуємо запит поетапно — кожен крок фільтрує або сортує дані
        var query = db.Notifications
            .Where(n => n.UserId == userId); // Завжди фільтруємо за userId

        if (onlyUnread)
            query = query.Where(n => !n.IsRead); // Додатковий фільтр, якщо потрібно

        var notifications = await query
            .OrderByDescending(n => n.CreatedAt) // Найновіші — першими
            .Skip((page - 1) * pageSize)         // Пропускаємо попередні сторінки
            .Take(pageSize)                       // Беремо лише pageSize записів
            .Select(n => new NotificationResponse( // Проєктуємо сутність у DTO
                n.Id, n.Type, n.Message, n.ActionUrl, n.IsRead, n.CreatedAt))
            .ToListAsync();

        return Results.Ok(notifications);
    }

    // GET /notifications/unread-count?userId=1
    private static async Task<IResult> GetUnreadCount(AppDbContext db, int userId)
    {
        var count = await db.Notifications
            .CountAsync(n => n.UserId == userId && !n.IsRead);

        // Повертаємо об'єкт, а не просто число — для консистентності JSON-відповідей
        return Results.Ok(new UnreadCountResponse(count));
    }

    // GET /notifications/5
    private static async Task<IResult> GetNotificationById(AppDbContext db, int id)
    {
        var notification = await db.Notifications.FindAsync(id);

        if (notification is null)
            return Results.NotFound(new { message = $"Нотифікацію з Id={id} не знайдено." });

        return Results.Ok(new NotificationResponse(
            notification.Id, notification.Type, notification.Message,
            notification.ActionUrl, notification.IsRead, notification.CreatedAt));
    }

    // POST /notifications
    private static async Task<IResult> CreateNotification(
        AppDbContext db,
        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(); // Зберігаємо зміни в БД; після цього notification.Id заповниться

        // 201 Created з посиланням на новий ресурс — стандарт REST
        return Results.Created($"/notifications/{notification.Id}",
            new NotificationResponse(
                notification.Id, notification.Type, notification.Message,
                notification.ActionUrl, notification.IsRead, notification.CreatedAt));
    }

    // POST /notifications/bulk
    // Масова розсилка — одна нотифікація надсилається одразу кільком користувачам.
    // Приклад: системне оголошення для 500 підписників, акційна пропозиція для групи,
    // сповіщення «новий пост від автора, на якого ви підписані».
    private static async Task<IResult> CreateBulkNotifications(
        AppDbContext db,
        BulkCreateNotificationRequest request)
    {
        if (request.UserIds.Length == 0)
            return Results.BadRequest(new { message = "Список UserIds не може бути порожнім." });

        // Обмежуємо розмір пакету — захист від зловживань і переповнення пам'яті.
        // При потребі відправити більше — клієнт повинен розбити на пакети.
        if (request.UserIds.Length > 1000)
            return Results.BadRequest(new { message = "Максимум 1000 одержувачів за один запит." });

        // Створюємо об'єкти нотифікацій у пам'яті для кожного userId.
        // Це швидка операція — просто ініціалізація об'єктів C#, без звернень до БД.
        var now = DateTime.UtcNow; // Фіксуємо час один раз для всіх нотифікацій
        var notifications = request.UserIds
            .Distinct()           // Видаляємо дублікати userId на випадок помилки на клієнті
            .Select(userId => new Notification
            {
                UserId = userId,
                Type = request.Type,
                Message = request.Message,
                ActionUrl = request.ActionUrl,
                IsRead = false,
                CreatedAt = now
            })
            .ToList();

        // AddRange — передаємо всі об'єкти одночасно.
        // EF Core зберігає їх у Change Tracker і при SaveChangesAsync
        // вставляє ОДНИМ батч-запитом (INSERT INTO ... VALUES (...), (...), (...)).
        //
        // Порівняйте з неефективним варіантом у циклі:
        // ❌  foreach (var n in notifications) { db.Add(n); await db.SaveChangesAsync(); }
        //     → N окремих INSERT-запитів, N round-trips до бази даних
        //
        // ✅  db.Notifications.AddRange(notifications); await db.SaveChangesAsync();
        //     → 1 батч INSERT (SQLite підтримує до ~999 параметрів; для більших обсягів
        //       EF Core автоматично розбиває на кілька батчів)
        db.Notifications.AddRange(notifications);
        await db.SaveChangesAsync();

        // Після SaveChangesAsync EF Core заповнює Id кожного об'єкта
        var createdIds = notifications.Select(n => n.Id).ToArray();

        return Results.Created("/notifications/bulk",
            new BulkCreateResult(notifications.Count, createdIds));
    }

    // PATCH /notifications/5/read
    private static async Task<IResult> MarkAsRead(AppDbContext db, int id)
    {
        var notification = await db.Notifications.FindAsync(id);

        if (notification is null)
            return Results.NotFound(new { message = $"Нотифікацію з Id={id} не знайдено." });

        if (notification.IsRead)
            return Results.Ok(new { message = "Нотифікація вже позначена як прочитана." });

        notification.IsRead = true;
        await db.SaveChangesAsync();

        return Results.Ok(new { message = "Нотифікацію позначено як прочитану." });
    }

    // PATCH /notifications/read-all?userId=1
    private static async Task<IResult> MarkAllAsRead(AppDbContext db, int userId)
    {
        // ExecuteUpdateAsync — ефективніший спосіб масового оновлення:
        // генерує один SQL UPDATE замість завантаження всіх сутностей у пам'ять
        var updated = await db.Notifications
            .Where(n => n.UserId == userId && !n.IsRead)
            .ExecuteUpdateAsync(s => s.SetProperty(n => n.IsRead, true));

        return Results.Ok(new { message = $"Позначено {updated} нотифікацій як прочитані." });
    }

    // DELETE /notifications/5
    private static async Task<IResult> DeleteNotification(AppDbContext db, int id)
    {
        var notification = await db.Notifications.FindAsync(id);

        if (notification is null)
            return Results.NotFound(new { message = $"Нотифікацію з Id={id} не знайдено." });

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

        return Results.NoContent(); // 204 No Content — стандартна відповідь на успішне видалення
    }
}

### Змінні
@baseUrl = http://localhost:5000
@userId = 1

### 1. Створити першу нотифікацію
POST {{baseUrl}}/notifications
Content-Type: application/json

{
  "userId": {{userId}},
  "type": "like",
  "message": "Олена поставила лайк на вашу фотографію",
  "actionUrl": "/posts/42"
}

###

### 2. Ще одна нотифікація — коментар
POST {{baseUrl}}/notifications
Content-Type: application/json

{
  "userId": {{userId}},
  "type": "comment",
  "message": "Іван прокоментував: \"Чудове фото!\"",
  "actionUrl": "/posts/42#comment-7"
}

###

### 3. Системна нотифікація без посилання
POST {{baseUrl}}/notifications
Content-Type: application/json

{
  "userId": {{userId}},
  "type": "system",
  "message": "Ваш обліковий запис успішно верифіковано"
}

###

### 4. Отримати всі нотифікації користувача
GET {{baseUrl}}/notifications?userId={{userId}}

###

### 5. Отримати тільки непрочитані
GET {{baseUrl}}/notifications?userId={{userId}}&onlyUnread=true

###

### 6. Перевірити кількість непрочитаних (для значка "дзвоника")
GET {{baseUrl}}/notifications/unread-count?userId={{userId}}

###

### 7. Позначити нотифікацію #1 як прочитану
PATCH {{baseUrl}}/notifications/1/read

###

### 8. Перевірити: тепер непрочитаних має бути 2
GET {{baseUrl}}/notifications/unread-count?userId={{userId}}

###

### 9. Позначити всі як прочитані
PATCH {{baseUrl}}/notifications/read-all?userId={{userId}}

###

### 10. Тепер лічильник має бути 0
GET {{baseUrl}}/notifications/unread-count?userId={{userId}}

###

### 11. Видалити нотифікацію #2
DELETE {{baseUrl}}/notifications/2

###

### 12. Спробувати отримати видалену — має бути 404
GET {{baseUrl}}/notifications/2

###

### 13. Масова нотифікація для кількох користувачів одразу
# Відправляємо системне оголошення одночасно для userId 1, 2 і 3
POST {{baseUrl}}/notifications/bulk
Content-Type: application/json

{
  "userIds": [1, 2, 3],
  "type": "system",
  "message": "Сайт буде недоступний 25 березня з 02:00 до 04:00 для планового обслуговування",
  "actionUrl": null
}

###

### 14. Перевірити: у userId=2 тепер є нотифікація
GET {{baseUrl}}/notifications?userId=2

###

### 15. Спроба масового надсилання із порожнім списком — має бути 400
POST {{baseUrl}}/notifications/bulk
Content-Type: application/json

{
  "userIds": [],
  "type": "system",
  "message": "Тест"
}