// MultiTenantConfiguration.php — default + per-tenant overrides

use Ecotone\Dbal\MultiTenantConnection\Configuration\MultiTenantConfiguration;
use Ecotone\Messaging\Attribute\ServiceContext;

final class TenantConfiguration
{
    #[ServiceContext]
    public function tenants(): MultiTenantConfiguration
    {
        return MultiTenantConfiguration::createWithDefaultConnection(
            tenantHeaderName: 'tenant',
            tenantToConnectionMapping: [
                'big_corp'     => 'big_corp_connection',
                'enterprise_x' => 'enterprise_x_connection',
            ],
            // every other tenant lands on the shared default
            defaultConnectionReferenceName: 'shared_tenants_connection',
        );
    }
}

// PlaceOrderController.php — the tenant arrives on the message metadata

final class PlaceOrderController
{
    public function __construct(private CommandBus $commands) {}

    public function __invoke(PlaceOrder $command, string $tenant): Response
    {
        // The 'tenant' header drives every downstream decision:
        // which database connection, which channel, which workers.
        $this->commands->send($command, metadata: ['tenant' => $tenant]);

        return new Response('', 202);
    }
}

// PlaceOrderHandler.php — handler is tenant-agnostic

#[Asynchronous('orders')]
#[CommandHandler]
public function placeOrder(PlaceOrder $cmd): void
{
    // Ecotone resolved the database connection from the 'tenant' header
    // before this body runs — no plan check, no branching.
}

// QueueTopology.php — dynamic channel selects per-tenant routing at runtime
// (Ecotone Enterprise — Dynamic Message Channels)

use Ecotone\Messaging\Channel\DynamicChannel\DynamicMessageChannelBuilder;
use Ecotone\Dbal\DbalBackedMessageChannelBuilder;
use Ecotone\Amqp\AmqpBackedMessageChannelBuilder;

#[ServiceContext]
public function queueTopology(): array
{
    return [
        DbalBackedMessageChannelBuilder::create('orders_shared'),
        AmqpBackedMessageChannelBuilder::create('orders_premium'),

        DynamicMessageChannelBuilder::createWithHeaderBasedStrategy(
            thisMessageChannelName: 'orders',          // handler code stays #[Asynchronous('orders')]
            headerName: 'tenant',
            headerMapping: [
                'big_corp'     => 'orders_premium',
                'enterprise_x' => 'orders_premium',
                // every other tenant falls through to the default
            ],
            defaultChannelName: 'orders_shared',
        ),
    ];
}

// OrderSaga.php — stateful coordinator, persisted by orderId

use Ecotone\Modelling\Attribute\Saga;
use Ecotone\Modelling\Attribute\EventHandler;
use Ecotone\Modelling\Attribute\Identifier;
use Ecotone\Messaging\Scheduling\Delayed;

#[Saga]
final class OrderSaga
{
    #[Identifier] public string $orderId;
    private OrderStage $stage = OrderStage::PlacedAwaitingPayment;

    #[EventHandler]
    public static function start(OrderPlaced $e): self
    {
        $self = new self();
        $self->orderId = $e->orderId;
        return $self;
    }

    #[EventHandler]
    public function onPaymentCaptured(PaymentCaptured $e, CommandBus $bus): void
    {
        $this->stage = OrderStage::PaidAwaitingFulfillment;
        $bus->send(new FulfillOrder($this->orderId));
    }

    // Cron-free 30-minute timeout for payment
    #[Delayed(thirtyMinutes: 'PT30M')]
    #[EventHandler]
    public function paymentTimeout(OrderPlaced $e, CommandBus $bus): void
    {
        if ($this->stage === OrderStage::PlacedAwaitingPayment) {
            $bus->send(new CancelOrder($this->orderId, reason: 'Payment timed out'));
        }
    }

    #[EventHandler]
    public function onFulfillmentFailed(FulfillmentFailed $e, CommandBus $bus): void
    {
        // Compensation: refund the captured payment
        $bus->send(new RefundPayment($this->orderId, $e->reason));
        $this->stage = OrderStage::CompensatedRefund;
    }
}