.NET Entegrasyonu

// State instance (EF Core ile persist)
public class OrderState : SagaStateMachineInstance
{
    public Guid CorrelationId { get; set; }
    public string CurrentState { get; set; } = "";
    public DateTime OrderDate { get; set; }
    public decimal Amount { get; set; }
    public int RetryCount { get; set; }
}

// State Machine tanımı
public class OrderStateMachine : MassTransitStateMachine<OrderState>
{
    public State Submitted { get; private set; } = null!;
    public State PaymentProcessing { get; private set; } = null!;
    public State Completed { get; private set; } = null!;
    public State Faulted { get; private set; } = null!;

    public Event<OrderSubmitted> OrderSubmittedEvent { get; private set; } = null!;
    public Event<PaymentCompleted> PaymentCompletedEvent { get; private set; } = null!;
    public Event<PaymentFailed> PaymentFailedEvent { get; private set; } = null!;

    public OrderStateMachine()
    {
        InstanceState(x => x.CurrentState);

        Event(() => OrderSubmittedEvent, x => x.CorrelateById(ctx => ctx.Message.OrderId));
        Event(() => PaymentCompletedEvent, x => x.CorrelateById(ctx => ctx.Message.OrderId));
        Event(() => PaymentFailedEvent, x => x.CorrelateById(ctx => ctx.Message.OrderId));

        Initially(
            When(OrderSubmittedEvent)
                .Then(ctx =>
                {
                    ctx.Saga.OrderDate = ctx.Message.Timestamp;
                    ctx.Saga.Amount = ctx.Message.Amount;
                })
                .PublishAsync(ctx => ctx.Init<ProcessPayment>(new
                {
                    OrderId = ctx.Saga.CorrelationId,
                    ctx.Saga.Amount
                }))
                .TransitionTo(PaymentProcessing));

        During(PaymentProcessing,
            When(PaymentCompletedEvent)
                .PublishAsync(ctx => ctx.Init<ShipOrder>(new
                {
                    OrderId = ctx.Saga.CorrelationId
                }))
                .TransitionTo(Completed),
            When(PaymentFailedEvent)
                .Then(ctx => ctx.Saga.RetryCount++)
                .If(ctx => ctx.Saga.RetryCount < 3,
                    binder => binder
                        .PublishAsync(ctx => ctx.Init<ProcessPayment>(new
                        {
                            OrderId = ctx.Saga.CorrelationId,
                            ctx.Saga.Amount
                        })))
                .If(ctx => ctx.Saga.RetryCount >= 3,
                    binder => binder.TransitionTo(Faulted)));
    }
}

// DI Registration
services.AddMassTransit(x =>
{
    x.AddSagaStateMachine<OrderStateMachine, OrderState>()
        .EntityFrameworkRepository(r =>
        {
            r.ConcurrencyMode = ConcurrencyMode.Optimistic;
            r.AddDbContext<DbContext, OrderSagaDbContext>((provider, builder) =>
            {
                builder.UseNpgsql(connectionString, m =>
                {
                    m.MigrationsAssembly(typeof(OrderSagaDbContext).Assembly.FullName);
                });
            });
        });

    x.UsingRabbitMq((context, cfg) =>
    {
        cfg.Host("rabbitmq-cluster.internal");
        cfg.ConfigureEndpoints(context);
    });
});

// Outbox: iş mantığı + mesaj publish AYNI DB transaction'ında
// Mesaj önce DB'ye yazılır, sonra background job ile RabbitMQ'ya gönderilir
// → DB commit olursa mesaj kesin gider, rollback olursa mesaj da silinir

services.AddMassTransit(x =>
{
    x.AddEntityFrameworkOutbox<AppDbContext>(o =>
    {
        o.UsePostgres();             // veya UseSqlServer()
        o.UseBusOutbox();            // Bus-level outbox (publish + send)
        o.QueryDelay = TimeSpan.FromSeconds(1);  // Polling interval
        o.DuplicateDetectionWindow = TimeSpan.FromMinutes(5);
    });

    x.AddConsumer<OrderCreatedConsumer>();

    x.UsingRabbitMq((context, cfg) =>
    {
        cfg.Host("rabbitmq-cluster.internal");
        cfg.ConfigureEndpoints(context);
    });
});

// Kullanım: Normal publish — Outbox otomatik araya girer
public class OrderService
{
    private readonly AppDbContext _db;
    private readonly IPublishEndpoint _publisher;

    public async Task CreateOrderAsync(CreateOrderRequest request)
    {
        var order = new Order
        {
            Id = Guid.NewGuid(),
            CustomerId = request.CustomerId,
            Amount = request.Amount,
            Status = OrderStatus.Created
        };

        _db.Orders.Add(order);

        // Bu publish, DB transaction commit edilene kadar RabbitMQ'ya GİTMEZ
        // Outbox middleware mesajı OutboxMessage tablosuna yazar
        await _publisher.Publish(new OrderCreated
        {
            OrderId = order.Id,
            Amount = order.Amount,
            Timestamp = DateTime.UtcNow
        });

        await _db.SaveChangesAsync();
        // Transaction commit → background delivery service mesajı RabbitMQ'ya gönderir
    }
}

// DbContext'e Outbox tablolarını ekle
public class AppDbContext : DbContext
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // MassTransit Outbox tabloları (InboxState, OutboxState, OutboxMessage)
        modelBuilder.AddInboxStateEntity();
        modelBuilder.AddOutboxStateEntity();
        modelBuilder.AddOutboxMessageEntity();
    }
}