public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Stock { get; set; }

    // ConcurrencyToken: будь-яка властивість що унікально ідентифікує версію
    [ConcurrencyToken]
    public Guid Version { get; set; } = Guid.NewGuid();
}

// Конфігурація через Fluent API:
builder.Property(p => p.Version).IsConcurrencyToken();

-- EF Core генерує:
UPDATE Products
SET Name = @name, Price = @price, Version = @newVersion
WHERE Id = @id AND Version = @originalVersion  -- ← перевірка!

-- Якщо між читанням і записом хтось змінив рядок (Version вже інша):
-- 0 рядків оновлено → DbUpdateConcurrencyException

public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
{
    // Оновити Version для всіх Modified entities з Version
    foreach (var entry in ChangeTracker.Entries<Product>()
                                        .Where(e => e.State == EntityState.Modified))
    {
        entry.Entity.Version = Guid.NewGuid();
    }

    return await base.SaveChangesAsync(cancellationToken);
}

try
{
    product.Price = newPrice;
    await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
    // ex.Entries: entity що спричинили конфлікт
    var entry = ex.Entries.Single();

    // Отримати значення з трьох джерел:
    var dbValues      = await entry.GetDatabaseValuesAsync(); // поточне у БД
    var currentValues = entry.CurrentValues;                  // що намагались записати
    var originalValues = entry.OriginalValues;               // що читали спочатку

    if (dbValues is null)
    {
        // Рядок видалено іншою транзакцією
        throw new BusinessException("Продукт був видалений іншим користувачем");
    }

    // Стратегія вирішення конфлікту:
    // A) Client Wins: зберегти поточні значення (перетерти!)
    entry.OriginalValues.SetValues(dbValues); // оновити Original
    // Спробувати збереження ще раз (з новою Version)

    // B) Database Wins: відкинути зміни, взяти з БД
    await entry.ReloadAsync();
    // entry.State → Unchanged, значення з БД

    // C) Merge: показати юзеру обидва варіанти
    throw new ConcurrencyConflictException(
        CurrentValues: currentValues.ToObject(),
        DatabaseValues: dbValues.ToObject());
}

// API: включаємо Version у відповідь
[HttpGet("{id}")]
public async Task<IActionResult> GetProduct(int id)
{
    var product = await context.Products.FindAsync(id);
    return Ok(new ProductDto
    {
        Id      = product!.Id,
        Name    = product.Name,
        Price   = product.Price,
        Version = product.Version.ToString() // ← передаємо клієнту
    });
}

// API: перевіряємо Version при PUT
[HttpPut("{id}")]
public async Task<IActionResult> UpdateProduct(int id, UpdateProductDto dto)
{
    var product = await context.Products.FindAsync(id);
    if (product is null) return NotFound();

    // Перевірка: Version з клієнта = Version у БД?
    if (product.Version != Guid.Parse(dto.Version))
        return Conflict("Дані змінились. Будь ласка, оновіть сторінку.");

    product.Name  = dto.Name;
    product.Price = dto.Price;

    try
    {
        await context.SaveChangesAsync();
        return Ok(new { product.Version }); // повертаємо нову Version
    }
    catch (DbUpdateConcurrencyException)
    {
        return Conflict("Одночасний конфлікт. Оновіть і спробуйте знову.");
    }
}

public class Order
{
    public int Id { get; set; }
    public string Status { get; set; } = string.Empty;
    public decimal TotalAmount { get; set; }

    // SQL Server: rowversion (timestamp) — автоматично оновлюється БД
    public byte[] RowVersion { get; set; } = null!;
}

// Конфігурація
public class OrderConfiguration : IEntityTypeConfiguration<Order>
{
    public void Configure(EntityTypeBuilder<Order> builder)
    {
        builder.Property(o => o.RowVersion)
               .IsRowVersion()     // ← позначає як RowVersion + ConcurrencyToken
               .IsConcurrencyToken();
    }
}

-- EF Core генерує для SQL Server:
UPDATE Orders
SET Status = @status
WHERE Id = @id AND RowVersion = @originalRowVersion
-- RowVersion оновлюється автоматично сервером при кожному UPDATE

// Npgsql: UseXminAsConcurrencyToken
builder.Property<uint>("xmin")
       .HasColumnType("xid")
       .ValueGeneratedOnAddOrUpdate()
       .IsConcurrencyToken();

// У DbContext OnModelCreating:
modelBuilder.Entity<Order>().UseXminAsConcurrencyToken();

-- SQL Server: UPDLOCK + ROWLOCK
SELECT * FROM Products WITH (UPDLOCK, ROWLOCK) WHERE Id = @id

-- PostgreSQL: FOR UPDATE
SELECT * FROM products WHERE id = @id FOR UPDATE

// SQL Server: через FromSqlRaw з hint
var product = await context.Products
    .FromSqlRaw("SELECT * FROM Products WITH (UPDLOCK, ROWLOCK) WHERE Id = {0}", productId)
    .FirstOrDefaultAsync();

// Тепер рядок заблокований до кінця транзакції
product!.Stock -= quantity;
await context.SaveChangesAsync();
// COMMIT → блокування знімається

// PostgreSQL: FOR UPDATE через Npgsql
var product = await context.Products
    .FromSqlRaw("SELECT * FROM \"Products\" WHERE \"Id\" = {0} FOR UPDATE", productId)
    .FirstOrDefaultAsync();

