Domain Events

/// <summary>
/// Marker interface for domain events. Enables event-driven architecture.
/// Domain events stay domain-pure; the Application layer wraps them for dispatch.
/// </summary>
public interface IDomainEvent
{
    DateTime OccurredOn { get; }
    Guid EventId { get; }
}

public abstract record DomainEvent : IDomainEvent
{
    public DateTime OccurredOn { get; } = DateTime.UtcNow;
    public Guid EventId { get; } = Guid.NewGuid();
}

/// <summary>
/// Carries a committed entity-change audit record through the owning module's transactional outbox.
/// The event ID is the deterministic central audit-log ID, making redelivery idempotent.
/// </summary>
public sealed record EntityChangeAuditCommittedEvent(
    Guid EventId,
    DateTime OccurredOn,
    AuditLog AuditLog) : IDomainEvent;

/// <summary>
/// Represents a domain event persisted in the outbox table.
/// Ensures reliable event delivery even if the app crashes after SaveChanges.
/// </summary>
public class OutboxMessage
{
    public Guid Id { get; set; }
    public string Type { get; set; } = string.Empty;     // Full type name
    public string Content { get; set; } = string.Empty;  // JSON-serialized event
    public DateTime OccurredOnUtc { get; set; }
    public DateTime? ProcessedOnUtc { get; set; }         // null = unprocessed
    public string? Error { get; set; }                    // Error message if failed
    public int RetryCount { get; set; }                   // Number of processing attempts
}

/// <summary>
/// EF Core SaveChanges interceptor that captures domain events
/// and persists them to the Outbox table in the SAME transaction.
/// This guarantees atomicity: entity changes + events are committed together.
/// </summary>
public class OutboxInterceptor : SaveChangesInterceptor
{
    public override async ValueTask<InterceptionResult<int>> SavingChangesAsync(
        DbContextEventData eventData,
        InterceptionResult<int> result,
        CancellationToken ct = default)
    {
        var context = eventData.Context!;

        // 1. Collect all domain events from tracked entities
        var entities = context.ChangeTracker
            .Entries<Entity<Guid>>()
            .Where(e => e.Entity.DomainEvents.Any())
            .ToList();

        var domainEvents = entities
            .SelectMany(e => e.Entity.DomainEvents)
            .ToList();

        // 2. Clear events from entities (prevent re-processing)
        entities.ForEach(e => e.Entity.ClearDomainEvents());

        // 3. Convert domain events → OutboxMessages
        var outboxMessages = domainEvents.Select(evt => new OutboxMessage
        {
            Id = Guid.NewGuid(),
            Type = evt.GetType().AssemblyQualifiedName!,
            Content = JsonSerializer.Serialize(evt, evt.GetType()),
            OccurredOnUtc = DateTime.UtcNow,
        });

        // 4. Add to outbox table (same transaction as entity changes)
        await context.Set<OutboxMessage>().AddRangeAsync(outboxMessages, ct);

        return await base.SavingChangesAsync(eventData, result, ct);
    }
}

/// <summary>
/// Background service that polls the Outbox table for unprocessed messages
/// and publishes them via AstraFlow mediator. Runs every 5 seconds.
/// </summary>
public class OutboxProcessor : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            using var scope = _serviceScopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<OutboxDbContext>();
            var publisher = scope.ServiceProvider.GetRequiredService<IDomainEventPublisher>();

            // 1. Get unprocessed messages (batch of 20)
            var messages = await dbContext.OutboxMessages
                .Where(m => m.ProcessedOnUtc == null)
                .OrderBy(m => m.OccurredOnUtc)
                .Take(20)
                .ToListAsync(ct);

            foreach (var message in messages)
            {
                try
                {
                    // 2. Deserialize event
                    var type = Type.GetType(message.Type)!;
                    var domainEvent = (IDomainEvent)JsonSerializer
                        .Deserialize(message.Content, type)!;

                    // 3. Publish via AstraFlow mediator
                    await publisher.PublishAsync(domainEvent, ct);

                    // 4. Mark as processed
                    message.ProcessedOnUtc = DateTime.UtcNow;
                }
                catch (Exception ex)
                {
                    message.Error = ex.Message;
                    message.RetryCount++;
                }
            }

            await dbContext.SaveChangesAsync(ct);
            await Task.Delay(TimeSpan.FromSeconds(5), ct);
        }
    }
}

/// <summary>
/// Recurring job that deletes processed outbox messages older than 7 days.
/// Runs daily at 2:00 AM UTC via Hangfire.
/// </summary>
public class OutboxCleanupJob : RecurringJobBase
{
    public override string JobId => "outbox-cleanup";
    public override string CronExpression => "0 2 * * *"; // Daily at 2 AM

    public override async Task ExecuteAsync(CancellationToken ct)
    {
        var cutoff = DateTime.UtcNow.AddDays(-7);
        var deleted = await _dbContext.OutboxMessages
            .Where(m => m.ProcessedOnUtc != null && m.ProcessedOnUtc < cutoff)
            .ExecuteDeleteAsync(ct);

        _logger.LogInformation("Cleaned up {Count} outbox messages", deleted);
    }
}