// Визначаємо Compiled Query як статичне поле
public class ProductRepository
{
    // Компільований запит: визначається один раз (static readonly)
    private static readonly Func<AppDbContext, int, Task<Product?>> GetByIdQuery =
        EF.CompileAsyncQuery(
            (AppDbContext ctx, int id) =>
                ctx.Products.FirstOrDefault(p => p.Id == id)
        );

    private static readonly Func<AppDbContext, decimal, IAsyncEnumerable<Product>> GetExpensiveQuery =
        EF.CompileAsyncQuery(
            (AppDbContext ctx, decimal minPrice) =>
                ctx.Products
                   .Where(p => p.Price >= minPrice && p.IsActive)
                   .OrderBy(p => p.Price)
        );

    private readonly AppDbContext _context;

    public ProductRepository(AppDbContext context) => _context = context;

    // Виклик: компіляція відбулась одноразово при першому виклику
    public async Task<Product?> GetByIdAsync(int id)
        => await GetByIdQuery(_context, id);

    public IAsyncEnumerable<Product> GetExpensiveProductsAsync(decimal minPrice)
        => GetExpensiveQuery(_context, minPrice);
}

// CompileQuery (синхронний)
private static readonly Func<AppDbContext, int, Product?> GetByIdSync =
    EF.CompileQuery(
        (AppDbContext ctx, int id) =>
            ctx.Products.FirstOrDefault(p => p.Id == id)
    );

// До 8 параметрів (включаючи DbContext)
private static readonly Func<AppDbContext, string, decimal, decimal, Task<List<Product>>>
    SearchProductsQuery =
        EF.CompileAsyncQuery(
            (AppDbContext ctx, string name, decimal minPrice, decimal maxPrice) =>
                ctx.Products
                   .Where(p => p.Name.Contains(name)
                             && p.Price >= minPrice
                             && p.Price <= maxPrice
                             && p.IsActive)
                   .OrderBy(p => p.Price)
                   .ToList() // ← Compiled Query повертає List для async
        );

// ❌ НЕМОЖЛИВО: умовна логіка у Compiled Query
var query = EF.CompileAsyncQuery((AppDbContext ctx, bool includeInactive) =>
    includeInactive
        ? ctx.Products.Where(p => true)
        : ctx.Products.Where(p => p.IsActive)); // ← Expression не може бути dynamic

// ✅ Два окремі Compiled Queries
private static readonly Func<AppDbContext, Task<List<Product>>> GetAllActive =
    EF.CompileAsyncQuery(ctx => ctx.Products.Where(p => p.IsActive).ToList());

private static readonly Func<AppDbContext, Task<List<Product>>> GetAll =
    EF.CompileAsyncQuery(ctx => ctx.Products.ToList());

// Звичайний: весь результат у RAM
var allProducts = await context.Products.ToListAsync();
// ↑ Чекає поки всі рядки прийдуть, тоді повертає

// Streaming через IAsyncEnumerable
await foreach (var product in context.Products.AsAsyncEnumerable())
{
    // Обробляємо кожен рядок по мірі надходження
    await ProcessProductAsync(product);
}
// ↑ Перший рядок обробляється до того як прийшов останній

// ASP.NET Core endpoint зі streaming response
[HttpGet("export")]
public async IAsyncEnumerable<ProductExportDto> ExportProductsAsync(
    [EnumeratorCancellation] CancellationToken ct)
{
    var query = context.Products
        .Where(p => p.IsActive)
        .OrderBy(p => p.Id)
        .Select(p => new ProductExportDto
        {
            Id         = p.Id,
            Name       = p.Name,
            Price      = p.Price,
            CategoryId = p.CategoryId
        })
        .AsAsyncEnumerable();

    await foreach (var product in query.WithCancellation(ct))
    {
        yield return product; // Відправляємо клієнту по мірі читання з БД
    }
}
// Клієнт отримує перший рядок майже миттєво
// Сервер ніколи не тримає всі записи в RAM

public async Task ProcessAllOrdersAsync(CancellationToken ct)
{
    int processedCount = 0;
    const int batchSize = 100;
    var batch = new List<Order>(batchSize);

    await foreach (var order in context.Orders
        .Where(o => o.Status == "Pending")
        .AsAsyncEnumerable()
        .WithCancellation(ct))
    {
        batch.Add(order);

        if (batch.Count >= batchSize)
        {
            await ProcessBatchAsync(batch);
            batch.Clear();
            processedCount += batchSize;
            _logger.LogInformation("Processed {Count} orders", processedCount);
        }
    }

    // Обробити залишок
    if (batch.Count > 0)
        await ProcessBatchAsync(batch);
}

