// Ці три зміни — в одній автоматичній транзакції
var order = new Order
{
    CustomerId  = customerId,
    Status      = "Pending",
    PlacedAt    = DateTime.UtcNow,
    TotalAmount = 15000m
};
context.Orders.Add(order);

context.OrderLineItems.Add(new OrderLineItem
{
    Order      = order,
    ProductId  = 1,
    Quantity   = 2,
    UnitPrice  = 5000m
});
context.OrderLineItems.Add(new OrderLineItem
{
    Order      = order,
    ProductId  = 3,
    Quantity   = 1,
    UnitPrice  = 5000m
});

// Один SaveChanges → одна транзакція:
// BEGIN TRANSACTION
//   INSERT INTO Orders (...) VALUES (...)      → Id=42
//   INSERT INTO OrderLineItems (...) VALUES (...) → FK OrderId=42
//   INSERT INTO OrderLineItems (...) VALUES (...) → FK OrderId=42
// COMMIT
await context.SaveChangesAsync();

// 100 нових продуктів → не 100 окремих викликів!
for (int i = 0; i < 100; i++)
    context.Products.Add(new Product { Name = $"P{i}", Price = 100m * i, CategoryId = 1 });

await context.SaveChangesAsync();
// SQL: один виклик з ~3 батчами по ~34 INSERT кожен
// (за замовчуванням MaxBatchSize залежить від провайдера: SQL Server ~42, PostgreSQL ~1000)

options.UseSqlServer(connectionString, opts =>
    opts.MaxBatchSize(100)); // повільніше якщо занадто велике

// Явна транзакція через EF Core API
await using var transaction = await context.Database.BeginTransactionAsync();

try
{
    // Операція 1: створити Order і рядки
    var order = new Order { CustomerId = customerId, Status = "Pending", TotalAmount = 15000m };
    context.Orders.Add(order);
    await context.SaveChangesAsync(); // SaveChanges в межах явної транзакції

    // Операція 2: зменшити залишок (ОКРЕМИЙ SaveChanges!)
    var product = await context.Products.FindAsync(productId);
    product!.Stock -= quantity;
    await context.SaveChangesAsync(); // Той самий DbConnection → та сама транзакція

    // Операція 3: raw SQL для атомарного оновлення балансу
    await context.Database.ExecuteSqlInterpolatedAsync(
        $"UPDATE CustomerWallets SET Balance = Balance - {totalAmount} WHERE CustomerId = {customerId}");
    // Теж у тій самій транзакції!

    // Все успішно → Commit
    await transaction.CommitAsync();
}
catch (Exception ex)
{
    // Будь-яка помилка → Rollback всіх трьох операцій
    await transaction.RollbackAsync();
    _logger.LogError(ex, "Order creation failed, transaction rolled back");
    throw;
}

using var transaction = await context.Database.BeginTransactionAsync(
    IsolationLevel.ReadCommitted); // ← явне зазначення рівня ізоляції

// PostgreSQL: додатково підтримує Snapshot Isolation
using var tx = await context.Database.BeginTransactionAsync(
    System.Data.IsolationLevel.Snapshot);
// Читання — snapshot на момент початку транзакції (MVCC)
// Без блокувань при читанні

await using var transaction = await context.Database.BeginTransactionAsync();

try
{
    // Крок 1: Базові операції (обов'язкові)
    context.Orders.Add(order);
    await context.SaveChangesAsync();

    // Встановлюємо Savepoint — «контрольна точка»
    await transaction.CreateSavepointAsync("after_order_creation");

    try
    {
        // Крок 2: Необов'язкові/ризиковані операції
        await SendNotificationToWarehouseAsync(order.Id);
        await UpdateInventorySystemAsync(order.LineItems);
        await context.SaveChangesAsync();
    }
    catch (Exception innerEx)
    {
        // Помилка у необов'язковій частині → відкотитись до SavePoint
        // Крок 1 (Order) — залишається!
        await transaction.RollbackToSavepointAsync("after_order_creation");
        _logger.LogWarning(innerEx, "Inventory update failed, rolled back to savepoint");
        // Продовжуємо без inventory update
    }

    await transaction.CommitAsync(); // Order збережено
}
catch
{
    await transaction.RollbackAsync(); // Повний відкат
    throw;
}

try
{
    await context.SaveChangesAsync();
}
catch (DbUpdateException ex)
{
    // ex.Entries: список EntityEntry що спричинили помилку
    foreach (var entry in ex.Entries)
    {
        _logger.LogError(
            "Failed to save {EntityType} with state {State}: {Message}",
            entry.Entity.GetType().Name,
            entry.State,
            ex.InnerException?.Message);
    }

    // Перевіряємо тип помилки через inner exception
    if (ex.InnerException is Microsoft.Data.SqlClient.SqlException sqlEx)
    {
        switch (sqlEx.Number)
        {
            case 2627: // Unique Constraint Violation
            case 2601:
                throw new ConflictException("Запис з таким значенням вже існує", ex);

            case 547:  // Foreign Key Constraint
                throw new ValidationException("Неприпустиме значення зовнішнього ключа", ex);

            case 1205: // Deadlock
                throw new RetryableException("Deadlock detected, please retry", ex);

            default:
                throw; // невідома помилка — перекидаємо
        }
    }

    throw;
}

// Polly для retry з exponential backoff
using Polly;
using Polly.Retry;

var retryPolicy = Policy<int>
    .Handle<DbUpdateException>(ex =>
        ex.InnerException is SqlException sqlEx && sqlEx.Number == 1205) // Deadlock
    .Or<TimeoutException>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
        onRetry: (exception, delay, attempt, _) =>
        {
            _logger.LogWarning(
                exception.Exception,
                "Retry {Attempt} after {Delay}s due to: {Message}",
                attempt, delay.TotalSeconds, exception.Exception.Message);
        });

int affected = await retryPolicy.ExecuteAsync(async () =>
{
    // Важливо: при retry DbContext може бути у поганому стані
    // Для retry — або новий scope, або скидання стану трекера
    context.ChangeTracker.Clear(); // Скидаємо трекер перед повторною спробою
    context.Orders.Add(order);
    return await context.SaveChangesAsync();
});

// Налаштування EnableRetryOnFailure для SQL Server
services.AddDbContext<AppDbContext>(options =>
{
    options.UseSqlServer(connectionString, sqlOpts =>
    {
        sqlOpts.EnableRetryOnFailure(
            maxRetryCount:       5,               // до 5 спроб
            maxRetryDelay:       TimeSpan.FromSeconds(30),
            errorNumbersToAdd:   [1205, 40613]    // Deadlock + SQL Azure timeout
        );
    });
});

// БЕЗ цього — InvalidOperationException при спробі retry всередині явної транзакції
var strategy = context.Database.CreateExecutionStrategy();

await strategy.ExecuteAsync(async () =>
{
    await using var transaction = await context.Database.BeginTransactionAsync();

    try
    {
        // Всі операції всередині strategy.ExecuteAsync
        context.Orders.Add(order);
        await context.SaveChangesAsync();

        await context.Database.ExecuteSqlInterpolatedAsync(
            $"UPDATE Wallets SET Balance = Balance - {amount} WHERE Id = {walletId}");

        await transaction.CommitAsync();
    }
    catch
    {
        await transaction.RollbackAsync();
        throw; // ExecutionStrategy перехопить і повторить
    }
});