public class OutboxMessage
{
    public Guid    Id           { get; set; } = Guid.NewGuid();
    public string  Type         { get; set; } = string.Empty; // "OrderPlaced", "StockReserved"
    public string  Payload      { get; set; } = string.Empty; // JSON серіалізована подія
    public string  Status       { get; set; } = "Pending";    // Pending, Sent, Failed
    public DateTime CreatedAt   { get; set; } = DateTime.UtcNow;
    public DateTime? SentAt     { get; set; }
    public int     RetryCount   { get; set; } = 0;
    public string? ErrorMessage { get; set; }
}

public class OrderService
{
    private readonly AppDbContext _context;

    public async Task<Order> PlaceOrderAsync(CreateOrderDto dto)
    {
        await using var transaction = await _context.Database.BeginTransactionAsync();

        try
        {
            // 1. Бізнес-логіка: створити Order
            var order = new Order
            {
                CustomerId  = dto.CustomerId,
                Status      = "Pending",
                TotalAmount = dto.TotalAmount,
                PlacedAt    = DateTime.UtcNow
            };
            _context.Orders.Add(order);

            // 2. Зберегти подію у Outbox — в тій самій транзакції!
            var orderPlacedEvent = new OrderPlacedEvent
            {
                OrderId    = order.Id, // EF Core заповнить Id після SaveChanges
                CustomerId = order.CustomerId,
                Amount     = order.TotalAmount
            };

            _context.OutboxMessages.Add(new OutboxMessage
            {
                Type    = nameof(OrderPlacedEvent),
                Payload = JsonSerializer.Serialize(orderPlacedEvent)
            });

            // 3. Один SaveChanges: і Order, і OutboxMessage — атомарно
            await _context.SaveChangesAsync();

            await transaction.CommitAsync();

            return order;
        }
        catch
        {
            await transaction.RollbackAsync();
            throw;
        }
    }
}

public class OutboxProcessorWorker : BackgroundService
{
    private readonly IServiceScopeFactory  _scopeFactory;
    private readonly IMessageBus           _messageBus;
    private readonly ILogger<OutboxProcessorWorker> _logger;

    public OutboxProcessorWorker(
        IServiceScopeFactory scopeFactory,
        IMessageBus messageBus,
        ILogger<OutboxProcessorWorker> logger)
    {
        _scopeFactory = scopeFactory;
        _messageBus   = messageBus;
        _logger       = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await ProcessPendingMessagesAsync(stoppingToken);
            await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
        }
    }

    private async Task ProcessPendingMessagesAsync(CancellationToken ct)
    {
        using var scope   = _scopeFactory.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();

        // Беремо пакет Pending повідомлень
        var messages = await context.OutboxMessages
            .Where(m => m.Status == "Pending" && m.RetryCount < 5)
            .OrderBy(m => m.CreatedAt)
            .Take(50)
            .ToListAsync(ct);

        foreach (var message in messages)
        {
            try
            {
                // Публікуємо у месседж-брокер
                await _messageBus.PublishAsync(message.Type, message.Payload, ct);

                message.Status = "Sent";
                message.SentAt = DateTime.UtcNow;
            }
            catch (Exception ex)
            {
                message.RetryCount++;
                message.ErrorMessage = ex.Message;

                if (message.RetryCount >= 5)
                    message.Status = "Failed"; // Dead letter

                _logger.LogError(ex, "Failed to publish OutboxMessage {Id}", message.Id);
            }
        }

        await context.SaveChangesAsync(ct);
    }
}

// Консьюмер: ідемпотентна обробка
public class OrderPlacedEventConsumer
{
    public async Task HandleAsync(OrderPlacedEvent evt, AppDbContext context)
    {
        // Перевірка: чи вже оброблено?
        var alreadyProcessed = await context.ProcessedEvents
            .AnyAsync(pe => pe.EventId == evt.EventId);

        if (alreadyProcessed)
        {
            _logger.LogInformation("Event {EventId} already processed, skipping", evt.EventId);
            return;
        }

        // Обробка бізнес-логіки
        await DoBusinessLogicAsync(evt);

        // Зберегти що обробили
        context.ProcessedEvents.Add(new ProcessedEvent { EventId = evt.EventId });
        await context.SaveChangesAsync();
    }
}

public interface IUnitOfWork : IDisposable
{
    IProductRepository    Products    { get; }
    IOrderRepository      Orders      { get; }
    ICustomerRepository   Customers   { get; }

    Task<int>  SaveChangesAsync(CancellationToken ct = default);
    Task       BeginTransactionAsync();
    Task       CommitAsync();
    Task       RollbackAsync();
}

public class UnitOfWork : IUnitOfWork
{
    private readonly AppDbContext _context;
    private IDbContextTransaction? _transaction;

    public UnitOfWork(AppDbContext context,
                      IProductRepository products,
                      IOrderRepository orders,
                      ICustomerRepository customers)
    {
        _context  = context;
        Products  = products;
        Orders    = orders;
        Customers = customers;
    }

    public IProductRepository  Products  { get; }
    public IOrderRepository    Orders    { get; }
    public ICustomerRepository Customers { get; }

    public Task<int> SaveChangesAsync(CancellationToken ct = default)
        => _context.SaveChangesAsync(ct);

    public async Task BeginTransactionAsync()
        => _transaction = await _context.Database.BeginTransactionAsync();

    public async Task CommitAsync()
    {
        if (_transaction is not null)
        {
            await _transaction.CommitAsync();
            await _transaction.DisposeAsync();
            _transaction = null;
        }
    }

    public async Task RollbackAsync()
    {
        if (_transaction is not null)
        {
            await _transaction.RollbackAsync();
            await _transaction.DisposeAsync();
            _transaction = null;
        }
    }

    public void Dispose()
    {
        _transaction?.Dispose();
        _context.Dispose();
    }
}