-- OFFSET пагінація: сторінка 1000 (по 20 елементів)
SELECT * FROM Products ORDER BY CreatedAt, Id
OFFSET 19980 ROWS           -- БД читає і відкидає 19980 рядків!
FETCH NEXT 20 ROWS ONLY

-- Перша сторінка: немає фільтра (або MaxDate/MaxId)
SELECT TOP 20 * FROM Products
WHERE IsActive = 1
ORDER BY CreatedAt DESC, Id DESC;
-- Запам'ятовуємо: останній item має CreatedAt='2024-03-15 10:30:00', Id=1542

-- Наступна сторінка: фільтр за останнім значенням
SELECT TOP 20 * FROM Products
WHERE IsActive = 1
  AND (CreatedAt < '2024-03-15 10:30:00'  -- або
       OR (CreatedAt = '2024-03-15 10:30:00' AND Id < 1542))
ORDER BY CreatedAt DESC, Id DESC;
-- БД бере перші 20 з індексу — без OFFSET!

public record CursorPage<T>
{
    public List<T> Items { get; init; } = new();
    public bool HasMore { get; init; }
    public string? NextCursor { get; init; } // Base64-encoded cursor
}

public record ProductCursor(DateTime CreatedAt, int Id);

public class ProductRepository
{
    private readonly AppDbContext _context;

    public ProductRepository(AppDbContext context) => _context = context;

    public async Task<CursorPage<Product>> GetPageAsync(
        string? cursor = null,
        int pageSize = 20,
        CancellationToken ct = default)
    {
        // Розкодовуємо cursor з попередньої сторінки
        ProductCursor? decoded = null;
        if (cursor is not null)
        {
            var json = Encoding.UTF8.GetString(Convert.FromBase64String(cursor));
            decoded = JsonSerializer.Deserialize<ProductCursor>(json);
        }

        var query = context.Products
            .Where(p => p.IsActive);

        // Keyset фільтр: якщо cursor є — фільтруємо за ним
        if (decoded is not null)
        {
            query = query.Where(p =>
                p.CreatedAt < decoded.CreatedAt ||
                (p.CreatedAt == decoded.CreatedAt && p.Id < decoded.Id));
        }

        // Беремо на 1 більше щоб визначити HasMore
        var items = await query
            .OrderByDescending(p => p.CreatedAt)
            .ThenByDescending(p => p.Id)
            .Take(pageSize + 1)
            .AsNoTracking()
            .ToListAsync(ct);

        var hasMore = items.Count > pageSize;
        if (hasMore) items.RemoveAt(items.Count - 1); // прибираємо "зайвий"

        // Формуємо cursor для наступної сторінки
        string? nextCursor = null;
        if (hasMore && items.Count > 0)
        {
            var last = items[^1];
            var cursorObj = new ProductCursor(last.CreatedAt, last.Id);
            var json = JsonSerializer.Serialize(cursorObj);
            nextCursor = Convert.ToBase64String(Encoding.UTF8.GetBytes(json));
        }

        return new CursorPage<Product>
        {
            Items      = items,
            HasMore    = hasMore,
            NextCursor = nextCursor
        };
    }
}

// API Controller
[HttpGet("products")]
public async Task<IActionResult> GetProducts(
    [FromQuery] string? cursor = null,
    [FromQuery] int pageSize = 20)
{
    var page = await _productRepository.GetPageAsync(cursor, pageSize);

    return Ok(new
    {
        Items      = page.Items,
        HasMore    = page.HasMore,
        NextCursor = page.NextCursor // клієнт передає у наступному запиті
    });
}

// Include: повні entity об'єкти з навігаційними властивостями
var orders = await context.Orders
    .Include(o => o.Customer)
    .Include(o => o.LineItems)
        .ThenInclude(li => li.Product)
    .Where(o => o.Status == "Pending")
    .ToListAsync();

// Можна змінювати і зберігати:
orders[0].Status = "Processing";
await context.SaveChangesAsync(); // ← Change Tracker відстежує зміни

// Select: тільки потрібні поля, один запит, без overhead Change Tracker
var orderDtos = await context.Orders
    .Where(o => o.Status == "Pending")
    .Select(o => new OrderListDto
    {
        Id           = o.Id,
        OrderNumber  = o.OrderNumber,
        CustomerName = o.Customer.FullName,     // JOIN без Include
        ItemCount    = o.LineItems.Count(),      // COUNT у підзапиті
        TotalAmount  = o.TotalAmount,
        PlacedAt     = o.PlacedAt
    })
    .ToListAsync();

// Не зберігаємо — це DTO для відображення